Get nested type name without namespace

Question

Suppose I have a nested class structure like this:

namespace My.Namespace {
    public class Foo {
        public class Bar {
            public class Baz {
                public string Test { get; set; }
            }
        }
    }
}

I need to get the nested type name of Baz without the namespace, i.e. Foo+Bar+Baz in a generic method. Unfortunately, .Name will just return Baz and .FullName will give me the namespace as well. Right now I'm using this:

protected T LoadSample<T>(string fileName) 
{
    var t = typeof(T);
    var nestedTypeName = t.Namespace == null
        ? t.FullName                                 // T is declared outside of a namespace
        : t.FullName.Substring(t.Namespace.Length + 1);
    ...
}

But this just looks ugly. Is there a more standard method for getting just Foo+Bar+Baz in this situation?

To clarify what's going on inside this method, this is part of a unit test for an XML serialization class. LoadSample will load an XML file, wrap it in a little more XML to create an 'envelope', attempt to parse it, and return the result if it succeeds. The problem is that the 'envelope' that the XML serialization class expects the XML to specify the type name in a particular format. For example:

<baz>
    <test>Testing</test>
</baz>

Will be wrapped in an evelope like this:

<evelope>
    <messageType>urn:My.Namespace:Foo+Bar+Baz</messageType>
    <message>
        <test>Testing</test>
    </message>
</evelope>

Answer 1

Well, one brute force way of doing it is to recurse over the type's DeclaringType property:

public static string TypeName (Type type)
{
   if(type.DeclaringType == null)
      return type.Name;

   return TypeName(type.DeclaringType) + "." + type.Name;
}

Running the following program:

static void Main(string[] args)
{
   var type = typeof(My.Namespace.Foo.Bar.Baz);
   var name = TypeName(type);
}

returns the name Foo.Bar.Baz as you would expect.

Answer 2

It sounds like this might be what you are looking for I think.

Type.ReflectedType Property (.NET 4.5)

GetType(t).ReflectedType;

I am not sure what version of the framework that you are using though.

---

this may only work if you nest it

(GetType(GetType(t).ReflectedType).ReflectedType).ToString() + "." + (GetType(t).ReflectedType).ToString() + "." + (GetType(t).Name).ToString();

that is kind of messy too though.

---

There is also the GetNestedTypes and GetNestedType Methods which will return the types along the way.

you may have to create a function that will recursively build the nested class name for you.

Answer 3

System.Type inherits a Name property from System.Reflection.MemberInfo (MSDN), which returns the name of the member, not the fully qualified name. As you've noticed that returns Baz when you want Foo.Bar.Baz.

Either you use reflection to get the three types and concatenate their .Name, or you do what you did and chop off the namespace from the fully qualified name.

And it's ugly. What are we trying to accomplish here?

protected T LoadSample<T>(string fileName)

If you're loading data from a file named by the fileName argument, and using reflection to instantiate Baz, I'd suggest abstracting this dirt away into a SampleFactory<T>... I'm curious about what happens to the type's name in the rest of your code; reading your code makes me wonder why you would need to do this to load a sample T from fileName.

Is it possible that your life would be simpler if T had a new() type constraint (i.e. if T had a parameterless constructor)?

Answer 4

When reflecting on types you could look at the MemberType to determine whether to add the + sign before the name of the type:

public static string GetTypeName(Type type)
{
    if (type.MemberType == MemberTypes.NestedType)
    {
        return string.Concat(GetTypeName(type.DeclaringType), "+", type.Name);
    }

    return type.Name;
}

With your example types the output of:

GetTypeName(typeof(My.Namespace.Foo.Bar.Baz));

is Foo+Bar+Baz