C# 获取C中泛型类型的用户友好名称#

有没有一种不编写递归方法的简单方法，该方法将为

type

类中的泛型类型提供一个“用户友好”的名称

例如，对于以下代码，我希望类似“列表”的内容，而不是以下代码给出的简写或全名：

var list = new List<Dictionary<int, string>>();
var type = list.GetType();

Console.WriteLine(type.Name);
Console.WriteLine(type.FullName);

var list=newlist（）；
var type=list.GetType（）；
Console.WriteLine（type.Name）；
Console.WriteLine（type.FullName）；

根据您编辑的问题，您需要以下内容：

public static string GetFriendlyName(this Type type)
{
    if (type == typeof(int))
        return "int";
    else if (type == typeof(short))
        return "short";
    else if (type == typeof(byte))
        return "byte";
    else if (type == typeof(bool)) 
        return "bool";
    else if (type == typeof(long))
        return "long";
    else if (type == typeof(float))
        return "float";
    else if (type == typeof(double))
        return "double";
    else if (type == typeof(decimal))
        return "decimal";
    else if (type == typeof(string))
        return "string";
    else if (type.IsGenericType)
        return type.Name.Split('`')[0] + "<" + string.Join(", ", type.GetGenericArguments().Select(x => GetFriendlyName(x)).ToArray()) + ">";
    else
        return type.Name;
}

System.Collections.Generic.List<System.Collections.Generic.Dictionary<int, string>>

公共静态字符串GetFriendlyName（此类型）
{
if（type==typeof（int））
返回“int”；
else if（type==typeof（short））
返回“短”；
else if（type==typeof（byte））
返回“字节”；
else if（type==typeof（bool））
返回“bool”；
else if（type==typeof（long））
返回“长”；
else if（type==typeof（float））
返回“浮动”；
else if（type==typeof（double））
返回“双”；
else if（type==typeof（十进制））
返回“十进制”；
else if（type==typeof（string））
返回“字符串”；
else if（type.IsGenericType）
返回类型.Name.Split（'`'[0]+''；
其他的
返回类型.名称；
}

还可以对泛型类型使用反射：

var dict = new Dictionary<string, int>();

    Type type = dict.GetType();
    Console.WriteLine("Type arguments:");
    foreach (Type arg in type.GetGenericArguments())
    {
        Console.WriteLine("  {0}", arg);
    }

var dict=newdictionary（）；
Type Type=dict.GetType（）；
WriteLine（“类型参数：”）；
foreach（Type.GetGenericArguments（）中的类型arg）
{
Console.WriteLine（“{0}”，arg）；
}

然后，您可以将它放入对象的某个扩展方法中，并在任何需要的地方使用它。我还想补充一点，每个递归都可以写成命令式代码

因此，整个代码将如下所示：

 static void GetGenericParametersNames(Type type)
        {
            Queue<Type> typeQueue = new Queue<Type>();
            typeQueue.Enqueue(type);
            while (typeQueue.Any())
            {
                var t = typeQueue.Dequeue();
                Console.WriteLine("  {0}", arg);

                foreach (Type arg in t.GetGenericArguments())
                {
                    typeQueue.Enqueue(t);
                }
            }
        }

静态无效GetGenericParametersNames（类型）
{
队列类型队列=新队列（）；
typeQueue.Enqueue（类型）；
while（typeQueue.Any（））
{
var t=typeQueue.Dequeue（）；
Console.WriteLine（“{0}”，arg）；
foreach（在t.GetGenericArguments（）中键入arg）
{
typeQueue.Enqueue（t）；
}
}
}

通过调用已提供给您的递归方法，可以避免编写递归方法：

static string GetTypeName(Type type)
{
    var codeDomProvider = CodeDomProvider.CreateProvider("C#");
    var typeReferenceExpression = new CodeTypeReferenceExpression(new CodeTypeReference(type));
    using (var writer = new StringWriter())
    {
        codeDomProvider.GenerateCodeFromExpression(typeReferenceExpression, writer, new CodeGeneratorOptions());
        return writer.GetStringBuilder().ToString();
    }
}

请注意，这包括类型名称空间，但不包括程序集引用。对于问题中的类型，结果如下所示：

public static string GetFriendlyName(this Type type)
{
    if (type == typeof(int))
        return "int";
    else if (type == typeof(short))
        return "short";
    else if (type == typeof(byte))
        return "byte";
    else if (type == typeof(bool)) 
        return "bool";
    else if (type == typeof(long))
        return "long";
    else if (type == typeof(float))
        return "float";
    else if (type == typeof(double))
        return "double";
    else if (type == typeof(decimal))
        return "decimal";
    else if (type == typeof(string))
        return "string";
    else if (type.IsGenericType)
        return type.Name.Split('`')[0] + "<" + string.Join(", ", type.GetGenericArguments().Select(x => GetFriendlyName(x)).ToArray()) + ">";
    else
        return type.Name;
}

