以来Enum型の実装IConvertibleより良い実装は、次のようなものでなければなりません：

public T GetEnumFromString<T>(string value) where T : struct, IConvertible
{
   if (!typeof(T).IsEnum) 
   {
      throw new ArgumentException("T must be an enumerated type");
   }

   //...
}

これは引き続き、実装する値型の受け渡しを許可しますIConvertible。チャンスはまれです。

• ジェネリックスは.NET 2.0以降で利用可能です。したがって、彼らは2005年も利用可能です。 - Vivek
• さて、あなたがこのパスを下ることを選択した場合、それをさらに制限してください...＆quot;クラスTestClass＆gt;ここで、T：struct、IComparable、IFormattable、IConvertible＆quot; - Ricardo Nolde
• もう1つの提案は識別子TEnumでジェネリック型を定義することです。 TEnum：struct、IConvertible、IComparible、IFormattable {}ここで、public TEnum GetEnumFromString＆lt; TEnum＆gt;（文字列値） - Lisa
• ほとんどの組み込みの値の型はこれらのインターフェイスをすべて実装しているため、他のインターフェイスを含めることで多くの利益を得ることはできません。これは、ジェネリック拡張メソッドの制約の場合に特に当てはまります。これらの拡張メソッドは、すべてのオブジェクトに感染するウィルスのようなものですが、enumでの操作には非常に便利です。 IConvertableは少なくともそれをかなり絞り込んでいます。 - russbishop
• @ Samam：あなたが投稿したとき、このスレッドは6歳半でした。正解でした。答えの中にコンパイル時のチェックはありませんでした。それから3日後、6年後に、あなたはあなたの希望を得ました - 下のJulien Lebosquainの投稿方法をご覧ください。 - David I. McIntosh

この機能はC＃7.3で最終的にサポートされています！

次のスニペット（ドットネットのサンプル）はそれが使用することを示しています：

public static Dictionary<int, string> EnumNamedValues<T>() where T : System.Enum
{
    var result = new Dictionary<int, string>();
    var values = Enum.GetValues(typeof(T));

    foreach (int item in values)
        result.Add(item, Enum.GetName(typeof(T), item));
    return result;
}

C＃プロジェクトの言語バージョンをバージョン7.3に設定してください。

元の答えは以下のとおりです：

私はゲームに遅れていますが、私はそれをどのように行うことができるかを見るために挑戦しました。 C＃（またはVB.NETでは可能ではありませんが、F＃ではスクロールダウンします）可能ですMSILで私はこの小さな....事を書いた

