Generische Liste von generischen Objekten

Question

Angenommen, ich habe ein Objekt, das ein Datenfeld darstellt. Dieses Objekt benötigt die folgenden Eigenschaften: Name, Typ, Wert, Länge. Hier ist das Objekt:

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

ich Generika verwendet haben, weil ich den Benutzer des Codes zwingen wollen nur in der Lage sein einen Wert von bestimmten Art zuzuordnen.
Jetzt ist das Problem, wenn ich eine Liste von Feldern erstellen möchte.
Wenn ich die Liste wie List<Field<object>> erstellen, dann können wir einen beliebigen Wert zu einem bestimmten Feld in der Liste zuweisen, und wenn wir nach Type fragen, erhalten wir 'Objekt'.
Die Sache ist - auf dieser Liste möchte ich einige Felder mit Strings, einige mit Ints, Datumsangaben und sogar benutzerdefinierte Objekte, die wiederum eine Liste von Feldern haben ...
Ist die Generika eine gute Lösung für so etwas wie Das? Wenn ja, wie würde ich es umsetzen? Wenn nicht, was ist ein besserer Weg?

--- EDIT ---
einfach ein wenig mehr Hintergrund hinzuzufügen:
1. Ich könnte eine Liste von Feldern wollen, und jedes Feld werden verschiedene Datentypen halten, etwa so:

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

2. Später werde ich diese Objekte abfragen müssen, und deren Attribute automatisch in einer Schleife, so etwas wie das:

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

Answer 1

Ja, Generika ist eine gute Wahl. Der Schlüssel Typsicherheit zu erreichen (und die Art der Type Eigenschaft identifizieren zu sein, ist eine Abstraktion zwischen der Liste und Field<T> Klasse hinzuzufügen.

haben Field<T> implementieren die Schnittstelle IField. Diese Schnittstelle keine Mitglieder benötigen.

erklären Sie dann Ihre Liste als List<IField> zu sein.

diese Weise können Sie die Liste beschränken sich nur auf Felder enthalten, aber jedes Feld kann von einem anderen Typ sein.

später die Werte tun, nur zu lesen, um dann

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

Answer 2

Ich schlage vor, Sie eine Schnittstelle zu definieren und Feld implementiert diese Schnittstelle

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

so können Sie diesen Code schreiben:

var list = new List<IField>(); 

jetzt diese Liste ein beliebiges Objekt vom Typ enthalten Field<T>