GetType () может врать?

Основываясь на следующем вопросе, заданном несколько дней назад в SO: GetType () и полиморфизм, и прочитав ответ Эрика Липперта , я начал думать, действительно ли создание GetType()виртуального объекта не гарантирует, что объект не может лгать о нем Type.

В частности, в ответе Эрика говорится следующее:

Разработчики фреймворка не собираются добавлять невероятно опасную функцию, такую ​​как разрешение объекту лгать о своем типе только для того, чтобы согласовать его с тремя другими методами того же типа.

Теперь вопрос: могу ли я создать объект, который лжет о своем типе, не будучи сразу очевидным? Я могу ошибаться здесь и хотел бы получить разъяснения, если это так, но рассмотрите следующий код:

public interface IFoo
{
    Type GetType();
}

И следующие две реализации указанного интерфейса:

public class BadFoo : IFoo
{
    Type IFoo.GetType()
    {
        return typeof(int);
    }
}

public class NiceFoo : IFoo
{
}

Затем, если вы запустите следующую простую программу:

static void Main(string[] args)
{
    IFoo badFoo = new BadFoo();
    IFoo niceFoo = new NiceFoo();
    Console.WriteLine("BadFoo says he's a '{0}'", badFoo.GetType().ToString());
    Console.WriteLine("NiceFoo says he's a '{0}'", niceFoo.GetType().ToString());
    Console.ReadLine();
}

Конечно же, badFooвыводит ошибочный Type.

Я не знаю, имеет ли это какое-либо серьезное значение на основании того, что Эрик описывает такое поведение как « невероятно опасную особенность », но может ли этот шаблон представлять реальную угрозу?

Хороший вопрос! На мой взгляд, вы могли бы ввести в заблуждение другого разработчика, только если бы GetType был виртуальным для объекта, а это не так.

То, что вы сделали, похоже на слежку за GetType, например:

public class BadFoo
{
    public new Type GetType()
    {
        return typeof(int);
    }
}

с этим классом (и используя образец кода из MSDN для метода GetType () ) вы действительно можете иметь:

int n1 = 12;
BadFoo foo = new BadFoo();

Console.WriteLine("n1 and n2 are the same type: {0}",
                  Object.ReferenceEquals(n1.GetType(), foo.GetType())); 
// output: 
// n1 and n2 are the same type: True

Итак, ты успешно солгал, не так ли? Что ж, да и нет ... Учтите, что использование этого в качестве эксплойта означало бы использование вашего экземпляра BadFoo в качестве аргумента для метода, который ожидает, вероятно, общий objectили общий базовый тип для иерархии объектов. Что-то вроде этого:

public void CheckIfInt(object ob)
{
    if(ob.GetType() == typeof(int))
    {
        Console.WriteLine("got an int! Initiate destruction of Universe!");
    }
    else
    {
        Console.WriteLine("not an int");
    }
}

но CheckIfInt(foo)печатает «не int».

Итак, в основном (вернемся к вашему примеру), вы действительно можете использовать свой «лживый тип» только с помощью кода, который кто-то написал против вашего IFooинтерфейса, что очень ясно говорит о том, что у него есть «собственный» GetType()метод.

Только если GetType () был виртуальным для объекта, вы могли бы создать «лживый» тип, который можно было бы использовать с методами, подобными CheckIfIntвыше, для создания хаоса в библиотеках, написанных кем-то другим.

Есть два способа быть уверенным в Типе:

1. Используйте typeofтип, который не может быть перегружен

   IFoo badFoo = new BadFoo();
   IFoo niceFoo = new NiceFoo();
   
   Console.WriteLine("BadFoo says he's a '{0}'", badFoo.GetType().ToString());
   Console.WriteLine("NiceFoo says he's a '{0}'", niceFoo.GetType().ToString());
   
   Console.WriteLine("BadFoo really is a '{0}'", typeof(BadFoo));
   Console.WriteLine("NiceFoo really is a '{0}'", typeof(NiceFoo));
   Console.ReadLine();
   

2. Приведите экземпляр к objectи вызовите GetType()метод

   IFoo badFoo = new BadFoo();
   IFoo niceFoo = new NiceFoo();
   
   Console.WriteLine("BadFoo says he's a '{0}'", badFoo.GetType().ToString());
   Console.WriteLine("NiceFoo says he's a '{0}'", niceFoo.GetType().ToString());
   
   Console.WriteLine("BadFoo really is a '{0}'", ((object)badFoo).GetType());
   Console.WriteLine("NiceFoo really is a '{0}'", ((object)niceFoo).GetType());
   Console.ReadLine();
   

Нет, вы не можете заставить GetType лгать. Вы только вводите новый метод. Его будет вызывать только код, который знает об этом методе.

