使用 C# 2.0 中的泛型將分隔字符串轉換為數組枚舉

Question

我需要將逗號分隔的字符串轉換為泛型類中的枚舉類型數組。

問題是我需要基於泛型 T 創建一個數組。

這是我的代碼：

class Program
{
    static void Main(string[] args)
    {
        var testIt = new TestIt<TestValues[]>();
        TestValues[] converted = testIt.Convert("Pizza,Sub");
    }
}

public class TestIt<T> 
{
    public T Convert(string delimitedValues)
    {
        var valueType = typeof(T);
        var elementType = valueType;
        if (!valueType.IsArray)
        {
            throw new Exception("T is not an array");
        }

        if (valueType.HasElementType)
        {
            elementType = valueType.GetElementType();
        }

        var elements = delimitedValues.Split(',');
        foreach (var elementValue in elements)
        {
            var newElement = Enum.Parse(elementType, elementValue.Trim(), true);
            // not sure what I can do with the element here
        }

    }
}

public enum TestValues
{
    Unknown,
    Pizza,
    Sub,
    Burger
}

關於我如何做到這一點的任何想法？ 我難住了！

我嘗試創建枚舉類型的對象數組，但似乎無法將其轉換為 T。

請記住，這是.Net Framwork 2.0，所以我的工具箱是有限的。

感謝任何人都可以提供的任何想法。

Answer 1

試試這個類：

public class TestIt
{
    public static T[] Convert<T>(string delimitedValues)
    {
        if (!typeof(T).IsEnum)
        {
            throw new ArgumentException();
        }

        if (delimitedValues == string.Empty)
        {
            return new T[0];
        }

        string[] parts = delimitedValues.Split(',');
        T[] converted = Array.ConvertAll(parts, x => (T)Enum.Parse(typeof(T), x));
        return converted;
    }
}

按照慣例，您使用T作為泛型參數而不是T[]

像這樣使用它：

TestValues[] values = TestIt.Convert<TestValues>("Unknown,Pizza");

即使少一個演員，你也可以做到：

public static T[] Convert<T>(string delimitedValues) where T : struct
{
    if (!typeof(T).IsEnum)
    {
        throw new ArgumentException();
    }

    if (delimitedValues == string.Empty)
    {
        return new T[0];
    }

    string[] parts = delimitedValues.Split(',');
    T[] converted = new T[parts.Length];

    for (int i = 0; i < parts.Length; i++)
    {
        if (!Enum.TryParse(parts[i], out converted[i]))
        {
            throw new FormatException(parts[i]);
        }
    }

    return converted;
}

如果你願意，你甚至可以有一個返回T?[] （一個可以為空的枚舉數組）

public static T?[] ConvertNullable<T>(string delimitedValues) where T : struct
{
    if (!typeof(T).IsEnum)
    {
        throw new ArgumentException();
    }

    if (delimitedValues == string.Empty)
    {
        return new T[0];
    }

    string[] parts = delimitedValues.Split(',');
    T?[] converted = new T?[parts.Length];

    for (int i = 0; i < parts.Length; i++)
    {
        if (parts[i] == string.Empty)
        {
            continue;
        }

        T value;

        if (!Enum.TryParse(parts[i], out value))
        {
            throw new FormatException(parts[i]);
        }

        converted[i] = value;
    }

    return converted;
}

使用它喜歡;

TestValues?[] values = TestIt.ConvertNullable<TestValues>(",Unknown,,Pizza,");

請注意，最后一個版本不會跳過“無效”值，它仍然會拋出這些值。 只需將string.Empty元素轉換為null 。 可悲的是有一個問題：如果你ConvertNullable<TestValues>(string.Empty)它將返回一個TestValues[0] ，但該字符串甚至可以轉換為TestValues[1] { null } 。

現在，如果你真的想要一個包含所有東西的披薩：

