Convertir les chaînes de définition de type générique de type C# style CLR

Question

Je veux convertir un style C# type générique chaîne, comme:

"System.Dictionary<System.String, System.String>" 

Pour son équivalent CLR:

"System.Dictionary`1[System.String, System.String]" 

et retour . Existe-t-il un moyen facile de le faire, ou dois-je recourir à la manipulation de chaînes?

EDIT:

ne me reste que la représentation de chaîne en C#/VB/etc sous forme de style. Je n'ai pas d'objet Type ou quelque chose de similaire sous la main. Une autre question aurait été: comment obtenir un objet Type à partir d'une représentation sous forme de chaîne comme "System.Dictionary<System.String, System.String>" (après cela, je peux obtenir le nom complet de l'objet type).

EDIT # 2:

Justification: Je crée des objets dynamiquement à l'aide CodeDom. L'entrée à partir de laquelle je génère le CodeDom peut contenir des types au format C# (ou tout autre format propriétaire tel que VB.NET), mais je dois les utiliser dans un CodeTypeReference, qui n'accepte que le format de style CLR.

Answer 1

Je crois que je fait face à un problème similaire dans le passé et écrit la méthode utilitaire suivante pour y remédier:

// Utilitiy to convert class name string to namespace-qualified name 
    public static Type GetTypeByName(string ClassName, 
     string TypesNamespacePrefix = "AssemblyTopLevel.AssemblyMidLevel.", 
     Dictionary<string, Type> ConcreteTypeMap = null) 
    { 
     if ((ConcreteTypeMap != null) && (ConcreteTypeMap.ContainsKey(ClassName))) 
      return ConcreteTypeMap[ClassName]; 

     if ((ConcreteTypeMap != null) && (ConcreteTypeMap.ContainsKey(TypesNamespacePrefix + ClassName))) 
      return ConcreteTypeMap[TypesNamespacePrefix + ClassName]; 

     try 
     { 
      if (Type.GetType(ClassName) != null) 
       return Type.GetType(ClassName); 
     } 
     catch { } 

     try 
     { 
      if (Type.GetType(TypesNamespacePrefix + ClassName) != null) 
       return Type.GetType(TypesNamespacePrefix + ClassName); 
     } 
     catch { } 

     Stack<int> GenericCounterStack = new Stack<int>(); 
     Stack<int> GenericStartIndexStack = new Stack<int>(); 
     Dictionary<int, int> GenericCountMapByStartIndex = new Dictionary<int, int>(); 
     int Count = 1; 
     int GenericStartIndex = -1; 
     int PreviousHighestGenericIndex = -1; 

     foreach (char c in ClassName) 
     { 
      if (c.Equals('<')) 
      { 
       if (GenericStartIndex != -1) 
       { 
        GenericCounterStack.Push(Count); 
        GenericStartIndexStack.Push(GenericStartIndex); 
       } 
       Count = 1; 
       GenericStartIndex = PreviousHighestGenericIndex + 1; 
       PreviousHighestGenericIndex = Math.Max(GenericStartIndex, PreviousHighestGenericIndex); 
      } 
      else if (c.Equals(',')) 
      { 
       Count++; 
      } 
      else if (c.Equals('>')) 
      { 
       GenericCountMapByStartIndex[GenericStartIndex] = Count; 
       if (GenericCounterStack.Count != 0) 
        Count = GenericCounterStack.Pop(); 
       if (GenericStartIndexStack.Count != 0) 
        GenericStartIndex = GenericStartIndexStack.Pop(); 
      } 
     } 

     ClassName = ClassName.Replace("<" + TypesNamespacePrefix, "<"); 

     StringBuilder FullyQualifiedClassName = new StringBuilder(TypesNamespacePrefix); 

     GenericStartIndex = 0; 
     foreach (char c in ClassName) 
     { 
      if (c.Equals('<')) 
      { 
       FullyQualifiedClassName.Append("`" + GenericCountMapByStartIndex[GenericStartIndex].ToString() 
        + "[" + TypesNamespacePrefix); 
       GenericStartIndex++; 
      } 
      else if (c.Equals(',')) 
      { 
       FullyQualifiedClassName.Append("," + TypesNamespacePrefix); 
      } 
      else if (c.Equals('>')) 
      { 
       FullyQualifiedClassName.Append("]"); 
      } 
      else 
       FullyQualifiedClassName.Append(c); 
     } 

     ClassName = FullyQualifiedClassName.ToString(); 

     return Type.GetType(ClassName); 
    } 