// license: http://www.apache.org/licenses/LICENSE-2.0.html
.assembly MyThing{}
.class public abstract sealed MyThing.Thing
       extends [mscorlib]System.Object
{
  .method public static !!T  GetEnumFromString<valuetype .ctor ([mscorlib]System.Enum) T>(string strValue,
                                                                                          !!T defaultValue) cil managed
  {
    .maxstack  2
    .locals init ([0] !!T temp,
                  [1] !!T return_value,
                  [2] class [mscorlib]System.Collections.IEnumerator enumerator,
                  [3] class [mscorlib]System.IDisposable disposer)
    // if(string.IsNullOrEmpty(strValue)) return defaultValue;
    ldarg strValue
    call bool [mscorlib]System.String::IsNullOrEmpty(string)
    brfalse.s HASVALUE
    br RETURNDEF         // return default it empty

    // foreach (T item in Enum.GetValues(typeof(T)))
  HASVALUE:
    // Enum.GetValues.GetEnumerator()
    ldtoken !!T
    call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
    call class [mscorlib]System.Array [mscorlib]System.Enum::GetValues(class [mscorlib]System.Type)
    callvirt instance class [mscorlib]System.Collections.IEnumerator [mscorlib]System.Array::GetEnumerator() 
    stloc enumerator
    .try
    {
      CONDITION:
        ldloc enumerator
        callvirt instance bool [mscorlib]System.Collections.IEnumerator::MoveNext()
        brfalse.s LEAVE

      STATEMENTS:
        // T item = (T)Enumerator.Current
        ldloc enumerator
        callvirt instance object [mscorlib]System.Collections.IEnumerator::get_Current()
        unbox.any !!T
        stloc temp
        ldloca.s temp
        constrained. !!T

        // if (item.ToString().ToLower().Equals(value.Trim().ToLower())) return item;
        callvirt instance string [mscorlib]System.Object::ToString()
        callvirt instance string [mscorlib]System.String::ToLower()
        ldarg strValue
        callvirt instance string [mscorlib]System.String::Trim()
        callvirt instance string [mscorlib]System.String::ToLower()
        callvirt instance bool [mscorlib]System.String::Equals(string)
        brfalse.s CONDITION
        ldloc temp
        stloc return_value
        leave.s RETURNVAL

      LEAVE:
        leave.s RETURNDEF
    }
    finally
    {
        // ArrayList's Enumerator may or may not inherit from IDisposable
        ldloc enumerator
        isinst [mscorlib]System.IDisposable
        stloc.s disposer
        ldloc.s disposer
        ldnull
        ceq
        brtrue.s LEAVEFINALLY
        ldloc.s disposer
        callvirt instance void [mscorlib]System.IDisposable::Dispose()
      LEAVEFINALLY:
        endfinally
    }

  RETURNDEF:
    ldarg defaultValue
    stloc return_value

  RETURNVAL:
    ldloc return_value
    ret
  }
} 

これは、〜するそれが有効であれば、このように見えるC＃：

T GetEnumFromString<T>(string valueString, T defaultValue) where T : Enum

次に、次のC＃コードを使用します。

using MyThing;
// stuff...
private enum MyEnum { Yes, No, Okay }
static void Main(string[] args)
{
    Thing.GetEnumFromString("No", MyEnum.Yes); // returns MyEnum.No
    Thing.GetEnumFromString("Invalid", MyEnum.Okay);  // returns MyEnum.Okay
    Thing.GetEnumFromString("AnotherInvalid", 0); // compiler error, not an Enum
}

残念ながら、これはあなたのコードのこの部分がC＃の代わりにMSILで書かれていることを意味します。System.Enum。それは別のアセンブリにコンパイルされるので、一種のバマーです。しかし、それはそうした方法で展開する必要はありません。

行を削除することにより.assembly MyThing{}次のようにilasmを呼び出します。

ilasm.exe /DLL /OUTPUT=MyThing.netmodule

アセンブリの代わりにnetmoduleを取得します。

残念なことに、VS2010以前のバージョンでは、netmodule参照の追加がサポートされていません。つまり、デバッグ中に2つの別々のアセンブリに残す必要があります。アセンブリの一部として追加する唯一の方法は、csc.exeを自分自身で実行することです/addmodule:{files}コマンドライン引数。それはないだろうあまりにもMSBuildスクリプトで痛い。もちろん、あなたが勇敢で愚かな人なら、毎回手動でcscを実行することができます。また、複数のアセンブリがアクセスする必要があるため、確かに複雑になります。

だから、それは.Netで行うことができます。それは余分な努力の価値があるのですか？ええと、私はあなたにそれを決定させるでしょう。

代替案としてのF＃ソリューション

余分なクレジット：一般的な制限はenumMSIL：F＃以外の少なくとも1つの.NET言語でも可能です。