Вы не можете, например, заставить сторонний код или код фреймворка вызывать ваш новый метод GetType вместо реального, поскольку этот код не знает, что ваш метод существует, и поэтому никогда не вызовет его.

Однако вы можете запутать собственных разработчиков таким заявлением. Любой код, скомпилированный с вашим объявлением и использующий параметры или переменные, набранные как IFoo или любой производный от него тип, действительно будет использовать вместо этого ваш новый метод. Но поскольку это влияет только на ваш собственный код, это не представляет собой «угрозы».

Если вы действительно хотите предоставить описание настраиваемого типа для класса, это следует сделать с помощью дескриптора настраиваемого типа , возможно, путем аннотирования вашего класса с помощью TypeDescriptionProviderAttribute . Это может быть полезно в некоторых ситуациях.

Ну, на самом деле это уже тип , который может лежать в GetType: любой обнуляемого типа.

Этот код :

int? x = 0; int y = 0;
Console.WriteLine(x.GetType() == y.GetType());

выходы True.

На самом деле int?врет не кто, просто неявное приведение objectпревращается int?в коробку int. Но, тем не менее, нельзя отличить int?от intс GetType().

Я не думаю, что это произойдет, поскольку каждый код библиотеки, вызывающий GetType, объявляет переменную как 'Object' или как общий тип 'T'.

Следующий код:

    public static void Main(string[] args)
    {
        IFoo badFoo = new BadFoo();
        IFoo niceFoo = new NiceFoo();
        PrintObjectType("BadFoo", badFoo);
        PrintObjectType("NiceFoo", niceFoo);
        PrintGenericType("BadFoo", badFoo);
        PrintGenericType("NiceFoo", niceFoo);
    }

    public static void PrintObjectType(string actualName, object instance)
    {
        Console.WriteLine("Object {0} says he's a '{1}'", actualName, instance.GetType());
    }

    public static void PrintGenericType<T>(string actualName, T instance)
    {
        Console.WriteLine("Generic Type {0} says he's a '{1}'", actualName, instance.GetType());
    }

печатает:

Object BadFoo говорит, что он TypeConcept.BadFoo

Объект NiceFoo говорит, что он TypeConcept.NiceFoo

Generic Type BadFoo говорит, что он TypeConcept.BadFoo

Общий тип NiceFoo говорит, что он «TypeConcept.NiceFoo»

Единственный раз, когда такой код приведет к плохому сценарию, - это ваш собственный код, где вы объявляете тип параметра как IFoo

    public static void Main(string[] args)
    {
        IFoo badFoo = new BadFoo();
        IFoo niceFoo = new NiceFoo();
        PrintIFoo("BadFoo", badFoo);
        PrintIFoo("NiceFoo", niceFoo);
    }

    public static void PrintIFoo(string actualName, IFoo instance)
    {
        Console.WriteLine("IFoo {0} says he's a '{1}'", actualName, instance.GetType());
    }

IFoo BadFoo говорит, что он System.Int32

IFoo NiceFoo говорит, что он «TypeConcept.NiceFoo»

Насколько я могу судить, худшее из того, что может случиться, - это вводить в заблуждение невинных программистов, которые случайно используют отравленный класс, например:

Type type = myInstance.GetType();
string fullName = type.FullName;
string output;
if (fullName.Contains(".Web"))
{
    output = "this is webby";
}
else if (fullName.Contains(".Customer"))
{
    output = "this is customer related class";
}
else
{
    output = "unknown class";
}

Если myInstanceэто экземпляр класса, который вы описываете в вопросе, он будет рассматриваться как неизвестный тип.

Так что мой ответ - нет, реальной угрозы здесь не вижу.

У вас есть несколько вариантов, если вы хотите перестраховаться от такого рода взлома:

В первую очередь передать на объект

Вы можете вызвать исходный GetType()метод, сначала приведя экземпляр к object:

 Console.WriteLine("BadFoo says he's a '{0}'", ((object)badFoo).GetType());

приводит к:

BadFoo says he's a 'ConsoleApplication.BadFoo'

Использовать шаблонный метод

Использование этого метода шаблона также даст вам настоящий тип:

static Type GetType<T>(T obj)
{
    return obj.GetType();
}

GetType(badFoo);

Есть разница между object.GetTypeи IFoo.GetType. GetTypeвызывается во время компиляции для неизвестных объектов, а не для интерфейсов. В вашем примере с выводом badFoo.GetTypeожидается bahaviour, потому что вы перегружаете метод. Единственное, что другие программисты могут запутаться в таком поведении.

Но если вы typeof()его используете, вы увидите, что тип тот же, и вы не можете перезаписать typeof().

Также программист может видеть во время компиляции, какой метод GetTypeон вызывает.

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