C# Parse从Enum获取对象值，然后必须将对象值更改为特定的Enum值。可以使用Convert.ChangeType转换为枚举值。请看一下下面的代码片段 public T ConvertStringValueToEnum<T>(string valueToParse){ return Convert.ChangeType(Enum.Parse(typeof(T), valueToParse, true), typeof(T)); } public T ConvertStringValueToEnum（字符串值ToParse）{ 返回Convert.ChangeType（Enum.Parse（typeof（T），valueToParse，true），typeof（T））； }

尝试以下示例：

 public static T GetEnum<T>(string model)
    {
        var newModel = GetStringForEnum(model);

        if (!Enum.IsDefined(typeof(T), newModel))
        {
            return (T)Enum.Parse(typeof(T), "None", true);
        }

        return (T)Enum.Parse(typeof(T), newModel.Result, true);
    }

    private static Task<string> GetStringForEnum(string model)
    {
        return Task.Run(() =>
        {
            Regex rgx = new Regex("[^a-zA-Z0-9 -]");
            var nonAlphanumericData = rgx.Matches(model);
            if (nonAlphanumericData.Count < 1)
            {
                return model;
            }
            foreach (var item in nonAlphanumericData)
            {
                model = model.Replace((string)item, "");
            }
            return model;
        });
    }

publicstatict GetEnum（字符串模型）
{
var newModel=GetStringForEnum（模型）；
如果（！Enum.IsDefined（typeof（T），newModel））
{
返回（T）Enum.Parse（typeof（T），“无”，true）；
}
返回（T）Enum.Parse（typeof（T），newModel.Result，true）；
}
私有静态任务GetStringForEnum（字符串模型）
{
返回任务。运行（（）=>
{
正则表达式rgx=新正则表达式（“[^a-zA-Z0-9-]”）；
var nonAlphanumericData=rgx.Matches（模型）；
if（非alphanumericData.Count<1）
{
收益模型；
}
foreach（非alphanumeric数据中的var项）
{
模型=模型。替换（（字符串）项“”）；
}
收益模型；
});
}

在此示例中，您可以发送每个字符串，并设置

Enum

。如果您的

Enum

具有所需的数据，请将其作为

Enum

类型返回。

        <Extension()>
    Public Function ToEnum(Of TEnum)(ByVal value As String, ByVal defaultValue As TEnum) As TEnum
        If String.IsNullOrEmpty(value) Then
            Return defaultValue
        End If

        Return [Enum].Parse(GetType(TEnum), value, True)
    End Function

公共函数ToEnum（共十个）（ByVal值为字符串，ByVal defaultValue为十个）为十个
如果String.IsNullOrEmpty（值），则
返回默认值
如果结束
返回[Enum].Parse（GetType（TEnum），value，True）
端函数

公共TEnum-ToEnum（此字符串值，TEnum-defaultValue）{
if（string.IsNullOrEmpty（value））
返回默认值；
返回Enum.Parse（typeof（TEnum），value，true）；}

不确定这是何时添加的，但在Enum类上现在有一个

Parse（stringValue）

与上述示例类似使用：

var MyStatus=Enum.Parse（“活动”）

或通过以下方式忽略套管：

var MyStatus=Enum.Parse（“active”，true）

以下是它使用的反编译方法：

[NullableContext（0）]
公共静态TEnum解析（[Nullable（1）]字符串值），其中TEnum:struct
{
返回Enum.Parse（值，false）；
}
[NullableContext（0）]
公共静态TEnum解析（[Nullable（1）]字符串值，bool ignoreCase），其中TEnum:struct
{
十年结果；
Enum.TryParse（值、ignoreCase、true、out结果）；
返回结果；
}

如果属性名称与您想要的名称不同（即语言差异），您可以这样做：

StatusEnum MyStatus = StatusEnum.Parse("Active");

   enum Mood
   {
      Angry,
      Happy,
      Sad
   } 

   // ...
   Mood m = (Mood) Enum.Parse(typeof(Mood), "Happy", true);
   Console.WriteLine("My mood is: {0}", m.ToString());

    public enum Store : short
{
    [Description("Rio Big Store")]
    Rio = 1
}

MyType.cs

using System;
using System.Runtime.Serialization;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;

[JsonConverter(typeof(StringEnumConverter))]
public enum MyType
{
    [EnumMember(Value = "person")]
    Person,
    [EnumMember(Value = "annan_deltagare")]
    OtherPerson,
    [EnumMember(Value = "regel")]
    Rule,
}

EnumExtensions.cs

using System;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;

public static class EnumExtensions
{
    public static TEnum ToEnum<TEnum>(this string value) where TEnum : Enum
    {
        var jsonString = $"'{value.ToLower()}'";
        return JsonConvert.DeserializeObject<TEnum>(jsonString, new StringEnumConverter());
    }

