.NET: определить тип «этого» класса в его статическом методе.

В нестатическом методе я мог бы использовать, this.GetType()и он вернул бы Type. Как я могу получить то же самое Typeв статическом методе? Конечно, я не могу просто писать, typeof(ThisTypeName)потому что ThisTypeNameэто известно только во время выполнения. Спасибо!

Если вы ищете 1 лайнер, эквивалентный this.GetType()статическим методам, попробуйте следующее.

Type t = MethodBase.GetCurrentMethod().DeclaringType

Хотя это, вероятно, намного дороже, чем просто использовать typeof(TheTypeName).

Есть кое-что, что другие ответы не совсем прояснили, и что имеет отношение к вашей идее о том, что тип доступен только во время выполнения.

Если вы используете производный тип для выполнения статического члена, настоящее имя типа в двоичном файле опускается. Так, например, скомпилируйте этот код:

UnicodeEncoding.GetEncoding(0);

Теперь используйте ildasm ... вы увидите, что вызов излучается следующим образом:

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

Компилятор разрешил вызов Encoding.GetEncoding- не осталось никаких следов UnicodeEncoding. Боюсь, это делает ваше представление о "нынешнем типе" бессмысленным.

Другое решение - использовать самореференционный тип

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

Затем в классе, который его наследует, я создаю тип со ссылкой на себя:

public class Child: Parent<Child>
{
}

Теперь тип вызова typeof (TSelfReferenceType) внутри Parent будет получать и возвращать Type вызывающего абонента без необходимости в экземпляре.

Child.GetType();

-Роб

Вы не можете использовать thisстатический метод, поэтому это невозможно напрямую. Однако, если вам нужен тип какого-либо объекта, просто вызовите GetTypeего и сделайте thisэкземпляр параметром, который вы должны передать, например:

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

Хотя это кажется плохим дизайном. Вы уверены, что вам действительно нужно получить тип самого экземпляра внутри его собственного статического метода? Это кажется немного странным. Почему бы просто не использовать метод экземпляра?

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

Я не понимаю, почему вы не можете использовать typeof (ThisTypeName). Если это неуниверсальный тип, то это должно работать:

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

Если это общий тип, то:

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

Я упустил что-то очевидное?

Когда ваш член статический, вы всегда будете знать, к какому типу он принадлежит во время выполнения. В таком случае:

class A
{
  public static int GetInt(){}

}
class B : A {}

Вы не можете звонить (редактировать: очевидно, вы можете, см. Комментарий ниже, но вы все равно будете звонить в A):

B.GetInt();

поскольку член является статическим, он не участвует в сценариях наследования. Следовательно, вы всегда знаете, что это тип А.

Для моих целей мне нравится идея @T-moty. Несмотря на то, что я много лет использовал информацию о типе с саморегулированием, позже ссылаться на базовый класс будет труднее.

Например (используя пример @Rob Leclerc сверху):

public class ChildA: Parent<ChildA>
{
}

public class ChildB: Parent<ChildB>
{
}

Например, работа с этим шаблоном может быть сложной; как вернуть базовый класс из вызова функции?

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

Или при приведении типов?

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

Поэтому я стараюсь избегать этого, когда могу, и использую, когда необходимо. Если необходимо, я бы посоветовал вам следовать этому шаблону:

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

Теперь вы можете (более) легко работать с BaseClass. Однако бывают случаи, как моя текущая ситуация, когда раскрытие производного класса из базового класса не требуется, и использование предложения @ M-moty может быть правильным подходом.

Однако использование кода @ M-moty работает только до тех пор, пока базовый класс не содержит конструкторов экземпляров в стеке вызовов. К сожалению, в моих базовых классах используются конструкторы экземпляров.

Поэтому вот мой метод расширения, который учитывает конструкторы экземпляра базового класса:

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

ИЗМЕНИТЬ Эти методы будут работать только тогда, когда вы развертываете файлы PDB с исполняемым файлом / библиотекой, как мне указал markmnl .

В противном случае будет обнаружена огромная проблема: хорошо работает в разработке, но, возможно, не в производстве.

Служебный метод, просто вызовите метод, когда вам нужно, из любого места вашего кода:

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