Liên kết enum với chuỗi trong C #

Tôi biết điều sau đây là không thể vì kiểu liệt kê phải là số nguyên

enum GroupTypes
{
    TheGroup = "OEM",
    TheOtherGroup = "CMB"
}

Từ cơ sở dữ liệu của tôi, tôi nhận được một trường với các mã không toàn diện ( OEMvà và CMB). Tôi muốn làm cho lĩnh vực này thành một enumhoặc một cái gì đó dễ hiểu. Bởi vì nếu mục tiêu là khả năng đọc, giải pháp nên ngắn gọn.

Tôi có những lựa chọn nào khác?

Tôi thích sử dụng các thuộc tính trong một lớp thay vì các phương thức, vì chúng trông giống enum hơn.

Đây là một ví dụ cho Logger:

public class LogCategory
{
    private LogCategory(string value) { Value = value; }

    public string Value { get; set; }

    public static LogCategory Trace   { get { return new LogCategory("Trace"); } }
    public static LogCategory Debug   { get { return new LogCategory("Debug"); } }
    public static LogCategory Info    { get { return new LogCategory("Info"); } }
    public static LogCategory Warning { get { return new LogCategory("Warning"); } }
    public static LogCategory Error   { get { return new LogCategory("Error"); } }
}

Truyền các giá trị chuỗi an toàn kiểu làm tham số:

public static void Write(string message, LogCategory logCategory)
{
    var log = new LogEntry { Message = message };
    Logger.Write(log, logCategory.Value);
}

Sử dụng:

Logger.Write("This is almost like an enum.", LogCategory.Info);

Bạn cũng có thể sử dụng mô hình mở rộng:

public enum MyEnum
{
    [Description("String 1")]
    V1= 1,
    [Description("String 2")]
    V2= 2
} 

Lớp học mở rộng của bạn

public static class MyEnumExtensions
{
    public static string ToDescriptionString(this MyEnum val)
    {
        DescriptionAttribute[] attributes = (DescriptionAttribute[])val
           .GetType()
           .GetField(val.ToString())
           .GetCustomAttributes(typeof(DescriptionAttribute), false);
        return attributes.Length > 0 ? attributes[0].Description : string.Empty;
    }
} 

sử dụng:

MyEnum myLocal = MyEnum.V1;
print(myLocal.ToDescriptionString());

Làm thế nào về việc sử dụng một lớp tĩnh với hằng số?

static class GroupTypes
{
  public const string TheGroup = "OEM";
  public const string TheOtherGroup = "CMB";
}

void DoSomething(string groupType)
{
  if(groupType == GroupTypes.TheGroup)
  {
    // Be nice
  }  
  else if (groupType == GroupTypes.TheOtherGroup)
  {
    // Continue to be nice
  }
  else
  {
    // unexpected, throw exception?
  }
}

Bạn có thể thêm các thuộc tính cho các mục trong bảng liệt kê và sau đó sử dụng sự phản chiếu để lấy các giá trị từ các thuộc tính.

Bạn sẽ phải sử dụng công cụ xác định "trường" để áp dụng các thuộc tính, như vậy:

enum GroupTypes
{
    [field:Description("OEM")]
    TheGroup,

    [field:Description("CMB")]
    TheOtherGroup
}

Sau đó, bạn sẽ phản ánh trên các trường tĩnh của loại enum (trong trường hợp này là GroupTypes) và nhận DescriptionAttributegiá trị bạn đang tìm kiếm bằng cách sử dụng sự phản chiếu:

public static DescriptionAttribute GetEnumDescriptionAttribute<T>(
    this T value) where T : struct
{
    // The type of the enum, it will be reused.
    Type type = typeof(T);

    // If T is not an enum, get out.
    if (!type.IsEnum) 
        throw new InvalidOperationException(
            "The type parameter T must be an enum type.");

    // If the value isn't defined throw an exception.
    if (!Enum.IsDefined(type, value))
        throw new InvalidEnumArgumentException(
            "value", Convert.ToInt32(value), type);

    // Get the static field for the value.
    FieldInfo fi = type.GetField(value.ToString(), 
        BindingFlags.Static | BindingFlags.Public);

    // Get the description attribute, if there is one.
    return fi.GetCustomAttributes(typeof(DescriptionAttribute), true).
        Cast<DescriptionAttribute>().SingleOrDefault();
}

