เหตุใดจึงต้องใช้วิธีการทั่วไปที่มีข้อ จำกัด ประเภทแทนที่จะเป็นชนิดของตัวเอง?

ในคำถาม StackExchange ที่แตกต่างกันฉันสังเกตเห็นคนที่ใช้ต้นแบบนี้:

void DoSomething<T>(T arg) where T: SomeSpecificReferenceType
{
    //Code....
}

โปรดจำไว้ว่ามีข้อ จำกัด ประเภทเดียว ( SomeSpecificReferenceType) ข้อแตกต่างและความได้เปรียบของการเขียนแบบนี้คืออะไรแทนที่จะเป็นเพียง:

void DoSomething(SomeSpecificReferenceType arg)
{
    //Code....
}

ในทั้งสองกรณีargจะต้องมีการตรวจสอบประเภทเวลาคอมไพล์ ในทั้งสองกรณีเนื้อความของวิธีการนั้นสามารถพึ่งพาความรู้ที่argเป็นของ (หรือเป็นผู้สืบทอด) ประเภทที่เฉพาะเจาะจงซึ่งรู้จักกันในเวลารวบรวม

นี่เป็นกรณีของผู้พัฒนา overzealous การเรียนรู้เกี่ยวกับ generics ก่อนที่จะเรียนรู้เกี่ยวกับมรดกธรรมดาหรือไม่? หรือมีเหตุผลที่ถูกต้องว่าทำไมลายเซ็นวิธีการที่จะเขียนด้วยวิธีนี้?

นี่เป็นกรณีของผู้พัฒนา overzealous การเรียนรู้เกี่ยวกับ generics ก่อนที่จะเรียนรู้เกี่ยวกับมรดกธรรมดาหรือไม่?

ใช่มันอาจจะเป็น

หรือมีเหตุผลที่ถูกต้องว่าทำไมลายเซ็นวิธีการที่จะเขียนด้วยวิธีนี้?

บางที โดยทั่วไปก็ต้องการทำให้รู้สึกมากขึ้นถ้ามีค่าตอบแทนที่มีส่วนเกี่ยวข้องหรือพารามิเตอร์อื่นที่ใช้TT

แต่เป็นไปได้ว่า internals ของรหัสใช้T(อาจเป็นอาร์กิวเมนต์ของ serializer?) และจำเป็นต้องใช้เฉพาะTและไม่ใช่คลาสข้อ จำกัด คุณจะเห็นว่าบางครั้งเมื่อข้อ จำกัด เป็นอินเทอร์เฟซที่จับคู่กับnewข้อ จำกัด และความกล้าของวิธีการสร้างTs ด้วยเหตุผลบางอย่าง

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

ฉันคิดว่าตัวเองจำคำตอบที่พิมพ์ได้

ในเวลานั้นเหตุผลก็เป็นเช่นนี้:
(รหัสอาจแตกต่างกันเพียงเพื่อแสดงให้เห็นถึงหนึ่งในสาเหตุที่เป็นไปได้ว่าทำไมมีข้อ จำกัด ในพารามิเตอร์ประเภทในวิธีการทั่วไป)

class SomeSingleton
{
    static Dictionary<Type, List<object>> staticTypeSpecificList;
    public void AddObjectToList<T>(T t) where T : SomeCommonThing
    {
        Type tt = t.GetType();
        List<object> list;
        if (!staticTypeSpecificList.TryGet(tt, out list))
        {
            list = new List<object>();
            staticTypeSpecificList.Add(tt, list);
        }
        list.Add(t);
    }
}

โดยทั่วไปแล้วโค้ดจะได้รับการจัดการประเภทการเข้ารหัสด้วยตนเองเอง มันอาจผสมกับสิ่งที่สะท้อน

ยกตัวอย่างเช่นโดยใช้Method<T>(T arg) where T : ...หนึ่งสามารถแทนที่ด้วยarg.GetType() typeof(T)แม้ว่าฉันไม่รู้ว่าตัวเลือกนั้นดีหรือไม่ดี

ฉันเดาว่านี่เป็นเพียงตัวอย่างของผู้เขียน (อาจเป็นฉันหรือคนอื่น) ไม่ได้คิดอย่างรอบคอบถึงความเป็นไปได้ทั้งหมดของการเข้ารหัสในขณะเดียวกันก็ให้ความสำคัญกับคำถาม / ปัญหาที่แตกต่างกัน