จะกำหนด enum ด้วยค่าสตริงได้อย่างไร?

ฉันกำลังพยายามกำหนดEnumและเพิ่มตัวคั่นทั่วไปที่ถูกต้องซึ่งใช้ใน CSV หรือไฟล์ที่คล้ายกัน จากนั้นฉันจะเชื่อมโยงกับComboBoxแหล่งข้อมูลเป็นแหล่งข้อมูลดังนั้นเมื่อใดก็ตามที่ฉันเพิ่มหรือลบออกจากนิยาม Enum ฉันไม่จำเป็นต้องเปลี่ยนแปลงอะไรในกล่องคำสั่งผสม

ปัญหาคือฉันจะกำหนด enum ด้วยการแทนค่าสตริงได้อย่างไร:

public enum SeparatorChars{Comma = ",", Tab = "\t", Space = " "}

คุณทำไม่ได้ - ค่า enum ต้องเป็นค่าอินทิกรัล คุณสามารถใช้แอตทริบิวต์เพื่อเชื่อมโยงค่าสตริงกับแต่ละค่า enum หรือในกรณีนี้ถ้าตัวคั่นทุกตัวเป็นอักขระเดี่ยวคุณสามารถใช้charค่า:

enum Separator
{
    Comma = ',',
    Tab = '\t',
    Space = ' '
}

(แก้ไข: เพื่อชี้แจงคุณไม่สามารถสร้างcharประเภทพื้นฐานของ enum ได้ แต่คุณสามารถใช้charค่าคงที่เพื่อกำหนดค่าอินทิกรัลที่สอดคล้องกับค่า enum แต่ละค่าประเภทพื้นฐานของ enum ข้างต้นคือint)

จากนั้นวิธีการขยายหากคุณต้องการ:

public string ToSeparatorString(this Separator separator)
{
    // TODO: validation
    return ((char) separator).ToString();
}

เท่าที่ฉันทราบคุณจะไม่ได้รับอนุญาตให้กำหนดค่าสตริงให้กับ enum สิ่งที่คุณทำได้คือสร้างคลาสที่มีค่าคงที่ของสตริง

public static class SeparatorChars
{
    public static String Comma { get { return ",";} } 
    public static String Tab { get { return "\t,";} } 
    public static String Space { get { return " ";} } 
}

คุณสามารถบรรลุได้ แต่จะต้องมีการทำงานเล็กน้อย

1. กำหนดคลาสแอตทริบิวต์ซึ่งจะมีค่าสตริงสำหรับ enum
2. กำหนดวิธีการขยายซึ่งจะคืนค่าจากแอตทริบิวต์ เช่น .. GetStringValue (ค่า Enum นี้) จะส่งกลับค่าแอตทริบิวต์
3. จากนั้นคุณสามารถกำหนด enum แบบนี้ ..

การทดสอบ enum สาธารณะ: int {
    [StringValue ("a")]
    ฟู = 1,
    [StringValue ("b")]
    บางอย่าง = 2        
} 

4. เพื่อรับค่าจาก Attrinbute Test.Foo.GetStringValue ();

อ้างถึง: Enum พร้อมค่าสตริงใน C #

สำหรับ enum ธรรมดาของค่าสตริง (หรือประเภทอื่น ๆ ):

public static class MyEnumClass
{
    public const string 
        MyValue1 = "My value 1",
        MyValue2 = "My value 2";
}

การใช้งาน: string MyValue = MyEnumClass.MyValue1;

คุณไม่สามารถทำได้ด้วย enums แต่คุณสามารถทำได้ดังนี้:

public static class SeparatorChars
{
    public static string Comma = ",";

    public static string Tab = "\t";

    public static string Space = " ";
}

คุณทำไม่ได้เนื่องจาก enum สามารถขึ้นอยู่กับประเภทตัวเลขดั้งเดิมเท่านั้น คุณสามารถลองใช้Dictionaryแทน:

Dictionary<String, char> separators = new Dictionary<string, char>
{
    {"Comma", ','}, 
    {"Tab",  '\t'}, 
    {"Space", ' '},
};

หรือคุณสามารถใช้enum ปกติDictionary<Separator, char>หรือDictionary<Separator, string>ที่ไหนก็ได้Separator:

enum Separator
{
    Comma,
    Tab,
    Space
}

ซึ่งน่าจะดีกว่าการจัดการกับสตริงโดยตรง

คลาสที่เลียนแบบพฤติกรรม enum แต่ใช้stringแทนintสามารถสร้างได้ดังนี้ ...

public class GrainType
{
    private string _typeKeyWord;

    private GrainType(string typeKeyWord)
    {
        _typeKeyWord = typeKeyWord;
    }