type MyThing =
    static member GetEnumFromString<'T when 'T :> Enum> str defaultValue: 'T =
        /// protect for null (only required in interop with C#)
        let str = if isNull str then String.Empty else str

        Enum.GetValues(typedefof<'T>)
        |> Seq.cast<_>
        |> Seq.tryFind(fun v -> String.Compare(v.ToString(), str.Trim(), true) = 0)
        |> function Some x -> x | None -> defaultValue

これは完全なVisual Studio IDEサポートでよく知られている言語なので、保守が簡単ですが、依然としてソリューションに別のプロジェクトが必要です。しかし、それは自然にかなり異なるILを生成します（コードは非常に異なる）、それはFSharp.Core他の外部ライブラリと同様に、あなたの流通の一部になる必要があります。

使用方法（基本的にはMSILソリューションと同じ）を使用して、同義の構造体で正しく失敗することを示します。

// works, result is inferred to have type StringComparison
var result = MyThing.GetEnumFromString("OrdinalIgnoreCase", StringComparison.Ordinal);
// type restriction is recognized by C#, this fails at compile time
var result = MyThing.GetEnumFromString("OrdinalIgnoreCase", 42);

• ええ、非常にハードコア。私はILでコード化できる人のために最大の敬意を払いますが、そしてより多くの言語レベル（アプリケーション、ビジネスルール、UI、コンポーネントライブラリなどの下ではまだ低レベルと見なされているレベル）で機能がどのようにサポートされているかを理解してください。 - TonyG
• 私が本当に知りたいのは、C＃チームがまだMSILによってサポートされているため、これをまだ許可していない理由です。 - MgSam
• @MgSam - からエリック・リッパート：There's no particularly unusual reason why not; we have lots of other things to do, limited budgets, and this one has never made it past the "wouldn't this be nice?" discussion in the language design team. - Christopher Currens
• @LordofScripts：私はその理由は、TにSystem.Enumすべてのことを行うことはできませんT人々は期待するかもしれないが、C＃の作者は、彼らはそれを完全に禁止するかもしれないと考えた。私はその決定を不幸に思っています。なぜなら、C＃は単にSystem.Enum制約を記述することは可能でした。HasAnyFlags<T>(this T it, T other)拡張メソッドでは、Enum.HasFlag(Enum)その引数を型チェックした。 - supercat
• 私がここで終わったことのないプロジェクトがあったとは思わない。 C＃6は110％の構文砂糖であり、これは実現できませんでしたか？ごまかす - Michael Blackburn

C＃≧7.3

C＃7.3（Visual Studio 2017≧v15.7で利用可能）から、このコードは完全に有効になりました。

public static TEnum Parse<TEnum>(string value)
where TEnum : struct, Enum { ... }

C＃≦7.2

制約の継承を悪用して、実際のコンパイラが強制するenum制約を持つことができます。次のコードは、classとstruct制約が同時に発生する：

public abstract class EnumClassUtils<TClass>
where TClass : class
{

    public static TEnum Parse<TEnum>(string value)
    where TEnum : struct, TClass
    {
        return (TEnum) Enum.Parse(typeof(TEnum), value);
    }

}

public class EnumUtils : EnumClassUtils<Enum>
{
}

使用法：

EnumUtils.Parse<SomeEnum>("value");

注：これはC＃5.0言語仕様で具体的に述べられています。

型パラメータSが型パラメータTに依存する場合、   [...]これは有効です   Sは値型制約を持ち、Tは参照型を持つ   制約。実際には、TをSystem.Object型に制限します。   System.ValueType、System.Enum、および任意のインターフェイスタイプ。

• @ DavidI.McIntoshEnumClassUtils<System.Enum>Tを任意のものに制限するのに十分ですSystem.Enum任意の派生型。structにParseそれを実際の列挙型にさらに制限します。あなたはに制限する必要がありますEnumある時点で。これを行うには、クラスをネストする必要があります。見るgist.github.com/MrJul/7da12f5f2d6c69f03d79 - Julien Lebosquain
• ちょうど明確にするために、私のコメント「楽しくない」あなたのソリューションに対するコメントではありませんでした。それは本当に美しいハックです。単に「気持ちが悪い」とは、そのMSは、私たちにそのような複雑なハックを使用させる。 - David I. McIntosh
• 拡張メソッドにも使用できるようにこれを動作させる方法はありますか？ - Mord Zuber
• 私はこのクラスが奇妙な方法で継承されないように内部コンストラクタを追加します。 - John Gietzen
• 何がwhere TClass : classここで拘束ゲイン？ - tsemer

編集

質問には、ジュリアン・レボスケイン。 私は彼の答えをignoreCase、defaultValueオプションの引数を追加しながらTryParseそしてParseOrDefault。

public abstract class ConstrainedEnumParser<TClass> where TClass : class
// value type constraint S ("TEnum") depends on reference type T ("TClass") [and on struct]
{
    // internal constructor, to prevent this class from being inherited outside this code
    internal ConstrainedEnumParser() {}
    // Parse using pragmatic/adhoc hard cast:
    //  - struct + class = enum
    //  - 'guaranteed' call from derived <System.Enum>-constrained type EnumUtils
    public static TEnum Parse<TEnum>(string value, bool ignoreCase = false) where TEnum : struct, TClass
    {
        return (TEnum)Enum.Parse(typeof(TEnum), value, ignoreCase);
    }
    public static bool TryParse<TEnum>(string value, out TEnum result, bool ignoreCase = false, TEnum defaultValue = default(TEnum)) where TEnum : struct, TClass // value type constraint S depending on T
    {
        var didParse = Enum.TryParse(value, ignoreCase, out result);
        if (didParse == false)
        {
            result = defaultValue;
        }
        return didParse;
    }
    public static TEnum ParseOrDefault<TEnum>(string value, bool ignoreCase = false, TEnum defaultValue = default(TEnum)) where TEnum : struct, TClass // value type constraint S depending on T
    {
        if (string.IsNullOrEmpty(value)) { return defaultValue; }
        TEnum result;
        if (Enum.TryParse(value, ignoreCase, out result)) { return result; }
        return defaultValue;
    }
}

public class EnumUtils: ConstrainedEnumParser<System.Enum>
// reference type constraint to any <System.Enum>
{
    // call to parse will then contain constraint to specific <System.Enum>-class
}

使用例：

WeekDay parsedDayOrArgumentException = EnumUtils.Parse<WeekDay>("monday", ignoreCase:true);
WeekDay parsedDayOrDefault;
bool didParse = EnumUtils.TryParse<WeekDay>("clubs", out parsedDayOrDefault, ignoreCase:true);
parsedDayOrDefault = EnumUtils.ParseOrDefault<WeekDay>("friday", ignoreCase:true, defaultValue:WeekDay.Sunday);

古い

私の古い改善Vivekの答えコメントと「新しい」開発を使用して：

• つかいますTEnumユーザーを分かりやすくするため
• 追加の制約チェックのためのインターフェイス制約を追加する
• 〜するTryParseハンドルignoreCase既存のパラメータ （VS2010 / .Net 4で導入されました）
• オプションでジェネリックを使用するdefault値（VS2005 / .Net 2で導入された）
• つかいますオプションの引数（VS2010 / .Net 4で導入された）デフォルト値でdefaultValueそしてignoreCase

その結果：

public static class EnumUtils
{
    public static TEnum ParseEnum<TEnum>(this string value,
                                         bool ignoreCase = true,
                                         TEnum defaultValue = default(TEnum))
        where TEnum : struct,  IComparable, IFormattable, IConvertible
    {
        if ( ! typeof(TEnum).IsEnum) { throw new ArgumentException("TEnum must be an enumerated type"); }
        if (string.IsNullOrEmpty(value)) { return defaultValue; }
        TEnum lResult;
        if (Enum.TryParse(value, ignoreCase, out lResult)) { return lResult; }
        return defaultValue;
    }
}

型Tが列挙型であることをチェックするクラスの静的コンストラクターを定義し、そうでない場合は例外をスローすることができます。これは、Jeffery RichterがC＃による書籍CLRで述べた方法です。

internal sealed class GenericTypeThatRequiresAnEnum<T> {
    static GenericTypeThatRequiresAnEnum() {
        if (!typeof(T).IsEnum) {
        throw new ArgumentException("T must be an enumerated type");
        }
    }
}

次に、解析メソッドでは、Enum.Parse（typeof（T）、input、true）を使用して、stringからenumに変換できます。最後の真のパラメータは、入力の大文字小文字を無視するためのものです。

• これはジェネリッククラスのための良いオプションです - もちろん、ジェネリックメソッドのための助けにはなりません。 - McGarnagle
• また、これはコンパイル時に強制されません。Enum Tコンストラクタが実行されたとき。これはインスタンスコンストラクタを待つよりもはるかに良いですが。 - jrh

私はdimarzionistによってサンプルを修正しました。このバージョンはEnumでのみ動作し、構造体を通過させません。

public static T ParseEnum<T>(string enumString)
    where T : struct // enum 
    {
    if (String.IsNullOrEmpty(enumString) || !typeof(T).IsEnum)
       throw new Exception("Type given must be an Enum");
    try
    {

       return (T)Enum.Parse(typeof(T), enumString, true);
    }
    catch (Exception ex)
    {
       return default(T);
    }
}

• 失敗した場合はデフォルト値を返しません。例外を伝播させます（Enum.Parseと同じように）。代わりに、TryParseを使用してboolを返し、outパラメータを使用して結果を返します。 - Mark Simpson
• OPは大文字と小文字を区別しないようにしたいと考えています。 - Konrad Morawski
• これは大文字と小文字を区別しないので、最後の＆trueの＆＃39; 〜のためです - increddibelly

私は少しコードを改善しようとしました：

public T LoadEnum<T>(string value, T defaultValue = default(T)) where T : struct, IComparable, IFormattable, IConvertible
{
    if (Enum.IsDefined(typeof(T), value))
    {
        return (T)Enum.Parse(typeof(T), value, true);
    }
    return defaultValue;
}

• それはあなたが電話することができるので、これは受け入れられた答えよりも優れていますdefaultValue.ToString("D", System.Globalization.NumberFormatInfo.CurrentInfo)列挙型の種類がわからないにもかかわらず、そのオブジェクトは列挙型です。 - styfle
• 事前確認はIsDefinedしかし、ケースの無感覚を台無しにするでしょう。とは異なりParse、IsDefinedありませんignoreCase引数、MSDNは正確なケースにのみ一致していると言います。 - Nyerguds

また、Enum制約を使用するC＃7.3のリリースは、追加のチェックや処理をすることなく、すぐにサポートされるため、考慮する必要があります。

したがって、プロジェクトの言語バージョンをC＃7.3に変更した場合、次のコードは完全に正常に動作します：

    private static T GetEnumFromString<T>(string value, T defaultValue) where T : Enum
    {
        // Your code goes here...
    }

言語バージョンをC＃7.3に変更する方法がわからない場合は、次のスクリーンショットを参照してください。

編集1 - 必要なVisual StudioのバージョンとReSharperを考慮

Visual Studioに新しい構文を認識させるには、バージョン15.7以上が必要です。 Microsoftのリリースノートにも記載されていますVisual Studio 2017 15.7リリースノート。この正当な質問を指摘してくれてありがとう@MohamedElshawaf。

Plsはまた、私のケースでは、ReSharper 2018.1を書いている時点で、このEDITはまだC＃7.3をサポートしていないことに気づいています。 ReSharperを有効にすると、Enumの制約がエラーとして表示されます型パラメータの制約として 'System.Array'、 'System.Delegate'、 'System.Enum'、 'System.ValueType'、 'object'を使用できません。 ReSharperは、メソッドの型パラメータTの 'Enum'制約を削除する

ただし、一時的にReSharperをオフにした場合ツール - >オプション - > ReSharper Ultimate - >一般VS 15.7以上とC＃7.3以上を使用すると、構文が完全にうまくいくことがわかります。

• どのVSバージョンを使用していますか？ - mshwf
• これは現在受け入れられている回答になるはずです - Patrick Roberts
• @MohamedElshawaf私はC＃7.3のサポートを含むバージョン15.7を信じています - Patrick Roberts
• 私はそれを書いた方が良いと思うwhere T : struct, Enum、渡すことを避けるためにSystem.Enum型パラメータとしてのそれ自身。 - Mariusz Pawelski
• @MariuszPawelskiのように書くstruct, Enum。私の根拠は答えとコメントで説明されていますここに。 - Stephen Kennedy

私は、enum値に関連付けられたテキストでenumを使用する必要がある特定の要件を持っています。たとえば、エラーの種類を指定するためにenumを使用すると、エラーの詳細を記述する必要があります。

public static class XmlEnumExtension
{
    public static string ReadXmlEnumAttribute(this Enum value)
    {
        if (value == null) throw new ArgumentNullException("value");
        var attribs = (XmlEnumAttribute[]) value.GetType().GetField(value.ToString()).GetCustomAttributes(typeof (XmlEnumAttribute), true);
        return attribs.Length > 0 ? attribs[0].Name : value.ToString();
    }

    public static T ParseXmlEnumAttribute<T>(this string str)
    {
        foreach (T item in Enum.GetValues(typeof(T)))
        {
            var attribs = (XmlEnumAttribute[])item.GetType().GetField(item.ToString()).GetCustomAttributes(typeof(XmlEnumAttribute), true);
            if(attribs.Length > 0 && attribs[0].Name.Equals(str)) return item;
        }
        return (T)Enum.Parse(typeof(T), str, true);
    }
}

public enum MyEnum
{
    [XmlEnum("First Value")]
    One,
    [XmlEnum("Second Value")]
    Two,
    Three
}

 static void Main()
 {
    // Parsing from XmlEnum attribute
    var str = "Second Value";
    var me = str.ParseXmlEnumAttribute<MyEnum>();
    System.Console.WriteLine(me.ReadXmlEnumAttribute());
    // Parsing without XmlEnum
    str = "Three";
    me = str.ParseXmlEnumAttribute<MyEnum>();
    System.Console.WriteLine(me.ReadXmlEnumAttribute());
    me = MyEnum.One;
    System.Console.WriteLine(me.ReadXmlEnumAttribute());
}

これが参考になることを願っています：

public static TValue ParseEnum<TValue>(string value, TValue defaultValue)
                  where TValue : struct // enum 
{
      try
      {
            if (String.IsNullOrEmpty(value))
                  return defaultValue;
            return (TValue)Enum.Parse(typeof (TValue), value);
      }
      catch(Exception ex)
      {
            return defaultValue;
      }
}

• 大文字と小文字の区別が必要な場合は、return (TValue)Enum.Parse(typeof (TValue), value);によってreturn (TValue)Enum.Parse(typeof (TValue), value, true); - Paulo Santos

興味深いことに、明らかにこれは他のランゲージでも可能（マネージドC ++、IL）。

引用するには：

...両方の制約は実際に有効なILを生成し、別の言語で記述されている場合はC＃で消費することもできます（管理C ++またはILでこれらの制約を宣言できます）。

知るか

• Managed Extensions for C ++では、ジェネリックのサポートはありません。あなたはC ++ / CLIを意味すると思います。 - Ben Voigt

これが私のそれです。回答とMSDNの組み合わせ

public static TEnum ParseToEnum<TEnum>(this string text) where TEnum : struct, IConvertible, IComparable, IFormattable
{
    if (string.IsNullOrEmpty(text) || !typeof(TEnum).IsEnum)
        throw new ArgumentException("TEnum must be an Enum type");

    try
    {
        var enumValue = (TEnum)Enum.Parse(typeof(TEnum), text.Trim(), true);
        return enumValue;
    }
    catch (Exception)
    {
        throw new ArgumentException(string.Format("{0} is not a member of the {1} enumeration.", text, typeof(TEnum).Name));
    }
}

MSDNソース

• これは本当に理にかなっていません。もしTEnum実際にはEnum型ですがtext空の文字列です。ArgumentException「TEnumは列挙型でなければならない」と言っている。そうであっても。 - Nick

既存の回答はC＃<= 7.2の時点で真です。ただし、C＃言語があります機能リクエスト（corefx機能要求）を使用して以下を許可します。

public class MyGeneric<TEnum> where TEnum : System.Enum
{ }

執筆時点では、言語開発ミーティングでは "ディスカッション中"となっています。

EDIT

毎時ノワールの情報、これはC＃で導入されています7.3。

• 興味深い議論がありました、ありがとう。石ではまだ何も設定されていませんが（まだ） - johnc
• @johnc、非常に真実だが、それは価値があるはよく尋ねられる機能です。公正なオッズが入ってくる。 - DiskJunky
• これはC＃7.3にあります：docs.microsoft.com/en-us/visualstudio/releasenotes/…。 :) - nawfal