Tôi đã chọn trả lại DescriptionAttributechính nó ở trên, trong trường hợp bạn muốn có thể xác định liệu thuộc tính có được áp dụng hay không.

Bạn có thể làm điều đó rất dễ dàng thực sự. Sử dụng mã sau đây.

enum GroupTypes
{
   OEM,
   CMB
};

Sau đó, khi bạn muốn lấy giá trị chuỗi của từng phần tử enum, chỉ cần sử dụng dòng mã sau đây.

String oemString = Enum.GetName(typeof(GroupTypes), GroupTypes.OEM);

Trước đây tôi đã sử dụng phương pháp này thành công và tôi cũng đã sử dụng một lớp hằng để giữ các hằng chuỗi, cả hai đều hoạt động khá tốt, nhưng tôi có xu hướng thích điều này hơn.

Hãy thử thêm hằng vào một lớp tĩnh. Bạn không kết thúc với Loại, nhưng bạn sẽ có các hằng số có tổ chức, dễ đọc:

public static class GroupTypes {

    public const string TheGroup = "OEM";
    public const string TheOtherGroup = "CMB";

}

Tạo một enum thứ hai, cho DB của bạn chứa các mục sau:

enum DBGroupTypes
{
    OEM = 0,
    CMB = 1
}

Bây giờ, bạn có thể sử dụng Enum.Pude để lấy giá trị DBgroupTypes chính xác từ các chuỗi "OEM" và "CMB". Sau đó, bạn có thể chuyển đổi chúng thành int và truy xuất các giá trị chính xác từ phép liệt kê đúng mà bạn muốn sử dụng thêm trong mô hình của mình.

Sử dụng một lớp học.

Chỉnh sửa: Ví dụ tốt hơn

class StarshipType
{
    private string _Name;
    private static List<StarshipType> _StarshipTypes = new List<StarshipType>();

    public static readonly StarshipType Ultralight = new StarshipType("Ultralight");
    public static readonly StarshipType Light = new StarshipType("Light");
    public static readonly StarshipType Mediumweight = new StarshipType("Mediumweight");
    public static readonly StarshipType Heavy = new StarshipType("Heavy");
    public static readonly StarshipType Superheavy = new StarshipType("Superheavy");

    public string Name
    {
        get { return _Name; }
        private set { _Name = value; }
    }

    public static IList<StarshipType> StarshipTypes
    {
        get { return _StarshipTypes; }
    }

    private StarshipType(string name, int systemRatio)
    {
        Name = name;
        _StarshipTypes.Add(this);
    }

    public static StarshipType Parse(string toParse)
    {
        foreach (StarshipType s in StarshipTypes)
        {
            if (toParse == s.Name)
                return s;
        }
        throw new FormatException("Could not parse string.");
    }
}

Một cách khác để giải quyết vấn đề, là có một enum và một chuỗi các chuỗi sẽ ánh xạ các giá trị enum với danh sách các chuỗi:

public enum GroupTypes
{
    TheGroup  = 0,
    TheOtherGroup 
}

string[] GroupTypesStr = {
    "OEM",
    "CMB"
};

bạn có thể sử dụng nó như thế này:

Log.Write(GroupTypesStr[(int)GroupTypes.TheOtherGroup]);

Nó sẽ nhắc CMB

PROS:

1. Mã dễ dàng và sạch sẽ.
2. Hiệu suất cao (đặc biệt so với các phương pháp sử dụng các lớp)

Nhược điểm:

1. Có xu hướng làm rối danh sách khi chỉnh sửa nó, nhưng nó sẽ ổn cho một danh sách ngắn.

Đây là phương thức mở rộng mà tôi đã sử dụng để lấy giá trị enum dưới dạng chuỗi. Đầu tiên ở đây là enum.

public enum DatabaseEnvironment
{
    [Description("AzamSharpBlogDevDatabase")]
    Development = 1, 
    [Description("AzamSharpBlogQADatabase")]
    QualityAssurance = 2, 
    [Description("AzamSharpBlogTestDatabase")] 
    Test = 3
}

Thuộc tính Mô tả đến từ System.ComponentModel.