public static class EnumSplitter
{
    public static T[] Convert<T>(string delimitedValues) where T : struct
    {
        if (!typeof(T).IsEnum)
        {
            throw new ArgumentException();
        }

        if (delimitedValues == string.Empty)
        {
            return new T[0];
        }

        string[] parts = delimitedValues.Split(',');
        T[] converted = new T[parts.Length];

        for (int i = 0; i < parts.Length; i++)
        {
            if (!Enum.TryParse(parts[i], out converted[i]))
            {
                throw new FormatException(parts[i]);
            }
        }

        return converted;
    }

    public static TArray ConvertArray<TArray>(string delimitedValues) where TArray : IList
    {
        return MethodCache<TArray>.Convert(delimitedValues);
    }

    public static T?[] ConvertNullable<T>(string delimitedValues) where T : struct
    {
        if (!typeof(T).IsEnum)
        {
            throw new ArgumentException();
        }

        if (delimitedValues == string.Empty)
        {
            return new T?[0];
        }

        string[] parts = delimitedValues.Split(',');
        T?[] converted = new T?[parts.Length];

        for (int i = 0; i < parts.Length; i++)
        {
            if (parts[i] == string.Empty)
            {
                continue;
            }

            T value;

            if (!Enum.TryParse(parts[i], out value))
            {
                throw new FormatException(parts[i]);
            }

            converted[i] = value;
        }

        return converted;
    }

    public static TArray ConvertNullableArray<TArray>(string delimitedValues) where TArray : IList
    {
        return MethodCache<TArray>.Convert(delimitedValues);
    }

    private static class MethodCache<TArray> where TArray : IList
    {
        public static readonly Func<string, TArray> Convert;

        static MethodCache()
        {
            if (!typeof(TArray).IsArray)
            {
                throw new ArgumentException("TArray");
            }

            Type element = typeof(TArray).GetElementType();
            Type element2 = Nullable.GetUnderlyingType(element);

            if (element2 == null)
            {
                Convert = (Func<string, TArray>)Delegate.CreateDelegate(typeof(Func<string, TArray>), typeof(EnumSplitter).GetMethod("Convert").MakeGenericMethod(element));
            }
            else
            {
                Convert = (Func<string, TArray>)Delegate.CreateDelegate(typeof(Func<string, TArray>), typeof(EnumSplitter).GetMethod("ConvertNullable").MakeGenericMethod(element2));
            }
        }
    }
}

我使用MethodCache<>類來緩存對“正確” Convert<>方法的反射調用。

用途：

TestValues[] arr1 = EnumSplitter.Convert<TestValues>("Unknown,Pizza");
TestValues?[] arr2 = EnumSplitter.ConvertNullable<TestValues>("Unknown,,Pizza,");
TestValues[] arr3 = EnumSplitter.ConvertArray<TestValues[]>("Unknown,Pizza");
TestValues?[] arr4 = EnumSplitter.ConvertNullableArray<TestValues?[]>("Unknown,,Pizza,");

Answer 2

對您的代碼進行最少的更改：您可以使用Array.CreateInstance因為您已經知道數組長度（在Split()之后的elements.Length ），然后調用Convert.ChangeType()以便能夠將Array轉換為T ：

public T Convert(string delimitedValues)
{
    var valueType = typeof(T);
    var elementType = valueType;
    if (!valueType.IsArray)
    {
        throw new Exception("T is not an array");
    }

    if (valueType.HasElementType)
    {
        elementType = valueType.GetElementType();
    }

    var elements = delimitedValues.Split(',');

    var arrayToReturn = Array.CreateInstance(elementType, elements.Length);

    for (int i = 0; i < elements.Length; i++ )
    {
        var newElement = Enum.Parse(elementType, elements[i].Trim(), true);
        arrayToReturn.SetValue(newElement, i);
    }

    return (T)System.Convert.ChangeType(arrayToReturn, valueType);
}

Answer 3

public static T[] ToEnumsArray<T>(this string stringValuesWithDelimeter) where T : struct
    {
        var result = new List<T>();
        if (!string.IsNullOrWhiteSpace(stringValuesWithDelimeter))
        {
            var arr = stringValuesWithDelimeter.Split(',');
            foreach (var item in arr)
            {
                if (Enum.TryParse(item, true, out T enumResult))
                {
                    result.Add(enumResult);
                }
            }
        }
        return result.ToArray();
    }