在c#中关联枚举和字符串

我只需创建一个字典，并使用代码作为键。

编辑:为了解决关于执行反向查找(查找键)的注释，这将不是非常有效。如果有必要，我将编写一个新类来处理它。

为你的DB创建第二个枚举，包含以下内容:

enum DBGroupTypes
{
OEM = 0,
CMB = 1
}

现在，您可以使用Enum。解析以从字符串“OEM”和“CMB”中检索正确的DBGroupTypes值。然后，您可以将这些值转换为int，并从您希望在模型中进一步使用的正确枚举中检索正确的值。

可以向枚举中的项添加属性，然后使用反射从属性中获取值。

你必须使用"field"说明符来应用属性，如下所示:

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


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

然后你将反射枚举类型的静态字段(在本例中是GroupTypes)，并使用反射获得你正在寻找的值的DescriptionAttribute:

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

我选择在上面返回DescriptionAttribute本身，以便您能够确定是否应用了该属性。

使用类。

编辑:更好的例子

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

尝试向静态类中添加常量。你最终不会得到一个Type，但你会得到可读的、有组织的常量:

public static class GroupTypes {


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


}

您是否考虑过使用字典查找表?

enum GroupTypes
{
TheGroup,
TheOtherGroup
}


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

然后，您可以使用GroupTypeLookup.TryGetValue()在读取字符串时查找它。

我会把它变成一个类，完全避免使用枚举。然后使用类型处理程序，你可以在从db中获取对象时创建对象。

即:

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


}

你也可以使用扩展模型:

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

你的扩展类

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

用法:

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

我的第一个问题-你有访问数据库本身的权限吗?这应该在数据库中规范化，否则，任何解决方案都将容易出错。根据我的经验，充满“OEM”和“CMB”的数据字段往往会随着时间的推移混合“OEM”和其他“垃圾数据”....如果可以规范化它，就可以使用包含元素的表中的键作为Enum，这样就完成了，结构更加简洁。

如果这是不可用的，我将使你的Enum，并使一个类来解析你的字符串为你的Enum。这至少会让您在处理非标准条目时具有一定的灵活性，在捕获或处理错误时也比使用enumeration . parse /Reflection/etc等方法灵活得多。字典可以工作，但如果你遇到大小写问题，可能会崩溃。

我建议你写一个类，这样你就可以:

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

这样可以保留大部分的可读性，而不必更改DB。

我喜欢使用类中的属性而不是方法，因为它们看起来更像枚举。

下面是一个Logger的例子:

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


public string Value { get; private 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"); } }


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

将类型安全的字符串值作为参数传入:

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

用法:

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

你可以很容易地做到。使用下面的代码。

enum GroupTypes
{
OEM,
CMB
};

然后，当您想获取每个枚举元素的字符串值时，只需使用下面的代码行。

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

我曾经成功地使用过这个方法，我也使用过一个常量类来保存字符串常量，两者都很好，但我倾向于这样做。

这里是扩展方法，我用来获得枚举值作为字符串。首先是枚举。

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

Description属性来自System.ComponentModel。

这是我的扩展方法:

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

现在，你可以使用下面的代码访问枚举字符串值:

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

使用带有常量的静态类如何?

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

c#不支持枚举字符串，但在大多数情况下，您可以使用List或Dictionary来获得所需的效果。

打印通过/失败结果:

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

如果我理解正确，你需要一个从字符串到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");

如果您愿意，可以使用枚举类型的泛型使其更加花哨。

根据其他人的意见，这是我想到的。这种方法避免了在想要获得常量值的地方键入. value。

我有一个基类的所有字符串枚举像这样:

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是这样的:

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

一个实际的string enum是这样的:

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

有了这个，你可以使用颜色。红色甚至序列化到json而不使用Value属性

我甚至实现了@Even(通过class X和public static X成员)建议的一些枚举，只是为了后来发现，这些天，从。net 4.5开始，有正确的 ToString()方法。

现在我将所有内容重新实现为枚举。

我不需要任何健壮的东西，比如将字符串存储在属性中。我只需要将MyEnum.BillEveryWeek转换为“每周账单”或MyEnum.UseLegacySystem转换为“使用遗留系统”——基本上是将枚举通过驼形大小写分割为单个小写单词。

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()输出“使用遗留系统”

如果设置了多个标志，它会将其转换为普通英语(逗号分隔，除了最后一个逗号中的“and”)。

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


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

您可以使用两个枚举。一个用于数据库，另一个用于可读性。

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


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

要使用它，你只需要先转换为代码:

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

然后，如果你想让它更方便，你可以添加一个扩展函数，只适用于这种类型的枚举:

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

然后你可以这样做:

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

在VS 2015中，你可以使用nameof

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

用法:

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

这是一种使用作为强类型参数或字符串的方法:

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

Glennular Extension方法的一个小调整，所以你可以在其他东西上使用扩展，而不仅仅是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;
}
}
}