Và đây là phương pháp mở rộng của tôi:

public static string GetValueAsString(this DatabaseEnvironment environment) 
{
    // get the field 
    var field = environment.GetType().GetField(environment.ToString());
    var customAttributes = field.GetCustomAttributes(typeof (DescriptionAttribute), false);

    if(customAttributes.Length > 0)
    {
        return (customAttributes[0] as DescriptionAttribute).Description;  
    }
    else
    {
        return environment.ToString(); 
    }
}

Bây giờ, bạn có thể truy cập enum dưới dạng giá trị chuỗi bằng mã sau:

[TestFixture]
public class when_getting_value_of_enum
{
    [Test]
    public void should_get_the_value_as_string()
    {
        Assert.AreEqual("AzamSharpBlogTestDatabase",DatabaseEnvironment.Test.GetValueAsString());  
    }
}

Bạn đã xem xét một bảng tra cứu bằng cách sử dụng một từ điển?

enum GroupTypes
{
    TheGroup,
    TheOtherGroup
}

Dictionary<string, GroupTypes> GroupTypeLookup = new Dictionary<string, GroupTypes>();
// initialize lookup table:
GroupTypeLookup.Add("OEM", TheGroup);
GroupTypeLookup.Add("CMB", TheOtherGroup);

Sau đó, bạn có thể sử dụng GroupTypeLookup.TryGetValue () để tìm kiếm một chuỗi khi bạn đọc nó.

public class DataType
{
    private readonly string value;
    private static readonly Dictionary<string, DataType> predefinedValues;

    public static readonly DataType Json = new DataType("json");
    public static readonly DataType Xml = new DataType("xml");
    public static readonly DataType Text = new DataType("text");
    public static readonly DataType Html = new DataType("html");
    public static readonly DataType Binary = new DataType("binary");

    static DataType()
    {
        predefinedValues = new Dictionary<string, DataType>();
        predefinedValues.Add(Json.Value, Json);
        predefinedValues.Add(Xml.Value, Xml);
        predefinedValues.Add(Text.Value, Text);
        predefinedValues.Add(Html.Value, Html);
        predefinedValues.Add(Binary.Value, Binary);
    }

    private DataType(string value)
    {
        this.value = value;
    }

    public static DataType Parse(string value)
    {
        var exception = new FormatException($"Invalid value for type {nameof(DataType)}");
        if (string.IsNullOrEmpty(value))
            throw exception;

        string key = value.ToLower();
        if (!predefinedValues.ContainsKey(key))
            throw exception;

        return predefinedValues[key];
    }

    public string Value
    {
        get { return value; }
    }
}

C # không hỗ trợ chuỗi liệt kê, nhưng trong hầu hết các tình huống, bạn có thể sử dụng Danh sách hoặc Từ điển để có được hiệu ứng mong muốn.

Ví dụ: Để in kết quả đạt / không đạt:

List<string> PassFail = new List<string> { "FAIL", "PASS" };
bool result = true;
Console.WriteLine("Test1: " + PassFail[result.GetHashCode()]);

Tôi sẽ làm cho nó vào một lớp để tránh một enum hoàn toàn. Và sau đó với việc sử dụng một bộ gõ, bạn có thể tạo đối tượng khi bạn lấy nó từ db.

I E:

public class Group
{
    public string Value{ get; set; }
    public Group( string value ){ Value = value; } 
    public static Group TheGroup() { return new Group("OEM"); }
    public static Group OtherGroup() { return new Group("CMB"); }

}

Tôi sẽ chỉ tạo một từ điển và sử dụng mã làm chìa khóa.

Chỉnh sửa: Để giải quyết nhận xét về việc thực hiện tra cứu ngược (tìm khóa), điều này sẽ không hiệu quả khủng khiếp. Nếu điều này là cần thiết, tôi sẽ viết một lớp mới để xử lý nó.

Câu hỏi đầu tiên của tôi - Bạn có quyền truy cập vào Cơ sở dữ liệu không? Điều này nên được chuẩn hóa trong cơ sở dữ liệu, lý tưởng là, bất kỳ giải pháp nào cũng sẽ dễ bị lỗi. Theo kinh nghiệm của tôi, các trường dữ liệu đầy "OEM" và "CMB" có xu hướng kết thúc với những thứ như "OEM" và 'dữ liệu tào lao' khác trộn lẫn theo thời gian .... Nếu bạn có thể bình thường hóa nó, bạn có thể sử dụng khóa trong bảng chứa các thành phần là Enum của bạn và bạn đã hoàn thành, với cấu trúc sạch hơn nhiều.

