Is it always the case that the nameof() is equal to the typeof().Name?

Question

I've tested Class, Methods, Fields, Properties, and Enums to see if there are any cases when this is not true?

DotNetFiddle Example

using System;

public class Program
{
    public static void Main()
    {
        var fooType = typeof(Foo);
        ThrowIfNotEqual(fooType.Name, nameof(Foo));

        var fi = fooType.GetField(nameof(Foo.field));
        ThrowIfNotEqual(fi.Name, nameof(Foo.field));

        var pi = fooType.GetProperty(nameof(Foo.property));
        ThrowIfNotEqual(pi.Name, nameof(Foo.property));

        var mi = fooType.GetMethod(nameof(Foo.method));
        ThrowIfNotEqual(mi.Name, nameof(Foo.method));

        var fi2 = fooType.GetNestedTypes()[0];
        ThrowIfNotEqual(fi2.Name, nameof(Foo.myEnum));

        ThrowIfNotEqual("TestThisMethod", "WorksAsExpected");
    }

    public static void ThrowIfNotEqual(string a, string b)
    {
        if (a != b) throw new InvalidOperationException($"Are Not Equal: {a} != {b}");
    }

    public class Foo
    {
        public string field;
        public string property { get; set; }
        public void method() { }
        public enum myEnum
        {
            A
        }
    }
}

Results:

Run-time exception (line -1): Are Not Equal: TestThisMethod != WorksAsExpected

Answer 1

Is it always the case that the nameof() is equal to the typeof().Name?

No there are lots ways to break this, just as an example

public class Foo<T>

E.g

var fooType = typeof(Foo<string>);
Console.WriteLine(fooType.Name);
Console.WriteLine(nameof(Foo<string>));

Output

Foo`1
Foo

There are also many situations where you will get compiler errors on just predefined types using nameof()

Console.WriteLine(nameof(int)); //CS1525    Invalid expression term 'int'   

---

nameof (C# Reference)

Remarks

Because the argument needs to be an expression syntactically, there are many things disallowed that are not useful to list. The following are worth mentioning that produce errors