Tipo.GetType ("espacio de nombres.a.b. className") devuelve null

También puede obtener el tipo sin nombre calificado de ensamblado, pero también con el nombre dll, por ejemplo:

Type myClassType = Type.GetType("TypeName,DllName");

Tuve la misma situación y funcionó para mí. Necesitaba un objeto de tipo "DataModel.QueueObject "y tenía una referencia a "DataModel", así que obtuve el tipo de la siguiente manera:

Type type = Type.GetType("DataModel.QueueObject,DataModel");

La segunda cadena después de la coma es el nombre de referencia (nombre dll).

Intenta usar este método

 public static Type GetType(string typeName)
        {
            var type = Type.GetType(typeName);
            if (type != null) return type;
            foreach (var a in AppDomain.CurrentDomain.GetAssemblies())
            {
                type = a.GetType(typeName);
                if (type != null)
                    return type;
            }
            return null ;
        }

Dictionary<string, Type> typeCache;
...
public static bool TryFindType(string typeName, out Type t) {
    lock (typeCache) {
        if (!typeCache.TryGetValue(typeName, out t)) {
            foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies()) {
                t = a.GetType(typeName);
                if (t != null)
                    break;
            }
            typeCache[typeName] = t; // perhaps null
        }
    }
    return t != null;
}

Si el ensamblaje es parte de la construcción de un ASP.NET aplicación, puede utilizar la clase BuildManager:

using System.Web.Compilation
...
BuildManager.GetType(typeName, false);

Si es un tipo anidado, es posible que se olvide de transformar a . a +

A pesar de todo, typeof( T).FullName te dirá lo que deberías estar diciendo

EDITAR: POR cierto, los usos (como estoy seguro de que sabes) son solo directivas para el compilador en tiempo de compilación y por lo tanto no pueden tener ningún impacto en el éxito de la llamada a la API. (Si tenía referencias de proyecto o ensamblado, eso podría haber tenido influencia-por lo tanto, la información no es inútil, solo necesita un poco de filtrado...)

Si su clase no está en assambly actual debe dar qualifiedName y este código muestra cómo obtener qualifiedname de la clase

string qualifiedName = typeof(YourClass).AssemblyQualifiedName;

Y luego puedes obtener type con qualifiedName

Type elementType = Type.GetType(qualifiedName);

Estoy abriendo controles de usuario dependiendo de los controles de usuario a los que el usuario tenga acceso especificado en una base de datos. Así que usé este método para obtener el nombre del tipo...

Dim strType As String = GetType(Namespace.ClassName).AssemblyQualifiedName.ToString
Dim obj As UserControl = Activator.CreateInstance(Type.GetType(strType))

Así que ahora se puede usar el valor devuelto en strType para crear una instancia de ese objeto.

Si se hace referencia al ensamblado y la Clase es visible:

typeof(namespace.a.b.ClassName)

GetType devuelve null porque el tipo no se encuentra, con typeof, el compilador puede ayudarle a encontrar el error.

Intente usar el nombre de tipo completo que incluye la información del ensamblado, por ejemplo:

string typeName = @"MyCompany.MyApp.MyDomain.MyClass, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null";
Type myClassType = Type.GetType(typeName);

Tuve la misma situación cuando estaba usando solo el espacio de nombres.classname para obtener el tipo de una clase en un ensamblado diferente y no funcionaría. Solo funcionó cuando incluí la información del ensamblado en mi cadena de texto como se muestra arriba.

Cuando solo tengo el nombre de la clase uso esto:

Type obj = AppDomain.CurrentDomain.GetAssemblies().SelectMany(t => t.GetTypes()).Where(t => String.Equals(t.Name, _viewModelName, StringComparison.Ordinal)).First();

Asegúrese de que la coma está directamente después del nombre completo

typeof(namespace.a.b.ClassName, AssemblyName)

Ya que esto no funcionará

typeof(namespace.a.b.ClassName ,AssemblyName)

Me quedé perplejo durante unos días en este

Esta solución anterior parece ser la mejor para mí, pero no funcionó para mí, así que lo hice de la siguiente manera:

AssemblyName assemblyName = AssemblyName.GetAssemblyName(HttpContext.Current.Server.MapPath("~\\Bin\\AnotherAssembly.dll"));
string typeAssemblyQualifiedName = string.Join(", ", "MyNamespace.MyType", assemblyName.FullName);

Type myType = Type.GetType(typeAssemblyQualifiedName);

La condición previa es que conozca la ruta del ensamblado. En mi caso lo sé porque este es un ensamblaje construido a partir de otro proyecto interno y está incluido en la carpeta bin de nuestro proyecto.

En caso de que importe, estoy usando Visual Studio 2013, mi.NET objetivo es 4.0. Este es un ASP.NET proyecto, por lo que estoy recibiendo ruta absoluta a través de HttpContext. Sin embargo, absoluta path no es un requisito como parece de MSDN en AssemblyQualifiedNames

Para mí, un "+" era la clave! Esta es mi clase(es una anidada) :

namespace PortalServices
{
public class PortalManagement : WebService
{
    public class Merchant
    {}
}
}

Y esta línea de código funcionó:

Type type = Type.GetType("PortalServices.PortalManagement+Merchant");

Como Tipo.GetType (String) necesita el tipo .AssemblyQualifiedName debe usar Assembly.CreateQualifiedName (String, String).

string typeName = "MyNamespace.MyClass"; // Type.FullName
string assemblyName = "MyAssemblyName"; // MyAssembly.FullName or MyAssembly.GetName().Name
string assemblyQualifiedName = Assembly.CreateQualifiedName(assemblyName , typeName);
Type myClassType = Type.GetType(assemblyQualifiedName);

Como AssemblyName no necesita FullName, solo se requiere el nombre sin la Versión, la Cultura y PublicKeyToken.

Hice trampa. Dado que los tipos que quiero crear (por nombre) están todos en una dll que controlo, simplemente pongo un método estático en la dll en el ensamblado que toma un nombre simple y llama a type.GetType de ese contexto y devuelve el resultado.

El propósito original era que el tipo pudiera especificarse por nombre en los datos de configuración. Desde entonces, he cambiado el código para que el usuario especifique un formato para procesar. Las clases de controlador de formato implementan una interfaz que determina si el tipo puede analizar el formato especificado. Luego uso reflexión para encontrar tipos que implementan la interfaz y encontrar uno que maneje el formato. Así que ahora la configuración especifica un nombre de formato, no un tipo específico. El código de reflexión puede mirar las DLL adyacentes y cargarlas, así que tengo una arquitectura de plug-in de tipo pobre.