Nếu không có sẵn, tôi sẽ tạo Enum của bạn và tạo một lớp để phân tích chuỗi của bạn thành Enum cho bạn. Điều này ít nhất sẽ cung cấp cho bạn một số linh hoạt trong việc xử lý các mục không chuẩn và linh hoạt hơn nhiều cho việc bẫy hoặc xử lý lỗi so với thực hiện bất kỳ cách giải quyết nào bằng Enum.Pude / Reflection / v.v. Một từ điển sẽ hoạt động, nhưng có thể bị hỏng nếu bạn gặp vấn đề, v.v.

Tôi khuyên bạn nên viết một lớp để bạn có thể làm:

// I renamed this to GroupType, since it sounds like each element has a single type...
GroupType theType = GroupTypeParser.GetGroupType(theDBString);

Điều này bảo tồn hầu hết khả năng đọc của bạn mà không phải thay đổi DB.

Nếu tôi hiểu chính xác, bạn cần chuyển đổi từ chuỗi sang enum:

enum GroupTypes {
    Unknown = 0,
    OEM = 1,
    CMB = 2
}
static GroupTypes StrToEnum(string str){
    GroupTypes g = GroupTypes.Unknown;
    try {
        object o = Enum.Parse(typeof(GroupTypes), str, true);
        g = (GroupTypes)(o ?? 0);
    } catch {
    }
    return g;
}
// then use it like this
GroupTypes g1 = StrToEnum("OEM");
GroupTypes g2 = StrToEnum("bad value");

Bạn có thể làm cho nó lạ mắt hơn với tướng cho loại enum nếu bạn muốn.

Trong VS 2015, bạn có thể sử dụng nameof

public class LogCategory
{
    public static string Trace;
    public static string Debug;
    public static string Info;
    public static string Warning;
    public static string Error;
}

Sử dụng:

Logger.Write("This is almost like an enum.", nameof(LogCategory.Info));

Một điều chỉnh nhỏ đối với phương pháp Mở rộng Glennular, vì vậy bạn có thể sử dụng tiện ích mở rộng cho những thứ khác ngoài chỉ ENUM;

using System;
using System.ComponentModel;
namespace Extensions {
    public static class T_Extensions {
        /// <summary>
        /// Gets the Description Attribute Value
        /// </summary>
        /// <typeparam name="T">Entity Type</typeparam>
        /// <param name="val">Variable</param>
        /// <returns>The value of the Description Attribute or an Empty String</returns>
        public static string Description<T>(this T t) {
            DescriptionAttribute[] attributes = (DescriptionAttribute[])t.GetType().GetField(t.ToString()).GetCustomAttributes(typeof(DescriptionAttribute), false);
            return attributes.Length > 0 ? attributes[0].Description : string.Empty;
        }
    }
}

Hoặc sử dụng Linq

using System;
using System.ComponentModel;
using System.Linq;

namespace Extensions {


public static class T_Extensions {
        public static string Description<T>(this T t) =>
            ((DescriptionAttribute[])t
            ?.GetType()
            ?.GetField(t?.ToString())
            ?.GetCustomAttributes(typeof(DescriptionAttribute), false))
            ?.Select(a => a?.Description)
            ?.FirstOrDefault() 
            ?? string.Empty;  
    }
}

Theo câu trả lời của @Even Mien, tôi đã cố gắng đi xa hơn một chút và biến nó thành Chung chung, tôi dường như gần như ở đó nhưng một trường hợp vẫn chống lại và tôi có thể đơn giản hóa mã của mình một chút.
Tôi đăng nó ở đây nếu bất cứ ai thấy tôi có thể cải thiện và đặc biệt là làm cho nó hoạt động như thế nào vì tôi không thể gán nó từ một chuỗi

