.NET: determine el tipo de "esta" clase en su método estático

Question

En un método no estático podría usar this.GetType() y devolvería el Type. ¿Cómo puedo obtener el mismo Type en un método estático? Por supuesto, no puedo simplemente escribir typeof(ThisTypeName) porque ThisTypeName es conocido solo en tiempo de ejecución. ¡Gracias!

Answer 1

Si usted está buscando un revestimiento 1 que es equivalente a this.GetType() para los métodos estáticos, intente lo siguiente.

Type t = MethodBase.GetCurrentMethod().DeclaringType 

aunque esto es probablemente mucho más caro que simplemente usar typeof(TheTypeName).

Answer 2

No puede usar this en un método estático, por lo que no es posible directamente. Sin embargo, si usted necesita el tipo de un objeto, simplemente llame GetType en él y hacer que la instancia this un parámetro que tiene que pasar, por ejemplo .:

public class Car { 
    public static void Drive(Car c) { 
    Console.WriteLine("Driving a {0}", c.GetType()); 
    } 
} 

Este parece ser un mal diseño, sin embargo. ¿Estás seguro de que realmente necesitas obtener el tipo de instancia propia dentro de su propio método estático? Eso parece un poco extraño. ¿Por qué no usar simplemente un método de instancia?

public class Car { 
    public void Drive() { // Remove parameter; doesn't need to be static. 
    Console.WriteLine("Driving a {0}", this.GetType()); 
    } 
} 

Answer 3

Cuando su miembro es estático, siempre sabrá de qué tipo es parte en tiempo de ejecución. En este caso:

class A 
{ 
    public static int GetInt(){} 

} 
class B : A {} 

no se puede llamar (edit: al parecer, puede, véase el comentario a continuación, pero todavía estaría poniendo en A):

B.GetInt(); 

porque el miembro es estático, no juega parte en escenarios de herencia. Ergo, siempre sabes que el tipo es A.

Answer 4

No entiendo por qué no puedes usar typeof (ThisTypeName). Si se trata de un tipo no genérico, entonces esto debería funcionar:

class Foo { 
    static void Method1() { 
     Type t = typeof (Foo); // Can just hard code this 
    } 
} 

Si se trata de un tipo genérico, entonces:

class Foo<T> { 
    static void Method1() { 
     Type t = typeof (Foo<T>); 
    } 
} 

Me estoy perdiendo algo obvio aquí?

Answer 5

Hay algo que las otras respuestas no han aclarado del todo, y que es relevante para su idea de que el tipo solo está disponible en tiempo de ejecución.

Si utiliza un tipo derivado para ejecutar un miembro estático, real nombre de tipo se omite en el binario. Así, por ejemplo, compilar este código:

UnicodeEncoding.GetEncoding(0); 

Ahora usa ildasm en él ... verá que la llamada se emite la siguiente manera:

IL_0002: call  class [mscorlib]System.Text.Encoding 
[mscorlib]System.Text.Encoding::GetEncoding(int32) 

El compilador ha resuelto la llamada a Encoding.GetEncoding - no queda rastro de UnicodeEncoding. Eso hace que tu idea del "tipo actual" no tenga sentido, me temo.

Answer 6

Otra solución es utilizar un tipo selfreferecing

//My base class 
//I add a type to my base class use that in the static method to check the type of the caller. 
public class Parent<TSelfReferenceType> 
{ 
    public static Type GetType() 
    { 
     return typeof(TSelfReferenceType); 
    } 
} 

Luego, en la clase que hereda, hago un tipo de auto referencia:

public class Child: Parent<Child> 
{ 
} 

Ahora el tipo de llamada typeof (TSelfReferenceType) en el interior El padre recibirá y devolverá el tipo de llamante sin necesidad de una instancia.

Child.GetType(); 

-Rob

Answer 7

EDITAR Este método voluntad sólo funciona cuando se implementa archivos PDB con el ejecutable/biblioteca, como markmnl me señaló.

De lo contrario, será un gran problema para ser detectado: funciona bien en el desarrollo, pero tal vez no en la producción.

---

método de utilidad, sólo tiene que llamar al método cuando se necesita, desde cada lugar de su código:

public static Type GetType() 
{ 
    var stack = new System.Diagnostics.StackTrace(); 

    if (stack.FrameCount < 2) 
     return null; 

    return (stack.GetFrame(1).GetMethod() as System.Reflection.MethodInfo).DeclaringType; 
} 

Answer 8

Para mis propósitos, me gusta la idea de @ T-moty. Aunque utilicé la información del "tipo de autorreferencia" durante años, hacer referencia a la clase base es más difícil de hacer más adelante.

Por ejemplo (usando el Ejemplo @ Rob Leclerc desde arriba):

public class ChildA: Parent<ChildA> 
{ 
} 

public class ChildB: Parent<ChildB> 
{ 
} 

Trabajar con este patrón puede ser un reto, por ejemplo; ¿cómo se devuelve la clase base de una llamada a función?

public Parent<???> GetParent() {} 

¿O cuando tipo de fundición?

var c = (Parent<???>) GetSomeParent(); 

Por lo tanto, trato de evitarlo cuando puedo, y lo uso cuando debo. Si es necesario, sugeriría que siga este patrón:

class BaseClass 
{ 
    // All non-derived class methods goes here... 

    // For example: 
    public int Id { get; private set; } 
    public string Name { get; private set; } 
    public void Run() {} 
} 

class BaseClass<TSelfReferenceType> : BaseClass 
{ 
    // All derived class methods goes here... 

    // For example: 
    public TSelfReferenceType Foo() {} 
    public void Bar(TSelfRefenceType obj) {} 
} 

ya se puede (más) trabajar fácilmente con la BaseClass. Sin embargo, hay momentos, como mi situación actual, donde no es necesario exponer la clase derivada, desde dentro de la clase base, y usar la sugerencia de @M-moty podría ser el enfoque correcto.

Sin embargo, usar el código de @M-moty solo funciona siempre que la clase base no contenga ningún constructor de instancia en la pila de llamadas. Lamentablemente, mis clases base usan constructores de instancias.

Por lo tanto, aquí está mi método de extensión que tiene en cuenta la clase base 'instancia' constructores:

public static class TypeExtensions 
{ 
    public static Type GetDrivedType(this Type type, int maxSearchDepth = 10) 
    { 
     if (maxSearchDepth < 0) 
      throw new ArgumentOutOfRangeException(nameof(maxSearchDepth), "Must be greater than 0."); 

     const int skipFrames = 2; // Skip the call to self, skip the call to the static Ctor. 
     var stack = new StackTrace(); 
     var maxCount = Math.Min(maxSearchDepth + skipFrames + 1, stack.FrameCount); 
     var frame = skipFrames; 

     // Skip all the base class 'instance' ctor calls. 
     // 
     while (frame < maxCount) 
     { 
      var method = stack.GetFrame(frame).GetMethod(); 
      var declaringType = method.DeclaringType; 

      if (type.IsAssignableFrom(declaringType)) 
       return declaringType; 

      frame++; 
     } 

     return null; 
    } 
}