System.Collections.Generic.List<System.Collections.Generic.Dictionary<int, string>>

System.Collections.Generic.List

---

我不清楚这是否符合“类似于”

List

我在需要解决方案时使用了此代码：

    public static string FriendlyName(this Type type)
    {
        if (type.IsGenericType)
        {
            var namePrefix = type.Name.Split(new [] {'`'}, StringSplitOptions.RemoveEmptyEntries)[0];
            var genericParameters = type.GetGenericArguments().Select(FriendlyName).ToCsv();
            return namePrefix + "<" + genericParameters + ">";
        }

        return type.Name;
    }

…如果您正在创建自动生成的开发人员帮助页，这也很有用，因为它包括通用参数名称：

public static string DefinitionTitle(this Type type)
    {
        if (type.IsGenericType)
        {
            var namePrefix = type.Name.Split(new[] { '`' }, StringSplitOptions.RemoveEmptyEntries)[0];
            var genericParameters = type.GetGenericArguments().Select(a => a.Name).ToCsv();
            return namePrefix + "<" + genericParameters + ">";
        }

        return type.Name;
    }

公共静态字符串定义标题（此类型）
{
if（type.IsGenericType）
{
var namePrefix=type.Name.Split（新[]{'`}，StringSplitOptions.RemoveEmptyEntries）[0]；
var genericParameters=type.GetGenericArguments（）.Select（a=>a.Name.ToCsv（）；
返回namePrefix+“”；
}
返回类型.名称；
}

用法示例：

    var typeDisplayText = MyDataModel.GetType().FriendlyName();

    var typeDefinitionText = typeof(Dictionary<,>).DefinitionTitle());

var-typeDefinitionText=typeof（Dictionary.DefinitionTitle（））；

在柯克的基础上构建一个更完整的答案是这样的。修改：

• 支持所有C#关键字
• 支持自定义翻译
• 阵列
• 可空值是

  ValueType？

  而不是

  Nullable

以下是完整的代码：

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

    public static string GetFriendlyName(this Type type, Dictionary<Type, string> translations)
    {
        if(translations.ContainsKey(type))
            return translations[type];
        else if (type.IsArray)
        {
            var rank = type.GetArrayRank();
            var commas = rank > 1 
                ? new string(',', rank - 1)
                : "";
            return GetFriendlyName(type.GetElementType(), translations) + $"[{commas}]";
        }
        else if(type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
            return type.GetGenericArguments()[0].GetFriendlyName() + "?";
        else if (type.IsGenericType)
            return type.Name.Split('`')[0] + "<" + string.Join(", ", type.GetGenericArguments().Select(x => GetFriendlyName(x)).ToArray()) + ">";
        else
            return type.Name;
    }

    public static string GetFriendlyName(this Type type)
    {
        return type.GetFriendlyName(_defaultDictionary);
    }
}

公共静态类类型转换器
{
私有静态字典_defaultDictionary=新字典
{
{typeof（int），“int”}，
{typeof（uint），“uint”}，
{typeof（long），“long”}，
{typeof（ulong），“ulong”}，
{typeof（short），“short”}，
{typeof（ushort），“ushort”}，
{typeof（byte），“byte”}，
{typeof（sbyte），“sbyte”}，
{typeof（bool），“bool”}，
{typeof（float），“float”}，
{typeof（double），“double”}，
{typeof（decimal），“decimal”}，
{typeof（char），“char”}，
{typeof（string），“string”}，
{typeof（object），“object”}，
{typeof（void），“void”}
};
公共静态字符串GetFriendlyName（此类型，字典翻译）
{
if（翻译。容器（类型））
返回翻译[类型]；
else if（键入.IsArray）
{
var rank=type.GetArrayRank（）；
变量逗号=秩>1
？新字符串（“，”，秩-1）
: "";
返回GetFriendlyName（type.GetElementType（），translations）+$“[{commas}]”；
}
else if（type.IsGenericType&&type.GetGenericTypeDefinition（）==typeof（可为空））
返回类型。GetGenericArguments（）[0]。GetFriendlyName（）+“？”；
else if（type.IsGenericType）
返回类型.Name.Split（'`'[0]+''；
其他的
返回类型.名称；
}
公共静态字符串GetFriendlyName（此类型）
{
返回类型.GetFriendlyName（\u defaultDictionary）；
}
}

我建议您使用

全名

和子字符串…您也可以使用split，在

上，只取最后一个

之后剩下的任何内容。问题特别提到“不写递归方法”，尽管我不明白为什么。@hvd，是的，我真的不在乎OP的任意和虚假需求。简言之，不。递归方法是一种方法：）为大于和小于添加了正确的html格式…我已经为

系统编写了一个
FriendlyName
扩展方法。键入
，这样做。添加对包的引用，使用
添加适当的
（
使用ZSpitz.Util；
）并调用
var s=type.FriendlyName（Language.CSharp）。我只是做了一次后期清理，在此过程中，我循环了所有已知的名称空间。：string res=GetTypeName（myType