Liste générique d'objets génériques

Disons que j'ai un objet qui représente un champ de données, que l'objet doit les propriétés suivantes: Nom, Type, Valeur de la Longueur. Voici l'objet:

class Field<T>
{
    public string Name { get; set; }
    public Type Type
    {
        get
        {
            return typeof(T);
        }
    }
    public int Length { get; set; }
    public T Value { get; set; }
}

J'ai utilisé les génériques, parce que je veux forcer l'utilisateur du code seulement être en mesure d'attribuer une Valeur d'un certain Type.
Maintenant, le problème est lorsque je veux créer une liste de champs.
Si je crée la liste comme List<Field<object>> ensuite, nous peut attribuer une Valeur à un Champ donné sur la liste, et lorsque nous requête de Type, on obtient l '"objet".
Le truc, c'est sur cette liste que je veuille quelques champs de la tenue de chaînes, quelques holding ints, des dates, et même des objets personnalisés qui à son tour aura une liste de Champs...
Est les Génériques une bonne solution pour quelque chose comme ça? Si oui, comment pourrais-je aller sur la mise en œuvre? Si non, quelle est la meilleure façon?

---EDIT---
Juste pour ajouter un peu plus de fond:
1. J'aimerais une liste de champs, et chaque champ tiendra autre type de données, comme suit :

List<Field<object>> lst = new List<Field<object>>();
lst.Add(new Field<string>());
lst.Add(new Field<int>());
lst.Add(new Field<SomeObjectFromMyApp>());

2. Plus tard, j'aurai une requête à ces objets et leurs attributs automatiquement dans une boucle, quelque chose comme ça:

foreach(Field<object> fld in lst)
{
    Type t = fld.Type;
    //do some other stuff
}

source d'informationauteur Daniel Gruszczyk

  1. 13

    Oui, les génériques est un bon choix. La clé pour assurer la sécurité du type (et en étant d'identifier le type avec la Type propriété est d'ajouter une couche d'abstraction entre la liste et la Field<T> classe.

    Ont Field<T> implémenter l'interface IField. Cette interface n'a pas besoin de tous les membres.

    Ensuite déclarer votre liste comme étant List<IField>.

    De cette façon vous contraindre la liste pour ne contenir que des champs, mais chaque champ peut être d'un type différent.

    De lire ensuite les valeurs plus tard, il suffit de faire

    foreach(var field in list)
{
    var type = field.Type;
    ....
}
  2. 11

    Je vous suggère de définir une interface, et le Champ implémente cette interface

    public interface IField
    {

    }

public class Field<T> : IField
    {
        public string Name { get; set; }
        public Type Type
        {
            get
            {
                return typeof(T);
            }
        }
        public int Length { get; set; }
        public T Value { get; set; }
    }

    de sorte que vous pouvez écrire ce code:

    var list = new List<IField>();

    maintenant cette liste peut contenir n'importe quel objet de type Field<T>