C＃获取泛型类型名称

Question

我需要某种方式来获取类型的名称，当type.IsGenericType = true。

Type t = typeof(List<String>); 
    MessageBox.Show(..?..); 

我想要的，是一个消息框，List描述了...我怎么能做到这一点弹出？

Answer 1

Type t = ...; 

if (t.IsGenericType) 
{ 
    Type g = t.GetGenericTypeDefinition(); 

    MessageBox.Show(g.Name);        // displays "List`1" 

    MessageBox.Show(g.Name.Remove(g.Name.IndexOf('`'))); // displays "List" 
} 

Answer 2

假设你只是想看看它的List<T>代替List<string>你需要做的：

MessageBox.Show(t.GetGenericTypeDefinition().FullName) 

见http://msdn.microsoft.com/en-us/library/system.type.getgenerictypedefinition.aspx

Answer 3

您可以实现一个扩展方法来获得“友好名称“，如下所示：

public static class TypeNameExtensions 
{ 
    public static string GetFriendlyName(this Type type) 
    { 
     string friendlyName = type.Name; 
     if (type.IsGenericType) 
     { 
      int iBacktick = friendlyName.IndexOf('`'); 
      if (iBacktick > 0) 
      { 
       friendlyName = friendlyName.Remove(iBacktick); 
      } 
      friendlyName += "<"; 
      Type[] typeParameters = type.GetGenericArguments(); 
      for (int i = 0; i < typeParameters.Length; ++i) 
      { 
       string typeParamName = typeParameters[i].Name; 
       friendlyName += (i == 0 ? typeParamName : "," + typeParamName); 
      } 
      friendlyName += ">"; 
     } 

     return friendlyName; 
    } 
} 

有了这个项目，你现在可以说：

MessageBox.Show(t.GetFriendlyName()); 

它会显示“列表<字符串>”。

我知道OP没有要求泛型类型参数，但我更喜欢这种方式。 ;-)

命名空间和standard aliases for built-in types作为练习给读者。

Answer 4

我改进了代码生成中使用的yoyos版本。 请注意，现在所有类型都被引用full qualified => global :: System.String。

  public static string GetFriendlyTypeName(Type type) 
      { 
       string friendlyName = type.Name; 
       if (type.IsGenericType) 
       { 
        int iBacktick = friendlyName.IndexOf('`'); 
        if (iBacktick > 0) 
        { 
         friendlyName = friendlyName.Remove(iBacktick); 
        } 
        friendlyName += "<"; 
        Type[] typeParameters = type.GetGenericArguments(); 
        for (int i = 0; i < typeParameters.Length; ++i) 
        { 
         string typeParamName = GetFriendlyTypeName(typeParameters[i]); 
         friendlyName += (i == 0 ? typeParamName : "," + typeParamName); 
        } 
        friendlyName += ">"; 
        friendlyName = "global::" + type.Namespace + "." + friendlyName; 
       } 
       else 
       { 
        friendlyName = "global::" + type.FullName; 
       } 

       return friendlyName.Replace('+', '.'); 
      } 

Answer 5

public static class TypeNameExtensions 
{ 
    public static string GetFriendlyName(this Type type) 
    { 
     var friendlyName = type.Name; 
     if (!type.IsGenericType) return friendlyName; 

     var iBacktick = friendlyName.IndexOf('`'); 
     if (iBacktick > 0) friendlyName = friendlyName.Remove(iBacktick); 

     var genericParameters = type.GetGenericArguments().Select(x => x.GetFriendlyName()); 
     friendlyName += "<" + string.Join(", ", genericParameters) + ">"; 

     return friendlyName; 
    } 
} 

Answer 6

我采取的对YOYO的做法。为基元确保更友好的名称，处理数组，并递归处理嵌套泛型。也是单元测试。

private static readonly Dictionary<Type, string> _typeToFriendlyName = new Dictionary<Type, string> 
    { 
     { typeof(string), "string" }, 
     { typeof(object), "object" }, 
     { typeof(bool), "bool" }, 
     { typeof(byte), "byte" }, 
     { typeof(char), "char" }, 
     { typeof(decimal), "decimal" }, 
     { typeof(double), "double" }, 
     { typeof(short), "short" }, 
     { typeof(int), "int" }, 
     { typeof(long), "long" }, 
     { typeof(sbyte), "sbyte" }, 
     { typeof(float), "float" }, 
     { typeof(ushort), "ushort" }, 
     { typeof(uint), "uint" }, 
     { typeof(ulong), "ulong" }, 
     { typeof(void), "void" } 
    }; 

    public static string GetFriendlyName(this Type type) 
    { 
     string friendlyName; 
     if (_typeToFriendlyName.TryGetValue(type, out friendlyName)) 
     { 
      return friendlyName; 
     } 

     friendlyName = type.Name; 
     if (type.IsGenericType) 
     { 
      int backtick = friendlyName.IndexOf('`'); 
      if (backtick > 0) 
      { 
       friendlyName = friendlyName.Remove(backtick); 
      } 
      friendlyName += "<"; 
      Type[] typeParameters = type.GetGenericArguments(); 
      for (int i = 0; i < typeParameters.Length; i++) 
      { 
       string typeParamName = typeParameters[i].GetFriendlyName(); 
       friendlyName += (i == 0 ? typeParamName : ", " + typeParamName); 
      } 
      friendlyName += ">"; 
     } 

     if (type.IsArray) 
     { 
      return type.GetElementType().GetFriendlyName() + "[]"; 
     } 

     return friendlyName; 
    } 

[TestFixture] 
public class TypeHelperTest 
{ 
    [Test] 
    public void TestGetFriendlyName() 
    { 
     Assert.AreEqual("string", typeof(string).FriendlyName()); 
     Assert.AreEqual("int[]", typeof(int[]).FriendlyName()); 
     Assert.AreEqual("int[][]", typeof(int[][]).FriendlyName()); 
     Assert.AreEqual("KeyValuePair<int, string>", typeof(KeyValuePair<int, string>).FriendlyName()); 
     Assert.AreEqual("Tuple<int, string>", typeof(Tuple<int, string>).FriendlyName()); 
     Assert.AreEqual("Tuple<KeyValuePair<object, long>, string>", typeof(Tuple<KeyValuePair<object, long>, string>).FriendlyName()); 
     Assert.AreEqual("List<Tuple<int, string>>", typeof(List<Tuple<int, string>>).FriendlyName()); 
     Assert.AreEqual("Tuple<short[], string>", typeof(Tuple<short[], string>).FriendlyName()); 
    } 
} 

Answer 7

这是我对此的看法。因为我所看到的，它始终存在，所以我没有进行反向检查。你可以添加它，如果你想，但我喜欢保持简单。

public static string GetFriendlyName(this Type type) 
{ 
    if (type.IsGenericType) 
    { 
     var name = type.Name.Substring(0, type.Name.IndexOf('`')); 
     var types = string.Join(",", type.GetGenericArguments().Select(GetFriendlyName)); 
     return $"{name}<{types}>"; 
    } 
    else 
    { 
     return type.Name; 
    } 
}