私はいつもこれが好きでした（あなたは適切に修正することができます）：

public static IEnumerable<TEnum> GetEnumValues()
{
  Type enumType = typeof(TEnum);

  if(!enumType.IsEnum)
    throw new ArgumentException("Type argument must be Enum type");

  Array enumValues = Enum.GetValues(enumType);
  return enumValues.Cast<TEnum>();
}

私はILを使ったChristopher Currensのソリューションが好きでしたが、MSILをビルドプロセスに組み込むという厄介なビジネスに対処したくない人には、私はC＃で同様の機能を書いていました。

ただし、以下のような一般的な制限は使用できません。where T : Enum列挙型は特別な型です。したがって、ジェネリック型が本当に列挙型かどうかをチェックする必要があります。

私の機能は：

public static T GetEnumFromString<T>(string strValue, T defaultValue)
{
    // Check if it realy enum at runtime 
    if (!typeof(T).IsEnum)
        throw new ArgumentException("Method GetEnumFromString can be used with enums only");

    if (!string.IsNullOrEmpty(strValue))
    {
        IEnumerator enumerator = Enum.GetValues(typeof(T)).GetEnumerator();
        while (enumerator.MoveNext())
        {
            T temp = (T)enumerator.Current;
            if (temp.ToString().ToLower().Equals(strValue.Trim().ToLower()))
                return temp;
        }
    }

    return defaultValue;
}

