T を列挙型に制約するジェネリックメソッドを作成する

https://stackoverflow.com/questions/79126

09-06-2019
|

質問

を拡張する関数を構築しています。 Enum.Parse というコンセプト

Enum 値が見つからない場合にデフォルト値を解析できるようにします。
大文字と小文字は区別されません

そこで私は次のように書きました。

public static T GetEnumFromString<T>(string value, T defaultValue) where T : Enum
{
    if (string.IsNullOrEmpty(value)) return defaultValue;
    foreach (T item in Enum.GetValues(typeof(T)))
    {
        if (item.ToString().ToLower().Equals(value.Trim().ToLower())) return item;
    }
    return defaultValue;
}

「制約を特別なクラスにすることはできません」というエラーが表示されます System.Enum.

それは十分に公平ですが、Generic Enumを許可する回避策はありますか、それとも次のようにする必要がありますか? Parse 関数を作成し、型を属性として渡すと、コードに醜いボックス化要件が強制されます。

編集以下のすべての提案を大変歓迎いたします。ありがとうございます。

に落ち着きました（大文字と小文字を区別しないようにループをそのままにしました。XML を解析するときにこれを使用しています）

public static class EnumUtils
{
    public static T ParseEnum<T>(string value, T defaultValue) where T : struct, IConvertible
    {
        if (!typeof(T).IsEnum) throw new ArgumentException("T must be an enumerated type");
        if (string.IsNullOrEmpty(value)) return defaultValue;

        foreach (T item in Enum.GetValues(typeof(T)))
        {
            if (item.ToString().ToLower().Equals(value.Trim().ToLower())) return item;
        }
        return defaultValue;
    }
}

編集： (2015 年 2 月 16 日) Julien Lebosquain が最近投稿しました MSIL または F# でコンパイラが強制するタイプセーフな汎用ソリューション以下は一見の価値があり、賛成票を投じる価値があります。解決策がページのさらに上に浮かんだ場合は、この編集を削除します。

解決

以来 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. 。チャンスは稀だけどね。

他のヒント

この機能はついに 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

アセンブリではなくネットモジュールを取得します。

残念ながら、VS2010 (および明らかにそれ以前) ではネットモジュール参照の追加がサポートされていないため、デバッグ時に 2 つの別々のアセンブリに残しておく必要があります。これらをアセンブリの一部として追加できる唯一の方法は、次のコマンドを使用して csc.exe を自分で実行することです。 /addmodule:{files} コマンドライン引数。そんなことはないでしょう あまりにも MSBuild スクリプトでは面倒です。もちろん、勇気があるか愚かであれば、毎回手動で csc を実行することもできます。そして、複数のアセンブリがアクセスする必要があるため、確実に複雑になります。

したがって、.Net でも実行できます。余分な努力をする価値はあるでしょうか?そうですね、それについてはあなたに決めてもらいましょう。

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

追加クレジット:一般的な制限があることが判明しました。 enum MSIL 以外に少なくとも 1 つの他の .NET 言語で可能です。F#。

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);

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はsystem.object、system.valueType、system.enum、および任意のインターフェイスタイプに制限されます。

編集

この質問には見事に答えられましたジュリアン・レボスクェイン。彼の答えを次のように拡張したいと思います 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);

古い

私のこれまでの改良点ヴィヴェクの答えコメントと「新しい」開発を使用して:

使用 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 の著書「CLR via C#」で言及されている方法です。

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

次に、parse メソッドで、Enum.Parse(typeof(T), input, true) を使用して文字列から列挙型に変換するだけです。最後の true パラメータは、入力の大文字と小文字を無視するためのものです。

また、C# 7.3 のリリース以降、Enum 制約を使用することは、追加のチェックなどを行う必要がなく、すぐに使用できる状態でサポートされていることも考慮する必要があります。

したがって、プロジェクトの言語バージョンを 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 に感謝します。

私の場合、この編集を書いている時点で ReSharper 2018.1 はまだ 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 以降を使用していることを考慮すると、構文はまったく問題ないことがわかります。

dimarzionist さんのサンプルを改造してみました。このバージョンは列挙型でのみ動作し、構造体は通過できません。

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);
    }
}

コードを少し改善してみました。

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;
}

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;
      }
}

興味深いことに、どうやらこれは他の言語でも可能 (マネージド C++、イリノイ州直接)。

引用するには:

...どちらの制約も実際には有効な IL を生成し、別の言語で記述されている場合は C# で使用することもできます (これらの制約はマネージド C++ または IL で宣言できます)。

知るか

これが私の見解です。回答と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 ソース

既存の回答は C# <=7.2 の時点で当てはまります。ただし、C#言語はあります機能リクエスト (に結び付けられている) コアFX 機能リクエスト）により、以下を許可します。

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

執筆時点では、この機能は言語開発会議で「議論中」です。

編集

とおりナウファルの情報、これは C# で導入されています 7.3.

私はいつもこれが好きでした (必要に応じて変更できます):

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 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 のソリューションを再利用できるユーティリティクラスにカプセル化しました。ただし、型制約「where 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

以前の他の回答で述べたように;これはソースコードでは表現できませんが、実際には IL レベルで実行できます。@クリストファー・カレンズ答え ILがそれに対してどのように行動するかを示しています。

とフォディアドイン ExtraConstraints.Fody これを実現するには、ビルドツールを使用した非常に簡単な方法があります。nuget パッケージを追加するだけです (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);

完全を期すために、以下は Java ソリューションです。C# でも同じことができると思います。これにより、コード内の任意の場所で型を指定する必要がなくなります。代わりに、解析しようとしている文字列で型を指定します。

問題は、文字列がどの列挙型に一致するかを知る方法がないことです。そのため、答えはその問題を解決することです。

文字列値だけを受け入れるのではなく、「enumeration.value」形式で列挙と値の両方を含む文字列を受け入れます。動作するコードは以下のとおりです。Java 1.8 以降が必要です。また、単に color="red" ではなく color="Color.red" のように表示されるため、XML がより正確になります。

enum 名ドット値名を含む文字列を使用して acceptEnumeratedValue() メソッドを呼び出します。

このメソッドは正式な列挙値を返します。

import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;


public class EnumFromString {

    enum NumberEnum {One, Two, Three};
    enum LetterEnum {A, B, C};


    Map<String, Function<String, ? extends Enum>> enumsByName = new HashMap<>();

    public static void main(String[] args) {
        EnumFromString efs = new EnumFromString();

        System.out.print("\nFirst string is NumberEnum.Two - enum is " + efs.acceptEnumeratedValue("NumberEnum.Two").name());
        System.out.print("\nSecond string is LetterEnum.B - enum is " + efs.acceptEnumeratedValue("LetterEnum.B").name());

    }

    public EnumFromString() {
        enumsByName.put("NumberEnum", s -> {return NumberEnum.valueOf(s);});
        enumsByName.put("LetterEnum", s -> {return LetterEnum.valueOf(s);});
    }

    public Enum acceptEnumeratedValue(String enumDotValue) {

        int pos = enumDotValue.indexOf(".");

        String enumName = enumDotValue.substring(0, pos);
        String value = enumDotValue.substring(pos + 1);

        Enum enumeratedValue = enumsByName.get(enumName).apply(value);

        return enumeratedValue;
    }


}

ライセンス： CC-BY-SA と帰属

所属していません StackOverflow

T を列挙型に制約するジェネリック メソッドを作成する

この機能はついに C# 7.3 でサポートされました。

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

C# ≥ 7.3

C# ≤ 7.2

T を列挙型に制約するジェネリックメソッドを作成する