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

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