或者使用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;
}
}

另一种处理这个问题的方法是，有一个枚举和一个字符串数组，将枚举值映射到字符串列表:

public enum GroupTypes
{
TheGroup  = 0,
TheOtherGroup
}


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

你可以这样使用它:

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

它将提示CMB

优点:

1. 简单干净的代码。
2. 高性能(特别是与那些方法相比 李使用类)< / >

缺点:

1. 在编辑列表时容易弄乱列表，但对于a来说是可以的 李短名单。< / >

我基本上是在寻找@ArthurC的反思答案

稍微扩展一下他的回答，你可以通过一个泛型函数来让它更好:

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

然后你就可以把你有的东西都包起来了

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

或

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

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

我做过类似的事情;

public enum BusinessUnits
{
NEW_EQUIPMENT = 0,
USED_EQUIPMENT = 1,
RENTAL_EQUIPMENT = 2,
PARTS = 3,
SERVICE = 4,
OPERATOR_TRAINING = 5
}


public class BusinessUnitService
{
public static string StringBusinessUnits(BusinessUnits BU)
{
switch (BU)
{
case BusinessUnits.NEW_EQUIPMENT: return "NEW EQUIPMENT";
case BusinessUnits.USED_EQUIPMENT: return "USED EQUIPMENT";
case BusinessUnits.RENTAL_EQUIPMENT: return "RENTAL EQUIPMENT";
case BusinessUnits.PARTS: return "PARTS";
case BusinessUnits.SERVICE: return "SERVICE";
case BusinessUnits.OPERATOR_TRAINING: return "OPERATOR TRAINING";
default: return String.Empty;
}
}
}

用这个称呼它;

BusinessUnitService.StringBusinessUnits(BusinessUnits.PARTS)

我想完全避免使用字符串字面量，而且我也不需要在项目描述中有空间。更重要的是，我想要有一种机制来检查所提供的字符串是否是一个有效的项目，所以我想出了这个解决方案:

public class Seasons
{
public static string Spring { get; }
public static string Summer { get; }
public static string Fall { get; }
public static string Winter { get; }


public static bool IsValid(string propertyName)
{
if (string.IsNullOrEmpty(propertyName))
{
return false;
}


try
{
return typeof(Seasons).GetProperty(propertyName) != null;
}
catch
{
return false;
}
}
}

它是这样工作的:

void Main()
{
string s = nameof(Seasons.Fall);
Console.WriteLine($"Fall is valid: {Seasons.IsValid(s)}"); // true


s = "WrongSeason";
Console.WriteLine($"WrongSeason is valid: {Seasons.IsValid(s)}"); // false
}

我尝试将IsValid()重构为基类并使用反射来读取类型(MethodBase.GetCurrentMethod(). declaringtype)，但由于我希望它是静态的，所以它返回基类类型，而不是继承的类型。你的补救措施将是非常欢迎的!这就是我想要达到的目标:

public  class Seasons : ConstantStringsBase
{
// ... same
}


public  class ConstantStringsBase
{
public static bool IsValid(string propertyName)
{
return MethodBase.GetCurrentMethod().DeclaringType.GetProperty(propertyName) != null;
}
}

