C# 泛型聲明

Question

是否可以獲得通過反射獲得的類型的“c＃名稱”，例如：

System.Collections.Generic.List`1[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]

我想得到：

List<String>

是否可以不拆分字符串？ 例如，使用反射。

謝謝！

Answer 1

不是直接的，但您可以檢查類型本身以找出答案。

public static string TypeName(Type t) {
    if (!t.IsGenericType) return t.Name;

    StringBuilder ret = new StringBuilder();
    ret.Append(t.Name).Append("<");

    bool first = true;
    foreach(var arg in t.GetGenericArguments()) {
        if (!first) ret.Append(", ");
        first = false;

        ret.Append(TypeName(arg));
    }

    ret.Append(">");
    return ret.ToString();
}

Answer 2

是的，您可以通過使用CodeDom和CSharpCodeProvider來做到這一點，而無需借助拆分、解析或操作字符串：

using CodeDom;
using Microsoft.CSharp;

// ...

Type yourType = typeof(List<string>);  // for example

using (var provider = new CSharpCodeProvider())
{
    var typeRef = new CodeTypeReference(yourType);
    Console.WriteLine(provider.GetTypeOutput(typeRef));
}

（您可能需要執行一些額外的字符串操作來刪除命名空間前綴。例如，如果您希望 output 成為List<string>而不是System.Collections.Generic.List<string> 。）

Answer 3

您需要解析一個字符串，如：

t`x[[a(,b,c,d)]]

其中 t 是實際類型； x - 通用參數的數量； a,b,c,d 等 - 通用參數

Answer 4

您可以檢查類型以確定它是否嵌套以及它是泛型構造的還是原始類型。 特別是，我意識到嵌套泛型類型在類型名稱字符串的末尾列出了其泛型 arguments。 文檔Type.GetType Method (String)中提到了這一點。

我已經部分解決了任務，我的解決方案通過了以下測試。

        [TestMethod]
        public void Tests()
        {

            Assert.AreEqual("int",typeof(int).ToCSharpMethodReturnTypeName());
            Assert.AreEqual("int[]",typeof(int[]).ToCSharpMethodReturnTypeName());
            Assert.AreEqual("int?", typeof(int?).ToCSharpMethodReturnTypeName());

            Assert.AreEqual("UnitTypeFriendlyNamesExtensionsTest.Inner2<string,IDictionary<string,object>>.SubInner<int,List<byte[]>,object>", typeof(Inner2<string,IDictionary<string,object>>.SubInner<int,List<byte[]>,object>).ToCSharpMethodReturnTypeName());

            Assert.ThrowsException<NotImplementedException>(()=> typeof(Inner2<string, IDictionary<string, object>>.SubInner<int, List<byte[]>, object>).DeclaringType.ToCSharpMethodReturnTypeName());

            var t = typeof(TestGenericReturnType<DateTime>);
            var m = t.GetMethod("GetService");
            var tt = m.ReturnType;

            Assert.AreEqual("DateTime",tt.ToCSharpMethodReturnTypeName());

            Assert.AreEqual("IDictionary<string,object>",typeof(IDictionary<string,object>).ToCSharpMethodReturnTypeName());
            Assert.AreEqual("IList<int[]>",typeof(IList<int[]>).ToCSharpMethodReturnTypeName());
            Assert.AreEqual("UnitTypeFriendlyNamesExtensionsTest.Astruc?",typeof(Astruc?).ToCSharpMethodReturnTypeName());
            Assert.AreEqual("UnitTypeFriendlyNamesExtensionsTest.Inner", typeof(Inner).ToCSharpMethodReturnTypeName());
        }

擴展 class 處理嵌套和泛型構造類型以及原始類型。

public static class TypeFriendlyNamesExtensions
{
    private static readonly Dictionary<Type, string> TypeToFriendlyName = new Dictionary<Type, string>
    {
        {typeof(string), "string"},
        {typeof(object), "object"},
        {typeof(bool), "bool"},
        {typeof(byte), "byte"},
        {typeof(char), "char"},
        {typeof(decimal), "decimal"},
        {typeof(double), "double"},
        {typeof(short), "short"},
        {typeof(int), "int"},
        {typeof(long), "long"},
        {typeof(sbyte), "sbyte"},
        {typeof(float), "float"},
        {typeof(ushort), "ushort"},
        {typeof(uint), "uint"},
        {typeof(ulong), "ulong"},
        {typeof(void), "void"}
    };

    public static string ToCSharpMethodReturnTypeName(this Type type)
    {
        var sb = new StringWriter();
        ToCSharpNameEntry2(sb, type);
        return sb.ToString();
    }

    private static void ToCSharpNameEntry2(TextWriter sb, Type type0)
    {
        var list = GetContainingTypeList(type0);
        var usedGenericArgumentCounter = 0;

        HandleNestedLevel(sb, list, 0, ref usedGenericArgumentCounter);
        foreach (var ix in Enumerable.Range(1, list.Count - 1))
        {
            sb.Write(".");
            HandleNestedLevel(sb, list, ix, ref usedGenericArgumentCounter);
        }
    }

