Enumの文字列表現

Question

私は以下の列挙を持っています：

public enum AuthenticationMethod
{
    FORMS = 1,
    WINDOWSAUTHENTICATION = 2,
    SINGLESIGNON = 3
}

ただし問題は、AuthenticationMethod.FORMSを要求するときには "FORMS"という単語が必要で、id 1は必要ないということです。

私はこの問題に対する次の解決策を見つけました（ link ）：

まず、 "StringValue"というカスタム属性を作成する必要があります。

public class StringValue : System.Attribute
{
    private readonly string _value;

    public StringValue(string value)
    {
        _value = value;
    }

    public string Value
    {
        get { return _value; }
    }

}

それから私は私の列挙子にこの属性を追加することができます：

public enum AuthenticationMethod
{
    [StringValue("FORMS")]
    FORMS = 1,
    [StringValue("WINDOWS")]
    WINDOWSAUTHENTICATION = 2,
    [StringValue("SSO")]
    SINGLESIGNON = 3
}

そしてもちろん、そのStringValueを取得するために何かが必要です。

public static class StringEnum
{
    public static string GetStringValue(Enum value)
    {
        string output = null;
        Type type = value.GetType();

        //Check first in our cached results...

        //Look for our 'StringValueAttribute' 

        //in the field's custom attributes

        FieldInfo fi = type.GetField(value.ToString());
        StringValue[] attrs =
           fi.GetCustomAttributes(typeof(StringValue),
                                   false) as StringValue[];
        if (attrs.Length > 0)
        {
            output = attrs[0].Value;
        }

        return output;
    }
}

今すぐ私は列挙子の文字列値を取得するためのツールを持っています。それから私はこのようにそれを使うことができます：

string valueOfAuthenticationMethod = StringEnum.GetStringValue(AuthenticationMethod.FORMS);

さて、これらの作業はすべて魅力的なものですが、私はそれが非常に多くの作業であることに気付きました。私はこれのためのよりよい解決策があるかどうか疑問に思いました。

私はまた、辞書と静的プロパティを使って何かを試しましたが、それはどちらも良くありませんでした。

Answer 1

type-safe-enum patternを試してください。

public sealed class AuthenticationMethod {

    private readonly String name;
    private readonly int value;

    public static readonly AuthenticationMethod FORMS = new AuthenticationMethod (1, "FORMS");
    public static readonly AuthenticationMethod WINDOWSAUTHENTICATION = new AuthenticationMethod (2, "WINDOWS");
    public static readonly AuthenticationMethod SINGLESIGNON = new AuthenticationMethod (3, "SSN");        

    private AuthenticationMethod(int value, String name){
        this.name = name;
        this.value = value;
    }

    public override String ToString(){
        return name;
    }

}

---

更新 明示的（または暗黙的）な型変換は、

• マッピングによる静的フィールドの追加

  private static readonly Dictionary<string, AuthenticationMethod> instance = new Dictionary<string,AuthenticationMethod>();
  

  • n.bインスタンスコンストラクタを呼び出すときに "enum member"フィールドの初期化がNullReferenceExceptionをスローしないようにするには、必ずクラス内の "enum member"フィールドの前にDictionaryフィールドを配置してください。これは、静的フィールド初期化子が宣言順に、そして静的コンストラクターの前に呼び出されるため、インスタンス・コンストラクターがすべての静的フィールドが初期化される前、および静的コンストラクターが呼び出される前に呼び出すことができるという奇妙で必要だが混乱を招く状況を作り出します。

• インスタンスコンストラクタでこのマッピングを埋める

  instance[name] = this;
  

• および ユーザー定義型変換演算子の追加

  public static explicit operator AuthenticationMethod(string str)
  {
      AuthenticationMethod result;
      if (instance.TryGetValue(str, out result))
          return result;
      else
          throw new InvalidCastException();
  }
  

Answer 2

使用方法

Enum.GetName(Type MyEnumType,  object enumvariable)  

のように（Shipperが定義済みのEnumであると仮定します）

Shipper x = Shipper.FederalExpress;
string s = Enum.GetName(typeof(Shipper), x);

Enumクラスには他にも調べる価値のある静的メソッドがたくさんあります。

Answer 3

ToString（）を使用すると、値ではなく名前を参照できます。

Console.WriteLine("Auth method: {0}", AuthenticationMethod.Forms.ToString());

ドキュメントはこちらです。

http://msdn.Microsoft.com/ja-jp/library/16c1xs4z.aspx

...そして、もしあなたがPascal Caseであなたのenumに名前をつけるなら（私がそうであるように - ThisIsMyEnumValue = 1などのように）、あなたはフレンドリーフォームを印刷するために非常に単純な正規表現を使うことができます

static string ToFriendlyCase(this string EnumString)
{
    return Regex.Replace(EnumString, "(?!^)([A-Z])", " $1");
}

どの文字列からでも簡単に呼び出すことができます。

Console.WriteLine("ConvertMyCrazyPascalCaseSentenceToFriendlyCase".ToFriendlyCase());

出力：

私のクレイジーパスカルケースの文をフレンドリーなケースに変換する

カスタム属性を作成してそれらを列挙型に結び付けたり、列挙型の値をわかりやすい文字列と結合するためにルックアップテーブルを使用して家の中を走り回ったりするのを節約します。より再利用可能です。もちろん、それはあなたがあなたの解決策が提供するあなたのenumと 異なる friendly nameを持つことを可能にしません。

もっと複雑なシナリオでも、私はあなたのオリジナルの解決策が好きです。あなたの解決策をさらに一歩進めて、あなたのGetStringValueをあなたのenumの拡張メソッドにすることができれば、StringEnum.GetStringValueのようにそれを参照する必要はないでしょう。

public static string GetStringValue(this AuthenticationMethod value)
{
  string output = null;
  Type type = value.GetType();
  FieldInfo fi = type.GetField(value.ToString());
  StringValue[] attrs = fi.GetCustomAttributes(typeof(StringValue), false) as StringValue[];
  if (attrs.Length > 0)
    output = attrs[0].Value;
  return output;
}

列挙型インスタンスから直接アクセスすることができます。

Console.WriteLine(AuthenticationMethod.SSO.GetStringValue());

Answer 4

残念ながら、列挙型の属性を取得するためのリフレクションは非常に遅いです。

この質問を参照してください： 誰もが列挙値のカスタム属性に到達するための迅速な方法を知っていますか？

.ToString()はenumでもかなり遅いです。

列挙型の拡張メソッドを書くこともできます。

public static string GetName( this MyEnum input ) {
    switch ( input ) {
        case MyEnum.WINDOWSAUTHENTICATION:
            return "Windows";
        //and so on
    }
}

これは素晴らしいことではありませんが、早くなるでしょうし、属性やフィールド名の反映を必要としません。

---

C＃6アップデート

C＃6を使用できる場合、新しいnameof演算子は列挙型に対して機能するため、nameof(MyEnum.WINDOWSAUTHENTICATION)はコンパイル時で"WINDOWSAUTHENTICATION"に変換され、enum名を取得する最も簡単な方法になります。

これは明示的な列挙型をインライン化された定数に変換するので、変数の中にある列挙型に対しては機能しません。そう：