到目前为止，我有以下结果:

        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 .... :(:(

奇迹发生的地方:

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






}

我只需要为我的枚举声明这个:

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

摘自@EvenMien，并添加了一些评论。(也适用于我自己的用例)

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("Login");
public static AgentAction Logout = new AgentAction("Logout");


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

添加这个类

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

这项工作使用CallerMemberName来最小化编码

使用:

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

测试:

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

输出:

ScannerDefaultFlashLight
Scanner1dCodes

.Net Core 3.0/ c# 8.0(如果您的工作环境允许您升级项目)中新增了一个简短的switch语句，看起来有点枚举。在一天结束的时候，这和我们多年来一直在使用的无聊的开关语句是一样的。

这里唯一真正的区别是switch语句得到了一个新的suit。

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

你会注意到上面我从在这里复制的代码，实际上是使用一个enum作为参数。

这并不是您想要的(相信我，我早就想要类似OP要求的东西了)，但我实际上觉得这是MS. JMO抛出的橄榄枝。

希望它能帮助到一些人!

我使用了在之前的回答中提到的结构，但去掉了任何复杂性。对我来说，这就像创建一个字符串枚举。它的使用方式与枚举的使用方式相同。

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

使用示例:

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

为什么不使用相同的枚举，而只是调用.ToString()?

using System;


public class EnumSample
{
enum Holidays
{
Christmas = 1,
Easter = 2
};


public static void Main()
{
Enum myHolidays = Holidays.Christmas;
Console.WriteLine("The value of this instance is '{0}'", myHolidays.ToString());
}
}

下面是我对这个问题的看法，使用c# 9.0语法来保持整洁。我为枚举定义了一个基类:

public class StringEnum
{
protected StringEnum(string value) { Value = value; }
public string Value { get; }
public override string ToString() => Value;
}

创建新的枚举样式类型是简单而紧凑的:

public class GroupTypes : StringEnum
{
private GroupTypes(string value) : base(value) {}


public static readonly GroupTypes TheGroup = new("OEM");
public static readonly GroupTypes TheOtherGroup = new("CMB");
}

像这样使用它:

void Example(GroupTypes groupType)
{
Console.WriteLine(groupType); // Will print "OEM" or "CMB"
if (groupType == GroupTypes.TheGroup) { ... }
}

您还可以向StringEnum添加更多的功能，然后它将对所有子类可用(例如，实现IComparable并覆盖Equals和GetHashCode)

如果不是你的枚举的所有值都有一个字符串，如果你想稍后设置这些值，我使用如下类:

 public class SessionResoult
{
public enum SessionResoultType
{
Success,
Error,
}
public SessionResoult(SessionResoultType sesionResoultType, string value = null)
{
Type = sesionResoultType;
Value = value;
       

}


public SessionResoultType Type { get; set; }


public string Value { get; private set; }
  



public sealed class Success : SessionResoult
{
public Success() : base(SessionResoultType.Success) { }
}


public sealed class Error : SessionResoult
{
public Error(string value) : base(SessionResoultType.Error, value) { }
}


public override string ToString()
{
if(this is Success)
{
return (SessionResoultType.Success.ToString());
}else if(this is Error)
{
return $"{SessionResoultType.Error}:{this.Value}";
}
else { return base.ToString(); }
}


}

使用的例子:

# EYZ0

如果你喜欢自己编写扩展，上面有几个很好的答案

我使用CodeHelper.Core.Extensions

enum GroupTypes
{


[StringValue("OEM")] TheGroup,
[StringValue("CMB")] TheOtherGroup = "CMB"
}


GroupTypes.TheOtherGroup.ToStringValue()

我要分享一个不同的答案。我想发送一个字符串来返回一个字符串。例如:Airport = A, Railway = R。

public enum LocationType
{
AIRPORT = 1,
RAILWAY = 2,
DOWNTOWN = 3
}
    

public enum ShortLocationType
{
A = 1,
R = 2,
D = 3
}


((ShortLocationType)(int)Enum.Parse(typeof(LocationType), "AIRPORT")).ToString();

输出“A"

((ShortLocationType)(int)Enum.Parse(typeof(LocationType), "DOWNTOWN")).ToString();

输出“D"

基于https://stackoverflow.com/a/1343517/1818723，我想出了一个带有TryParse方法的enum

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


public string Value { get; private set; }


private static List<FancyStringEnum> choices = new List<FancyStringEnum>
{
new FancyStringEnum("Small") ,
new FancyStringEnum("Big Thing") ,
new FancyStringEnum("Value with Spaces")
};


public static FancyStringEnum Small { get { return choices[0]; } }
public static FancyStringEnum BigThing { get { return choices[1]; } }
public static FancyStringEnum ValueWithSpaces { get { return choices[2]; } }


public override string ToString()
{
return Value;
}


public static bool TryParse(string value, bool ignoreCase, out FancyStringEnum result)
{
var sc = StringComparison.InvariantCulture;
if (ignoreCase)
sc = StringComparison.InvariantCultureIgnoreCase;


foreach (var choice in choices)
{


if (choice.Value.Equals(value, sc))
{
result = choice;
return true;
}
}


result = new FancyStringEnum(null);
return false;
}


public static FancyStringEnum Parse(string value, bool ignoreCase)
{
var sc = StringComparison.InvariantCulture;
if (ignoreCase)
sc = StringComparison.InvariantCultureIgnoreCase;


foreach (var choice in choices)
{


if (choice.Value.Equals(value, sc))
{
return choice;
}
}


return new FancyStringEnum(null);
}
}

将类型安全的字符串值作为参数传入:

public static void Do(string message, FancyStringEnum value)
{
if (value == FancyStringEnum.Small)
{
//do something
} else if (value == FancyStringEnum.BigThing)
{
//do something else
}
}

TryParse和解析在行动:

string something = "something"; //substiture with "small" to see it parsed
if (FancyStringEnum.TryParse(something, true, out var se))
Console.WriteLine(se.Value);
else
Console.WriteLine($"unable to parse {something}");


//or


var v2 = FancyStringEnum.Parse(something, true);
if (v2.Value == null)
Console.WriteLine($"unable to parse {something}");
else
Console.WriteLine(v2.Value); //do something with parsed enum


    

是否可以提取基类，用更少的代码创建StringEnums