    public static bool EqualsTo<TEnum>(this string strA, TEnum enumB) where TEnum : Enum
    {
        TEnum enumA;
        try
        {
            enumA = strA.ToEnum<TEnum>();
        }
        catch
        {
            return false;
        }
        return enumA.Equals(enumB);
    }
}

使用系统；
使用Newtonsoft.Json；
使用Newtonsoft.Json.Converters；
公共静态类枚举扩展
{
公共静态TEnum-ToEnum（此字符串值），其中TEnum:Enum
{
var jsonString=$“{value.ToLower（）}”；
返回JsonConvert.DeserializeObject（jsonString，new StringEnumConverter（））；
}
公共静态bool EqualsTo（这个字符串strA，TEnum enumB），其中TEnum:Enum
{
细线；
尝试
{
enumA=strA.ToEnum（）；
}
抓住
{
返回false；
}
返回enumA.Equals（enumB）；
}
}

Program.cs

public class Program
{
    static public void Main(String[] args) 
    { 
        var myString = "annan_deltagare";
        var myType = myString.ToEnum<MyType>();
        var isEqual = myString.EqualsTo(MyType.OtherPerson);
        //Output: true
    }     
}

公共类程序
{
静态公共void Main（字符串[]args）
{ 
var myString=“annan_deltagare”；
var myType=myString.ToEnum（）；
var isEqual=myString.EqualsTo（MyType.OtherPerson）；
//输出：真
}     
}

如果要在null或空时使用默认值（例如，从配置文件检索时，该值不存在），并在字符串或数字与任何枚举值不匹配时引发异常。但要注意提莫回答中的警告（）

