Есть ли обходной путь для использования статических методов в универсальном классе?

Лучшим вариантом было бы просто принять конкретную функцию 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

Как вызвать универсальный метод с заданным объектом типа? < / а>

Не могли бы вы просто реализовать статический метод 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;
    }
}

Это будет итог для всех будущих зрителей.

Поскольку просто вызвать метод нельзя, основная проблема - получить делегата. Есть два подхода:

• через отражение
• от звонящего

Вы можете подумать, что отражение идет медленно, но с производительностью это не проблема. Если делегат хранится в статическом поле, это нужно делать только один раз для каждого класса, поскольку универсальные типы не имеют общих статических членов.

Проверяемость во время компиляции является проблемой. Если вы очень заботитесь о проверяемости во время компиляции, вам следует передать делегат от вызывающего. Если вас больше волнует вызов чистого метода, вам придется пожертвовать проверяемостью во время компиляции.

PS: Некоторые люди предложили иметь словарь или переключатель / case или if / else, где хранятся делегаты. Этого делать не следует. Это не имеет преимуществ перед хранением делегата в статическом поле универсального класса (универсальные типы не имеют общих статических членов).