जेनेरिक तर्क कई असेंबली

Question

से आते हैं जब मुझे अपने पूर्ण नाम से केवल एक प्रकार बनाना होगा: "System.String" या "Tuple'2 [string, Mytype]"। स्ट्रिंग में असेंबली के बारे में कोई जानकारी नहीं है। यहां कोड कैसा दिखता है।

private static Type LoadType(string typeName) 
{ 
    // try loading the type 
    Type type = Type.GetType(typeName, false); 

    if (type != null) 
     return type; 

    // if the loading was not successfull iterate all the referenced assemblies and try to load the type. 
    Assembly asm = Assembly.GetEntryAssembly(); 
    AssemblyName[] referencedAssemblies = asm.GetReferencedAssemblies(); 
    foreach (AssemblyName referencedAssemblyName in referencedAssemblies) 
    { 
     type = referencedAssembly.GetType(typeName, false); 
     if (type != null) 
      return type; 
    } 
    throw new TypeLoadException(string.Format("Could not load the Type '{0}'",typeName)); 
} 

यह विधि काम करता है जब प्रकार सामान्य नहीं होता है। लेकिन असेंबली के माध्यम से पुनरावृत्त सामान्य प्रकारों के लिए हमेशा विफल रहता है क्योंकि किसी भी असेंबली में प्रकार बनाने के लिए आवश्यक सभी परिभाषाएं होती हैं।

क्या GetTypes को कॉल करते समय प्रकार संकल्प के लिए गुणक असेंबली प्रदान करने का कोई तरीका है?

Answer 1

आप इसे मुश्किल तरीके से मुझे लगता है कि क्या करना है करने के लिए जा रहे हैं। सौभाग्य से यह मुश्किल नहीं है। बहुत सरल:

• प्रकार का नाम प्रकार परिभाषा और सामान्य प्रकार के तर्कों में पार्स करें।
• सामान्य प्रकार परिभाषा वस्तु
• प्रत्येक सामान्य प्रकार तर्क
• के लिए प्रकार की वस्तुओं को प्राप्त प्राप्त सामान्य प्रकार परिभाषा और प्रकार परिभाषा वस्तु पर MakeGenericType पद्धति का उपयोग करके सामान्य प्रकार तर्क से बाहर सामान्य प्रकार का निर्माण।

Answer 2

इस तरह कुछ ....

Type.GetType("namespace.typename`1[[namespace.typename, assemblyname]], assemblyname"); 

उदा

var type = Type.GetType("System.Collections.Generic.List`1[[System.String, mscorlib]], mscorlib"); 
var instance = Activator.CreateInstance(type); 

या, एरिक कहते हैं .. अगर आप हाथ में प्रकार है, बस इसे बनाने ..

Type genericType = typeof(Dictionary<,>); 
Type constructedType = genericType.MakeGenericType(new Type[] { typeof(String), typeof(String) }); 

Answer 3

प्रारूप't1 [[t2, a2] [t3, a3]], a1', इस काम करता है:

private Type GetAckwardType(string typeName) 
{ 
    var tokens = typeName.Split(new [] {"[[", "]]", "]["}, StringSplitOptions.None); 
    if (tokens.Length == 1) 
     return Type.GetType(typeName, true); 

    var plainType = Type.GetType(tokens[0] + tokens[tokens.Length - 1], true); 
    var args = tokens.Skip(1).Take(tokens.Length - 2).Select(_ => Type.GetType(_, true)).ToArray(); 
    return plainType.MakeGenericType(args); 
} 

Answer 4

यहाँ किसी भी प्रकार प्राप्त करने के लिए है मेरी मुश्किल तरीके से समाधान:

/// <summary> 
    /// Gets the type associated with the specified name. 
    /// </summary> 
    /// <param name="typeName">Full name of the type.</param> 
    /// <param name="type">The type.</param> 
    /// <param name="customAssemblies">Additional loaded assemblies (optional).</param> 
    /// <returns>Returns <c>true</c> if the type was found; otherwise <c>false</c>.</returns> 
    public static bool TryGetTypeByName(string typeName, out Type type, params Assembly[] customAssemblies) 
    { 
     if (typeName.Contains("Version=") 
      && !typeName.Contains("`")) 
     { 
      // remove full qualified assembly type name 
      typeName = typeName.Substring(0, typeName.IndexOf(',')); 
     } 

     type = Type.GetType(typeName); 

     if (type == null) 
     { 
      type = GetTypeFromAssemblies(typeName, customAssemblies); 
     } 

     // try get generic types 
     if (type == null 
      && typeName.Contains("`")) 
     { 
      var match = Regex.Match(typeName, "(?<MainType>.+`(?<ParamCount>[0-9]+))\\[(?<Types>.*)\\]"); 

      if (match.Success) 
      { 
       int genericParameterCount = int.Parse(match.Groups["ParamCount"].Value); 
       string genericDef = match.Groups["Types"].Value; 
       List<string> typeArgs = new List<string>(genericParameterCount); 
       foreach (Match typeArgMatch in Regex.Matches(genericDef, "\\[(?<Type>.*?)\\],?")) 
       { 
        if (typeArgMatch.Success) 
        { 
         typeArgs.Add(typeArgMatch.Groups["Type"].Value.Trim()); 
        } 
       } 

       Type[] genericArgumentTypes = new Type[typeArgs.Count]; 
       for (int genTypeIndex = 0; genTypeIndex < typeArgs.Count; genTypeIndex++) 
       { 
        Type genericType; 
        if (TryGetTypeByName(typeArgs[genTypeIndex], out genericType, customAssemblies)) 
        { 
         genericArgumentTypes[genTypeIndex] = genericType; 
        } 
        else 
        { 
         // cant find generic type 
         return false; 
        } 
       } 

       string genericTypeString = match.Groups["MainType"].Value; 
       Type genericMainType; 
       if (TryGetTypeByName(genericTypeString, out genericMainType)) 
       { 
        // make generic type 
        type = genericMainType.MakeGenericType(genericArgumentTypes); 
       } 
      } 
     } 

     return type != null; 
    } 

    private static Type GetTypeFromAssemblies(string typeName, params Assembly[] customAssemblies) 
    { 
     Type type = null; 

     if (customAssemblies != null 
      && customAssemblies.Length > 0) 
     { 
      foreach (var assembly in customAssemblies) 
      { 
       type = assembly.GetType(typeName); 

       if (type != null) 
        return type; 
      } 
     } 

     var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies(); 
     foreach (var assembly in loadedAssemblies) 
     { 
      type = assembly.GetType(typeName); 

      if (type != null) 
       return type; 
     }   

     return type; 
    }