如何转换（字符串，标记的列表，枚举与标志）之间的一个枚举？ [英] How do I convert an enum between (string, list of flags, enum with flags)?

问题描述

我如何从枚举转换为字符串，反之亦然？

How do I convert from enums to strings and vice versa?

和服用该枚举可以包含多个标志我怎么能得到的所有名单的情况下，标志枚举包含？

And taking the case that enums can contain multiple flags, how can I get a list of all the flags an enum contains?

推荐答案

从枚举字符串： [枚举实例]的ToString（ ）;

例如：使用System.Windows.Input;

ModifierKeys mk = ModifierKeys.None | ModifierKeys.Alt | ModifierKeys.Shift | ModifierKeys.Control;
mk.Tostring();

返回：

returns:

Alt，Ctrl，Shift键
注：无标志得到了删除

Alt, Control, Shift Note: "None" flag got removed

从字符串枚举：

Enum.TryParse（[（字符串）值]出[店面变量]）;

或

Enum.Parse（typeof运算（[枚举类型]），[（字符串）值]，[（布尔）应忽略字符大小写]）;

例如：<？code>使用System.Windows.Input ;

// Way 1:
ModifierKeys outenum;
bool successful = Enum.TryParse("None,Alt,Control,Shift", out outenum);

Console.WriteLine($"Is Successful ? : {successful}, result : {outenum.ToString()}");

结果：是否成功？ ：是的，结果是：Alt，Ctrl，Shift键

或

// Way 2:
ModifierKeys outenum = (ModifierKeys)Enum.Parse(typeof(ModifierKeys), "None,Alt,Control,Shift", true);
Console.WriteLine(outenum.ToString());

结果： Alt，Ctrl，Shift键

从枚举标志为List

例如：

        ModifierKeys mk = ModifierKeys.None | ModifierKeys.Alt | ModifierKeys.Shift | ModifierKeys.Control;
        List<ModifierKeys> mklist =
            mk
            .ToString() // Convert the enum to string
            .Split(new[] { "," } , StringSplitOptions.RemoveEmptyEntries) // Converts the string to Enumerable of string
            .Select(//converts each element of the list to an enum, and makes an Enumerable out of the newly-converted items
                strenum =>
                {
                    ModifierKeys outenum;
                    Enum.TryParse(strenum , out outenum);
                    return outenum;
                })
            .ToList(); // Creates a List from the Enumerable

结果： {ModifierKeys.Alt， ModifierKeys.Shift，ModifierKeys.Control}

从枚举标志清单枚举

例如：

 ModifierKeys[] mk = {ModifierKeys.None, ModifierKeys.Alt, ModifierKeys.Control, ModifierKeys.Shift};
 ModifierKeys mkc = mk.Aggregate((prev, next) => prev | next);
 Console.WriteLine(mkc.ToString());

结果： Alt，Ctrl，Shift键

从字符串列表来枚举

例如：

    string[] mk = {"None", "Alt", "Control", "Shift"};
    ModifierKeys mkc = mk.Select(x => {ModifierKeys outenum; Enum.TryParse(x, out outenum); return outenum;}).Aggregate((prev , next) => prev | next);
    Console.WriteLine(mkc.ToString());

结果： Alt，Ctrl，Shift键

• 使用方法1，从字符串转换为枚举，当是首选，因为如果方法2失败，它抛出一个异常，但如果方法1失败则返回false


• 当分离枚举标志在解析枚举字符串，使用，分离器仅


• 有标记之间的空格枚举字符串都不会有问题，所以
  无，Alt，Ctrl，Shift键 = 无，Alt，Ctrl，Shift键

• Using way 1 when converting from string to Enum is preferred, because if way 2 fails it throws an exception, but if way 1 fails it returns false
• When separating enum flags while parsing enum string, use the , separator only
• Having spaces between flags in enum string won't matter, so "None , Alt,Control, Shift" = "None,Alt,Control,Shift"

我写了一个简单的通用EnumConverter类为您节省时间

I wrote a simple Generic EnumConverter class that saves you time

public class EnumConverter<T> where T : struct, IConvertible, IFormattable
{
    private Type EnumType { get; set; }

    public Type UnderlyingType
    {
        get
        {
            return Enum.GetUnderlyingType(EnumType);
        }
    }
    public EnumConverter()
    {
        if (typeof(T).IsEnum)
            EnumType = typeof(T);
        else
            throw new ArgumentException("Provided type must be an enum");
    }
    public IEnumerable<T> ToFlagsList(T FromSingleEnum)
    {
        return FromSingleEnum.ToString()
        .Split(new[] { "," } , StringSplitOptions.RemoveEmptyEntries)
        .Select(
            strenum =>
            {
                T outenum = default(T);
                Enum.TryParse(strenum , true , out outenum);
                return outenum;
            });
    }
    public IEnumerable<T> ToFlagsList(IEnumerable<string> FromStringEnumList)
    {
        return FromStringEnumList
        .Select(
            strenum =>
            {
                T outenum = default(T);
                Enum.TryParse(strenum , true , out outenum);
                return outenum;
            });
    }

    public T ToEnum(string FromString)
    {
        T outenum = default(T);
        Enum.TryParse(FromString , true , out outenum);
        return outenum;
    }
    public T ToEnum(IEnumerable<T> FromListOfEnums)
    {
        var provider = new NumberFormatInfo();
        var intlist = FromListOfEnums.Select(x => x.ToInt32(provider));
        var aggregatedint = intlist.Aggregate((prev , next) => prev | next);
        return (T)Enum.ToObject(EnumType , aggregatedint);
    }
    public T ToEnum(IEnumerable<string> FromListOfString)
    {
        var enumlist = FromListOfString.Select(x =>
        {
            T outenum = default(T);
            Enum.TryParse(x , true , out outenum);
            return outenum;
        });
        return ToEnum(enumlist);
    }

    public string ToString(T FromEnum)
    {
        return FromEnum.ToString();
    }
    public string ToString(IEnumerable<T> FromFlagsList)
    {
        return ToString(ToEnum(FromFlagsList));
    }

    public object ToUnderlyingType(T FromeEnum)
    {
        return Convert.ChangeType(FromeEnum , UnderlyingType);
    }
}

用法：

Usage :

 EnumConverter<ModifierKeys> conv = new EnumConverter<ModifierKeys>();
 //conv.ToEnum
 //conv.ToFlagsList
 //conv.ToString

这篇关于如何转换（字符串，标记的列表，枚举与标志）之间的一个枚举？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！