获取没有任何泛型信息的类型名称

Question

If I write:

var type = typeof(List<string>);
Console.WriteLine(type.Name);

It will write:

List`1

I want it to write just:

List

How can I do that? Is there a smarter way to do it without having to use Substring or similar string manipulation functions?

Answer 1

No, it makes perfect sense for it to include the generic arity in the name - because it's part of what makes the name unique (along with assembly and namespace, of course).

Put it this way: System.Nullable and System.Nullable<T> are very different types. It's not expected that you'd want to confuse the two... so if you want to lose information, you're going to have to work to do it. It's not very hard, of course, and can be put in a helper method:

public static string GetNameWithoutGenericArity(this Type t)
{
    string name = t.Name;
    int index = name.IndexOf('`');
    return index == -1 ? name : name.Substring(0, index);
}

Then:

var type = typeof(List<string>);
Console.WriteLine(type.GetNameWithoutGenericArity());

Answer 2

If someone is interested, I created some extensionmethods for this problem that create a more "readable" string

it produces something like

List[string]
outer.inner[other.whatever]
IEnumerable[T0]
Dictionary[string:int]

Test here

public static class TypeEx
{
    public static string GetTypeName(this Type type)
    {
        if (type == null)
            throw new ArgumentNullException(nameof(type));

        if (!type.IsGenericType)
            return type.GetNestedTypeName();

        StringBuilder stringBuilder = new StringBuilder();
        _buildClassNameRecursiv(type, stringBuilder);
        return stringBuilder.ToString();
    }

    private static void _buildClassNameRecursiv(Type type, StringBuilder classNameBuilder, int genericParameterIndex = 0)
    {
        if (type.IsGenericParameter)
            classNameBuilder.AppendFormat("T{0}", genericParameterIndex + 1);
        else if (type.IsGenericType)
        {
            classNameBuilder.Append(GetNestedTypeName(type) + "[");
            int subIndex = 0;
            foreach (Type genericTypeArgument in type.GetGenericArguments())
            {
                if (subIndex > 0)
                    classNameBuilder.Append(":");

                _buildClassNameRecursiv(genericTypeArgument, classNameBuilder, subIndex++);
            }
            classNameBuilder.Append("]");
        }
        else
            classNameBuilder.Append(type.GetNestedTypeName());
    }

    public static string GetNestedTypeName(this Type type)
    {
        if (type == null)
            throw new ArgumentNullException(nameof(type));
        if (!type.IsNested)
            return type.Name;

        StringBuilder nestedName = new StringBuilder();
        while(type != null)
        {
            if(nestedName.Length>0)
                nestedName.Insert(0,'.');

            nestedName.Insert(0, _getTypeName(type));

            type = type.DeclaringType;
        }
        return nestedName.ToString();
    }

    private static string _getTypeName(Type type)
    {
        return type.IsGenericType ? type.Name.Split('`')[0]: type.Name;
    }
}

Answer 3

不，不是，因为“ generic-type-string”是类型名称的一部分。

Answer 4

 Console.WriteLine(type.GetGenericTypeDefinition().UnderlyingSystemType.Name)

Answer 5

static void Main(string[] args)
{

    Console.WriteLine(WhatIsMyType<IEnumerable<string>>());
    Console.WriteLine(WhatIsMyType<List<int>>());
    Console.WriteLine(WhatIsMyType<IList<int>>());
    Console.WriteLine(WhatIsMyType<List<ContentBlob>>());
    Console.WriteLine(WhatIsMyType<int[]>());
    Console.WriteLine(WhatIsMyType<ContentBlob>());
    Console.WriteLine(WhatIsMyType<Dictionary<string, Dictionary<int, int>>>());
}

public static string WhatIsMyType<T>()
{
    return typeof(T).NameWithGenerics();
}

public static string NameWithGenerics(this Type type)
{
    if (type == null)
        throw new ArgumentNullException(nameof(type));

    if (type.IsArray)
        return $"{type.GetElementType()?.Name}[]";

    if (!type.IsGenericType) 
        return type.Name;

    var name = type.GetGenericTypeDefinition().Name;
    var index = name.IndexOf('`');
    var newName = index == -1 ? name : name.Substring(0, index);
        
    var list = type.GetGenericArguments().Select(NameWithGenerics).ToList();
    return $"{newName}<{string.Join(",", list)}>";
}

Example output:

IEnumerable<String>
List<Int32>
IList<Int32>
List<ContentBlob>
Int32[]
ContentBlob
Dictionary<String,Dictionary<Int32,Int32>>

Answer 6

Here's the code from this answer inside a static class and namespace for easier copy-and-pasting.

Also, there's another extension method to get the type its namespace.

using System;

namespace TODO
{
    public static class TypeExtensions
    {
        /// <summary>
        /// From: https://stackoverflow.com/a/6386234/569302
        /// </summary>
        public static string GetNameWithoutGenericArity(this Type t)
        {
            string name = t.Name;
            int index = name.IndexOf('`');
            return index == -1 ? name : name.Substring(0, index);
        }
        public static string GetFullNameWithoutGenericArity(this Type t)
        {
            var result = $"{t.Namespace}.{t.GetNameWithoutGenericArity()}";
            return result;
        }
    }
}

Answer 7

The easiest way I can think of as of C#6(I think) you can do the following:

public static void Main(string[] args)
{
    Console.WriteLine(nameof(List<int>));
    Console.WriteLine(nameof(Dictionary<int, int>));
}

This will print:

List
Dictionary