Obtener un System.Type del nombre parcial del tipo

Question

Quiero obtener un System.Type dado solo el nombre del tipo en un string.

Por ejemplo, si tengo un objeto:

MyClass abc = new MyClass(); 

Entonces se puede decir:

System.Type type = abc.GetType(); 

Pero lo que si todo lo que tengo es:

string className = "MyClass"; 

Answer 1

Type type = Type.GetType("foo.bar.MyClass, foo.bar"); 

MSDN. Asegúrese de que el nombre sea Assembly Qualified.

Answer 2

Type type = Type.GetType("MyClass"); 

Asegúrese de incluir el espacio de nombres. Hay sobrecargas del método que controla la sensibilidad a mayúsculas y minúsculas y si se lanza una excepción si no se encuentra el nombre del tipo.

Answer 3

para crear una instancia de la clase después de obtener el tipo, e invocar un método -

Type type = Type.GetType("foo.bar.MyClass, foo.bar"); 
object instanceObject = System.Reflection.Activator.CreateInstance(type); 
type.InvokeMember(method, BindingFlags.InvokeMethod, null, instanceObject, new object[0]); 

Answer 4

Type.GetType(...) puede fallar a veces, si el operador typeof no se puede utilizar.

En su lugar, puede reflejar los ensamblados del dominio actual para poder hacerlo.

comprobar mi respuesta en this thread

Answer 5

Otra forma de obtener el tipo de corriente u otra assebly.

(asume que el espacio de nombres de clase contiene su montaje):

---

public static Type GetType(string fullName) 
{ 
    if (string.IsNullOrEmpty(fullName)) 
     return null; 
    Type type = Type.GetType(fullName); 
    if (type == null) 
    { 
     string targetAssembly = fullName; 
     while (type == null && targetAssembly.Length > 0) 
     { 
      try 
      { 
       int dotInd = targetAssembly.LastIndexOf('.'); 
       targetAssembly = dotInd >= 0 ? targetAssembly.Substring(0, dotInd) : ""; 
       if (targetAssembly.Length > 0) 
        type = Type.GetType(fullName + ", " + targetAssembly); 
      } 
      catch { } 
     } 
    } 
    return type; 
} 

Answer 6

Aquí es un método simple para crear e inicializar un nuevo objeto a partir de su nombre y parámetros:

// Creates and initializes a new object from its name and parameters 
    public Object CreateObjectByName(string name, params Object[] args) 
    { 
     string s = "<prefix>" + name; // case sensitive; Type.FullName 
     Type type = Type.GetType(s); 
     Object o = System.Activator.CreateInstance(type, args); 
     return o; 
    } 

Un ejemplo de cómo se podría usar esto es leer un archivo que contenga nombres de clase [o nombres de clase parciales] y parámetros y luego agregar los objetos devueltos a una lista de objetos de un tipo base que sea commo. n a los objetos creados.

Para ver lo que su nombre de la clase [o] debe ser similar, utilizar temporalmente algo como esto [si su clase se llama NewClass]:

string z = (new NewClass(args)).GetType().FullName; 

Answer 7

Depende de la que el conjunto de la clase es.Si está en mscorlib o llamando al montaje de todo lo que necesita es

Type type = Type.GetType("namespace.class"); 

Pero si se hace referencia desde algún otro montaje, lo que tendría que hacer:

Assembly assembly = typeof(SomeKnownTypeInAssembly).Assembly; 
Type type = assembly.GetType("namespace.class"); 

//or 

Type type = Type.GetType("namespace.class, assembly"); 

---

Si sólo tiene el nombre de clase "MyClass", entonces debe obtener de alguna manera el nombre del espacio de nombres (o el nombre del espacio de nombres y el nombre del ensamblado en caso de que se trate de un ensamblaje al que se hace referencia) y concat junto con el nombre de la clase. Algo así como:

//if class is in same assembly 
var namespace = typeof(SomeKnownTypeInNamespace).Namespace; 
Type type = Type.GetType(namespace + "." + "MyClass"); 


//or for cases of referenced classes 
var assembly = typeof(SomeKnownTypeInAssembly).Assembly; 
var namespace = typeof(SomeKnownTypeInNamespace).Namespace; 
Type type = assembly.GetType(namespace + "." + "MyClass"); 
//or 
Type type = Type.GetType(namespace + "." + "MyClass" + ", " + assembly.GetName().Name); 

---

Si usted no tiene absolutamente nada (sin preawareness incluso de nombre de ensamblado o el nombre de espacio de nombres), pero sólo el nombre de la clase, a continuación, se puede consultar la totalidad de las asambleas para seleccionar una cadena coincidente. Pero eso debería ser mucho más lento:

Type type = AppDomain.CurrentDomain.GetAssemblies() 
            .SelectMany(x => x.GetTypes()) 
            .FirstOrDefault(x => x.Name == "MyClass"); 

Tenga en cuenta que esto devuelve la primera clase de juego, por lo que no tiene que ser muy preciso si desea tener varias clases con el mismo nombre a través de ensambles/espacios de nombres. En cualquier caso, el almacenamiento en caché de los valores tiene sentido aquí. manera un poco más rápido es asumir que hay un espacio de nombres por defecto:

Type type = AppDomain.CurrentDomain.GetAssemblies() 
            .Select(a => new { a, a.GetTypes().First().Namespace }) 
            .Select(x => x.a.GetType(x.Namespace + "." + "MyClass")) 
            .FirstOrDefault(x => x != null); 

Pero eso es otra vez una suposición de que el tipo tendrá el mismo espacio de nombres que alguna otra clase al azar en la asamblea; demasiado quebradizo, no muy bueno.

---

Si desea clases de otros dominios, usted puede obtener una lista de todos los dominios de aplicación, siguiendo this link. A continuación, puede hacer lo mismo de consulta como se muestra arriba para cada dominio. Si su ensamblaje donde reside el tipo no está cargado aún, entonces tiene que cargarlo manualmente usando Assembly.Load, Assembly.LoadFrom etc.