Apakah ada solusi untuk menggunakan metode statis oleh kelas generik?

Pilihan terbaik adalah dengan menerima fungsi FromBytes tertentu sebagai delegasi ke fungsi FromBytes generik Anda. Hal ini menghindari biaya kinerja dan kurangnya verifikasi waktu kompilasi yang menyertai penggunaan refleksi.

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

Perhatikan bahwa jika Anda membuat metodenya, bukan kelas yang ada di dalamnya, menjadi generik, Anda bisa membuat kompiler menyimpulkan argumen generiknya. Itu bisa disebut seperti ini:

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

Masalahnya adalah Anda mencoba menggunakan FromBytes sebagai metode ekstensi padahal sebenarnya tidak. Dari apa yang saya kumpulkan, Anda mencoba memanggil FromBytes yang sesuai untuk <T> apa pun, sebagaimana didefinisikan di kelas apa pun yang telah Anda buat untuk T.

Yang perlu Anda lakukan adalah memanggil metode melalui refleksi.

Coba lihat beberapa rangkaian pesan ini untuk mendapatkan bantuan tentang cara mencapai hal ini.

Gunakan Refleksi untuk memanggil metode generik pada objek instance dengan tanda tangan: SomeObject.SomeGenericInstanceMethod‹T›(T argumen)

Bagaimana cara menggunakan refleksi untuk memanggil metode generik?

Memanggil metode generik menggunakan refleksi di .NET

Bagaimana cara memanggil metode generik dengan objek Tipe tertentu?

Bisakah Anda mengimplementasikan metode FromBytes statis secara umum di kelas utilitas? Lalu lakukan hal seperti ini?

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

Metode utilitas itu mungkin agak jelek jika setiap metode FromBytes sangat berbeda, tetapi tidak akan terlalu buruk, itu semua adalah kode yang dulu ada di setiap kelas.

Sesuatu seperti ini:

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....
    }
}

Anda juga dapat menyembunyikan kode refleksi di sini seperti yang ditunjukkan oleh jawaban lain. Sayangnya tampaknya tidak ada cara yang bersih untuk melakukan hal ini, namun menyembunyikan hal-hal yang berantakan dalam metode utilitas mungkin merupakan pilihan terbaik.

Anda dapat menggunakan refleksi untuk menemukan metode pada tipe tersebut dan kemudian membangun delegasi untuknya. Sesuatu seperti:

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

Anda dapat mencoba sesuatu seperti ini:

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

Anda membuat pencarian untuk menemukan metode yang ingin Anda panggil untuk membangun instance.

Tidak yakin apakah ini berhasil untuk Anda, tetapi ini adalah sebuah pilihan:

1. Tentukan antarmuka IHaveFromBytesMethod<T> yang mendefinisikan metode instance FromBytes(...).
2. Jadikan semua tipe Foo# mengimplementasikan antarmuka ini. (Jika Anda tidak ingin metode instance ini segera terlihat, Anda dapat mengimplementasikan antarmuka secara eksplisit.)
3. Semua implementasi metode instan hanya meneruskan panggilan ke metode statis jenis tersebut.
4. Batasi tipe parameter T di kelas ListOfFoo<T> Anda untuk mengimplementasikan antarmuka ini dan untuk menyediakan konstruktor tanpa parameter.
5. Saat Anda memerlukan metode statis, buat objek dummy baru bertipe T menggunakan konstruktor tanpa parameter, lalu panggil metode instance pada instance dummy tersebut.

Antarmuka:

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

Salah satu kelas 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);
    }
}

Kelas ListOfFoo<T> yang dimodifikasi:

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

Saya ingin mengucapkan terima kasih kepada kalian semua, Anda memberi saya beberapa wawasan untuk dipikirkan. Saya telah mempertimbangkan setiap pendekatan dan memikirkan pro dan kontranya dan menulis kode berikut. Apa yang Anda pikirkan? Menurut saya ini adalah kompromi yang baik untuk kegunaan, keterbacaan, dan kinerja. Itu hanya tidak memiliki pemeriksaan kompiler.

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

Ini akan menjadi ringkasan untuk semua pemirsa di masa depan.

Karena Anda tidak bisa memanggil metode tersebut begitu saja, masalah utamanya adalah mendapatkan delegasi. Ada dua pendekatan:

• melalui refleksi
• dari penelepon

Anda mungkin berpikir refleksinya lambat, namun kinerja tidak menjadi masalah. Jika delegasi disimpan dalam bidang statis, hal ini hanya perlu dilakukan satu kali per kelas, karena tipe generik tidak berbagi anggota statis.

Verifikasi waktu kompilasi adalah sebuah masalah. Jika Anda sangat peduli dengan verifikasi waktu kompilasi, Anda harus meneruskan delegasi dari pemanggil. Jika Anda lebih peduli dengan pemanggilan metode yang bersih, Anda harus mengorbankan kemampuan verifikasi waktu kompilasi.

PS: Beberapa orang menyarankan untuk memiliki kamus atau switch/case atau if/else tempat delegasi disimpan. Ini adalah sesuatu yang tidak boleh Anda lakukan. Ini tidak memiliki keuntungan dibandingkan menyimpan delegasi dalam bidang statis kelas generik (tipe generik tidak berbagi anggota statis).