Cho đến nay tôi có kết quả như sau:

        Console.WriteLine(TestEnum.Test1);//displays "TEST1"

        bool test = "TEST1" == TestEnum.Test1; //true

        var test2 = TestEnum.Test1; //is TestEnum and has value

        string test3 = TestEnum.Test1; //test3 = "TEST1"

        var test4 = TestEnum.Test1 == TestEnum.Test2; //false
         EnumType<TestEnum> test5 = "TEST1"; //works fine

        //TestEnum test5 = "string"; DOESN'T compile .... :(:(

Trường hợp phép thuật xảy ra:

public abstract  class EnumType<T>  where T : EnumType<T>   
{

    public  string Value { get; set; }

    protected EnumType(string value)
    {
        Value = value;
    }


    public static implicit operator EnumType<T>(string s)
    {
        if (All.Any(dt => dt.Value == s))
        {
            Type t = typeof(T);

            ConstructorInfo ci = t.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic,null, new Type[] { typeof(string) }, null);

            return (T)ci.Invoke(new object[] {s});
        }
        else
        {
            return null;
        }
    }

    public static implicit operator string(EnumType<T> dt)
    {
        return dt?.Value;
    }


    public static bool operator ==(EnumType<T> ct1, EnumType<T> ct2)
    {
        return (string)ct1 == (string)ct2;
    }

    public static bool operator !=(EnumType<T> ct1, EnumType<T> ct2)
    {
        return !(ct1 == ct2);
    }


    public override bool Equals(object obj)
    {
        try
        {
            return (string)obj == Value;
        }
        catch
        {
            return false;
        }
    }

    public override int GetHashCode()
    {
        return Value.GetHashCode();
    }

    public static IEnumerable<T> All
     => typeof(T).GetProperties()
       .Where(p => p.PropertyType == typeof(T))
       .Select(x => (T)x.GetValue(null, null));



}

Tôi chỉ sau đó phải khai báo điều này cho enum của tôi:

public class TestEnum : EnumType<TestEnum> 
{

    private TestEnum(string value) : base(value)
    {}

    public static TestEnum Test1 { get { return new TestEnum("TEST1"); } }
    public static TestEnum Test2 { get { return new TestEnum("TEST2"); } }
}

Mới trong .Net Core 3.0 / C # 8.0 (nếu môi trường làm việc của bạn cho phép bạn nâng cấp dự án của mình) là một câu lệnh chuyển đổi tay ngắn có vẻ hơi enum-ish. Vào cuối ngày, đó là cùng một câu lệnh chuyển đổi nhàm chán cũ mà chúng ta đã sử dụng trong nhiều năm.

Chỉ có sự khác biệt thực sự ở đây là tuyên bố chuyển đổi có một bộ đồ mới.

public static RGBColor FromRainbow(Rainbow colorBand) =>
colorBand switch
{
    Rainbow.Red    => new RGBColor(0xFF, 0x00, 0x00),
    Rainbow.Orange => new RGBColor(0xFF, 0x7F, 0x00),
    Rainbow.Yellow => new RGBColor(0xFF, 0xFF, 0x00),
    Rainbow.Green  => new RGBColor(0x00, 0xFF, 0x00),
    Rainbow.Blue   => new RGBColor(0x00, 0x00, 0xFF),
    Rainbow.Indigo => new RGBColor(0x4B, 0x00, 0x82),
    Rainbow.Violet => new RGBColor(0x94, 0x00, 0xD3),
    _              => throw new ArgumentException(message: "invalid enum value", paramName: nameof(colorBand)),
};

Bạn sẽ nhận thấy rằng mã ở trên mà tôi đã sao chép từ đây , thực sự đang sử dụng một enum làm thông số.

Đó không phải là chính xác những gì bạn muốn (và tin tôi đi, tôi đã muốn một cái gì đó tương tự như những gì OP yêu cầu trong một thời gian dài), nhưng tôi thực sự cảm thấy như đây là một nhánh ô liu từ MS. JMO.

Hy vọng nó sẽ giúp được ai đó!

Tôi đã sử dụng một cấu trúc như được ám chỉ trong một câu trả lời trước đó, nhưng đã bỏ đi với bất kỳ sự phức tạp nào. Đối với tôi, điều này giống như tạo ra một bảng liệt kê các chuỗi. Nó được sử dụng theo cách tương tự như một phép liệt kê được sử dụng.

    struct ViewTypes
    {
        public const string View1 = "Whatever string you like";
        public const string View2 = "another string";
    }