私はあなたが再利用できるユーティリティクラスにVivekのソリューションをカプセル化しました。あなたのタイプには "T：struct、IConvertible"という型制約を定義する必要があることに注意してください。

using System;

internal static class EnumEnforcer
{
    /// <summary>
    /// Makes sure that generic input parameter is of an enumerated type.
    /// </summary>
    /// <typeparam name="T">Type that should be checked.</typeparam>
    /// <param name="typeParameterName">Name of the type parameter.</param>
    /// <param name="methodName">Name of the method which accepted the parameter.</param>
    public static void EnforceIsEnum<T>(string typeParameterName, string methodName)
        where T : struct, IConvertible
    {
        if (!typeof(T).IsEnum)
        {
            string message = string.Format(
                "Generic parameter {0} in {1} method forces an enumerated type. Make sure your type parameter {0} is an enum.",
                typeParameterName,
                methodName);

            throw new ArgumentException(message);
        }
    }

    /// <summary>
    /// Makes sure that generic input parameter is of an enumerated type.
    /// </summary>
    /// <typeparam name="T">Type that should be checked.</typeparam>
    /// <param name="typeParameterName">Name of the type parameter.</param>
    /// <param name="methodName">Name of the method which accepted the parameter.</param>
    /// <param name="inputParameterName">Name of the input parameter of this page.</param>
    public static void EnforceIsEnum<T>(string typeParameterName, string methodName, string inputParameterName)
        where T : struct, IConvertible
    {
        if (!typeof(T).IsEnum)
        {
            string message = string.Format(
                "Generic parameter {0} in {1} method forces an enumerated type. Make sure your input parameter {2} is of correct type.",
                typeParameterName,
                methodName,
                inputParameterName);

            throw new ArgumentException(message);
        }
    }

