C# универсальный тип в базовом классе

Question

Я пишу систему, которая имеет набор буферов протокола (с использованием Protobuf сети), я хочу, чтобы определить что-то вроде этого в абстрактном классе они все унаследует от:

public byte[] GetBytes() 

однако, для буфера serealiser протокола требуется аргумент типа, есть ли эффективный способ получить тип наследующего класса?

Пример:

public byte[] GetBytes() 
    { 
     using (MemoryStream stream = new MemoryStream()) 
     { 
      Serializer.Serialize<T /* what goes here? */>(stream, this); 
      return stream.ToArray(); 
     } 
    } 

Answer 1

Просто написать "T" правильный?

, а затем в вашем объявлении класса:

public class M<T> 

?

- Edit

И тогда, когда вы унаследовали его:

public class Foo : M<Apple> 

Answer 2

Определите базовый класс как BaseClass<T>, а затем ваши производные классы заменить Т с типом сериализатора DerivedClass<SerializerType>.

Вы также можете указать ограничения на аргумент типа, например.

BaseClass<T> where T : SerializerBase 

Here является описание типов ограничений, которые можно применить.

Answer 3

Вы можете сделать это с помощью отражения, но protobuf-net сделал это для вас.

Просто измените вызов:

Serializer.NonGeneric.Serialize(stream, this /* Takes an object here */); 

Это работает путем создания универсального метода во время выполнения с помощью отражения. Подробнее см. Код (second method here).

Answer 4

Вам не нужно ничего особенного здесь ... поскольку protobuf-net уважает наследование. Если у вас есть:

[ProtoInclude(typeof(Foo), 20)] 
[ProtoInclude(typeof(Bar), 21)] 
public abstract class MyBase { 
    /* other members */ 

    public byte[] GetBytes() 
    { 
     using(MemoryStream ms = new MemoryStream()) 
     { 
      Serializer.Serialize<MyBase>(ms, this); // MyBase can be implicit 
      return ms.ToArray(); 
     } 
    } 
} 
[ProtoContract] 
class Foo : MyBase { /* snip */ } 
[ProtoContract] 
class Bar : MyBase { /* snip */ } 

тогда это сработает. Для сериализации данных он всегда начинается с основания (контракта) типа; так что даже если вы сделали Serializer.Serialize<Foo>(stream, obj), первое, что он сделает, это обнаружить, что у него есть базовый класс, который является контрактом, и переключиться на MyBase. Во время десериализации он идентифицирует правильный производный (конкретный) тип и использует его, поэтому вы можете использовать Deserialize с MyBase, и он будет строить Foo или Bar в зависимости от исходных данных.

Таким образом, следующие в основном идентичны:

Serializer.Serialize<BaseType>(dest, obj); 
... 
BaseType obj = Serializer.Deserialize<BaseType>(source); 

и

Serializer.Serialize<DerivedType>(dest, obj); 
... 
DerivedType obj = Serializer.Deserialize<DerivedType>(source); 

Основное различие в том, как переменные набираются.