Ví dụ sử dụng:

   switch( some_string_variable )
   {
      case ViewTypes.View1: /* do something */ break;
      case ViewTypes.View2: /* do something else */ break;
   }

Tôi thậm chí đã triển khai một vài enum theo đề xuất của @Even (thông qua class Xvà public static Xcác thành viên), chỉ để tìm hiểu sau đó rằng những ngày này, bắt đầu .Net 4.5, có quyền ToString() phương pháp .

Bây giờ tôi đang thực hiện lại tất cả mọi thứ trở lại enums.

Đây là một cách để sử dụng nó như một tham số được gõ mạnh hoặc như một chuỗi :

public class ClassLikeEnum
{
    public string Value
    {
        get;
        private set;
    }

    ClassLikeEnum(string value) 
    {
        Value = value;
    }

    public static implicit operator string(ClassLikeEnum c)
    {
        return c.Value;
    }

    public static readonly ClassLikeEnum C1 = new ClassLikeEnum("RandomString1");
    public static readonly ClassLikeEnum C2 = new ClassLikeEnum("RandomString2");
}

Bạn có thể sử dụng hai enum. Một cho cơ sở dữ liệu và một cho cơ sở dễ đọc.

Bạn chỉ cần đảm bảo rằng chúng vẫn đồng bộ, có vẻ như là một chi phí nhỏ. Bạn không phải đặt các giá trị, chỉ cần đặt các vị trí giống nhau, nhưng đặt các giá trị làm cho nó rất rõ ràng hai enum có liên quan và ngăn ngừa lỗi sắp xếp lại các thành viên enum. Và một bình luận cho đội bảo trì biết những thứ này có liên quan và phải được giữ đồng bộ.

// keep in sync with GroupTypes
public enum GroupTypeCodes
{
    OEM,
    CMB
}

// keep in sync with GroupTypesCodes
public enum GroupTypes
{
    TheGroup = GroupTypeCodes.OEM,
    TheOtherGroup = GroupTypeCodes.CMB
}

Để sử dụng nó, bạn chỉ cần chuyển đổi thành mã trước tiên:

GroupTypes myGroupType = GroupTypes.TheGroup;
string valueToSaveIntoDatabase = ((GroupTypeCodes)myGroupType).ToString();

Sau đó, nếu bạn muốn làm cho nó thuận tiện hơn nữa, bạn có thể thêm một chức năng mở rộng chỉ hoạt động cho loại enum này:

public static string ToString(this GroupTypes source)
{
    return ((GroupTypeCodes)source).ToString();
}

và sau đó bạn có thể làm:

GroupTypes myGroupType = GroupTypes.TheGroup;
string valueToSaveIntoDatabase = myGroupType.ToString();

Về cơ bản, tôi đã tìm kiếm câu trả lời Reflection của @ArthurC

Chỉ cần mở rộng câu trả lời của anh ấy một chút, bạn có thể làm cho nó tốt hơn bằng cách có một chức năng chung:

    // If you want for a specific Enum
    private static string EnumStringValue(GroupTypes e)
    {
        return EnumStringValue<GroupTypes>(e);
    }

    // Generic
    private static string EnumStringValue<T>(T enumInstance)
    {
        return Enum.GetName(typeof(T), enumInstance);
    } 

Sau đó, bạn có thể chỉ cần bọc bất cứ điều gì bạn có

EnumStringValue(GroupTypes.TheGroup) // if you incorporate the top part

hoặc là

EnumStringValue<GroupTypes>(GroupTypes.TheGroup) // if you just use the generic

Lấy từ @EvenMien và thêm vào một số ý kiến. (Cũng cho trường hợp sử dụng của riêng tôi)

public struct AgentAction
{
    private AgentAction(string value) { Value = value; }

    public string Value { get; private set; }

    public override string ToString()
    {
        return this.Value;
    }

    public static AgentAction Login = new AgentAction("Logout");
    public static AgentAction Logout = new AgentAction("Logout");

    public static implicit operator string(AgentAction action) { return action.ToString(); }
}

Thêm lớp này