    /// <summary>
    /// Makes sure that generic input parameter is of an enumerated type.
    /// </summary>
    /// <typeparam name="T">Type that should be checked.</typeparam>
    /// <param name="exceptionMessage">Message to show in case T is not an enum.</param>
    public static void EnforceIsEnum<T>(string exceptionMessage)
        where T : struct, IConvertible
    {
        if (!typeof(T).IsEnum)
        {
            throw new ArgumentException(exceptionMessage);
        }
    }
}

私は拡張メソッドを作成しましたto get integer value from enumメソッドの実装を見てください

public static int ToInt<T>(this T soure) where T : IConvertible//enum
{
    if (typeof(T).IsEnum)
    {
        return (int) (IConvertible)soure;// the tricky part
    }
    //else
    //    throw new ArgumentException("T must be an enumerated type");
    return soure.ToInt32(CultureInfo.CurrentCulture);
}

これは用法です

MemberStatusEnum.Activated.ToInt()// using extension Method
(int) MemberStatusEnum.Activated //the ordinary way

• それはおそらく機能しますが、質問との関連性はほとんどありません。 - quetzalcoatl

これまでの他の答えで述べたように。これはソースコードで表現することはできませんが、実際にILレベルで行うことができます。 @Christopher Currens回答ILがどのようにそれを行うかを示しています。