    public override string ToString()
    {
        return _typeKeyWord;
    }

    public static GrainType Wheat = new GrainType("GT_WHEAT");
    public static GrainType Corn = new GrainType("GT_CORN");
    public static GrainType Rice = new GrainType("GT_RICE");
    public static GrainType Barley = new GrainType("GT_BARLEY");

}

การใช้งาน ...

GrainType myGrain = GrainType.Wheat;

PrintGrainKeyword(myGrain);

แล้ว ...

public void PrintGrainKeyword(GrainType grain) 
{
    Console.Writeline("My Grain code is " + grain.ToString());   // Displays "My Grain code is GT_WHEAT"
}

มันเป็นคำตอบที่ล่าช้า แต่บางทีมันอาจจะช่วยใครบางคนได้ในอนาคต ฉันพบว่าการใช้โครงสร้างสำหรับปัญหาประเภทนี้ง่ายกว่า

ตัวอย่างต่อไปนี้คัดลอกส่วนที่วางจากรหัส MS:

namespace System.IdentityModel.Tokens.Jwt
{
    //
    // Summary:
    //     List of registered claims from different sources http://tools.ietf.org/html/rfc7519#section-4
    //     http://openid.net/specs/openid-connect-core-1_0.html#IDToken
    public struct JwtRegisteredClaimNames
    {
        //
        // Summary:
        //     http://tools.ietf.org/html/rfc7519#section-4
        public const string Actort = "actort";
        //
        // Summary:
        //     http://tools.ietf.org/html/rfc7519#section-4
        public const string Typ = "typ";
        //
        // Summary:
        //     http://tools.ietf.org/html/rfc7519#section-4
        public const string Sub = "sub";
        //
        // Summary:
        //     http://openid.net/specs/openid-connect-frontchannel-1_0.html#OPLogout
        public const string Sid = "sid";
        //
        // Summary:
        //     http://tools.ietf.org/html/rfc7519#section-4
        public const string Prn = "prn";
        //
        // Summary:
        //     http://tools.ietf.org/html/rfc7519#section-4
        public const string Nbf = "nbf";
        //
        // Summary:
        //     http://tools.ietf.org/html/rfc7519#section-4
        public const string Nonce = "nonce";
        //
        // Summary:
        //     http://tools.ietf.org/html/rfc7519#section-4
        public const string NameId = "nameid";

    }
}

อาจจะสายเกินไป แต่นี่มันจะไปแล้ว

เราสามารถใช้แอตทริบิวต์ EnumMember เพื่อจัดการค่า Enum

public enum EUnitOfMeasure
{
    [EnumMember(Value = "KM")]
    Kilometer,
    [EnumMember(Value = "MI")]
    Miles
}

ด้วยวิธีนี้ค่าผลลัพธ์สำหรับ EUnitOfMeasure จะเป็น KM หรือ MI นอกจากนี้ยังสามารถมองเห็นได้ในแอนดรูวิเทคำตอบ

สำหรับผู้ที่มาถึงที่นี่ที่กำลังมองหาคำตอบสำหรับคำถามทั่วไปคุณสามารถขยายแนวคิดของคลาสคงที่ได้หากคุณต้องการให้โค้ดของคุณมีลักษณะเหมือนenumไฟล์.

วิธีการต่อไปนี้ใช้ได้ผลเมื่อคุณยังไม่ได้สรุปตามที่enum namesคุณต้องการและenum valuesเป็นการนำstringเสนอenam name; ใช้nameof()เพื่อทำให้การปรับโครงสร้างใหม่ของคุณง่ายขึ้น

public static class Colours
{
    public static string Red => nameof(Red);
    public static string Green => nameof(Green);
    public static string Blue => nameof(Blue);
}

สิ่งนี้บรรลุความตั้งใจของ enum ที่มีค่าสตริง (เช่น pseudocode ต่อไปนี้):

public enum Colours
{
    "Red",
    "Green",
    "Blue"
}

ฉันสร้างคลาสพื้นฐานสำหรับการสร้าง enums มูลค่าสตริงใน. NET เป็นไฟล์ C # เพียงไฟล์เดียวที่คุณสามารถคัดลอกและวางลงในโปรเจ็กต์ของคุณหรือติดตั้งผ่านแพ็คเกจNuGetชื่อStringEnum StringEnum

การใช้งาน:

///<completionlist cref="HexColor"/> 
class HexColor : StringEnum<HexColor>
{
    public static readonly HexColor Blue = New("#FF0000");
    public static readonly HexColor Green = New("#00FF00");
    public static readonly HexColor Red = New("#000FF");
}

