How to load a generic type containing nested types from dynamically loaded assemblies?

Question

In the assembly loaded into the current AppDomain using Assembly.LoadFrom , I have the following code:

[TypeConverter(typeof(EnumConverter<Shapes>))]
public enum Shapes
{
  Triangle,
  Square,
  Circle
}

The generic EnumConverter <T> is defined in the assembly returned by the call to Assembly.GetEntryAssembly (). When I read the TypeConverter attribute at runtime, I get a fully qualified type name that looks something like this:

MyAssembly.EnumConverter`1[[MyDynamicAssembly.Shapes, MyDynamicAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]

However, when I call Type.GetType () on a string, it returns null. I was expecting to be able to get an instance of System.Type. Also note that MyDynamicAssembly was not created by Reflection.Emit (indicated in the MSDN article here ).

This code was generated in Visual Studio 2005 using the .NET Framework 2.0.

- /? 3.5?

Answer 1

MSDN , . , (, , Microsoft - .NET 4.0?)

public static class TypeHelpers
{
    /// <summary>
    /// Gets the System.Type with the specified name, performing a case-sensitive search.
    /// </summary>
    /// <param name="typeName">The assembly-qualified name of the type to get. See System.Type.AssemblyQualifiedName.</param>
    /// <param name="throwOnError">Whether or not to throw an exception or return null if the type was not found.</param>
    /// <param name="ignoreCase">Whether or not to perform a case-insensitive search.</param>
    /// <returns>The System.Type with the specified name.</returns>
    /// <remarks>
    /// This method can load types from dynamically loaded assemblies as long as the referenced assembly 
    /// has already been loaded into the current AppDomain.
    /// </remarks>
    public static Type GetType(string typeName, bool throwOnError, bool ignoreCase)
    {
        if(string.IsNullOrEmpty(typeName))
            throw new ArgumentNullException("typeName");

        // handle the trivial case
        Type type;
        if((type = Type.GetType(typeName, false, ignoreCase)) != null)
            return type;

        // otherwise, perform the recursive search
        try
        {
            return GetTypeFromRecursive(typeName, ignoreCase);
        }
        catch(Exception e)
        {
            if(throwOnError)
                throw;
        }

        return null;
    }

    #region Private Static Helper Methods

    private static Type GetTypeFromRecursive(string typeName, bool ignoreCase)
    {
        int startIndex = typeName.IndexOf('[');
        int endIndex = typeName.LastIndexOf(']');

        if(startIndex == -1)
        {
            // try to load the non-generic type (e.g. System.Int32)
            return TypeHelpers.GetNonGenericType(typeName, ignoreCase);
        }
        else
        {
            // determine the cardinality of the generic type
            int cardinalityIndex = typeName.IndexOf('`', 0, startIndex);
            string cardinalityString = typeName.Substring(cardinalityIndex + 1, startIndex - cardinalityIndex - 1);
            int cardinality = int.Parse(cardinalityString);

            // get the FullName of the non-generic type (e.g. System.Collections.Generic.List`1)
            string fullName = typeName.Substring(0, startIndex);
            if(typeName.Length - endIndex - 1 > 0)
                fullName += typeName.Substring(endIndex + 1, typeName.Length - endIndex - 1);

            // parse the child type arguments for this generic type (recursive)
            List<Type> list = new List<Type>();
            string typeArguments = typeName.Substring(startIndex + 1, endIndex - startIndex - 1);
            foreach(string item in EachAssemblyQualifiedName(typeArguments, cardinality))
            {
                Type typeArgument = GetTypeFromRecursive(item, ignoreCase);
                list.Add(typeArgument);
            }

            // construct the generic type definition
            return TypeHelpers.GetNonGenericType(fullName, ignoreCase).MakeGenericType(list.ToArray());
        }
    }

    private static IEnumerable<string> EachAssemblyQualifiedName(string s, int count)
    {
        Debug.Assert(count != 0);
        Debug.Assert(string.IsNullOrEmpty(s) == false);
        Debug.Assert(s.Length > 2);

        // e.g. "[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]"
        // e.g. "[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.DateTime, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]"
        // e.g. "[System.Collections.Generic.KeyValuePair`2[[System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.DateTime, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]"

        int startIndex = 0;
        int bracketCount = 0;

        while(count > 0)
        {
            bracketCount = 0;

            for(int i = startIndex; i < s.Length; i++)
            {
                switch(s[i])
                {
                    case '[':
                        bracketCount++;
                        continue;

                    case ']':
                        if(--bracketCount == 0)
                        {
                            string item = s.Substring(startIndex + 1, i - startIndex - 1);
                            yield return item;
                            startIndex = i + 2;
                        }
                        break;

                    default:
                        continue;
                }
            }

            if(bracketCount != 0)
            {
                const string SR_Malformed = "The brackets are unbalanced in the string, '{0}'.";
                throw new FormatException(string.Format(SR_Malformed, s));
            }

            count--;
        }
    }

    private static Type GetNonGenericType(string typeName, bool ignoreCase)
    {
        // assume the type information is not a dynamically loaded assembly
        Type type = Type.GetType(typeName, false, ignoreCase);
        if(type != null)
            return type;

        // otherwise, search the assemblies in the current AppDomain for the type
        int assemblyFullNameIndex = typeName.IndexOf(',');
        if(assemblyFullNameIndex != -1)
        {
            string assemblyFullName = typeName.Substring(assemblyFullNameIndex + 2, typeName.Length - assemblyFullNameIndex - 2);
            foreach(Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
            {
                if(assembly.GetName().FullName == assemblyFullName)
                {
                    string fullName = typeName.Substring(0, assemblyFullNameIndex);
                    type = assembly.GetType(fullName, false, ignoreCase);
                    if(type != null)
                        return type;
                }
            }
        }

        // no luck? blow up
        const string SR_TypeNotFound = "The type, '{0}', was not found.";
        throw new ArgumentException(string.Format(SR_TypeNotFound, typeName), "typeName");
    }

    #endregion
}

, MbUnit:

[Test]
public void GetType_DictionaryOfStringAndDictionaryOfInt32AndKeyValuePairOfStringAndListOfInt32()
{
    Dictionary<string, Dictionary<int, KeyValuePair<string, List<int>>>> obj = 
    new Dictionary<string, Dictionary<int, KeyValuePair<string, List<int>>>>();

    string typeName = obj.GetType().FullName;
    Type type = TypeHelpers.GetType(typeName, true, false);

    Assert.IsTrue(type.Equals(obj.GetType()));
}

. , Type.GetType().