Vous pouvez en option fournir une carte de type concret, à optimiser pour les cas couramment invoqués:

static readonly Dictionary <string, Type> MyConcreteTypeMap = new Dictionary<string,Type>() 
    { 
     {"SomeClass", typeof(SomeClass)}, 
     {"AnotherClass", typeof(AnotherClass)} 
    } 

Ainsi, l'invocation ressemble à ceci:

Type DesiredType = GetTypeByName("SomeClass", "", MyConcreteTypeMap); 

ou

Type DesiredType = GetTypeByName("SomeOtherClass", "MyAssemblyTopLevel.MyAssemblyMidLevel."); 

ou

Type DesiredType = GetTypeByName("SomeOtherClass"); 

ou, tout à fait utile,

Type DesiredType = GetTypeByName("SomeOtherClass<OuterTemplate<InnerTemplate1,InnerTemplate2<InnerInnerTemplate1>>>"); 

ou, pour l'exemple d'origine ,

Type DesiredType = GetTypeByName("Dictionary<String,String>", "System."); 

Answer 2

typeof(System.Dictionary<System.String>, System.String>).FullName 

Quant à l'inverse, aucun indice :(

Answer 3

Je ne suis pas sûr que je comprends parfaitement votre question. De toute façon -Lorsque vous instancier une classe génétique Class<T1, ... ,Tn> le défini dans l'espace de noms Namespace, par exemple

Namespace.Class<T1, ... ,Tn> a = new Namespace.Class<Type1,...,Typen>(); 

a.GetType(). FullName vous donnera la représentation chaîne complète de la classe qui sera "Namespace.Class'n<Type1,...,Typen>"

Answer 4

typeof(System.Dictionary<System.String, System.String>).FullName devrait vous obtenir quelque chose comme:

System.Collections.Generic.Dictionary`2[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] 

pourrions avoir besoin de faire un peu remplacer les noms de type complet à l'intérieur du spec de paramètre de type. Toutefois, si vous utilisez le code ci-dessous

typeof(Dictionary<System.String, System.String>).ToString() 

Vous obtiendrez quelque chose comme ceci:

System.Collections.Generic.Dictionary`2[System.String,System.String] 

Pour reconvertir en une Type utilisation

Type.GetType("System.Collections.Generic.Dictionary`2[System.String,System.String]"); 

EDIT J'ai essayé de piratage ceci avec des expressions dynamiques mais n'a pas eu beaucoup de chance. Je pense, autre que l'analyse de la chaîne, vous pouvez utiliser une "option nucléaire" et compiler une DLL en utilisant CSharpCodeProvider, puis le charger en utilisant Assembly.LoadFile et exécuter une méthode qui évaluera typeof (...).

Answer 5

Je pense que c'est ce que vous cherchiez ...

var dict = new Dictionary<string, string>(); 
var type = dict.GetType(); 
var typeName = type.FullName; 
var newType = Type.GetType(typeName); 

Console.WriteLine(type == newType); //true 

Answer 6

Pour la direction .NET vers C#, je ne vois pas de moyen facile de le faire; vous devrez peut-être analyser le type vous-même.

Dans l'autre sens, il est assez facile:

public static string DotNetToCSharp(string tyName) { 
    var provider = new Microsoft.CSharp.CSharpCodeProvider(); 
    return provider.GetTypeOutput(new System.CodeDom.CodeTypeReference(tyName)); 
}