public class DatabasePreference {
    public DatabasePreference([CallerMemberName] string preferenceName = "") {
        PreferenceName = preferenceName;
    }
    public string PreferenceName;
}

Công việc này đang sử dụng CallerMemberNameđể giảm thiểu mã hóa

Sử dụng:

//Declare names
public static DatabasePreference ScannerDefaultFlashLight = new DatabasePreference();
public static DatabasePreference ScannerQrCodes = new DatabasePreference();
public static DatabasePreference Scanner1dCodes = new DatabasePreference();

Kiểm tra nó:

Console.WriteLine(ScannerDefaultFlashLight.PreferenceName);
Console.WriteLine(ScannerDefaultFlashLight.Scanner1dCodes);

đầu ra:

ScannerDefaultFlashLight
Scanner1dCodes

Dựa trên các ý kiến ​​khác, đây là những gì tôi nghĩ ra. Cách tiếp cận này tránh việc phải nhập. Giá trị mà bạn muốn nhận giá trị không đổi.

Tôi có một lớp cơ sở cho tất cả các enum chuỗi như thế này:

using System;
using Newtonsoft.Json;

[JsonConverter(typeof(ConstantConverter))]
public class StringEnum: IConvertible
{
    public string Value { get; set; }

    protected StringEnum(string value)
    {
        Value = value;
    }

    public static implicit operator string(StringEnum c)
    {
        return c.Value;
    }
    public string ToString(IFormatProvider provider)
    {
        return Value;
    }

    public TypeCode GetTypeCode()
    {
        throw new NotImplementedException();
    }

    public bool ToBoolean(IFormatProvider provider)
    {
        throw new NotImplementedException();
    }
    //The same for all the rest of IConvertible methods
}

JsonConverter giống như thế này:

using System;
using Newtonsoft.Json;

class ConstantConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return true;
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        if (value == null)
        {
            serializer.Serialize(writer, null);
        }
        else
        {
            serializer.Serialize(writer, value.ToString());
        }
    }
}

Và một chuỗi enum thực tế sẽ giống như thế này:

public sealed class Colors : StringEnum
{
    public static Colors Red { get { return new Catalog("Red"); } }
    public static Colors Yellow { get { return new Catalog("Yellow"); } }
    public static Colors White { get { return new Catalog("White"); } }

    private Colors(string value) : base(value) { }
}

Và với điều này, bạn chỉ có thể sử dụng Color.Red để thậm chí tuần tự hóa thành json mà không cần sử dụng thuộc tính Value

Tôi không cần bất cứ thứ gì mạnh mẽ như lưu trữ chuỗi trong các thuộc tính. Tôi chỉ cần biến một cái gì đó như MyEnum.BillEveryWeekthành "hóa đơn mỗi tuần" hoặc MyEnum.UseLegacySystemthành "sử dụng hệ thống kế thừa" - về cơ bản phân tách enum bằng vỏ lạc đà của nó thành các từ viết thường.

public static string UnCamelCase(this Enum input, string delimiter = " ", bool preserveCasing = false)
{
    var characters = input.ToString().Select((x, i) =>
    {

       if (i > 0 && char.IsUpper(x))
       {
           return delimiter + x.ToString(CultureInfo.InvariantCulture);
       }
       return x.ToString(CultureInfo.InvariantCulture);

    });

    var result = preserveCasing
       ? string.Concat(characters)
       : string.Concat(characters).ToLower();

    var lastComma = result.LastIndexOf(", ", StringComparison.Ordinal);

    if (lastComma > -1)
    {
       result = result.Remove(lastComma, 2).Insert(lastComma, " and ");
    }

    return result;
}

MyEnum.UseLegacySystem.UnCamelCase() đầu ra "sử dụng hệ thống kế thừa"

Nếu bạn có nhiều cờ được đặt, nó sẽ biến nó thành tiếng Anh đơn giản (được phân cách bằng dấu phẩy trừ dấu "và" thay cho dấu phẩy cuối cùng).

var myCustomerBehaviour = MyEnum.BillEveryWeek | MyEnum.UseLegacySystem | MyEnum.ChargeTaxes;

Console.WriteLine(myCustomerBehaviour.UnCamelCase());
//outputs "bill every week, use legacy system and charge taxes"