Why can't I use nameof with a generic when everything are known compile-time?

Question

public void Test<T>()
{
    Console.WriteLine(nameof(T));
}

Test<int>();

This code literally prints T and not int, which is not useful at all. I would like to get the name of an actual generic type parameter used without using reflections (typeof and then operate on the Type variable, etc.)

I read that the point of generic is to make a variation of code with different type in their definition all ready at compile time. And nameof is also a compile-time operator. In this case it should be enough to know that T here is an int. There must be some way to do this other than having to do it from the user side (e.g. Test<int>(nameof(int)))

If anyone curious about the use case, besides debugging for example I would like to add things to dictionary using the item's class name as a key. This dictionary has exactly one of each shape.

public AddShape<T>(T shape) where T : Shape
{
    dict.Add(nameof(T), shape.SerializableShape);
}

Answer 1

The nameof construct is for determining the name of a type, variable, field, etc. at compile time. It doesn’t help you when you want a type at runtime. What you could do is just use the object’s type information:

public AddShape<T>(T shape) where T : Shape
{
    dict.Add(shape.GetType().FullName, shape.SerializableShape);
}

Answer 2

Because nameof uses type information at compile time and would use the name as string from there but for a generic type T compiler cannot figure that out at compile time as it would be passed as parameter from where it would be consumed as it can be Shape or any subtype of it and that's the reason that it would be initialized at runtime, so that is why it cannot be used like above.

I also found this related which will also help:

https://stackoverflow.com/a/29878933/1875256

Hope it helps

Answer 3

The documentation isn't very clear about execution time of nameof, but you can find the following sentence:

Unfortunately typeof is not a constant expression like nameof

We also have the specification in the C# language repository which states:

A nameof_expression is a constant expression of type string, and has no effect at runtime.

It's a reason why nameof(T) returns "T" and not the actual type name in your case. Therefore you need another way to obtain the type name at runtime. It's the typeof operator. From the specification:

The typeof operator can be used on a type parameter. The result is the System.Type object for the run-time type that was bound to the type parameter.

class Shape { }
class Circle : Shape { }

class Program
{
    // Output of the following code is Circle
    static void Main(string[] args) => WriteType<Circle>();

    static void WriteType<T>() where T : Shape => Console.WriteLine(typeof(T).Name);
}

As you can see the result fully depends on the bound type of the WriteType<T> method. This means if the bound type is Shape then "Shape" would be printed. Therefore when you iterating over a collection of Shape's the bound type of T would be Shape and not Circle. It's because T is deduced as Shape.

static void Main(string[] args)
{
    var shapes = new Shape[] { new Circle() };
    foreach (var shape in shapes)
        WriteBoundType(shape);
    // Output is "Shape"
}

static void WriteBoundType<T>(T shape)
    where T : Shape => Console.WriteLine(typeof(T).Name);

If you want to obtain the runtime type of the current shape then you should use the GetType method. From the typeof operator documentation:

To obtain the run-time type of an expression, you can use the .NET Framework method GetType, as in the following example

It's your case. You need neither typeof nor nameof. You do not need even generics because you want the runtime type of the current instance.

public AddShape(Shape shape)
{
    dict.Add(shape.GetType().Name, shape.SerializableShape);
    // You also can use the result of GetType directly or its FullName.
    // It depends on your demands which we don't know well.
}

You failed because you have worked with C++ which is statically typed too, but there is a difference. As you know in C++ template arguments are substituted at compile time, but in .NET they are substituted at runtime. I would recommend you to read Differences Between C++ Templates and C# Generics.

Answer 4

Use typeof(T) as your key, nameof, if it worked, would actually be a horrendous choice because the name it returns is unqualified, so there would be nothing ensuring that the key is unique.

Answer 5

Use typeof(T).Name only ... not need from Shape