GetType () może kłamać?

Opierając się na pytaniu zadanym kilka dni temu w SO: GetType () i polimorfizmie oraz czytając odpowiedź Erica Lipperta , zacząłem się zastanawiać, czy tworzenie GetType()nie jest wirtualne naprawdę zapewni, że obiekt nie może kłamać na jego temat Type.

W szczególności odpowiedź Erica brzmi następująco:

Projektanci frameworka nie zamierzają dodawać niewiarygodnie niebezpiecznej funkcji, takiej jak pozwalanie obiektowi kłamać na temat jego typu, tylko po to, aby był zgodny z trzema innymi metodami tego samego typu.

Teraz pytanie brzmi: czy mogę stworzyć obiekt, który kłamie na temat swojego typu, nie będąc od razu oczywistym? Mogę się tutaj głęboko mylić i chciałbym wyjaśnić, jeśli tak jest, ale weź pod uwagę następujący kod:

public interface IFoo
{
    Type GetType();
}

I następujące dwie implementacje wspomnianego interfejsu:

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

public class NiceFoo : IFoo
{
}

Następnie, jeśli uruchomisz następujący prosty program:

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

Z pewnością badFoowyprowadza błąd Type.

Teraz nie wiem, czy ma to jakieś poważne konsekwencje, ponieważ Eric opisuje to zachowanie jako „ niezwykle niebezpieczną cechę ”, ale czy ten wzorzec może stanowić wiarygodne zagrożenie?

Fajne pytanie! Z mojego punktu widzenia można naprawdę zmylić innego programistę tylko wtedy, gdy GetType był wirtualny na obiekcie, a tak nie jest.

To, co zrobiłeś, jest podobne do shadowing GetType, na przykład:

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

z tą klasą (i używając przykładowego kodu z MSDN dla metody GetType () ) możesz rzeczywiście mieć:

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

więc, yikes, udało ci się skłamać, prawda? Cóż, tak i nie ... Weź pod uwagę, że użycie tego jako exploita oznaczałoby użycie Twojej instancji BadFoo jako argumentu w jakiejś metodzie, która oczekuje prawdopodobnie objectwspólnego typu podstawowego dla hierarchii obiektów. Coś takiego:

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

ale CheckIfInt(foo)wypisuje „nie int”.

Tak więc, w zasadzie (wracając do przykładu), mógłbyś wykorzystać swój „kłamliwy typ” tylko za pomocą kodu, który ktoś napisał na Twoim IFoo interfejsu, co jest bardzo wyraźne w tym, że ma on „niestandardową” GetType()metodę.

Tylko jeśli GetType () byłby wirtualny na obiekcie, byłbyś w stanie stworzyć „kłamliwy” typ, który mógłby być użyty z metodami takimi jak CheckIfIntpowyżej, aby siać spustoszenie w bibliotekach napisanych przez kogoś innego.

Istnieją dwa sposoby upewnienia się co do typu:

1. Użyj typeofna typie, którego nie można przeciążać

   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. Rzutuj instancję na objecti wywołaj GetType()metodę

   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();
   

Nie, nie możesz skłamać GetType. Wprowadzasz tylko nową metodę. Wywoła ją tylko kod, który zna tę metodę.

Nie możesz na przykład sprawić, aby kod strony trzeciej lub struktury wywoływał Twoją nową metodę GetType zamiast prawdziwej, ponieważ ten kod nie wie, że Twoja metoda istnieje i dlatego nigdy jej nie wywoła.

Możesz jednak pomylić własnych programistów z taką deklaracją. Każdy kod, który jest skompilowany z twoją deklaracją i który używa parametrów lub zmiennych wpisanych jako IFoo lub dowolnego typu pochodnego, faktycznie będzie używał twojej nowej metody. Ale ponieważ wpływa to tylko na twój własny kod, tak naprawdę nie stanowi „zagrożenia”.

Jeśli chcesz podać niestandardowy opis typu dla klasy, należy to zrobić za pomocą niestandardowego deskryptora typu , na przykład przez dodanie adnotacji do klasy za pomocą TypeDescriptionProviderAttribute . Może to być przydatne w niektórych sytuacjach.

Cóż, faktycznie nie jest już typ, który może leżeć w GetType: wszelkiego rodzaju pustych.

Ten kod :

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

wyjścia True.

Właściwie to nie ten, int?kto kłamie, po prostu ukryty rzut objectzamienia int?się w pudełko int. Ale mimo to ty nie może powiedzieć int?z into GetType().

Nie sądzę, aby tak było, ponieważ każdy kod biblioteki, który wywołuje GetType, będzie deklarował zmienną jako „Obiekt” lub jako typ ogólny „T”

Poniższy kod:

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

wydruki:

Obiekt BadFoo mówi, że jest „TypeConcept.BadFoo”

Obiekt NiceFoo mówi, że jest „TypeConcept.NiceFoo”

Typ ogólny BadFoo mówi, że jest „TypeConcept.BadFoo”

Typ ogólny NiceFoo mówi, że jest „TypeConcept.NiceFoo”

Jedynym przypadkiem, gdy ten rodzaj kodu spowoduje zły scenariusz, jest twój własny kod, w którym deklarujesz typ parametru jako 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 mówi, że jest „System.Int32”

IFoo NiceFoo mówi, że jest „TypeConcept.NiceFoo”

Najgorsze, co może się zdarzyć, o ile wiem, to wprowadzanie w błąd niewinnych programistów, którzy używają zatrutej klasy, na przykład:

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

Jeśli myInstancejest to instancja klasy takiej jak opisana w pytaniu, będzie ona traktowana jako typ nieznany.

Więc moja odpowiedź brzmi: nie, nie widzę tutaj żadnego prawdziwego zagrożenia.

Masz kilka opcji, jeśli chcesz grać bezpiecznie przeciwko tego rodzaju włamaniom:

Najpierw rzut na obiekt

Możesz wywołać oryginalną GetType()metodę, najpierw rzutując instancję na object:

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

prowadzi do:

BadFoo says he's a 'ConsoleApplication.BadFoo'

Użyj metody szablonowej

Użycie tej metody szablonu daje również prawdziwy typ:

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

GetType(badFoo);

Istnieje różnica między object.GetTypei IFoo.GetType. GetTypejest wywoływana w czasie kompilacji na nieznanych obiektach, a nie na interfejsach. W twoim przykładzie z wyjściem badFoo.GetTypeoczekuje się zachowania, ponieważ przeciążasz metodę. Chodzi tylko o to, że inni programiści mogą się pomylić z tym zachowaniem.

Ale jeśli typeof()go użyjesz , wyświetli się, że typ jest taki sam i nie możesz go nadpisać typeof().

Również programista może zobaczyć w czasie kompilacji, którą metodę GetTypewywołuje.

A więc do twojego pytania: ten wzorzec nie może stanowić wiarygodnego zagrożenia, ale nie jest też najlepszym stylem kodowania.