public static T ParseEnum（此字符串s，T defaultValue，bool ignoreCase=false）
其中T:struct，IComparable，IConvertible，IFormattable//如果C#>=7.3:struct，System.Enum
{
如果（（s？长度±0）=0）
{
返回默认值；
}
var valid=Enum.TryParse（s，ignoreCase，out T res）；
如果定义了（！valid | | |！Enum.IsDefined（typeof（T），res））
{
抛出新的InvalidOperationException(
$“{s}”不是枚举“{typeof（T）.FullName}”！”的有效值；
}
返回res；
}

首先，您需要装饰您的枚举，如下所示：

StatusEnum MyStatus = StatusEnum.Parse("Active");

   enum Mood
   {
      Angry,
      Happy,
      Sad
   } 

   // ...
   Mood m = (Mood) Enum.Parse(typeof(Mood), "Happy", true);
   Console.WriteLine("My mood is: {0}", m.ToString());

    public enum Store : short
{
    [Description("Rio Big Store")]
    Rio = 1
}

在.net 5中，我创建了以下扩展方法：

//The class also needs to be static, ok?
public static string GetDescription(this System.Enum enumValue)
    {
        FieldInfo fi = enumValue.GetType().GetField(enumValue.ToString());

        DescriptionAttribute[] attributes = (DescriptionAttribute[])fi.GetCustomAttributes(
            typeof(DescriptionAttribute), false);

        if (attributes != null && attributes.Length > 0) return attributes[0].Description;
        else return enumValue.ToString();
    }

现在，您可以在任何枚举中使用扩展方法

像这样：

var Desc = Store.Rio.GetDescription(); //Store is your Enum

---

如果绩效是重要的（总是重要的），那么Mckenzieg1给出的chk答案如下：@Avinash关于@Mckenzieg1的答案是正确的，但并不总是重要的。例如，如果您对每次分析都进行DB调用，那么担心枚举分析将是一种毫无意义的微观优化。@H.M.我认为扩展在这里并不合适-这是一种特殊情况，扩展将应用于每个字符串。如果你真的想这么做，那只是一个小小的改变。Enum.TryParse怎么样？很好。在上一个示例中，您需要where T:struct。如果代码已经包含描述，是否需要进行描述？好的，我这样做了：）我已经更新了它，将值作为对象，并将其转换为该方法内的字符串。通过这种方式，我可以使用int值.ToEnum而不是字符串。@SollyM我认为这是一个可怕的想法，因为这个扩展方法将应用于所有对象类型。两个扩展方法，一个用于字符串，一个用于int，在我看来会更干净、更安全。@Svish，没错。我这样做的唯一原因是因为我们的代码只在内部使用，我想避免编写2个扩展。由于我们唯一一次转换为Enum是使用string或int，所以我认为在其他方面没有问题。@S

/// <summary>
/// Parses string to TEnum without try/catch and .NET 4.5 TryParse()
/// </summary>
public static bool TryParseToEnum<TEnum>(string probablyEnumAsString_, out TEnum enumValue_) where TEnum : struct
{
    enumValue_ = (TEnum)Enum.GetValues(typeof(TEnum)).GetValue(0);
    if(!Enum.IsDefined(typeof(TEnum), probablyEnumAsString_))
        return false;

    enumValue_ = (TEnum) Enum.Parse(typeof(TEnum), probablyEnumAsString_);
    return true;
}

StatusEnum myStatus;
Enum.TryParse("Active", out myStatus);

Enum.TryParse("Active", out StatusEnum myStatus);

public static T ToEnum<T>(this string value, bool ignoreCase = true)
{
    return (T) Enum.Parse(typeof (T), value, ignoreCase);
}

FilterType filterType = type.ToEnum<FilterType>();

public static T ParseEnum<T>(string value, T defaultValue) where T : struct
{
    try
    {
        T enumValue;
        if (!Enum.TryParse(value, true, out enumValue))
        {
            return defaultValue;
        }
        return enumValue;
    }
    catch (Exception)
    {
        return defaultValue;
    }
}

StatusEnum MyStatus = EnumUtil.ParseEnum("Active", StatusEnum.None);

StatusEnum MyStatus = Enum<StatusEnum>.Parse("Active");

public static T ParseEnum<T>(string value)            //function declaration  
{
    return (T) Enum.Parse(typeof(T), value);
}

Importance imp = EnumUtil.ParseEnum<Importance>("Active");   //function call

using System;

class Program
{
    enum PetType
    {
    None,
    Cat = 1,
    Dog = 2
    }

    static void Main()
    {

    // Possible user input:
    string value = "Dog";

    // Try to convert the string to an enum:
    PetType pet = (PetType)Enum.Parse(typeof(PetType), value);

    // See if the conversion succeeded:
    if (pet == PetType.Dog)
    {
        Console.WriteLine("Equals dog.");
    }
    }
}
-------------
Output

Equals dog.

namespace System
{
    public static class StringExtensions
    {

        public static bool TryParseAsEnum<T>(this string value, out T output) where T : struct
        {
            T result;

            var isEnum = Enum.TryParse(value, out result);

            output = isEnum ? result : default(T);

            return isEnum;
        }
    }
}

using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
using static System.Console;

private enum Countries
    {
        NorthAmerica,
        Europe,
        Rusia,
        Brasil,
        China,
        Asia,
        Australia
    }

   [TestMethod]
        public void StringExtensions_On_TryParseAsEnum()
        {
            var countryName = "Rusia";

            Countries country;
            var isCountry = countryName.TryParseAsEnum(out country);

            WriteLine(country);

            IsTrue(isCountry);
            AreEqual(Countries.Rusia, country);

            countryName = "Don't exist";

            isCountry = countryName.TryParseAsEnum(out country);

            WriteLine(country);

            IsFalse(isCountry);
            AreEqual(Countries.NorthAmerica, country); // the 1rst one in the enumeration
        }

enum Example
{
    One = 1,
    Two = 2,
    Three = 3
}

var x = Enum.Parse("One,Two"); // x is now Three

    public static bool TryParse<T>(string value, out T result)
        where T : struct
    {
        var cacheKey = "Enum_" + typeof(T).FullName;

        // [Use MemoryCache to retrieve or create&store a dictionary for this enum, permanently or temporarily.
        // [Implementation off-topic.]
        var enumDictionary = CacheHelper.GetCacheItem(cacheKey, CreateEnumDictionary<T>, EnumCacheExpiration);

        return enumDictionary.TryGetValue(value.Trim(), out result);
    }

    private static Dictionary<string, T> CreateEnumDictionary<T>()
    {
        return Enum.GetValues(typeof(T))
            .Cast<T>()
            .ToDictionary(value => value.ToString(), value => value, StringComparer.OrdinalIgnoreCase);
    }

    private static Dictionary<Type, Dictionary<string, object>> dicEnum = new Dictionary<Type, Dictionary<string, object>>();
    public static T ToEnum<T>(this string value, T defaultValue)
    {
        var t = typeof(T);
        Dictionary<string, object> dic;
        if (!dicEnum.ContainsKey(t))
        {
            dic = new Dictionary<string, object>();
            dicEnum.Add(t, dic);
            foreach (var en in Enum.GetValues(t))
                dic.Add(en.ToString(), en);
        }
        else
            dic = dicEnum[t];
        if (!dic.ContainsKey(value))
            return defaultValue;
        else
            return (T)dic[value];
    }

using System.Runtime.Serialization;

public static TEnum ToEnum<TEnum>(this string value, TEnum defaultValue) where TEnum : struct
{
    if (string.IsNullOrEmpty(value))
    {
        return defaultValue;
    }

    TEnum result;
    var enumType = typeof(TEnum);
    foreach (var enumName in Enum.GetNames(enumType))
    {
        var fieldInfo = enumType.GetField(enumName);
        var enumMemberAttribute = ((EnumMemberAttribute[]) fieldInfo.GetCustomAttributes(typeof(EnumMemberAttribute), true)).FirstOrDefault();
        if (enumMemberAttribute?.Value == value)
        {
            return Enum.TryParse(enumName, true, out result) ? result : defaultValue;
        }
    }

    return Enum.TryParse(value, true, out result) ? result : defaultValue;
}

public enum OracleInstanceStatus
{
    Unknown = -1,
    Started = 1,
    Mounted = 2,
    Open = 3,
    [EnumMember(Value = "OPEN MIGRATE")]
    OpenMigrate = 4
}

var value = "Active";

StatusEnum status;
if (!Enum.TryParse<StatusEnum>(value, out status))
    status = StatusEnum.Unknown;

public T ConvertStringValueToEnum<T>(string valueToParse){
    return Convert.ChangeType(Enum.Parse(typeof(T), valueToParse, true), typeof(T));
}

 public static T GetEnum<T>(string model)
    {
        var newModel = GetStringForEnum(model);

        if (!Enum.IsDefined(typeof(T), newModel))
        {
            return (T)Enum.Parse(typeof(T), "None", true);
        }

        return (T)Enum.Parse(typeof(T), newModel.Result, true);
    }

    private static Task<string> GetStringForEnum(string model)
    {
        return Task.Run(() =>
        {
            Regex rgx = new Regex("[^a-zA-Z0-9 -]");
            var nonAlphanumericData = rgx.Matches(model);
            if (nonAlphanumericData.Count < 1)
            {
                return model;
            }
            foreach (var item in nonAlphanumericData)
            {
                model = model.Replace((string)item, "");
            }
            return model;
        });
    }

        <Extension()>
    Public Function ToEnum(Of TEnum)(ByVal value As String, ByVal defaultValue As TEnum) As TEnum
        If String.IsNullOrEmpty(value) Then
            Return defaultValue
        End If

        Return [Enum].Parse(GetType(TEnum), value, True)
    End Function

public TEnum ToEnum<TEnum>(this string value, TEnum defaultValue){
if (string.IsNullOrEmpty(value))
    return defaultValue;

return Enum.Parse(typeof(TEnum), value, true);}

using System;
using System.Runtime.Serialization;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;

[JsonConverter(typeof(StringEnumConverter))]
public enum MyType
{
    [EnumMember(Value = "person")]
    Person,
    [EnumMember(Value = "annan_deltagare")]
    OtherPerson,
    [EnumMember(Value = "regel")]
    Rule,
}

using System;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;

public static class EnumExtensions
{
    public static TEnum ToEnum<TEnum>(this string value) where TEnum : Enum
    {
        var jsonString = $"'{value.ToLower()}'";
        return JsonConvert.DeserializeObject<TEnum>(jsonString, new StringEnumConverter());
    }

    public static bool EqualsTo<TEnum>(this string strA, TEnum enumB) where TEnum : Enum
    {
        TEnum enumA;
        try
        {
            enumA = strA.ToEnum<TEnum>();
        }
        catch
        {
            return false;
        }
        return enumA.Equals(enumB);
    }
}

public class Program
{
    static public void Main(String[] args) 
    { 
        var myString = "annan_deltagare";
        var myType = myString.ToEnum<MyType>();
        var isEqual = myString.EqualsTo(MyType.OtherPerson);
        //Output: true
    }     
}

    public static T ParseEnum<T>(this string s, T defaultValue, bool ignoreCase = false) 
        where T : struct, IComparable, IConvertible, IFormattable//If C# >=7.3: struct, System.Enum 
    {
        if ((s?.Length ?? 0) == 0)
        {
            return defaultValue;
        }

        var valid = Enum.TryParse<T>(s, ignoreCase, out T res);

        if (!valid || !Enum.IsDefined(typeof(T), res))
        {
            throw new InvalidOperationException(
                $"'{s}' is not a valid value of enum '{typeof(T).FullName}'!");
        }
        return res;
    }

    public enum Store : short
{
    [Description("Rio Big Store")]
    Rio = 1
}

//The class also needs to be static, ok?
public static string GetDescription(this System.Enum enumValue)
    {
        FieldInfo fi = enumValue.GetType().GetField(enumValue.ToString());

        DescriptionAttribute[] attributes = (DescriptionAttribute[])fi.GetCustomAttributes(
            typeof(DescriptionAttribute), false);

        if (attributes != null && attributes.Length > 0) return attributes[0].Description;
        else return enumValue.ToString();
    }

var Desc = Store.Rio.GetDescription(); //Store is your Enum