มีวิธีแก้ไขชั่วคราวในการใช้วิธีคงที่โดยคลาสทั่วไปหรือไม่?

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

public delegate T FromBytesFunc<T>(byte[] bytes, ref int index);
public static List<T> FromBytes<T>(byte[] bytes, ref int index,
    FromBytesFunc<T> function)
{
    var count = bytes[index++];
    var listOfFoo = new List<T>();
    for (var i = 0; i < count; i++)
    {
        listOfFoo.Add(function(bytes, ref index));
    }

    return listOfFoo;
}

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

var list = SomeClass.FromBytes(bytes, ref index, Foo1.FromBytes);

ปัญหาคือคุณกำลังพยายามใช้ FromBytes เป็นวิธีการขยายเมื่อไม่ใช่ จากสิ่งที่ฉันรวบรวม คุณกำลังพยายามเรียก FromBytes ที่เหมาะสมสำหรับสิ่งใดก็ตามที่ <T> เป็น ตามที่กำหนดไว้ในคลาสใดก็ตามที่คุณได้สร้างไว้สำหรับ T

สิ่งที่คุณต้องทำคือเรียกวิธีการผ่านการไตร่ตรอง

ลองดูหัวข้อเหล่านี้บางส่วนเพื่อขอความช่วยเหลือในการบรรลุเป้าหมายนี้

ใช้ Reflection เพื่อเรียกวิธีการทั่วไปบนวัตถุ อินสแตนซ์ที่มีลายเซ็น: SomeObject.SomeGenericInstanceMethod‹T›(T อาร์กิวเมนต์)

ฉันจะใช้การสะท้อนกลับเพื่อเรียกวิธีการทั่วไปได้อย่างไร

การเรียกวิธีการทั่วไปโดยใช้การสะท้อนกลับใน .NET

จะเรียกวิธีการทั่วไปด้วยวัตถุ Type ที่กำหนดได้อย่างไร< /ก>

คุณสามารถใช้ static FromBytes วิธีการทั่วไปในคลาสยูทิลิตี้ได้หรือไม่? แล้วทำอะไรแบบนี้ล่ะ?

listOf.Add(Utility.FromBytes<T>(bytes, ref index));

วิธีอรรถประโยชน์นั้นอาจจะดูน่าเกลียดนิดหน่อยถ้าแต่ละวิธี FromBytes แตกต่างกันมาก แต่ก็ไม่ได้แย่เกินไป มันเป็นโค้ดทั้งหมดที่เคยใช้งานในแต่ละคลาสอยู่แล้ว

บางสิ่งเช่นนี้:

public static class Utility
{
    public static T FromBytes<T>(byte[] bytes, ref int index)
    {
          if (typeof(T) is Foo1)
          {
               return Foo1.GetBytes(bytes, ref index);
          }
          //etc....
    }
}

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

คุณสามารถใช้การสะท้อนกลับเพื่อค้นหาวิธีการในประเภทนั้น จากนั้นจึงสร้างผู้รับมอบสิทธิ์ให้ สิ่งที่ต้องการ:

delegate T FromBytesFunc<T>(byte[] bytes, ref int index);

