C # Generics (Generika)

using System;
mit System.Collections.Generic;

Namespace GenericApplication
{
    public class MyGenericArray <T>
    {
        Private T [] Array;
        public MyGenericArray (int size)
        {
            Array = new T [size + 1];
        }
        public T getItem (int index)
        {
            return array [index];
        }
        public void setItem (int index, T-Wert)
        {
            array [index] = Wert;
        }
    }
           
    Klasse Tester
    {
        static void Main (string [] args)
        {
            // Deklarieren Sie eine Integer-Array MyGenericArray <int> intArray = new MyGenericArray <int> (5);
            // Stellen Sie den Wert für (int c = 0; c <5; c ++)
            {
                intArray.setItem (c, c * 5);
            }
            // Gibt den Wert für (int c = 0; c <5; c ++)
            {
                Console.Write (intArray.getItem (c) + "");
            }
            Console.WriteLine ();
            // Deklarieren Sie ein Zeichen-Array MyGenericArray <char> charArray = new MyGenericArray <char> (5);
            // Stellen Sie den Wert für (int c = 0; c <5; c ++)
            {
                charArray.setItem (c, (char) (c + 97));
            }
            // Gibt den Wert für (int c = 0; c <5; c ++)
            {
                Console.Write (charArray.getItem (c) + "");
            }
            Console.WriteLine ();
            Console.ReadKey ();
        }
    }
}

05101520
abcde

Generika (Generika) Funktionen

Die Verwendung von Generika ist ein Programm, technische Fähigkeiten zu verbessern, und zwar in den folgenden Aspekten:

• Es hilft Ihnen, die Wiederverwendung von Code, der Art des Schutzes der Sicherheit und Verbesserung der Leistung zu maximieren.
• Sie können eine generische Auflistung Klassen erstellen. .NET Framework - Klassenbibliothek enthält mehrere neue generische Auflistung Klassen imSystem.Collections.GenericNamespace. Sie können diese generischen Collection - Klassen verwenden , anstattSystem.CollectionsCollection - Klassen.
• Sie können Ihre eigene generische Schnittstellen, generische Klassen, generische Methode generische Ereignisse und generische Delegaten.
• Sie können die generische Klasse beschränken auf bestimmte Datentypen zugreifen.
• Über generische Datentypen in der Art von Informationen verwendet wird, kann durch die Reflexion zur Laufzeit erhalten werden.

Generika (Generika) Methode

In dem obigen Beispiel haben wir die generische Klasse verwendet wird, können wir eine generische Methode Typ Parameter deklarieren. Das folgende Programm veranschaulicht dieses Konzept:

using System;
mit System.Collections.Generic;

Namespace GenericMethodAppl
{
    Klasse-Programm
    {
        static void Swap <T> (ref T lhs, ref T rhs)
        {
            T Temp;
            temp = LHS;
            lhs = rhs;
            rhs = Temp;
        }
        static void Main (string [] args)
        {
            int a, b;
            char c, d;
            a = 10;
            b = 20;
            c = 'I';
            d = 'V';

            // Anzeige vor dem Tauschwert Console.WriteLine ( "Int-Werte vor Swap-Aufruf:");
            Console.WriteLine ( "a = {0}, b = {1}", a, b);
            Console.WriteLine ( "Char-Werte vor Swap-Aufruf:");
            Console.WriteLine ( "c = {0}, d = {1}", c, d);

            // Makeln
            Swap <int> (ref a, ref b);
            Swap <char> (ref c, ref d);

            // Nach einem Austausch des Anzeigewertes Console.WriteLine ( "Int-Werte nach Swap-Aufruf:");
            Console.WriteLine ( "a = {0}, b = {1}", a, b);
            Console.WriteLine ( "Char-Werte nach Swap-Aufruf:");
            Console.WriteLine ( "c = {0}, d = {1}", c, d);
            Console.ReadKey ();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:

Int-Werte vor dem Aufruf von swap:
a = 10, b = 20
Char-Werte vor dem Aufruf von swap:
c = I, d = V
Int-Werte nach Swap-Aufruf:
a = 20, b = 10
Char-Werte nach Swap-Aufruf:
c = V, d = I

Generika (Generika) in Auftrag gegeben

Sie können generische Delegattyp Parameter definieren, durch. Zum Beispiel:

Delegierten T NumberChanger <T> (T n);

Das folgende Beispiel demonstriert die Verwendung der Provision:

using System;
mit System.Collections.Generic;

Delegierten T NumberChanger <T> (T n);
Namespace GenericDelegateAppl
{
    Klasse TestDelegate
    {
        static int num = 10;
        public static int AddNum (int p)
        {
            num + = p;
            Rückkehr num;
        }

        public static int MultNum (int q)
        {
            num * = q;
            Rückkehr num;
        }
        public static int getNum ()
        {
            Rückkehr num;
        }

        static void Main (string [] args)
        {
            // Erstellen Sie eine Delegatinstanz NumberChanger <int> NC1 = new NumberChanger <int> (AddNum);
            NumberChanger <int> nc2 = new NumberChanger <int> (MultNum);
            // Rufen Sie die Methode unter Verwendung eines Delegatobjekt NC1 (25);
            Console.WriteLine ( "Wert des Num: {0}", getNum ());
            NC2 (5);
            Console.WriteLine ( "Wert des Num: {0}", getNum ());
            Console.ReadKey ();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:

Wert von Num: 35
Wert von Num: 175