と飼料sアドインExtraConstraints.Fodyこれを達成するために、ビルドツールを使用して非常に簡単な方法があります。ちょうど彼らのナゲットパッケージを追加する（Fody、ExtraConstraints.Fody）をプロジェクトに追加し、次のように制約を追加します（ExtraConstraintsのReadmeの抜粋）。

public void MethodWithEnumConstraint<[EnumConstraint] T>() {...}

public void MethodWithTypeEnumConstraint<[EnumConstraint(typeof(ConsoleColor))] T>() {...}

Fodyは制約が存在するために必要なILを追加します。 また、代理人の制約の追加機能にも注意してください。

public void MethodWithDelegateConstraint<[DelegateConstraint] T> ()
{...}

public void MethodWithTypeDelegateConstraint<[DelegateConstraint(typeof(Func<int>))] T> ()
{...}

Enumについては、非常に面白いEnums.NET。

後でダイレクトキャスティングを使用しても問題ない場合は、System.Enum必要に応じて、メソッドの基本クラスを作成します。型パラメーターを慎重に置き換えるだけで済みます。メソッドの実装は次のようになります：

public static class EnumUtils
{
    public static Enum GetEnumFromString(string value, Enum defaultValue)
    {
        if (string.IsNullOrEmpty(value)) return defaultValue;
        foreach (Enum item in Enum.GetValues(defaultValue.GetType()))
        {
            if (item.ToString().ToLower().Equals(value.Trim().ToLower())) return item;
        }
        return defaultValue;
    }
}

次に、次のように使用できます。

var parsedOutput = (YourEnum)EnumUtils.GetEnumFromString(someString, YourEnum.DefaultValue);

• の使用Enum.ToObject()より柔軟な結果が得られます。さらに、大文字と小文字を区別しないで文字列を比較すると、呼び出しの必要性を否定できますToLower() - DiskJunky

Javaでは、あなたは使用するだろう...

    SomeClass<T extends enum> {
}

それはかなり簡単です。