nameof(AuthenticationMethod.FORMS) == "FORMS"

しかし...

var myMethod = AuthenticationMethod.FORMS;
nameof(myMethod) == "myMethod"

Answer 5

拡張メソッドを使います。

public static class AttributesHelperExtension
    {
        public static string ToDescription(this Enum value)
        {
            var da = (DescriptionAttribute[])(value.GetType().GetField(value.ToString())).GetCustomAttributes(typeof(DescriptionAttribute), false);
            return da.Length > 0 ? da[0].Description : value.ToString();
        }
}

enumを次のように飾ります。

public enum AuthenticationMethod
{
    [Description("FORMS")]
    FORMS = 1,
    [Description("WINDOWSAUTHENTICATION")]
    WINDOWSAUTHENTICATION = 2,
    [Description("SINGLESIGNON ")]
    SINGLESIGNON = 3
}

電話するとき

AuthenticationMethod.FORMS.ToDescription()あなたは"FORMS"を取得します。

Answer 6

ToString()メソッドを使うだけです

public enum any{Tomato=0,Melon,Watermelon}

文字列Tomatoを参照するには、単に

any.Tomato.ToString();

Answer 7

.Net 4.0以上でこれを解決する非常に簡単な方法です。他のコードは必要ありません。

public enum MyStatus
{
    Active = 1,
    Archived = 2
}

文字列を取得するには、単に使用します。

MyStatus.Active.ToString("f");

または

