.NET: Determine o tipo de “esta” classe em seu método estático

Em um método não estático, eu poderia usar this.GetType()e ele retornaria o Type. Como posso obter o mesmo Typeem um método estático? Claro, eu não posso simplesmente escrever typeof(ThisTypeName)porque ThisTypeNameé conhecido apenas em tempo de execução. Obrigado!

Se você está procurando um liner 1 que é equivalente aos this.GetType()métodos estáticos, tente o seguinte.

Type t = MethodBase.GetCurrentMethod().DeclaringType

Embora isso seja provavelmente muito mais caro do que apenas usar typeof(TheTypeName).

Há algo que as outras respostas não esclareceram e que é relevante para a sua ideia do tipo estar disponível apenas em tempo de execução.

Se você usar um tipo derivado para executar um membro estático, o nome do tipo real será omitido no binário. Portanto, por exemplo, compile este código:

UnicodeEncoding.GetEncoding(0);

Agora use ildasm nele ... você verá que a chamada é emitida assim:

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

O compilador resolveu a chamada para Encoding.GetEncoding- não há vestígios de UnicodeEncodingesquerda. Isso torna a sua ideia do "tipo atual" absurda, infelizmente.

Outra solução é usar um tipo autorreferencial

//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);
    }
}

Então, na classe que o herda, faço um tipo de autorreferência:

public class Child: Parent<Child>
{
}

Agora, o tipo de chamada typeof (TSelfReferenceType) dentro de Parent obterá e retornará o Type do chamador sem a necessidade de uma instância.

Child.GetType();

-Roubar

Você não pode usar thisem um método estático, então isso não é possível diretamente. Porém, se você precisa do tipo de algum objeto, basta chamá GetType-lo e fazer da thisinstância um parâmetro que você deve passar, por exemplo:

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

No entanto, este parece ser um design ruim. Tem certeza de que realmente precisa obter o tipo da própria instância dentro de seu próprio método estático? Isso parece um pouco bizarro. Por que não usar apenas um método de instância?

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

Não entendo por que você não pode usar typeof (ThisTypeName). Se este for um tipo não genérico, isso deve funcionar:

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

Se for um tipo genérico, então:

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

Estou perdendo algo óbvio aqui?

Quando seu membro é estático, você sempre saberá de que tipo ele faz parte em tempo de execução. Nesse caso:

class A
{
  public static int GetInt(){}

}
class B : A {}

Você não pode ligar (editar: aparentemente, você pode, veja o comentário abaixo, mas você ainda estaria ligando em A):

B.GetInt();

como o membro é estático, ele não faz parte dos cenários de herança. Portanto, você sempre sabe que o tipo é A.

Para os meus propósitos, gosto da ideia de @T-moty. Embora eu tenha usado informações de "tipo de autorreferência" por anos, referenciar a classe base é mais difícil de fazer mais tarde.

Por exemplo (usando o exemplo de @Rob Leclerc acima):

public class ChildA: Parent<ChildA>
{
}

public class ChildB: Parent<ChildB>
{
}

Trabalhar com esse padrão pode ser desafiador, por exemplo; como você retorna a classe base de uma chamada de função?

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

Ou quando digitar o casting?

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

Portanto, tento evitá-lo quando posso e usá-lo quando preciso. Se necessário, sugiro que siga este padrão:

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) {}
}

Agora você pode (mais) trabalhar facilmente com o BaseClass. No entanto, há momentos, como minha situação atual, em que expor a classe derivada, de dentro da classe base, não é necessário e usar a sugestão de @M-moty pode ser a abordagem certa.

No entanto, usar o código de @M-moty funciona apenas enquanto a classe base não contiver nenhum construtor de instância na pilha de chamadas. Infelizmente, minhas classes base usam construtores de instância.

Portanto, aqui está meu método de extensão que leva em consideração os construtores de 'instância' da classe base:

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;
    }
}

EDITAR Este método funcionará apenas quando você implantar arquivos PDB com o executável / biblioteca, como markmnl apontou para mim.

Caso contrário, será um grande problema a ser detectado: funciona bem no desenvolvimento, mas talvez não na produção.

Método utilitário, basta chamar o método quando precisar, de qualquer lugar do seu 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;
}