C# Get Generic Type Name

How do I get the type name of a generic type argument?

Your code should work. typeof(T).FullName is perfectly valid. This is a fully compiling, functioning program:

using System;

class Program 
{
    public static string MyMethod<T>()
    {
        return typeof(T).FullName;
    }

    static void Main(string[] args)
    {
        Console.WriteLine(MyMethod<int>());

        Console.ReadKey();
    }

}

Running the above prints (as expected):

System.Int32

C# Get Generic Type Name

Type t = ...;

if (t.IsGenericType)
{
    Type g = t.GetGenericTypeDefinition();

    MessageBox.Show(g.Name);                                // displays "List`1"

    MessageBox.Show(g.Name.Remove(g.Name.IndexOf('`')));    // displays "List"
}

C# get generic parameter name using reflection

You first have to use the method GetGenericTypeDefinition() on the Type to get another Type that represents the generic template. Then you can use GetGenericArguments() on that to receive the definition of the original placeholders including their names.

For example:

    class MyClass<Tkey, Tvalue> { };

    private IEnumerable<string> GetTypeParameterNames(Type fType)
    {
        List<string> result = new List<string>();

        if(fType.IsGenericType)
        {
            var lGenericTypeDefinition = fType.GetGenericTypeDefinition();

            foreach(var lGenericArgument in lGenericTypeDefinition.GetGenericArguments())
            {
                result.Add(lGenericArgument.Name);
            }
        }

        return result;
    }

    private void AnalyseObject(object Object)
    {
        if (Object != null)
        {
            var lTypeParameterNames = GetTypeParameterNames(Object.GetType());
            foreach (var name in lTypeParameterNames)
            {
                textBox1.AppendText(name + Environment.NewLine);
            }
        }
    }

    private void button1_Click(object sender, EventArgs e)
    {
        var object1 = new MyClass<string, string>();
        AnalyseObject(object1);

        var object2 = new List<string>();
        AnalyseObject(object2);

        AnalyseObject("SomeString");
    }

Get name of generic class without tilde

The back-tick is indicative that the class is a generic type. Probably the easiest thing is to just lop off anything from the back-tick forward:

string typeName = typeof(T).Name;
if (typeName.Contains('`')) typeName = typeName.Substring(0, typeName.IndexOf("`"));

Given a type instance, how to get generic type name in C#?

I see you already accepted an answer, but honestly, that answer isn't going to be enough to do this reliably if you just combine what's in there with what you already wrote. It's on the right track, but your code will only work for generic types with exactly one generic parameter, and it will only work when the generic type parameter itself is not generic!

This is a function (written as an extension method) that should actually work in all cases:

public static class TypeExtensions
{
    public static string ToGenericTypeString(this Type t)
    {
        if (!t.IsGenericType)
            return t.Name;
        string genericTypeName = t.GetGenericTypeDefinition().Name;
        genericTypeName = genericTypeName.Substring(0,
            genericTypeName.IndexOf('`'));
        string genericArgs = string.Join(",",
            t.GetGenericArguments()
                .Select(ta => ToGenericTypeString(ta)).ToArray());
        return genericTypeName + "<" + genericArgs + ">";
    }
}

This function is recursive and safe. If you run it on this input:

Console.WriteLine(
    typeof(Dictionary<string, List<Func<string, bool>>>)
    .ToGenericTypeString());

You get this (correct) output:

Dictionary<String,List<Func<String,Boolean>>>

c# get the name of the generic type parameter in generic class

In your example, you already set the generic type parameter to int, so you won't get your Type1.

Try this:

class MyClass<Type1>
{
    public Type data;
}
static void Main()
{
    Console.WriteLine(typeof(MyClass<>).GetGenericArguments()[0].Name);
    //prints: Type1
}

Get type name without any generics info

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());

How can I get generic Type from a string representation?

The format for generics is the name, a ` character, the number of type parameters, followed by a comma-delimited list of the types in brackets:

Type.GetType("System.Collections.Generic.IEnumerable`1[System.String]");

I'm not sure there's an easy way to convert from the C# syntax for generics to the kind of string the CLR wants. I started writing a quick regex to parse it out like you mentioned in the question, but realized that unless you give up the ability to have nested generics as type parameters the parsing will get very complicated.

Get name of generic class

This function returns a string representing the C# declaration for the given type.

It works on most things but there may be one or two edge cases for which it doesn't work correctly. I wrote it a while back, but looking at it now, I think it doesn't support nullables for one.

/// Returns a string that can be used as a C# type definition.
string GetTypeDefinition(Type t)
{
    if (t == typeof(void)) return "void";

    StringBuilder sb = new StringBuilder();

    string name = t.IsGenericType ? t.FullName.Substring(0, t.FullName.IndexOf("`")) : t.FullName;

    sb.Append(name);

    if (t.IsGenericType)
    {
        sb.Append("<");
        bool first = true;
        foreach(Type genericType in t.GenericTypeArguments)
        {
            if (!first) 
            {
                sb.Append(", ");
            }
            first = false;
            sb.Append(GetTypeDefinition(genericType));
        }
        sb.Append(">");
    }

    if (t.IsArray)
    {
        sb.Append("[]");
    }

    return sb.ToString();
}

Get user-friendly name for generic type in C#

Based on your edited question, you want something like this:

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;
}

---

Related Topics