public static ListOfFoo<T> FromBytes(byte[] bytes, ref int index)
{
    FromBytesFunc<T> fromBytes =
        (FromBytesFunc<T>)Delegate.CreateDelegate(
            typeof(FromBytesFunc<T>), typeof(T).GetMethod("FromBytes")

    var count = bytes[index++];
    var listOf = new ListOfFoo<T>();
    for (var i = 0; i < count; i++)
    {
        listOf.Add(fromBytes(bytes, ref index));
    }

    return listOf;
}

คุณสามารถลองสิ่งนี้:

sealed class RetType
{
    public object Value
    {
        get;
        private set;
    }

    public int Index
    {
        get;
        private set;
    }

    public RetType(object value, int index)
    {
        Value = value;
        Index = index;
    }
}

public class ListOfFoo<T> : System.Collections.Generic.List<T>
{
    static readonly Dictionary<Type, Func<byte[], int, RetType>> dic = new Dictionary<Type, Func<byte[], int, RetType>>
    {
        {
            typeof(Foo1),
            new Func<byte[], int, RetType>((bytes, index) =>
            {
                var value = Foo1.FromBytes(bytes, ref index);

                return new RetType(value, index);
            })
        }
        // add here others Foo
    };

    public static ListOfFoo<T> FromBytes(byte[] bytes, ref int index)
    {
        var count = bytes[index++];
        var listOf = new ListOfFoo<T>();
        for (var i = 0; i < count; i++)
        {
            var o = dic[typeof(T)](bytes, index);

            listOf.Add((T)o.Value);

            index = o.Index;
        }

        return listOf;
    }
}

คุณสร้างการค้นหาเพื่อค้นหาวิธีการที่คุณต้องการเรียกใช้เพื่อสร้างอินสแตนซ์

ไม่แน่ใจว่าสิ่งนี้เหมาะกับคุณหรือไม่ แต่เป็นตัวเลือก:

1. กำหนดอินเทอร์เฟซ IHaveFromBytesMethod<T> ซึ่งกำหนดวิธีการอินสแตนซ์ FromBytes(...)
2. ทำให้ Foo# ประเภททั้งหมดใช้อินเทอร์เฟซนี้ (หากคุณไม่ต้องการให้วิธีการอินสแตนซ์นี้มองเห็นได้ในทันที คุณสามารถปรับใช้อินเทอร์เฟซได้อย่างชัดเจน)
3. การใช้งานวิธีการอินสแตนซ์ทั้งหมดเพียงส่งต่อการเรียกไปยังวิธีการคงที่ของประเภทนั้น
4. จำกัดพารามิเตอร์ประเภท T ในคลาส ListOfFoo<T> ของคุณเพื่อใช้อินเทอร์เฟซนี้ และเพื่อจัดเตรียมตัวสร้างแบบไม่มีพารามิเตอร์
5. เมื่อคุณต้องการวิธีการคงที่ ให้สร้างอ็อบเจ็กต์จำลองใหม่ประเภท T โดยใช้ตัวสร้างแบบไม่มีพารามิเตอร์ จากนั้นเรียกใช้เมธอดอินสแตนซ์บนอินสแตนซ์จำลองนั้น

อินเตอร์เฟซ:

public interface IHaveFromBytesMethod<T>
{
    T FromBytes(byte[] bytes, ref int index);
}

หนึ่งในคลาส Foo#:

public class Foo1 : IHaveFromBytesMethod<Foo1>
{
    public Foo1()
    {
        // ...
    }

    public static Foo1 FromBytes(byte[] bytes, ref int index)
    {
        // ...
    }

    public Foo1 FromBytes(byte[] bytes, ref int index)
    {
        // within the instance method simply call the static method
        return Foo1.FromBytes(bytes, ref index);
    }
}

คลาส ListOfFoo<T> ที่แก้ไขแล้ว:

// requires T to implement the interface and provide a parameterless ctor!
public class ListOfFoo<T> : System.Collections.Generic.List<T>
    where T : IHaveFromBytesMethod<T>, new()
{
    public static ListOfFoo<T> FromBytes(byte[] bytes, ref int index)
    {
        // create dummy instance for accessing static method via instance method
        T dummy = new T();
        var count = bytes[index++];
        var listOfFoo = new ListOfFoo<T>();
        for (var i = 0; i < count; i++)
        {
            // instead of calling the static method,
            // call the instance method on the dummy instance
            listOfFoo.Add(dummy.FromBytes(bytes, ref index));
        }

        return listOfFoo;
    }
}

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

public class ListOfFoo<T> : System.Collections.Generic.List<T>
{
    private static readonly FromBytesFunc<T> BytesFromFunc = 
        (FromBytesFunc<T>)System.Delegate.CreateDelegate(
            typeof(FromBytesFunc<T>),
            typeof(T).GetMethod("FromBytes"));

    private delegate T2 FromBytesFunc<out T2>(byte[] bytes, ref int index);

    public static ListOfFoo<T> FromBytes(byte[] bytes, ref int index)
    {
        var count = bytes[index++];
        var listOfFoo = new ListOfFoo<T>();
        for (var i = 0; i < count; i++)
        {
            listOfFoo.Add(BytesFromFunc(bytes, ref index));
        }

        return listOfFoo;
    }
}

นี่จะเป็นบทสรุปสำหรับผู้ชมในอนาคตทั้งหมด

เนื่องจากคุณไม่สามารถเรียกใช้เมธอดได้ ปัญหาหลักคือการรับผู้รับมอบสิทธิ์ มีสองแนวทาง:

• ผ่านการสะท้อน
• จากผู้โทร

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

การตรวจสอบเวลาคอมไพล์เป็นปัญหา หากคุณใส่ใจมากเกี่ยวกับการตรวจสอบเวลาคอมไพล์ คุณควรส่งผู้รับมอบสิทธิ์จากผู้โทร หากคุณสนใจมากขึ้นเกี่ยวกับการโทรแบบ clean คุณจะต้องเสียสละการตรวจสอบเวลาคอมไพล์

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