net - reflection c# español

Obtener un System.Type del nombre parcial del tipo

Question

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

Por ejemplo, si tengo un objeto:

MyClass abc = new MyClass();

Entonces puedo decir:

System.Type type = abc.GetType();

Pero qué pasa si todo lo que tengo es:

string className = "MyClass";

Answer 1

Aquí hay 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 puede 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 es común a los objetos creados.

Para ver cómo debería ser tu nombre de clase [o], utiliza temporalmente algo como esto [si tu clase se llama NewClass]:

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

Answer 2

Depende del ensamblaje de la clase. Si está en mscorlib o ensamblado de llamadas, todo lo que necesita es

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

Pero si se hace referencia a partir de algún otro ensamblaje, tendría que hacer:

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

//or

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

Si solo tiene el nombre de clase "MyClass", 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 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 no tiene absolutamente nada (ni conocimiento de siquiera el nombre del ensamblado o el nombre del espacio de nombres), sino solo el nombre de la clase, puede consultar los ensamblajes completos 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 coincidente, por lo que no es necesario que sea muy preciso si tuviera varias clases con el mismo nombre en ensamblados / espacios de nombres. En cualquier caso, el almacenamiento en caché de los valores tiene sentido aquí. Una forma ligeramente más rápida es suponer que hay un espacio de nombre predeterminado :

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 una suposición de que su tipo tendrá el mismo espacio de nombres que cualquier otra clase aleatoria en el ensamblado; demasiado quebradizo, no muy bueno.

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

Answer 3

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

(Supone que el espacio de nombres de clase contiene su ensamblaje):

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 4

Para crear una instancia de su 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 5

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

En su lugar, puede reflexionar sobre los ensamblados del dominio actual para hacerlo.

revisa mi respuesta en este hilo

Answer 6

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 7

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

MSDN . Asegúrese de que el nombre sea Ensamblado Calificado .