MyStatus.Archived.ToString("f");`

値は「Active」または「Archived」になります。

Enum.ToStringを呼び出すときに異なる文字列フォーマット（上から "f"）を見るにはthis 列挙フォーマット文字列 page

Answer 8

System.ComponentModel名前空間からDescription属性を使用します。単純に列挙型を装飾してから、それを取得するためにこのコードを使用します。

public static string GetDescription<T>(this object enumerationValue)
            where T : struct
        {
            Type type = enumerationValue.GetType();
            if (!type.IsEnum)
            {
                throw new ArgumentException("EnumerationValue must be of Enum type", "enumerationValue");
            }

            //Tries to find a DescriptionAttribute for a potential friendly name
            //for the enum
            MemberInfo[] memberInfo = type.GetMember(enumerationValue.ToString());
            if (memberInfo != null && memberInfo.Length > 0)
            {
                object[] attrs = memberInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);

                if (attrs != null && attrs.Length > 0)
                {
                    //Pull out the description value
                    return ((DescriptionAttribute)attrs[0]).Description;
                }
            }
            //If we have no description attribute, just return the ToString of the enum
            return enumerationValue.ToString();

        }

例として：

public enum Cycle : int
{        
   [Description("Daily Cycle")]
   Daily = 1,
   Weekly,
   Monthly
}

このコードは、 "Friendly name"を必要としないenumをうまく処理し、enumの.ToString（）だけを返します。

Answer 9

私はJakubŠturcの答えが本当に好きですが、それはあなたがswitch-caseステートメントと一緒に使うことができないということが欠点です。これが彼の答えを少し修正したもので、switch文と共に使用できます。

public sealed class AuthenticationMethod
{
    #region This code never needs to change.
    private readonly string _name;
    public readonly Values Value;

    private AuthenticationMethod(Values value, String name){
        this._name = name;
        this.Value = value;
    }

    public override String ToString(){
        return _name;
    }
    #endregion

    public enum Values
    {
        Forms = 1,
        Windows = 2,
        SSN = 3
    }

    public static readonly AuthenticationMethod FORMS = new AuthenticationMethod (Values.Forms, "FORMS");
    public static readonly AuthenticationMethod WINDOWSAUTHENTICATION = new AuthenticationMethod (Values.Windows, "WINDOWS");
    public static readonly AuthenticationMethod SINGLESIGNON = new AuthenticationMethod (Values.SSN, "SSN");
}

それで、あなたはJakubŠturcの答えのすべての恩恵を受けます、それに我々はそのようにswitch文でそれを使うことができます：

var authenticationMethodVariable = AuthenticationMethod.FORMS;  // Set the "enum" value we want to use.
var methodName = authenticationMethodVariable.ToString();       // Get the user-friendly "name" of the "enum" value.

// Perform logic based on which "enum" value was chosen.
switch (authenticationMethodVariable.Value)
{
    case authenticationMethodVariable.Values.Forms: // Do something
        break;
    case authenticationMethodVariable.Values.Windows: // Do something
        break;
    case authenticationMethodVariable.Values.SSN: // Do something
        break;      
}

Answer 10

私は上記のいくつかの提案と、いくつかのキャッシュを組み合わせて使用​​します。今、私はネット上のどこかで見つけたいくつかのコードからアイデアを得ました、しかし、私はそれをどこで得たかを思い出すことも、それを見つけることもできません。それで、誰かが似たようなものを見つけた場合は、その帰属についてコメントしてください。

とにかく、使用法はタイプコンバーターを含みます、それであなたがUIに拘束力があるならば、それは「ただ働きます」。 Jakubのパターンを使って型変換から静的メソッドに初期化することで、コードをすばやく検索することができます。

基本的な使い方は次のようになります。

[TypeConverter(typeof(CustomEnumTypeConverter<MyEnum>))]
public enum MyEnum
{
    // The custom type converter will use the description attribute
    [Description("A custom description")]
    ValueWithCustomDescription,

   // This will be exposed exactly.
   Exact
}

カスタム列挙型コンバータのコードは次のとおりです。

public class CustomEnumTypeConverter<T> : EnumConverter
    where T : struct
{
    private static readonly Dictionary<T,string> s_toString = 
      new Dictionary<T, string>();

    private static readonly Dictionary<string, T> s_toValue = 
      new Dictionary<string, T>();

    private static bool s_isInitialized;

    static CustomEnumTypeConverter()
    {
        System.Diagnostics.Debug.Assert(typeof(T).IsEnum,
          "The custom enum class must be used with an enum type.");
    }

    public CustomEnumTypeConverter() : base(typeof(T))
    {
        if (!s_isInitialized)
        {
            Initialize();
            s_isInitialized = true;
        }
    }

    protected void Initialize()
    {
        foreach (T item in Enum.GetValues(typeof(T)))
        {
            string description = GetDescription(item);
            s_toString[item] = description;
            s_toValue[description] = item;
        }
    }

    private static string GetDescription(T optionValue)
    {
        var optionDescription = optionValue.ToString();
        var optionInfo = typeof(T).GetField(optionDescription);
        if (Attribute.IsDefined(optionInfo, typeof(DescriptionAttribute)))
        {
            var attribute = 
              (DescriptionAttribute)Attribute.
                 GetCustomAttribute(optionInfo, typeof(DescriptionAttribute));
            return attribute.Description;
        }
        return optionDescription;
    }

    public override object ConvertTo(ITypeDescriptorContext context, 
       System.Globalization.CultureInfo culture, 
       object value, Type destinationType)
    {
        var optionValue = (T)value;

        if (destinationType == typeof(string) && 
            s_toString.ContainsKey(optionValue))
        {
            return s_toString[optionValue];
        }

        return base.ConvertTo(context, culture, value, destinationType);
    }

    public override object ConvertFrom(ITypeDescriptorContext context, 
       System.Globalization.CultureInfo culture, object value)
    {
        var stringValue = value as string;

        if (!string.IsNullOrEmpty(stringValue) && s_toValue.ContainsKey(stringValue))
        {
            return s_toValue[stringValue];
        }

        return base.ConvertFrom(context, culture, value);
    }
}

}

Answer 11

あなたの質問では、実際にはどこにでも列挙型の数値が必要だと言ったことはありません。

もしあなたが文字列型の列挙型（整数型ではないので列挙型のベースになることはできません）を必要としないのなら、ここにあります：

    static class AuthenticationMethod
    {
        public static readonly string
            FORMS = "Forms",
            WINDOWSAUTHENTICATION = "WindowsAuthentication";
    }

それを参照するのにenumと同じ構文を使うことができます

if (bla == AuthenticationMethod.FORMS)

数値よりも少し遅くなります（数字ではなく文字列を比較します）が、プラス面では、文字列へのアクセスにリフレクション（低速）を使用していません。

Answer 12

ほとんどの人にとって、私は選択された JakubŠturcによる回答 が本当に好きでしたが、私はコードをコピー＆ペーストすることも嫌いです。

それで、私はEnumBaseクラスが欲しいと決心しました。そこから大部分の機能が継承され/組み込まれていて、振る舞いの代わりに内容に集中することを私に残しました。

このアプローチの主な問題は、Enum値は型保証されたインスタンスであるが、相互作用はEnum Class型の静的実装によるものであるという事実に基づいています。だから、ジェネリックスの魔法の助けを借りて、私はついに正しいミックスを手に入れたと思います。誰かが私がそうしたようにこれが役に立つと思うことを願っています。

Jakubの例から始めますが、継承と総称を使用します。

public sealed class AuthenticationMethod : EnumBase<AuthenticationMethod, int>
{
    public static readonly AuthenticationMethod FORMS =
        new AuthenticationMethod(1, "FORMS");
    public static readonly AuthenticationMethod WINDOWSAUTHENTICATION =
        new AuthenticationMethod(2, "WINDOWS");
    public static readonly AuthenticationMethod SINGLESIGNON =
        new AuthenticationMethod(3, "SSN");

    private AuthenticationMethod(int Value, String Name)
        : base( Value, Name ) { }
    public new static IEnumerable<AuthenticationMethod> All
    { get { return EnumBase<AuthenticationMethod, int>.All; } }
    public static explicit operator AuthenticationMethod(string str)
    { return Parse(str); }
}

そして、これが基本クラスです。

using System;
using System.Collections.Generic;
using System.Linq; // for the .AsEnumerable() method call

// E is the derived type-safe-enum class
// - this allows all static members to be truly unique to the specific
//   derived class
public class EnumBase<E, T> where E: EnumBase<E, T>
{
    #region Instance code
    public T Value { get; private set; }
    public string Name { get; private set; }

    protected EnumBase(T EnumValue, string Name)
    {
        Value = EnumValue;
        this.Name = Name;
        mapping.Add(Name, this);
    }

    public override string ToString() { return Name; }
    #endregion

    #region Static tools
    static private readonly Dictionary<string, EnumBase<E, T>> mapping;
    static EnumBase() { mapping = new Dictionary<string, EnumBase<E, T>>(); }
    protected static E Parse(string name)
    {
        EnumBase<E, T> result;
        if (mapping.TryGetValue(name, out result))
        {
            return (E)result;
        }

        throw new InvalidCastException();
    }
    // This is protected to force the child class to expose it's own static
    // method.
    // By recreating this static method at the derived class, static
    // initialization will be explicit, promising the mapping dictionary
    // will never be empty when this method is called.
    protected static IEnumerable<E> All
    { get { return mapping.Values.AsEnumerable().Cast<E>(); } }
    #endregion
}

Answer 13

拡張方法としてこれをどのように解決しましたか。

using System.ComponentModel;
public static string GetDescription(this Enum value)
{
    var descriptionAttribute = (DescriptionAttribute)value.GetType()
        .GetField(value.ToString())
        .GetCustomAttributes(false)
        .Where(a => a is DescriptionAttribute)
        .FirstOrDefault();

    return descriptionAttribute != null ? descriptionAttribute.Description : value.ToString();
}

列挙型：

public enum OrderType
{
    None = 0,
    [Description("New Card")]
    NewCard = 1,
    [Description("Reload")]
    Refill = 2
}

使い方（o.OrderTypeはenumと同じ名前のプロパティです）

o.OrderType.GetDescription()

実際の列挙値NewCardとRefillの代わりに、 "New Card"または "Reload"の文字列が表示されます。

Answer 14

Keithに同意しますが、投票することはできません（まだ）。

私は欲しいものを正確に返すために静的メソッドとswithステートメントを使います。データベースにはtinyintを格納し、私のコードは実際のenumのみを使用するので、文字列はUIの要件に対応します。何度もテストした結果、これが最高のパフォーマンスと出力の制御をもたらしました。

public static string ToSimpleString(this enum)
{
     switch (enum)
     {
         case ComplexForms:
             return "ComplexForms";
             break;
     }
}

public static string ToFormattedString(this enum)
{
     switch (enum)
     {
         case ComplexForms:
             return "Complex Forms";
             break;
     }
}

しかし、いくつかのアカウントによると、これはメンテナンスの悪夢といくつかのコードの匂いを引き起こす可能性があります。私は長くてたくさんのenum、あるいは頻繁に変わるenumを見張っています。そうでなければ、これは私にとって素晴らしい解決策でした。

Answer 15

単純な "Enum"を実装しようとしているが、その値が整数ではなく文字列である場合は、最も簡単な解決策がここにあります。

    public sealed class MetricValueList
    {
        public static readonly string Brand = "A4082457-D467-E111-98DC-0026B9010912";
        public static readonly string Name = "B5B5E167-D467-E111-98DC-0026B9010912";
    }

実装：

var someStringVariable = MetricValueList.Brand;

Answer 16

私はこれを以下に引用されている記事へのコメントとして投稿したかったのですが、担当者が足りないためできませんでした。コードにエラーが含まれていたので、このソリューションを使用しようとしている個人にこれを指摘したいと思いました。

[TypeConverter(typeof(CustomEnumTypeConverter(typeof(MyEnum))]
public enum MyEnum
{
  // The custom type converter will use the description attribute
  [Description("A custom description")]
  ValueWithCustomDescription,
  // This will be exposed exactly.
  Exact
}

あるべき

[TypeConverter(typeof(CustomEnumTypeConverter<MyEnum>))]
public enum MyEnum
{
  // The custom type converter will use the description attribute
  [Description("A custom description")]
  ValueWithCustomDescription,

  // This will be exposed exactly.
  Exact
}

光り輝く！

Answer 17

この問題に直面したとき、最初に答えを見つけようとするいくつかの質問があります。

• 私のenum値の名前はその目的のために十分に分かりやすいですか、それとも私はより親切なものを提供する必要がありますか？
• 往復する必要がありますか？つまり、テキスト値を取得してそれらをenum値に解析する必要がありますか。
• これは私のプロジェクトの多くの列挙型に必要なことなのか、それとも1つだけなのでしょうか。
• この情報をどのようなUI要素で表示するのですか。特に、UIにバインドするのか、それともプロパティシートを使用するのでしょうか。
• ローカライズする必要がありますか？

これを行う最も簡単な方法はEnum.GetValueを使うことです（そしてEnum.Parseを使ったラウンドトリップをサポートします）。 Steve Mitchamが示唆しているように、UIバインディングをサポートするためにTypeConverterを構築する価値もあります。 （プロパティシートを使用するときにTypeConverterを作成する必要はありません。これは、プロパティシートに関する素晴らしい点の1つです。ただし、それらには独自の問題があることはわかっています。）

一般的に、上記の質問に対する答えがうまくいかないことを示唆している場合、私の次のステップは静的なDictionary<MyEnum, string>、あるいはおそらくDictionary<Type, Dictionary<int, string>>を作成して投入することです。私は中間の属性付きコードの装飾のステップをスキップする傾向があります。それは、通常次に展開されるのは、配置後にフレンドリ値を変更する必要があるからです（ローカライズのために、いつもではない）.

Answer 18

私の変種

public struct Colors
{
    private String current;

    private static string red = "#ff0000";
    private static string green = "#00ff00";
    private static string blue = "#0000ff";

    private static IList<String> possibleColors; 

    public static Colors Red { get { return (Colors) red; } }
    public static Colors Green { get { return (Colors) green; } }
    public static Colors Blue { get { return (Colors) blue; } }

    static Colors()
    {
        possibleColors = new List<string>() {red, green, blue};
    }

    public static explicit operator String(Colors value)
    {
        return value.current;
    }

    public static explicit operator Colors(String value)
    {
        if (!possibleColors.Contains(value))
        {
            throw new InvalidCastException();
        }

        Colors color = new Colors();
        color.current = value;
        return color;
    }

    public static bool operator ==(Colors left, Colors right)
    {
        return left.current == right.current;
    }

    public static bool operator !=(Colors left, Colors right)
    {
        return left.current != right.current;
    }

    public bool Equals(Colors other)
    {
        return Equals(other.current, current);
    }

    public override bool Equals(object obj)
    {
        if (ReferenceEquals(null, obj)) return false;
        if (obj.GetType() != typeof(Colors)) return false;
        return Equals((Colors)obj);
    }

    public override int GetHashCode()
    {
        return (current != null ? current.GetHashCode() : 0);
    }

    public override string ToString()
    {
        return current;
    }
}

コードは少し醜いように見えますが、この構造体の使用法は実に見やすくなっています。

Colors color1 = Colors.Red;
Console.WriteLine(color1); // #ff0000

Colors color2 = (Colors) "#00ff00";
Console.WriteLine(color2); // #00ff00

// Colors color3 = "#0000ff"; // Compilation error
// String color4 = Colors.Red; // Compilation error

Colors color5 = (Colors)"#ff0000";
Console.WriteLine(color1 == color5); // True

Colors color6 = (Colors)"#00ff00";
Console.WriteLine(color1 == color6); // False

また、そのような列挙型がたくさん必要な場合は、コード生成（T4など）を使用することも考えられます。

Answer 19

オプション1：

public sealed class FormsAuth
{
     public override string ToString{return "Forms Authtentication";}
}
public sealed class WindowsAuth
{
     public override string ToString{return "Windows Authtentication";}
}

public sealed class SsoAuth
{
     public override string ToString{return "SSO";}
}

その後

object auth = new SsoAuth(); //or whatever

//...
//...
// blablabla

DoSomethingWithTheAuth(auth.ToString());

オプション2：

public enum AuthenticationMethod
{
        FORMS = 1,
        WINDOWSAUTHENTICATION = 2,
        SINGLESIGNON = 3
}

public class MyClass
{
    private Dictionary<AuthenticationMethod, String> map = new Dictionary<AuthenticationMethod, String>();
    public MyClass()
    {
         map.Add(AuthenticationMethod.FORMS,"Forms Authentication");
         map.Add(AuthenticationMethod.WINDOWSAUTHENTICATION ,"Windows Authentication");
         map.Add(AuthenticationMethod.SINGLESIGNON ,"SSo Authentication");
    }
}

Answer 20

私にとっては、実用的なアプローチは、クラス内のクラス、サンプルです。

public class MSEModel
{
    class WITS
    {
        public const string DATE = "5005";
        public const string TIME = "5006";
        public const string MD = "5008";
        public const string ROP = "5075";
        public const string WOB = "5073";
        public const string RPM = "7001";
... 
    }

Answer 21

私たちが解決しようとしている問題について考えても、それは私たちが必要とする列挙型ではありません。特定の数の値を互いに関連付けることを可能にするオブジェクトが必要です。言い換えれば、クラスを定義することです。

JakubŠturcの型保証されたenumパターンは私がここで見る最良の選択肢です。

それを見ろ：

• それはプライベートコンストラクタを持っているのでクラスだけが許容値を定義することができます。
• これはシールされたクラスなので、継承によって値を変更することはできません。
• それはタイプセーフであり、あなたのメソッドがそのタイプだけを要求することを可能にします。
• 値にアクセスすることによる反射性能の低下はありません。
• 最後に、名前、説明、数値など、3つ以上のフィールドを関連付けるように変更できます。

Answer 22

ここにはたくさんの素晴らしい答えがありましたが、私の場合は「文字列enum」から必要なものを解決できませんでした。

1. Switchステートメント（例：switch（myEnum））で使用可能
2. 関数パラメータに使用できます。 foo（myEnumタイプ）
3. 参照できます。 myEnum.FirstElement
4. 私は文字列を使用することができます。 foo（ "FirstElement"）== foo（myEnum.FirstElement）

1,2と4は実際には文字列のC＃Typedefで解決できます（文字列はc＃で切り替え可能なので）

3は静的なconst文字列で解くことができます。同じニーズがある場合は、これが最も簡単な方法です。

public sealed class Types
{

    private readonly String name;

    private Types(String name)
    {
        this.name = name;

    }

    public override String ToString()
    {
        return name;
    }

    public static implicit operator Types(string str)
    {
        return new Types(str);

    }
    public static implicit operator string(Types str)
    {
        return str.ToString();
    }


    #region enum

    public const string DataType = "Data";
    public const string ImageType = "Image";
    public const string Folder = "Folder";
    #endregion

}

これにより、次のようになります。

    public TypeArgs(Types SelectedType)
    {
        Types SelectedType = SelectedType
    }

そして

public TypeObject CreateType(Types type)
    {
        switch (type)
        {

            case Types.ImageType:
              //
                break;

            case Types.DataType:
             //
                break;

        }
    }

CreateTypeは文字列または型で呼び出すことができます。 しかし、欠点は、どの文字列も自動的に有効なenumになることです 、これは修正することができますが、ある種のinit関数が必要になります。

もしint値があなたにとって重要だったら（おそらく比較のスピードのために）、あなたはJakubŠturcからのいくつかのアイデアを素晴らしい答えを使ってbitクレイジー）をやることができます。

    public sealed class Types
{
    private static readonly Dictionary<string, Types> strInstance = new Dictionary<string, Types>();
    private static readonly Dictionary<int, Types> intInstance = new Dictionary<int, Types>();

    private readonly String name;
    private static int layerTypeCount = 0;
    private int value;
    private Types(String name)
    {
        this.name = name;
        value = layerTypeCount++;
        strInstance[name] = this;
        intInstance[value] = this;
    }

    public override String ToString()
    {
        return name;
    }


    public static implicit operator Types(int val)
    {
        Types result;
        if (intInstance.TryGetValue(val, out result))
            return result;
        else
            throw new InvalidCastException();
    }

    public static implicit operator Types(string str)
    {
        Types result;
        if (strInstance.TryGetValue(str, out result))
        {
            return result;
        }
        else
        {
            result = new Types(str);
            return result;
        }

    }
    public static implicit operator string(Types str)
    {
        return str.ToString();
    }

    public static bool operator ==(Types a, Types b)
    {
        return a.value == b.value;
    }
    public static bool operator !=(Types a, Types b)
    {
        return a.value != b.value;
    }

    #region enum

    public const string DataType = "Data";
    public const string ImageType = "Image";

    #endregion

}

しかしもちろん「タイプbob = 4」。あなたが最初にそれらを初期化していなければ意味がないでしょう。

しかし理論的にはTypeA == TypeBの方が速いでしょう….

Answer 23

私があなたを正しく理解しているならば、あなたは単に値からenumの名前を検索するために.ToString（）を使うことができます（それがEnumとして既にキャストされていると仮定して）。あなたが裸のintを持っていたならば（データベースか何かから言うことができます）、あなたは最初にenumにそれをキャストすることができます。以下の両方の方法はあなたにenum名を取得します。

AuthenticationMethod myCurrentSetting = AuthenticationMethod.FORMS;
Console.WriteLine(myCurrentSetting); // Prints: FORMS
string name = Enum.GetNames(typeof(AuthenticationMethod))[(int)myCurrentSetting-1];
Console.WriteLine(name); // Prints: FORMS

ただし、2つ目の方法では、intを使用していて、インデックスが1ベースである（0ベースではない）と想定しています。関数GetNamesも比較するとかなり重いので、呼び出されるたびに配列全体を生成しています。最初の手法でわかるように、実際には.ToString（）が暗黙的に呼び出されます。これらは両方とももちろんすでに答えの中で言及されています、私はただそれらの違いを明確にしようとしています。

Answer 24

古い投稿だが...

これに対する答えは、実際には非常に単純です。 Enum.ToString（） functionを使用してください。

この関数には6つのオーバーロードがあり、Enum.Tostring（ "F"）またはEnum.ToString（）を使用して文字列値を返すことができます。他に何も気にする必要はありません。ここに 働くデモです

この解決法はすべてのコンパイラでうまくいくとは限らないことに注意してください（ このデモは期待通りに動作しない ）が、少なくとも最新のコンパイラではうまくいきます。

Answer 25

これは、文字列を列挙型に関連付けるというタスクを実行するためのさらに別の方法です。

struct DATABASE {
    public enum enums {NOTCONNECTED, CONNECTED, ERROR}
    static List<string> strings =
        new List<string>() {"Not Connected", "Connected", "Error"};

    public string GetString(DATABASE.enums value) {
        return strings[(int)value];
    }
}

このメソッドは次のように呼ばれます。

public FormMain() {
    DATABASE dbEnum;

    string enumName = dbEnum.GetString(DATABASE.enums.NOTCONNECTED);
}

関連する列挙型をそれら自身の構造体にまとめることができます。このメソッドは列挙型を使用しているため、GetString()呼び出しを行うときにIntellisenseを使用して列挙のリストを表示できます。

オプションでDATABASE構造体にnew演算子を使用できます。これを使用しないと、文字列Listは最初のGetString()呼び出しが行われるまで割り当てられません。

Answer 26

mSDNに基づいて： http://msdn.Microsoft.com/en-us/library/cc138362.aspx

foreach (string str in Enum.GetNames(typeof(enumHeaderField)))
{
    Debug.WriteLine(str);
}

strはフィールドの名前になります

Answer 27

より大きい文字列列挙セットの場合、リストされた例は面倒になることがあります。ステータスコードのリスト、または他の文字列ベースの列挙体のリストが必要な場合は、属性システムを使用するのが面倒で、それ自体のインスタンスを含む静的クラスを構成するのが面倒です。私自身の解決策のために、私はそれをより簡単にするためにT4テンプレートを利用します。結果はHttpMethodクラスがどのように機能するかに似ています。

あなたはこのようにそれを使うことができます：

    string statusCode = ResponseStatusCode.SUCCESS; // Automatically converts to string when needed
    ResponseStatusCode codeByValueOf = ResponseStatusCode.ValueOf(statusCode); // Returns null if not found

    // Implements TypeConverter so you can use it with string conversion methods.
    var converter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(ResponseStatusCode));
    ResponseStatusCode code = (ResponseStatusCode) converter.ConvertFromInvariantString(statusCode);

    // You can get a full list of the values
    bool canIterateOverValues = ResponseStatusCode.Values.Any(); 

    // Comparisons are by value of the "Name" property. Not by memory pointer location.
    bool implementsByValueEqualsEqualsOperator = "SUCCESS" == ResponseStatusCode.SUCCESS; 

あなたはEnum.ttファイルから始めます。

<#@ include file="StringEnum.ttinclude" #>


<#+
public static class Configuration
{
    public static readonly string Namespace = "YourName.Space";
    public static readonly string EnumName = "ResponseStatusCode";
    public static readonly bool IncludeComments = true;

    public static readonly object Nodes = new
    {
        SUCCESS = "The response was successful.",
        NON_SUCCESS = "The request was not successful.",
        RESOURCE_IS_DISCONTINUED = "The resource requested has been discontinued and can no longer be accessed."
    };
}
#>

その後、StringEnum.ttincludeファイルに追加します。

<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ Assembly name="System.Core" #>
<#@ import namespace="System" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Reflection" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#@ CleanupBehavior processor="T4VSHost" CleanupAfterProcessingtemplate="true" #>

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;

namespace <#= Configuration.Namespace #>
{
    /// <summary>
    /// TypeConverter implementations allow you to use features like string.ToNullable(T).
    /// </summary>
    public class <#= Configuration.EnumName #>TypeConverter : TypeConverter
    {
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
        {
            return sourceType == typeof(string) || base.CanConvertFrom(context, sourceType);
        }

        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
        {
            var casted = value as string;

            if (casted != null)
            {
                var result = <#= Configuration.EnumName #>.ValueOf(casted);
                if (result != null)
                {
                    return result;
                }
            }

            return base.ConvertFrom(context, culture, value);
        }

        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
        {
            var casted = value as <#= Configuration.EnumName #>;
            if (casted != null && destinationType == typeof(string))
            {
                return casted.ToString();
            }

            return base.ConvertTo(context, culture, value, destinationType);
        }
    }

    [TypeConverter(typeof(<#= Configuration.EnumName #>TypeConverter))]
    public class <#= Configuration.EnumName #> : IEquatable<<#= Configuration.EnumName #>>
    {
//---------------------------------------------------------------------------------------------------
// V A L U E S _ L I S T
//---------------------------------------------------------------------------------------------------
<# Write(Helpers.PrintEnumProperties(Configuration.Nodes)); #>

        private static List<<#= Configuration.EnumName #>> _list { get; set; } = null;
        public static List<<#= Configuration.EnumName #>> ToList()
        {
            if (_list == null)
            {
                _list = typeof(<#= Configuration.EnumName #>).GetFields().Where(x => x.IsStatic && x.IsPublic && x.FieldType == typeof(<#= Configuration.EnumName #>))
                    .Select(x => x.GetValue(null)).OfType<<#= Configuration.EnumName #>>().ToList();
            }

            return _list;
        }

        public static List<<#= Configuration.EnumName #>> Values()
        {
            return ToList();
        }

        /// <summary>
        /// Returns the enum value based on the matching Name of the enum. Case-insensitive search.
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static <#= Configuration.EnumName #> ValueOf(string key)
        {
            return ToList().FirstOrDefault(x => string.Compare(x.Name, key, true) == 0);
        }


//---------------------------------------------------------------------------------------------------
// I N S T A N C E _ D E F I N I T I O N
//---------------------------------------------------------------------------------------------------      
        public string Name { get; private set; }
        public string Description { get; private set; }
        public override string ToString() { return this.Name; }

        /// <summary>
        /// Implcitly converts to string.
        /// </summary>
        /// <param name="d"></param>
        public static implicit operator string(<#= Configuration.EnumName #> d)
        {
            return d.ToString();
        }

        /// <summary>
        /// Compares based on the == method. Handles nulls gracefully.
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public static bool operator !=(<#= Configuration.EnumName #> a, <#= Configuration.EnumName #> b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Compares based on the .Equals method. Handles nulls gracefully.
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public static bool operator ==(<#= Configuration.EnumName #> a, <#= Configuration.EnumName #> b)
        {
            return a?.ToString() == b?.ToString();
        }

        /// <summary>
        /// Compares based on the .ToString() method
        /// </summary>
        /// <param name="o"></param>
        /// <returns></returns>
        public override bool Equals(object o)
        {
            return this.ToString() == o?.ToString();
        }

        /// <summary>
        /// Compares based on the .ToString() method
        /// </summary>
        /// <param name="other"></param>
        /// <returns></returns>
        public bool Equals(<#= Configuration.EnumName #> other)
        {
            return this.ToString() == other?.ToString();
        }

        /// <summary>
        /// Compares based on the .Name property
        /// </summary>
        /// <returns></returns>
        public override int GetHashCode()
        {
            return this.Name.GetHashCode();
        }
    }
}

<#+

public static class Helpers
{
        public static string PrintEnumProperties(object nodes)
        {
            string o = "";
            Type nodesTp = Configuration.Nodes.GetType();
            PropertyInfo[] props = nodesTp.GetProperties().OrderBy(p => p.Name).ToArray();

            for(int i = 0; i < props.Length; i++)
            {
                var prop = props[i];
                if (Configuration.IncludeComments)
                {
                    o += "\r\n\r\n";
                    o += "\r\n        ///<summary>";
                    o += "\r\n        /// "+Helpers.PrintPropertyValue(prop, Configuration.Nodes);
                    o += "\r\n        ///</summary>";
                }

                o += "\r\n        public static readonly "+Configuration.EnumName+" "+prop.Name+ " = new "+Configuration.EnumName+"(){ Name = \""+prop.Name+"\", Description = "+Helpers.PrintPropertyValue(prop, Configuration.Nodes)+ "};";
            }

            o += "\r\n\r\n";

            return o;
        }

        private static Dictionary<string, string> GetValuesMap()
        {
            Type nodesTp = Configuration.Nodes.GetType();
            PropertyInfo[] props= nodesTp.GetProperties();
            var dic = new Dictionary<string,string>();
            for(int i = 0; i < props.Length; i++)
            {
                var prop = nodesTp.GetProperties()[i];
                dic[prop.Name] = prop.GetValue(Configuration.Nodes).ToString();
            }
            return dic;
        }

        public static string PrintMasterValuesMap(object nodes)
        {
            Type nodesTp = Configuration.Nodes.GetType();
            PropertyInfo[] props= nodesTp.GetProperties();
            string o = "        private static readonly Dictionary<string, string> ValuesMap = new Dictionary<string, string>()\r\n        {";
            for(int i = 0; i < props.Length; i++)
            {
                var prop = nodesTp.GetProperties()[i];
                o += "\r\n            { \""+prop.Name+"\", "+(Helpers.PrintPropertyValue(prop,Configuration.Nodes)+" },");
            }
            o += ("\r\n        };\r\n");

            return o;
        }


        public static string PrintPropertyValue(PropertyInfo prop, object objInstance)
        {
            switch(prop.PropertyType.ToString()){
                case "System.Double":
                    return prop.GetValue(objInstance).ToString()+"D";
                case "System.Float":
                    return prop.GetValue(objInstance).ToString()+"F";
                case "System.Decimal":
                    return prop.GetValue(objInstance).ToString()+"M";
                case "System.Long":
                    return prop.GetValue(objInstance).ToString()+"L";
                case "System.Boolean":
                case "System.Int16":
                case "System.Int32":
                    return prop.GetValue(objInstance).ToString().ToLowerInvariant();
                case "System.String":
                    return "\""+prop.GetValue(objInstance)+"\"";
            }

            return prop.GetValue(objInstance).ToString();
        }

        public static string _ (int numSpaces)
        {
            string o = "";
            for(int i = 0; i < numSpaces; i++){
                o += " ";
            }

            return o;
        }
}
#>

最後に、Enum.ttファイルを再コンパイルすると、出力は次のようになります。

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

using System;
using System.Linq;
using System.Collections.Generic;

namespace YourName.Space
{
    public class ResponseStatusCode
    {
//---------------------------------------------------------------------------------------------------
// V A L U E S _ L I S T 
//---------------------------------------------------------------------------------------------------



        ///<summary>
        /// "The response was successful."
        ///</summary>
        public static readonly ResponseStatusCode SUCCESS = new ResponseStatusCode(){ Name = "SUCCESS", Description = "The response was successful."};


        ///<summary>
        /// "The request was not successful."
        ///</summary>
        public static readonly ResponseStatusCode NON_SUCCESS = new ResponseStatusCode(){ Name = "NON_SUCCESS", Description = "The request was not successful."};


        ///<summary>
        /// "The resource requested has been discontinued and can no longer be accessed."
        ///</summary>
        public static readonly ResponseStatusCode RESOURCE_IS_DISCONTINUED = new ResponseStatusCode(){ Name = "RESOURCE_IS_DISCONTINUED", Description = "The resource requested has been discontinued and can no longer be accessed."};


        private static List<ResponseStatusCode> _list { get; set; } = null;
        public static List<ResponseStatusCode> ToList()
        {
            if (_list == null)
            {
                _list = typeof(ResponseStatusCode).GetFields().Where(x => x.IsStatic && x.IsPublic && x.FieldType == typeof(ResponseStatusCode))
                    .Select(x => x.GetValue(null)).OfType<ResponseStatusCode>().ToList();
            }

            return _list;
        }

        public static List<ResponseStatusCode> Values()
        {
            return ToList();
        }

        /// <summary>
        /// Returns the enum value based on the matching Name of the enum. Case-insensitive search.
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static ResponseStatusCode ValueOf(string key)
        {
            return ToList().FirstOrDefault(x => string.Compare(x.Name, key, true) == 0);
        }


//---------------------------------------------------------------------------------------------------
// I N S T A N C E _ D E F I N I T I O N 
//---------------------------------------------------------------------------------------------------       
        public string Name { get; set; }
        public string Description { get; set; }
        public override string ToString() { return this.Name; }

        /// <summary>
        /// Implcitly converts to string.
        /// </summary>
        /// <param name="d"></param>
        public static implicit operator string(ResponseStatusCode d)
        {
            return d.ToString();
        }

        /// <summary>
        /// Compares based on the == method. Handles nulls gracefully.
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public static bool operator !=(ResponseStatusCode a, ResponseStatusCode b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Compares based on the .Equals method. Handles nulls gracefully.
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public static bool operator ==(ResponseStatusCode a, ResponseStatusCode b)
        {
            return a?.ToString() == b?.ToString();
        }

        /// <summary>
        /// Compares based on the .ToString() method
        /// </summary>
        /// <param name="o"></param>
        /// <returns></returns>
        public override bool Equals(object o)
        {
            return this.ToString() == o?.ToString();
        }

        /// <summary>
        /// Compares based on the .Name property
        /// </summary>
        /// <returns></returns>
        public override int GetHashCode()
        {
            return this.Name.GetHashCode();
        }
    }
}

Answer 28

さて、上記すべてを読んだ後、私はみんなが列挙子を文字列に変換する問題を過度に複雑にしたと感じます。列挙フィールドの上に属性を持つというアイデアは好きでしたが、属性は主にメタデータに使用されると思いますが、あなたの場合、必要なのはある種のローカライズだけであると思います。

public enum Color 
{ Red = 1, Green = 2, Blue = 3}


public static EnumUtils 
{
   public static string GetEnumResourceString(object enumValue)
    {
        Type enumType = enumValue.GetType();
        string value = Enum.GetName(enumValue.GetType(), enumValue);
        string resourceKey = String.Format("{0}_{1}", enumType.Name, value);
        string result = Resources.Enums.ResourceManager.GetString(resourceKey);
        if (string.IsNullOrEmpty(result))
        {
            result = String.Format("{0}", value);
        }
        return result;
    }
}

上記のメソッドを呼び出そうとすると、次のように呼び出せます。

public void Foo()
{
  var col = Color.Red;
  Console.WriteLine (EnumUtils.GetEnumResourceString (col));
}

必要なのは、すべての列挙値と対応する文字列を含むリソースファイルを作成することだけです。

リソース名リソース値
 Color_Red私の文字列の色を赤
 Color_Blue Blueeey 
 Color_Greenハルク色

実際にとてもいいのは、アプリケーションをローカライズする必要がある場合に非常に役立つということです。必要なのは新しい言語で別のリソースファイルを作成することだけです。とヴォラ！

Answer 29

そのような状況にあるとき、私は以下の解決策を提案します。

そして消費クラスとしてあなたが持つことができる

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyApp.Dictionaries
{
    class Greek
    {

        public static readonly string Alpha = "Alpha";
        public static readonly string Beta = "Beta";
        public static readonly string Gamma = "Gamma";
        public static readonly string Delta = "Delta";


        private static readonly BiDictionary<int, string> Dictionary = new BiDictionary<int, string>();


        static Greek() {
            Dictionary.Add(1, Alpha);
            Dictionary.Add(2, Beta);
            Dictionary.Add(3, Gamma);
            Dictionary.Add(4, Delta);
        }

        public static string getById(int id){
            return Dictionary.GetByFirst(id);
        }

        public static int getByValue(string value)
        {
            return Dictionary.GetBySecond(value);
        }

    }
}

双方向辞書を使用する：これに基づき（ https://stackoverflow.com/a/255638/986160 ）、キーは辞書の単一の値に関連付けられ、（ https：/ /stackoverflow.com/a/255630/986160 ）しかし、もう少しエレガントです。この辞書も列挙でき、あなたは整数から文字列へと行き来することができます。また、このクラスを除いて、コードベースに文字列を含める必要はありません。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace MyApp.Dictionaries
{

    class BiDictionary<TFirst, TSecond> : IEnumerable
    {
        IDictionary<TFirst, TSecond> firstToSecond = new Dictionary<TFirst, TSecond>();
        IDictionary<TSecond, TFirst> secondToFirst = new Dictionary<TSecond, TFirst>();

        public void Add(TFirst first, TSecond second)
        {
            firstToSecond.Add(first, second);
            secondToFirst.Add(second, first);
        }

        public TSecond this[TFirst first]
        {
            get { return GetByFirst(first); }
        }

        public TFirst this[TSecond second]
        {
            get { return GetBySecond(second); }
        }

        public TSecond GetByFirst(TFirst first)
        {
            return firstToSecond[first];
        }

        public TFirst GetBySecond(TSecond second)
        {
            return secondToFirst[second];
        }

        public IEnumerator GetEnumerator()
        {
            return GetFirstEnumerator();
        }

        public IEnumerator GetFirstEnumerator()
        {
            return firstToSecond.GetEnumerator();
        }

        public IEnumerator GetSecondEnumerator()
        {
            return secondToFirst.GetEnumerator();
        }
    }
}

Answer 30

この質問にはすでに答えられており、OPはすでに受け入れられている答えに満足していることを私はよく知っています。しかし、私は、受け入れられたものも含めて、ほとんどの答えがもう少し複雑であることに気付きました。

私はこのような状況を私に与えたプロジェクトを持っています、そして私はこのようにそれを達成することができました。

まず、列挙型の名前の大文字と小文字の区別を考慮する必要があります。

public enum AuthenticationMethod
{
    Forms = 1,
    WindowsAuthentication = 2,
    SingleSignOn = 3
}

その後、この拡張子を持っています：

using System.Text.RegularExpression;

public static class AnExtension
{
    public static string Name(this Enum value)
    {
        string strVal = value.ToString();
        try
        {
            return Regex.Replace(strVal, "([a-z])([A-Z])", "$1 $2");
        }
        catch
        {
        }
        return strVal;
    }
}

これによって、あなたはすべてのenum名をスペースで区切られた各Wordでの文字列表現に変えることができます。例：

AuthenticationMethod am = AuthenticationMethod.WindowsAuthentication;
MessageBox.Show(am.Name());

Answer 31

Enum.GetName(typeof(MyEnum), (int)MyEnum.FORMS)
Enum.GetName(typeof(MyEnum), (int)MyEnum.WINDOWSAUTHENTICATION)
Enum.GetName(typeof(MyEnum), (int)MyEnum.SINGLESIGNON)

出力は以下のとおりです。

「フォーム」

「ウィンドウセキュリティ」

"シングル・サインオン"

Answer 32

object Enum.Parse（System.Type enumType、文字列値、ブールignoreCase）を使用してください。 から入手した http://blogs.msdn.com/b/tims/archive/2004/04/02/106310.aspx

Answer 33

列挙型と、キーが列挙型の値になるディクショナリを宣言できます。将来的には、辞書を参照して値を取得できます。したがって、列挙型として関数にパラメーターを渡すことは可能ですが、辞書から実際の値を取得することができます。

using System;
using System.Collections.Generic;

namespace console_test
{
    class Program
    {
        #region SaveFormat
        internal enum SaveFormat
        {
            DOCX,
            PDF
        }

        internal static Dictionary<SaveFormat,string> DictSaveFormat = new Dictionary<SaveFormat, string>
        {
            { SaveFormat.DOCX,"This is value for DOCX enum item" },
            { SaveFormat.PDF,"This is value for PDF enum item" }
        };

        internal static void enum_value_test(SaveFormat save_format)
        {
            Console.WriteLine(DictSaveFormat[save_format]);
        }
        #endregion

        internal static void Main(string[] args)
        {
            enum_value_test(SaveFormat.DOCX);//Output: This is value for DOCX enum item
            Console.Write("Press any key to continue . . . ");
            Console.ReadKey(true);
        }
    }
}

Answer 34

私の答えは、@ user29964の答え（これははるかに単純で、Enumに最も近いものです）に取り組んでいます。

 public class StringValue : System.Attribute
    {
        private string _value;

        public StringValue(string value)
        {
            _value = value;
        }

        public string Value
        {
            get { return _value; }
        }



        public static string GetStringValue(Enum Flagvalue)
        {
            Type type = Flagvalue.GetType();
            string[] flags = Flagvalue.ToString().Split(',').Select(x => x.Trim()).ToArray();
            List<string> values = new List<string>();

            for (int i = 0; i < flags.Length; i++)
            {

                FieldInfo fi = type.GetField(flags[i].ToString());

                StringValue[] attrs =
                   fi.GetCustomAttributes(typeof(StringValue),
                                           false) as StringValue[];
                if (attrs.Length > 0)
                {
                    values.Add(attrs[0].Value);
                }
            }
            return String.Join(",", values);

        }

使用法

[Flags]
    public enum CompeteMetric
    {

        /// <summary>
        /// u
        /// </summary>
        [StringValue("u")]//Json mapping
        Basic_UniqueVisitors = 1 //Basic
             ,
        /// <summary>
        /// vi
        /// </summary>
        [StringValue("vi")]//json mapping
        Basic_Visits = 2// Basic
            ,
        /// <summary>
        /// rank
        /// </summary>
        [StringValue("rank")]//json mapping
        Basic_Rank = 4//Basic
 }

例

        CompeteMetric metrics = CompeteMetric.Basic_Visits | CompeteMetric.Basic_Rank;
        string strmetrics = StringValue.GetStringValue(metrics);

これは "vi、rank"を返します

Answer 35

私はHarveyと一緒ですが、constは使わないでください。私は文字列、整数、何でも混在させることができます。

public class xlsLayout
{
    public int xlHeaderRow = 1;
    public int xlFirstDataRow = 2;
    public int xlSkipLinesBetweenFiles = 1; //so 0 would mean don't skip
    public string xlFileColumn = "A";
    public string xlFieldColumn = "B";
    public string xlFreindlyNameColumn = "C";
    public string xlHelpTextColumn = "D";
}

じゃあ後で ...

public partial class Form1 : Form
{
    xlsLayout xlLayout = new xlsLayout();

    xl.SetCell(xlLayout.xlFileColumn, xlLayout.xlHeaderRow, "File Name");
    xl.SetCell(xlLayout.xlFieldColumn, xlLayout.xlHeaderRow, "Code field name");
    xl.SetCell(xlLayout.xlFreindlyNameColumn, xlLayout.xlHeaderRow, "Freindly name");
    xl.SetCell(xlLayout.xlHelpTextColumn, xlLayout.xlHeaderRow, "Inline Help Text");
}

Answer 36

Enumの国際化、またはそれぞれのリソースファイルからEnumのテキストを取得するために私が見つけたアプローチは、DescriptionAttributeクラスを継承することによって属性クラスを作成することです。

public class EnumResourceAttribute : DescriptionAttribute
{

    public Type ResourceType { get; private set; }
    public string ResourceName { get; private set; }
    public int SortOrder { get; private set; }
    public EnumResourceAttribute(Type ResourceType,
                         string ResourceName,
                         int SortOrder)
    {

        this.ResourceType = ResourceType;
        this.ResourceName = ResourceName;
        this.SortOrder = SortOrder;
    }
}

GetStringとGetStringsの拡張メソッドを提供する別のStaticクラスを作成します。

public static class EnumHelper
{
    public static string GetString(this Enum value)
    {
        EnumResourceAttribute ea =
       (EnumResourceAttribute)value.GetType().GetField(value.ToString())
        .GetCustomAttributes(typeof(EnumResourceAttribute), false)
         .FirstOrDefault();
        if (ea != null)
        {
            PropertyInfo pi = ea.ResourceType
             .GetProperty(CommonConstants.ResourceManager);
            if (pi != null)
            {
                ResourceManager rm = (ResourceManager)pi
                .GetValue(null, null);
                return rm.GetString(ea.ResourceName);
            }

        }
        return string.Empty;
    }


    public static IList GetStrings(this Type enumType)
    {
        List<string> stringList = new List<string>();
        FieldInfo[] fiArray = enumType.GetFields();
        foreach (FieldInfo fi in fiArray)
        {
            EnumResourceAttribute ea =
                (EnumResourceAttribute)fi
                     .GetCustomAttributes(typeof(EnumResourceAttribute), false)
                     .FirstOrDefault();
            if (ea != null)
            {
                PropertyInfo pi = ea.ResourceType
                                    .GetProperty(CommonConstants.ResourceManager);
                if (pi != null)
                {
                    ResourceManager rm = (ResourceManager)pi
                                          .GetValue(null, null);
                    stringList.Add(rm.GetString(ea.ResourceName));
                }
            }
        }
        return stringList.ToList();
    }
}

そしてあなたのEnumの要素にあなたは書くことができる：

public enum Priority
{
     [EnumResourceAttribute(typeof(Resources.AdviceModule), Resources.ResourceNames.AdviceCreateAdviceExternaPriorityMemberHigh, 1)]
    High,
     [EnumResourceAttribute(typeof(Resources.AdviceModule), Resources.ResourceNames.AdviceCreateAdviceExternaPriorityMemberRoutine, 2)]
    Routine
}

Resources.ResourceNames.AdviceCreateAdviceExternaPriorityMemberHigh＆Resources.ResourceNames.AdviceCreateAdviceExternaPriorityMemberRoutineはリソースファイル内の定数であるか、または値をさまざまなカルチャで使用できるようにすることができます。

WebアプリケーションをMVCアーキテクチャで実装している場合は、プロパティを作成します。

private IList result;
public IList Result
{
    get
    {
        result = typeof(Priority).GetStrings();
        return result;
    }
}

そしてあなたの.cshtmlファイルの中であなたはちょうどあなたのドロップダウンリストに列挙型をバインドすることができます：

@Html.DropDownListFor(model => Model.vwClinicalInfo.Priority, new SelectList(Model.Result))

ありがとうラトネシュ