Uzyskaj nazwę genericType w dobrym formacie za pomocą refleksji na C#

Question

Potrzebuję uzyskać nazwę typu generycznego w postaci jego deklaracji w kodzie.

Na przykład: list <Int32> chcę uzyskać ciąg "List <Int32>". Właściwość Standart Type.Name zwraca "List`1" w tej sytuacji.

EDIT: Przykład została ustalona

Answer 1

Ok, zrobiłem grono badań i odkryłem, że typeof (List) ma "GetGenericArguments", który dostarczy ci podtypy. Zrobiłbym to w ten sposób (dla jednego rodzaju generycznego, jeśli jest to multi, zajmie to pętlę lub coś w tym stylu, na żądanie mogę opublikować funkcję.)

Oto funkcja do tego . wielokrotne generyczne argumenty „” zagnieżdżone typy generyczne Uchwyty redakcją ponownie, aby ta użyciu funkcji zbiorczej.

static string GetFullName(Type t) 
{ 
    if (!t.IsGenericType) 
     return t.Name; 
    StringBuilder sb=new StringBuilder(); 

    sb.Append(t.Name.Substring(0, t.Name.LastIndexOf("`"))); 
    sb.Append(t.GetGenericArguments().Aggregate("<", 

     delegate(string aggregate,Type type) 
      { 
       return aggregate + (aggregate == "<" ? "" : ",") + GetFullName(type); 
      } 
     )); 
    sb.Append(">"); 

    return sb.ToString(); 
} 

Answer 2

Dobrze, że to dlatego, że nazwa typu w .NET faktycznie JEST List'1. "1" jest tak zwanym aritem generycznego i informuje o liczbie parametrów typu.

Jest to potrzebne, aby można było utworzyć więcej niż 1 ogólny typ o tej samej "nazwie", ale o innej liczbie ogólnych parametrów typu.

Na przykład istnieje więcej niż jeden typ "o nazwie" System.Action. Prawdziwe nazwy to System.Action'1, System.Action'2, System.Action'3 itd.

Jeśli więc wiesz, że Twój typ jest ogólny, możesz założyć, że jest to XX Koniec nazwy, więc możesz odciąć tę część, na przykład:

string strTypeName = typeof(List<>).Name.Substring(0, typeof(List<>).Name.LastIndexOf("`")); 

PS: Proszę zastąpić "z".

Answer 3

, który nie jest zbyt trudne ;-)

Ok, będę gryźć .. g Ten poniżej działa w trybie iniekcji i wyświetla prymitywne typy bez przestrzeni nazw (jak OP napisał):

static string PrettyPrintGenericTypeName(Type typeRef) 
    { 
    var rootType = typeRef.IsGenericType 
     ? typeRef.GetGenericTypeDefinition() 
     : typeRef; 

    var cleanedName = rootType.IsPrimitive 
          ? rootType.Name 
          : rootType.ToString(); 

    if (!typeRef.IsGenericType) 
     return cleanedName; 
    else 
     return cleanedName.Substring(0, 
            cleanedName.LastIndexOf('`')) 
      + typeRef.GetGenericArguments() 
        .Aggregate("<", 
           (r, i) => 
            r 
            + (r != "<" ? ", " : null) 
            + PrettyPrintGenericTypeName(i)) 
      + ">"; 
    } 

Powstały cleanedName wygląda następująco: System.Collections.Generic.Dictionary<System.Collections.Generic.List<Int32>, ConsoleApplication2.Program+SomeType>

Answer 4

Używanie wbudowanych funkcji i LINQ to można zapisać

static string PrettyTypeName(Type t) 
{ 
    if (t.IsGenericType) 
    { 
     return string.Format(
      "{0}<{1}>", 
      t.Name.Substring(0, t.Name.LastIndexOf("`", StringComparison.InvariantCulture)), 
      string.Join(", ", t.GetGenericArguments().Select(PrettyTypeName))); 
    } 

    return t.Name; 
} 

UWAGA: w starszej wersji C# kompilator wymaga wyraźnej .ToArray():

  string.Join(", ", t.GetGenericArguments().Select(PrettyTypeName).ToArray())); 

Answer 5

Kolejny przykład, który napisałem sam przed potknięciem się tutaj.

private string PrettyPrintGenericTypeName(Type p) 
    { 
     if (p.IsGenericType) { 
      var simpleName = p.Name.Substring(0, p.Name.IndexOf('`')); 
      var genericTypeParams = p.GenericTypeArguments.Select(PrettyPrintGenericTypeName).ToList(); 
      return string.Format("{0}<{1}>", simpleName, string.Join(", ", genericTypeParams)); 
     } else { 
      return p.Name; 
     } 
    } 

Answer 6

Stare pytanie, ale dziś tego potrzebuję. Napisałem więc metodę rozszerzenia, która może wyświetlać ładnie wyglądającą ogólną nazwę w języku C#, która może obsługiwać wielopoziomowe typy generyczne zagnieżdżone.