web-dev-qa-db-de.com

Beispiele für die Verwendung von Generics in .Net (C #/VB.NET)

An welchen Beispielen würden Sie Generics in C #/VB.NET verwenden und warum sollten Sie Generics verwenden?

28
Seenu

Sie deklarieren einfach einen Typ oder eine Methode mit zusätzlichen Tags, um die generischen Bits anzugeben:

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

Das Obige definiert einen generischen Typ Foo "von T", wobei die T vom Aufrufer bereitgestellt wird. Üblicherweise beginnen generische Typargumente mit T. Wenn es nur einen gibt, ist T in Ordnung - ansonsten nennen Sie sie alle sinnvoll: TSource, TValue, TListType etc

Im Gegensatz zu C++ - Vorlagen werden .NET-Generics von der Laufzeitumgebung bereitgestellt (keine Compiler-Tricks). Zum Beispiel:

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

Alle Ts wurden oben durch int ersetzt. Bei Bedarf können Sie generische Argumente mit Einschränkungen einschränken:

class Foo<T> where T : struct {}

Nun weigert sich Foo<string>, zu kompilieren - da string keine Struktur (Wertetyp) ist. 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 andere generische Typargumente beinhalten, zum Beispiel:

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

Sie können so viele generische Argumente verwenden, wie Sie benötigen:

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

Andere Dinge zu beachten:

  • statische Member usw. werden definiert pro generischer Typkombination - ein statisches Feld in Foo<int> ist daher von dem in Foo<float> getrennt.
  • methoden können auch generisch sein - versuchen Sie, nicht die gleichen Namen wie die Klasse zu verwenden, da Sie nicht in der Lage sein werden, diese zu unterscheiden
  • geschachtelte Typen erben die generischen Typen von ihren Eltern

zum Beispiel:

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

Beispiel 1: Sie möchten eine dreifache Klasse erstellen 

Class Triple<T1, T2, T3>
{
   T1 _first;
   T2 _second;
   T3 _Third;
}

Beispiel 2: Eine Hilfsklasse, die einen beliebigen Aufzählungswert für den angegebenen Datentyp analysiert

static public class EnumHelper<T>
{
   static public T Parse(string value)
   {
       return (T)Enum.Parse(typeof(T), value);
   }
}
6
Brijesh Mishra

Generische und äußerst hilfreiche Verwendung von Generika sind stark typisierte Auflistungsklassen. Traditionell mussten alle Auflistungsklassen übergebene Objekte sein und bei Abfrage zurückgegeben werden. Sie mussten die gesamte Typumwandlung selbst erledigen. Mit Generika müssen Sie das nicht tun. Sie können List (Of Integer) haben, und wenn Sie Werte von ihr anfordern, erhalten Sie Ganzzahlen. Sie erhalten keine Objekte, die Sie dann in Ganzzahlen konvertieren müssen.

4
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; }
    }
3
dewelloper

Die häufigsten Gründe und Anwendungsfälle für Generika werden in der zuvor genannten MSDN-Dokumentation beschrieben. Ein Vorteil von Generika, die ich hinzufügen möchte, ist, dass sie die Unterstützung des Tools im Entwicklungsprozess verbessern können. Refactoring-Tools wie die in Visual Studio oder ReSharper integrierten Tools basieren auf statischen Typanalysen, um beim Programmieren Unterstützung zu bieten. Da Generics normalerweise mehr Typinformationen zu Ihrem Objektmodell hinzufügen, gibt es mehr Informationen für solche Tools, die Sie analysieren und beim Kodieren unterstützen können. 

Auf einer konzeptionellen Ebene helfen Generika, "Querfragen" unabhängig von Ihrer Anwendungsdomäne zu lösen. Unabhängig davon, ob Sie eine Finanzanwendung oder eine Buchhandlung entwickeln, müssen Sie früher oder später Sammlungen von Dingen verwalten, sei es Konten, Bücher oder was auch immer. Die Implementierung solcher Sammlungen muss in der Regel wenig oder gar nichts über die Dinge wissen, die in diesen Sammlungen aufrechterhalten werden sollen. Daher sind die generischen Sammlungen, die mit dem .NET-Framework ausgeliefert werden, ein primäres Beispiel für einen Anwendungsfall von Generika.

3
Sven Künzler

Ein grundlegendes Beispiel wäre:

class Other{
 class Generic<T>
{
  void met1(T x);
}
static void Main()
{
  Generic<int> g = new Generic<int>();
  Generic<string> s = new Generic<string>();
}
}
1
user544079
    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; }
    }
0
dewelloper