คุณสมบัติ

• StringEnum ของคุณดูคล้ายกับ enum ทั่วไป:

    // Static Parse Method
    HexColor.Parse("#FF0000") // => HexColor.Red
    HexColor.Parse("#ff0000", caseSensitive: false) // => HexColor.Red
    HexColor.Parse("invalid") // => throws InvalidOperationException

    // Static TryParse method.
    HexColor.TryParse("#FF0000") // => HexColor.Red
    HexColor.TryParse("#ff0000", caseSensitive: false) // => HexColor.Red
    HexColor.TryParse("invalid") // => null

    // Parse and TryParse returns the preexistent instances
    object.ReferenceEquals(HexColor.Parse("#FF0000"), HexColor.Red) // => true

    // Conversion from your `StringEnum` to `string`
    string myString1 = HexColor.Red.ToString(); // => "#FF0000"
    string myString2 = HexColor.Red; // => "#FF0000" (implicit cast)

• Intellisense จะแนะนำชื่อ enum <completitionlist>ถ้าชั้นจะข้อเขียนด้วยกับความคิดเห็นของ (ใช้ได้ทั้งใน C # และ VB): เช่น

การติดตั้ง

ทั้ง:

• ติดตั้งแพ็คเกจ StringEnum NuGetล่าสุดซึ่งขึ้นอยู่กับ.Net Standard 1.0ว่ามันทำงานบน.Net Core> = 1.0, .Net Framework> = 4.5, Mono> = 4.6 ฯลฯ
• หรือวางคลาสพื้นฐาน StringEnum ต่อไปนี้ในโปรเจ็กต์ของคุณ ( เวอร์ชันล่าสุด )

    public abstract class StringEnum<T> : IEquatable<T> where T : StringEnum<T>, new()
    {
        protected string Value;
        private static IList<T> valueList = new List<T>();
        protected static T New(string value)
        {
            if (value == null)
                return null; // the null-valued instance is null.

            var result = new T() { Value = value };
            valueList.Add(result);
            return result;
        }

        public static implicit operator string(StringEnum<T> enumValue) => enumValue.Value;
        public override string ToString() => Value;

        public static bool operator !=(StringEnum<T> o1, StringEnum<T> o2) => o1?.Value != o2?.Value;
        public static bool operator ==(StringEnum<T> o1, StringEnum<T> o2) => o1?.Value == o2?.Value;

        public override bool Equals(object other) => this.Value.Equals((other as T)?.Value ?? (other as string));
        bool IEquatable<T>.Equals(T other) => this.Value.Equals(other.Value);
        public override int GetHashCode() => Value.GetHashCode();

        /// <summary>
        /// Parse the <paramref name="value"/> specified and returns a valid <typeparamref name="T"/> or else throws InvalidOperationException.
        /// </summary>
        /// <param name="value">The string value representad by an instance of <typeparamref name="T"/>. Matches by string value, not by the member name.</param>
        /// <param name="caseSensitive">If true, the strings must match case sensitivity.</param>
        public static T Parse(string value, bool caseSensitive = false)
        {
            var result = TryParse(value, caseSensitive);
            if (result == null)
                throw new InvalidOperationException((value == null ? "null" : $"'{value}'") + $" is not a valid {typeof(T).Name}");

            return result;
        }

        /// <summary>
        /// Parse the <paramref name="value"/> specified and returns a valid <typeparamref name="T"/> or else returns null.
        /// </summary>
        /// <param name="value">The string value representad by an instance of <typeparamref name="T"/>. Matches by string value, not by the member name.</param>
        /// <param name="caseSensitive">If true, the strings must match case sensitivity.</param>
        public static T TryParse(string value, bool caseSensitive = false)
        {
            if (value == null) return null;
            if (valueList.Count == 0) System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(typeof(T).TypeHandle); // force static fields initialization
            var field = valueList.FirstOrDefault(f => f.Value.Equals(value,
                    caseSensitive ? StringComparison.Ordinal
                                  : StringComparison.OrdinalIgnoreCase));
            // Not using InvariantCulture because it's only supported in NETStandard >= 2.0

            if (field == null)
                return null;

            return field;
        }
    }

• สำหรับNewtonsoft.Jsonการรองรับการทำให้เป็นอนุกรมให้คัดลอกเวอร์ชันเพิ่มเติมนี้แทน StringEnum.cs

ฉันตระหนักว่ารหัสนี้คล้ายกับคำตอบของเบ็น ฉันเขียนด้วยความจริงใจตั้งแต่เริ่มต้น อย่างไรก็ตามฉันคิดว่ามันมีคุณสมบัติพิเศษบางอย่างเช่นการ<completitionlist>แฮ็กคลาสที่ได้จะดูเหมือน Enum มากกว่าไม่มีการใช้การสะท้อนใน Parse () แพ็คเกจ NuGet และ repo ซึ่งฉันหวังว่าจะแก้ไขปัญหาและข้อเสนอแนะที่เข้ามา

จากคำตอบบางส่วนที่นี่ฉันได้ใช้คลาสพื้นฐานที่ใช้ซ้ำได้ซึ่งเลียนแบบพฤติกรรมของ enum แต่stringเป็นประเภทพื้นฐาน รองรับการดำเนินการต่างๆ ได้แก่ :

1. รับรายการค่าที่เป็นไปได้
2. แปลงเป็นสตริง
3. เปรียบเทียบกับกรณีอื่น ๆ ผ่านทาง.Equals, ==และ!=
4. การแปลงเป็น / จาก JSON โดยใช้ JSON.NET JsonConverter

นี่คือคลาสพื้นฐานที่ครบถ้วน:

public abstract class StringEnumBase<T> : IEquatable<T>
    where T : StringEnumBase<T>
{
    public string Value { get; }

    protected StringEnumBase(string value) => this.Value = value;

    public override string ToString() => this.Value;

    public static List<T> AsList()
    {
        return typeof(T)
            .GetProperties(BindingFlags.Public | BindingFlags.Static)
            .Where(p => p.PropertyType == typeof(T))
            .Select(p => (T)p.GetValue(null))
            .ToList();
    }

    public static T Parse(string value)
    {
        List<T> all = AsList();

        if (!all.Any(a => a.Value == value))
            throw new InvalidOperationException($"\"{value}\" is not a valid value for the type {typeof(T).Name}");

        return all.Single(a => a.Value == value);
    }

    public bool Equals(T other)
    {
        if (other == null) return false;
        return this.Value == other?.Value;
    }

    public override bool Equals(object obj)
    {
        if (obj == null) return false;
        if (obj is T other) return this.Equals(other);
        return false;
    }

    public override int GetHashCode() => this.Value.GetHashCode();

    public static bool operator ==(StringEnumBase<T> a, StringEnumBase<T> b) => a?.Equals(b) ?? false;

    public static bool operator !=(StringEnumBase<T> a, StringEnumBase<T> b) => !(a?.Equals(b) ?? false);

    public class JsonConverter<T> : Newtonsoft.Json.JsonConverter
        where T : StringEnumBase<T>
    {
        public override bool CanRead => true;

        public override bool CanWrite => true;

        public override bool CanConvert(Type objectType) => ImplementsGeneric(objectType, typeof(StringEnumBase<>));

        private static bool ImplementsGeneric(Type type, Type generic)
        {
            while (type != null)
            {
                if (type.IsGenericType && type.GetGenericTypeDefinition() == generic)
                    return true;

                type = type.BaseType;
            }

            return false;
        }

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            JToken item = JToken.Load(reader);
            string value = item.Value<string>();
            return StringEnumBase<T>.Parse(value);
        }

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value is StringEnumBase<T> v)
                JToken.FromObject(v.Value).WriteTo(writer);
        }
    }
}