    private static void HandleNestedLevel(TextWriter sb, IReadOnlyList<Type> list, int ix,
        ref int usedGenericArgumentCounter)
    {
        var type = list[ix];
        if (TypeToFriendlyName.TryGetValue(type, out string fname))
        {
            sb.Write(fname);
            return;
        }
        if (type.IsGenericParameter)
        {
            sb.Write(type.Name);
            return;
        }
        if (type.IsArray)
        {
            ToCSharpNameEntry2(sb, type.GetElementType());
            sb.Write("[]");
            return;
        }

        if (type.IsGenericType)
        {
            var innermostType = list[list.Count - 1];
            var args = list[list.Count - 1].GenericTypeArguments;
            if (!type.IsConstructedGenericType)
            {
                if (innermostType.IsConstructedGenericType)
                {
                    var sname = GetSname(type);
                    sb.Write(sname);
                    sb.Write("<");
                    ToCSharpNameEntry2(sb, args[usedGenericArgumentCounter++]);
                    var loopCounter = ((TypeInfo) type).GenericTypeParameters.Length;
                    while (0 < --loopCounter)
                    {
                        sb.Write(",");
                        ToCSharpNameEntry2(sb, args[usedGenericArgumentCounter++]);
                    }
                    sb.Write(">");
                    return;
                }
                throw new NotImplementedException();
            }
            if (typeof(Nullable<>) == type.GetGenericTypeDefinition())
            {
                ToCSharpNameEntry2(sb, args[0]);
                sb.Write("?");
                return;
            }
            var cname = GetSname(type);
            sb.Write(cname);
            sb.Write("<");
            ToCSharpNameEntry2(sb, args[usedGenericArgumentCounter++]);
            while (usedGenericArgumentCounter < args.Length)
            {
                sb.Write(",");
                ToCSharpNameEntry2(sb, args[usedGenericArgumentCounter++]);
            }
            sb.Write(">");
            return;
        }
        if (type.IsPointer)
        {
            ToCSharpNameEntry2(sb, type);
            sb.Write("*");
            return;
        }
        sb.Write(type.Name);
    }

    private static string GetSname(Type type)
    {
        var name = type.Name;
        return name.Substring(0, name.IndexOf('`'));
    }

    private static List<Type> GetContainingTypeList(Type type)
    {
        var list = new List<Type> {type};
        var t = type;
        while (t.IsNested)
        {
            t = t.DeclaringType;
            list.Insert(0, t);
        }
        return list;
    }

    private static void ToCSharpNameEntry(StringBuilder sb, Type type)
    {
        var genericTypeArguments = type.GenericTypeArguments;
        var usedGenericTypeCounter = 0;
        ToCSharpNameRecursive(sb, type, genericTypeArguments, ref usedGenericTypeCounter);
    }

    private static void ToCSharpNameRecursive(StringBuilder sb, Type type, IReadOnlyList<Type> genericTypeArguments,
        ref int genericTypesCounter)
    {
        if (TypeToFriendlyName.TryGetValue(type, out string res))
        {
            sb.Append(res);
            return;
        }

        HandleNonPriminiveTypes(sb, type, genericTypeArguments, ref genericTypesCounter);
    }

    private static void HandleNonPriminiveTypes(StringBuilder sb, Type type, IReadOnlyList<Type> typeGenericTypeArguments,
        ref int genericTypesCounter)
    {
        var list = new List<Type>();
        var t = type;
        list.Add(t);
        while (t.IsNested)
        {
            t = t.DeclaringType;
            list.Add(t);
        }
        list.Reverse();
        foreach (var type1 in list)
        {
            HandleNestedLevel(sb, type1, typeGenericTypeArguments, ref genericTypesCounter);
            sb.Append(".");
        }
        sb.Length -= 1;
    }

    private static void HandleNestedLevel(StringBuilder sb, Type type, IReadOnlyList<Type> typeGenericTypeArguments,
        ref int genericTypesCounter)
    {
        var name = type.Name;
        if (type.IsGenericType)
        {
            var info = type.GetTypeInfo();
            var def = info.GetGenericTypeDefinition();
            var psLength = info.IsConstructedGenericType
                ? info.GenericTypeArguments.Length
                : info.GenericTypeParameters.Length;
            if (typeof(Nullable<>) == def)
            {
                var type1 = typeGenericTypeArguments[genericTypesCounter++];
                ToCSharpNameEntry(sb, type1);
                sb.Append("?");
                return;
            }

            var n = name.Substring(0, name.IndexOf("`", StringComparison.InvariantCultureIgnoreCase));

            sb.Append(n);
            sb.Append("<");
            for (var i = 0; i < psLength; i++)
            {
                ToCSharpNameEntry(sb, typeGenericTypeArguments[genericTypesCounter++]);
                sb.Append(",");
            }
            sb.Length -= 1;
            sb.Append(">");
            return;
        }
        if (type.IsArray)
        {
            var type1 = type.GetElementType();
            ToCSharpNameEntry(sb, type1);
            sb.Append("[]");
            return;
        }
        sb.Append(name);
    }
}

我在編寫要由 Roslyn 編譯的源文本時使用擴展方法

Answer 5

...不分割字符串？

AFAIK，不。