GetType () yalan söyleyebilir mi?

Birkaç gün önce SO: GetType () ve polimorfizm'de birkaç gün önce sorulan şu soruya dayanarak ve Eric Lippert'in cevabını okuyarak , yapmanın GetType()sanal olmaması gerçekten bir nesnenin onun hakkında yalan söyleyemeyeceğini düşünmeye başladım Type.

Eric'in cevabı özellikle şu şekildedir:

Çerçeve tasarımcıları, bir nesnenin türü hakkında yalan söylemesine izin vererek, onu aynı türdeki diğer üç yöntemle tutarlı hale getirmek için inanılmaz derecede tehlikeli bir özellik eklemeyecekler.

Şimdi soru şudur: Bir nesneyi yapabilirsiniz yapar hemen belli olmadan kendi türü hakkında yalan? Burada son derece yanılıyor olabilirim ve durum buysa açıklamayı çok isterim, ancak aşağıdaki kodu göz önünde bulundurun:

public interface IFoo
{
    Type GetType();
}

Ve söz konusu arayüzün aşağıdaki iki uygulaması:

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

public class NiceFoo : IFoo
{
}

Ardından aşağıdaki basit programı çalıştırırsanız:

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

Yeterince emin badFoobir hatalı çıktı verir Type.

Şimdi, Eric'in bu davranışı " inanılmaz derecede tehlikeli bir özellik " olarak tanımlamasına dayanarak bunun ciddi sonuçları olup olmadığını bilmiyorum , ancak bu model inandırıcı bir tehdit oluşturabilir mi?

Güzel soru! Gördüğüm kadarıyla, bir geliştiriciyi ancak GetType nesne üzerinde sanal olsaydı gerçekten yanlış yönlendirebilirdin, ki öyle değil.

Yaptığınız şey, GetType'ı şu şekilde gölgelendirmeye benzer:

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

bu sınıfla (ve GetType () yöntemi için MSDN'deki örnek kodu kullanarak ) gerçekten sahip olabilirsiniz:

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

öyleyse, yikes, başarıyla yalan söyledin, değil mi? Evet ve hayır ... Bunu bir istismar olarak kullanmanın, BadFoo örneğinizi, bir objectnesneler hiyerarşisi için muhtemelen bir veya ortak bir temel tür bekleyen bir yöntem için argüman olarak kullanmak anlamına geleceğini düşünün . Bunun gibi bir şey:

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

ancak CheckIfInt(foo)"int değil" yazdırır.

Yani, temelde (örneğinize dönecek olursak), gerçekten yalnızca birinin sizin IFooarayüzünüze yazdığı kodla "yalancı tipinizden" yararlanabilirsiniz , ki bu onun "özel" bir GetType()metoda sahip olduğu gerçeği hakkında çok açık bir durumdur .

Yalnızca GetType () nesne üzerinde sanal ise CheckIfInt, başkası tarafından yazılmış kitaplıklarda tahribat yaratmak için yukarıdaki gibi yöntemlerle kullanılabilecek bir "yalancı" tip oluşturabilirdiniz.

Tür konusunda emin olmanın iki yolu vardır:

1. typeofAşırı yüklenemeyen Tip üzerinde kullanın

   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. Örneği bir'e dönüştürün objectve GetType()Yöntemi çağırın

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

Hayır, GetType'ı yalan söyleyemezsiniz. Yalnızca yeni bir yöntem tanıtıyorsunuz. Yalnızca bu yöntemin farkında olan kod onu çağıracaktır.

Örneğin, üçüncü taraf veya çerçeve kodunun gerçek olan yerine yeni GetType yönteminizi çağırmasını sağlayamazsınız, çünkü bu kod, yönteminizin var olduğunu bilmez ve bu nedenle onu asla çağırmaz.

Bununla birlikte, kendi geliştiricilerinizi böyle bir beyanla karıştırabilirsiniz. Bildiriminizle derlenen ve IFoo olarak yazılan parametreleri veya değişkenleri veya bundan türetilen herhangi bir türü kullanan herhangi bir kod, bunun yerine yeni yönteminizi kullanacaktır. Ancak bu yalnızca kendi kodunuzu etkilediği için gerçekten bir "tehdit" oluşturmaz.

Bir sınıf için özel bir tür açıklaması sağlamak istiyorsanız, bu , belki de sınıfınıza TypeDescriptionProviderAttribute ile açıklama ekleyerek , bir Özel Tür Tanımlayıcısı kullanılarak yapılmalıdır . Bu, bazı durumlarda faydalı olabilir.

Eh, aslında orada olduğunu zaten yalan bir tür GetTypeherhangi null türü:.

Bu kod :

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

çıktılar True.

Aslında öyle değil int?yalan söylüyor, sadece örtülü cast objectdönüşler int?bir kutulu içine int. Ama yine de sen olamaz söylemek int?dan intile GetType().

GetType'ı çağıran her kütüphane kodu değişkeni 'Nesne' veya Genel tip 'T' olarak ilan edeceği için bunun olacağını sanmıyorum

Aşağıdaki 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());
    }

baskılar:

BadFoo nesnesi onun bir 'TypeConcept.BadFoo' olduğunu söylüyor

NiceFoo nesnesi onun bir 'TypeConcept.NiceFoo' olduğunu söylüyor

Genel Tip BadFoo, 'TypeConcept.BadFoo' olduğunu söylüyor

Jenerik Tip NiceFoo, 'TypeConcept.NiceFoo' olduğunu söylüyor

Bu tür bir kodun kötü senaryolarla sonuçlanacağı tek zaman, parametre türünü IFoo olarak bildirdiğiniz kendi kodunuzdadır.

    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' olduğunu söylüyor

IFoo NiceFoo, 'TypeConcept.NiceFoo' olduğunu söylüyor

Söyleyebileceğim kadarıyla olabilecek en kötü şey, zehirli sınıfı kullanan yanıltıcı masum programcılardır, örneğin:

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

Eğer myInstancesöz konusu açıklamak gibi bir sınıfın örneğidir, sadece bilinmeyen türü olarak kabul edilir.

Yani cevabım hayır, burada gerçek bir tehdit göremiyorum.

Bu tür bir saldırıya karşı güvenli oynamak istiyorsanız bazı seçenekleriniz var:

Önce nesneye yayınlayın

Orijinal GetType()yöntemi ilk önce örneği bir şuna çevirerek çağırabilirsiniz object:

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

sonuçlanır:

BadFoo says he's a 'ConsoleApplication.BadFoo'

Şablon yöntemini kullanın

Bu şablon yöntemini kullanmak size gerçek türü de verecektir:

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

GetType(badFoo);

Arasında bir fark vardır object.GetTypeve IFoo.GetType. GetTypebilinmeyen nesnelerde derleme zamanında çağrılır, Arabirimler üzerinde değil. Örneğinizde çıktı ilebadFoo.GetType size yöntemini aşırı çünkü, bahaviour bekleniyor. Tek sorun, diğer programcıların bu davranıştan kafalarının karışmasıdır.

Ancak kullanırsanız typeof(), türün aynı olduğu sonucunu verir ve üzerine yazamazsınız typeof().

Ayrıca programcı derleme zamanında hangi yöntemi GetTypeçağırdığını görebilir.

Öyleyse sorunuza göre: Bu kalıp inandırıcı bir tehdit oluşturmaz, ancak aynı zamanda en iyi kodlama tarzı değildir.