Obtener el nombre del tipo sin espacio de nombres completo

Tengo el siguiente código:

return "[Inserted new " + typeof(T).ToString() + "]";

Pero

 typeof(T).ToString()

devuelve el nombre completo, incluido el espacio de nombres

¿Hay alguna forma de obtener el nombre de la clase (sin ningún calificador de espacio de nombres?)

typeof(T).Name // class name, no namespace
typeof(T).FullName // namespace and class name
typeof(T).Namespace // namespace, no class name

Pruebe esto para obtener parámetros de tipo para tipos genéricos:

public static string CSharpName(this Type type)
{
    var sb = new StringBuilder();
    var name = type.Name;
    if (!type.IsGenericType) return name;
    sb.Append(name.Substring(0, name.IndexOf('`')));
    sb.Append("<");
    sb.Append(string.Join(", ", type.GetGenericArguments()
                                    .Select(t => t.CSharpName())));
    sb.Append(">");
    return sb.ToString();
}

Quizás no sea la mejor solución (debido a la recurrencia), pero funciona. Las salidas se ven así:

Dictionary<String, Object>

hacer uso de ( Propiedades de tipo )

 Name   Gets the name of the current member. (Inherited from MemberInfo.)
 Example : typeof(T).Name;

typeof (T) .Name;

Después del C # 6.0 (incluido) puede usar el nombre de expresión:

using Stuff = Some.Cool.Functionality  
class C {  
    static int Method1 (string x, int y) {}  
    static int Method1 (string x, string y) {}  
    int Method2 (int z) {}  
    string f<T>() => nameof(T);  
}  

var c = new C()  

nameof(C) -> "C"  
nameof(C.Method1) -> "Method1"   
nameof(C.Method2) -> "Method2"  
nameof(c.Method1) -> "Method1"   
nameof(c.Method2) -> "Method2"  
nameof(z) -> "z" // inside of Method2 ok, inside Method1 is a compiler error  
nameof(Stuff) = "Stuff"  
nameof(T) -> "T" // works inside of method but not in attributes on the method  
nameof(f) -> “f”  
nameof(f<T>) -> syntax error  
nameof(f<>) -> syntax error  
nameof(Method2()) -> error “This expression does not have a name”  

¡Nota! nameofno obtiene el tipo de tiempo de ejecución del objeto subyacente, es solo el argumento en tiempo de compilación. Si un método acepta un IEnumerable, nameof simplemente devuelve "IEnumerable", mientras que el objeto real podría ser "List".

mejor forma de usar:

obj.GetType().BaseType.Name