GetType () โกหกได้ไหม?

จากคำถามต่อไปนี้ที่ถามเมื่อไม่กี่วันที่ผ่านมาใน SO: GetType () และความหลากหลายและอ่านคำตอบของ Eric Lippertฉันเริ่มคิดว่าถ้าทำให้GetType()ไม่เสมือนจริงทำให้มั่นใจได้ว่าวัตถุไม่สามารถโกหกTypeได้

โดยเฉพาะคำตอบของ Eric ระบุสิ่งต่อไปนี้:

นักออกแบบเฟรมเวิร์กจะไม่เพิ่มคุณสมบัติที่อันตรายอย่างเหลือเชื่อเช่นการปล่อยให้วัตถุโกหกเกี่ยวกับประเภทของมันเพียงเพื่อให้มันสอดคล้องกับวิธีการอื่น ๆ อีกสามวิธีในประเภทเดียวกัน

ตอนนี้คำถามคือ: ฉันสามารถทำให้วัตถุที่ไม่โกหกเกี่ยวกับประเภทของมันโดยไม่ได้รับที่ชัดเจนได้ทันทีหรือไม่ ฉันอาจจะคิดผิดอย่างสุดซึ้งที่นี่และฉันชอบที่จะชี้แจงหากเป็นเช่นนั้น แต่ให้พิจารณารหัสต่อไปนี้:

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

พอแน่ใจว่าผลผิดพลาดbadFooType

ตอนนี้ฉันไม่รู้ว่าสิ่งนี้มีผลกระทบร้ายแรงใด ๆ จากการที่เอริคอธิบายพฤติกรรมนี้ว่าเป็น " ลักษณะที่อันตรายอย่างไม่น่าเชื่อ " แต่รูปแบบนี้อาจเป็นภัยคุกคามที่น่าเชื่อถือได้หรือไม่

เป็นคำถามที่ดี! อย่างที่ฉันเห็นคุณสามารถทำให้นักพัฒนาคนอื่นเข้าใจผิดได้ก็ต่อเมื่อ 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กับ Type ที่ไม่สามารถโอเวอร์โหลดได้

   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 หรือประเภทใด ๆ ที่ได้มาจากนั้นจะใช้วิธีการใหม่ของคุณแทน แต่เนื่องจากสิ่งนี้มีผลต่อโค้ดของคุณเท่านั้นจึงไม่ได้กำหนดให้เป็น "ภัยคุกคาม"

หากคุณไม่ต้องการที่จะให้คำอธิบายประเภทที่กำหนดเองสำหรับการเรียนนี้ควรจะทำโดยใช้ประเภทที่กำหนดเองอธิบายอาจจะโดย annotating ชั้นเรียนของคุณกับTypeDescriptionProviderAttribute สิ่งนี้จะมีประโยชน์ในบางสถานการณ์

ที่จริงมีอยู่แล้วประเภทหนึ่งที่สามารถอยู่ได้GetType: ประเภทที่ว่างเปล่า

รหัสนี้ :

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

Trueเอาท์พุท

จริงๆแล้วไม่ใช่int?ใครโกหก แต่โดยปริยายโยนให้objectกลายint?เป็นบ็intอกซ์ แต่อย่างไรก็ตามคุณไม่สามารถบอกได้int?จากการที่มีintGetType()

ฉันไม่คิดว่าจะเป็นเช่นนั้นเนื่องจากรหัสไลบรารีทุกตัวที่เรียก GetType จะประกาศตัวแปรเป็น 'Object' หรือเป็น Generic type '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'

Object NiceFoo บอกว่าเขาเป็น 'TypeConcept.NiceFoo'

ประเภททั่วไป 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.GetTypeGetTypebadFoo.GetType

แต่ถ้าคุณใช้typeof()มันจะแสดงผลว่าเป็นประเภทเดียวกันและคุณไม่สามารถเขียนทับtypeof()ได้

นอกจากนี้โปรแกรมเมอร์ยังสามารถดูได้ในเวลารวบรวมว่าGetTypeเขาเรียกใช้วิธีใด

สำหรับคำถามของคุณ: รูปแบบนี้ไม่สามารถก่อให้เกิดภัยคุกคามที่น่าเชื่อถือได้ แต่ก็ไม่ใช่รูปแบบการเข้ารหัสที่ดีที่สุด