และนี่คือวิธีที่คุณจะใช้ "string enum" ของคุณ:

[JsonConverter(typeof(JsonConverter<Colour>))]
public class Colour : StringEnumBase<Colour>
{
    private Colour(string value) : base(value) { }

    public static Colour Red => new Colour("red");
    public static Colour Green => new Colour("green");
    public static Colour Blue => new Colour("blue");
}

ซึ่งสามารถใช้ได้ดังนี้:

public class Foo
{
    public Colour colour { get; }

    public Foo(Colour colour) => this.colour = colour;

    public bool Bar()
    {
        if (this.colour == Colour.Red || this.colour == Colour.Blue)
            return true;
        else
            return false;
    }
}

ฉันหวังว่าใครบางคนจะพบว่าสิ่งนี้มีประโยชน์!

ก่อนอื่นคุณพยายามกำหนดสตริงไม่ใช่ตัวอักษรแม้ว่าจะเป็นเพียงอักขระเดียวก็ตาม ใช้ "," แทน "," สิ่งต่อไปคือ enums ใช้ประเภทอินทิกรัลโดยที่charคุณไม่สามารถใช้ค่ายูนิโค้ดได้ แต่ฉันขอแนะนำอย่างยิ่งว่าคุณไม่ควรทำเช่นนั้น หากคุณมั่นใจว่าค่าเหล่านี้ยังคงเหมือนเดิมในวัฒนธรรมและภาษาที่แตกต่างกันฉันจะใช้คลาสคงที่กับสตริง const

