C # - Plusieurs types génériques dans une liste

Ce n'est probablement pas possible, mais j'ai cette classe:

public class Metadata<DataType> where DataType : struct
{
    private DataType mDataType;
}

Il y a plus à cela, mais gardons les choses simples. Le type générique (DataType) est limité aux types valeur par l'instruction where. Ce que je veux faire, c'est avoir une liste de ces objets de métadonnées de différents types (DataType). Tel que:

List<Metadata> metadataObjects;
metadataObjects.Add(new Metadata<int>());
metadataObjects.Add(new Metadata<bool>());
metadataObjects.Add(new Metadata<double>());

Est-ce seulement possible?

public abstract class Metadata
{
}

// extend abstract Metadata class
public class Metadata<DataType> : Metadata where DataType : struct
{
    private DataType mDataType;
}

Suite à la réponse de Leppie, pourquoi ne pas créer MetaDataune interface:

public interface IMetaData { }

public class Metadata<DataType> : IMetaData where DataType : struct
{
    private DataType mDataType;
}

J'ai également utilisé une version non générique, en utilisant le newmot - clé:

public interface IMetadata
{
    Type DataType { get; }

    object Data { get; }
}

public interface IMetadata<TData> : IMetadata
{
    new TData Data { get; }
}

L'implémentation d'interface explicite est utilisée pour permettre aux deux Datamembres:

public class Metadata<TData> : IMetadata<TData>
{
    public Metadata(TData data)
    {
       Data = data;
    }

    public Type DataType
    {
        get { return typeof(TData); }
    }

    object IMetadata.Data
    {
        get { return Data; }
    }

    public TData Data { get; private set; }
}

Vous pouvez dériver une version ciblant les types de valeur:

public interface IValueTypeMetadata : IMetadata
{

}

public interface IValueTypeMetadata<TData> : IMetadata<TData>, IValueTypeMetadata where TData : struct
{

}

public class ValueTypeMetadata<TData> : Metadata<TData>, IValueTypeMetadata<TData> where TData : struct
{
    public ValueTypeMetadata(TData data) : base(data)
    {}
}

Cela peut être étendu à tout type de contraintes génériques.