Dela via

Allmänna metoder (programmeringsguide för C#)

  • Artikel

En allmän metod är en metod som deklareras med typparametrar enligt följande:

static void Swap<T>(ref T lhs, ref T rhs)
{
    T temp;
    temp = lhs;
    lhs = rhs;
    rhs = temp;
}

Följande kodexempel visar ett sätt att anropa metoden med hjälp int av för typargumentet:

public static void TestSwap()
{
    int a = 1;
    int b = 2;

    Swap<int>(ref a, ref b);
    System.Console.WriteLine(a + " " + b);
}

Du kan också utelämna typargumentet och kompilatorn kommer att härleda det. Följande anrop till Swap motsvarar föregående anrop:

Swap(ref a, ref b);

Samma regler för typinferens gäller för statiska metoder och instansmetoder. Kompilatorn kan härleda typparametrarna baserat på de metodargument som du skickar in. det kan inte bara härleda typparametrarna från ett villkor eller ett returvärde. Därför fungerar inte typinferens med metoder som inte har några parametrar. Typinferens inträffar vid kompileringstillfället innan kompilatorn försöker lösa överlagrade metodsignaturer. Kompilatorn tillämpar typinferenslogik på alla generiska metoder som har samma namn. I steget överlagringsmatchning innehåller kompilatorn endast de generiska metoder där typinferensen lyckades.

I en generisk klass kan icke-generiska metoder komma åt parametrarna på klassnivå enligt följande:

class SampleClass<T>
{
    void Swap(ref T lhs, ref T rhs) { }
}

Om du definierar en allmän metod som använder samma typparametrar som den innehållande klassen genererar kompilatorn varnings-CS0693 eftersom argumentet som anges för det inre T döljer argumentet som angetts för den yttre T. Om du behöver flexibiliteten att anropa en generisk klassmetod med andra typargument än de som angavs när klassen instansierades kan du överväga att ange en annan identifierare för metodens typparameter, som du ser i GenericList2<T> följande exempel.

class GenericList<T>
{
    // CS0693.
    void SampleMethod<T>() { }
}

class GenericList2<T>
{
    // No warning.
    void SampleMethod<U>() { }
}

Använd begränsningar för att aktivera mer specialiserade åtgärder för typparametrar i metoder. Den här versionen av Swap<T>, nu med namnet SwapIfGreater<T>, kan bara användas med typargument som implementerar IComparable<T>.

void SwapIfGreater<T>(ref T lhs, ref T rhs) where T : System.IComparable<T>
{
    T temp;
    if (lhs.CompareTo(rhs) > 0)
    {
        temp = lhs;
        lhs = rhs;
        rhs = temp;
    }
}

Allmänna metoder kan överbelastas på flera typparametrar. Följande metoder kan till exempel finnas i samma klass:

void DoWork() { }
void DoWork<T>() { }
void DoWork<T, U>() { }

Du kan också använda typparametern som returtyp för en metod. I följande kodexempel visas en metod som returnerar en matris av typen T:

T[] Swap<T>(T a, T b)
{
    return [b, a];
}

Språkspecifikation för C#

Mer information finns i C#-språkspecifikationen.

Se även