แม้ว่าจะไม่สามารถใช้ a charหรือ a stringเป็นฐานสำหรับ enum ได้ แต่ฉันคิดว่านี่ไม่ใช่สิ่งที่คุณชอบทำจริงๆ

เช่นเดียวกับที่คุณพูดถึงคุณต้องการมีความเป็นไปได้มากมายและแสดงการแสดงสตริงของสิ่งนี้ภายในกล่องคำสั่งผสม หากผู้ใช้เลือกหนึ่งในการแสดงสตริงเหล่านี้คุณต้องการที่จะได้รับ enum ที่เกี่ยวข้อง และเป็นไปได้:

ก่อนอื่นเราต้องเชื่อมโยงสตริงกับค่า enum ซึ่งสามารถทำได้โดยใช้DescriptionAttributeเหมือนว่ามันจะมีการอธิบายไว้ที่นี่หรือที่นี่

ตอนนี้คุณต้องสร้างรายการค่า enum และคำอธิบายที่เกี่ยวข้อง สามารถทำได้โดยใช้วิธีการต่อไปนี้:

/// <summary>
/// Creates an List with all keys and values of a given Enum class
/// </summary>
/// <typeparam name="T">Must be derived from class Enum!</typeparam>
/// <returns>A list of KeyValuePair&lt;Enum, string&gt; with all available
/// names and values of the given Enum.</returns>
public static IList<KeyValuePair<T, string>> ToList<T>() where T : struct
{
    var type = typeof(T);

    if (!type.IsEnum)
    {
        throw new ArgumentException("T must be an enum");
    }

    return (IList<KeyValuePair<T, string>>)
            Enum.GetValues(type)
                .OfType<T>()
                .Select(e =>
                {
                    var asEnum = (Enum)Convert.ChangeType(e, typeof(Enum));
                    return new KeyValuePair<T, string>(e, asEnum.Description());
                })
                .ToArray();
}

ตอนนี้คุณจะมีรายการคู่ค่าคีย์ของ enums ทั้งหมดและคำอธิบาย ลองกำหนดสิ่งนี้เป็นแหล่งข้อมูลสำหรับกล่องคำสั่งผสม

var comboBox = new ComboBox();
comboBox.ValueMember = "Key"
comboBox.DisplayMember = "Value";
comboBox.DataSource = EnumUtilities.ToList<Separator>();

comboBox.SelectedIndexChanged += (sender, e) =>
{
    var selectedEnum = (Separator)comboBox.SelectedValue;
    MessageBox.Show(selectedEnum.ToString());
}

ผู้ใช้จะเห็นการแสดงสตริงทั้งหมดของ enum และภายในรหัสของคุณคุณจะได้รับค่า enum ที่ต้องการ

เราไม่สามารถกำหนดการแจงนับเป็นประเภทสตริงได้ ประเภทที่ได้รับการอนุมัติสำหรับ enum คือ byte, sbyte, short, ushort, int, uint, long หรือ ulong

หากคุณต้องการรายละเอียดเพิ่มเติมเกี่ยวกับการแจงนับโปรดไปที่ลิงก์ด้านล่างลิงก์นั้นจะช่วยให้คุณเข้าใจการแจงนับ การแจงนับ

@ narendras1414

มันใช้ได้กับฉัน ..

   public class ShapeTypes
    {
        private ShapeTypes() { }
        public static string OVAL
        {
            get
            {
                return "ov";
            }
            private set { }
        }

        public static string SQUARE
        {
            get
            {
                return "sq";
            }
            private set { }
        }

        public static string RECTANGLE
        {
            get
            {
                return "rec";
            }
            private set { }
        }
    }

สิ่งที่ฉันเพิ่งเริ่มทำคือการใช้Tuples

public static (string Fox, string Rabbit, string Horse) Animals = ("Fox", "Rabbit", "Horse");
...
public static (string Comma, string Tab, string Space) SeparatorChars = (",", "\t", " ");

คลาส Enumaration

 public sealed class GenericDateTimeFormatType
    {

        public static readonly GenericDateTimeFormatType Format1 = new GenericDateTimeFormatType("dd-MM-YYYY");
        public static readonly GenericDateTimeFormatType Format2 = new GenericDateTimeFormatType("dd-MMM-YYYY");

        private GenericDateTimeFormatType(string Format)
        {
            _Value = Format;
        }

        public string _Value { get; private set; }
    }

Enumaration Consuption

public static void Main()
{
       Country A = new Country();

       A.DefaultDateFormat = GenericDateTimeFormatType.Format1;

      Console.ReadLine();
}