Anwendungsbeispiele für Generics in .Net (C # / VB.NET)

Einfach, deklarieren Sie einen Typ oder eine Methode mit zusätzlichen tags zur Angabe der generischen bits:

class Foo<T> {
    public Foo(T value) {
        Value = value;
    }
    public T Value {get;private set;}
}

Den oben definiert einen generischen Typ Foo "von T", wo die T wird durch die Anrufer. Per Konvention generischen Typ-Argumente beginnen mit T., Wenn es nur einer ist, ist T ist in Ordnung - sonst nennen Sie alle sinnvoll: TSource, TValue, TListType etc

Im Gegensatz zu C++ - templates .NET Generika werden von der Laufzeit (nicht compiler-tricks). Zum Beispiel:

Foo<int> foo = new Foo<int>(27);

Alle Ts ersetzt wurden, mit int im oben. Wenn nötig, können Sie einschränken, generische Argumente mit Einschränkungen:

class Foo<T> where T : struct {}

Nun Foo<string> wird sich weigern, zu kompilieren - wie string ist nicht eine Struktur, die (Wert-Typ). Gültige Einschränkungen sind:

T : class //reference-type (class/interface/delegate)
T : struct //value-type except Nullable<T>
T : new() //has a public parameterless constructor
T : SomeClass //is SomeClass or inherited from SomeClass
T : ISomeInterface //implements ISomeInterface

Einschränkungen können auch die anderen generischen Typ-Argumente, zum Beispiel:

T : IComparable<T> //or another type argument

Können Sie so viele Allgemeine Argumente, wie Sie benötigen:

public struct KeyValuePair<TKey,TValue> {...}

Andere Dinge zu beachten:

• statische member etc definiert sind pro generische Typ-Kombination - also ein statisches Feld auf Foo<int> getrennt, auf Foo<float>.
• Methoden können generisch sein, zu versuchen zu vermeiden, mit den gleichen Namen wie die Klasse verwendet, da Sie nicht in der Lage sein, um keine Verwechslungen
• geschachtelte Typen Erben die generischen Typen, die von Ihren Eltern

Beispiel:

class Foo<T> {
    class Bar<TInner> {} //is effectively Bar<T,TInner>, for the outer T
}

InformationsquelleAutor der Antwort Marc Gravell

Einem gemeinsamen und sehr hilfreich, die Verwendung von Generika ist stark typisierte collection-Klassen. Traditionell werden alle collection-Klassen mussten übergeben werden Objekte, und die Objekte zurückgeben, wenn die Abfrage ausgeführt wird. Sie hatte, um alle die Art der Konvertierung selbst. Mit Generika, die Sie nicht haben zu tun. Sie können List(Of Integer), und beim anfordern von Werten aus, du bekommst ganze zahlen. Bekommen Sie keine Objekte, die man dann umwandeln in ganze zahlen umgewandelt.

InformationsquelleAutor der Antwort Instance Hunter

    private void button1_Click_1(object sender, RoutedEventArgs e)
    {
        TextValue<string, int> foo = new TextValue<string, int>("",0);
        foo.Text = "Hi there";
        foo.Value = 3995;
        MessageBox.Show(foo.Text);
    }

    class TextValue<TText, TValue>
    {
        public TextValue(TText text, TValue value)
        {
            Text = text;
            Value = value;
        }
        public TText Text { get; set; }
        public TValue Value { get; set; }
    }

InformationsquelleAutor der Antwort dewelloper

    private void button1_Click_1(object sender, RoutedEventArgs e)
    {
        TextValue<string, int> foo;
        List<TextValue<string, int>> listTextValue = new List<TextValue<string, int>>();
        for (int k = 0; k < 5; ++k)
        {
            foo = new TextValue<string, int>("",0);
            foo.Text = k.ToString();
            foo.Value = k;
            listTextValue.Add(foo);
            otherList.
            MessageBox.Show(foo.Text);
        }

    }

    class TextValue<TText, TValue>
    {
        public TextValue(TText text, TValue value){Text = text; Value = value;}
        public TText Text { get; set; }
        public TValue Value { get; set; }
    }

InformationsquelleAutor der Antwort dewelloper