Metódusok túlterhelése

Sok programozási nyelv lehetőséget nyújt alapértelmezett/opcionális paraméterek megszabására. Lehetővé teszi a programozó számára egy vagy több paraméter opcionálissá tételét azáltal, hogy egy alapértelmezett értéket ad meg. Ez főleg akkor hasznos, ha már létező kódhoz kell új funkcionalitást hozzáadni.

Elképzelhető például, hogy egy létező metódushoz új funkcionalitást szeretnél hozzátenni, ami azzal járhat, hogy egy vagy több új paraméter hozzáadására van szükség. Azonban ezáltal minden kód, ami a metódus régebbi változatát használja, érvénytelen lesz, ugyanis kevesebb paramétert biztosítanak a szükségesnél. Hogy ne kelljen ezeket mind átírni, megadhatod az új paramétereket opcionálisként is. Ehhez egy alapértelmezett értéket kell adnod nekik, és ha a metódus hívásakor ezek nem kapnak értéket, akkor az alapértelmezett érték lesz használva.

Az alapértelmezett paraméterek a C# 4.0-ás verzióban jelentek meg először, de azelőtt a C# fejlesztők egy másik technikát használtak, ami nagyrészt ugyanazt csinálja. Ezt metódus túlterhelésnek hívják. Ezzel a programozó több ugyanolyan nevű metódust is megírhat, feltéve, hogy azoknak nem azonosak a paraméterei. Ahogy jobban megismered a .NET keretrendszer osztályait, rá fogsz jönni, hogy a metódus túlterhelés széles körben használt. Egy jó példa erre a String osztály Substring() metódusa. Ennek van egy másik, túlterhelt változata is:

string Substring (int startIndex)
string Substring (int startIndex, int length)

Ez azt jelenti, hogy egy vagy két paraméterrel is használható. Ha csak eggyel hívod, akkor feltételezve van, hogy a length (hossz) paraméter az egész hátralévő stringre vonatkozik. Ezzel időt nyerünk, ha csak a string utolsó részét akarjuk megkapni.

Viszont ha ugyanannak a metódusnak több verzióját definiáljuk, hogyan kerüljük el azt, hogy ugyanazt a kódot kelljen több helyen is megadnunk? Egyszerűen: hagyjuk, hogy a metódus egyszerűbb verziói az összetettebbre hagyatkozzanak. Lássuk a példát:

class SillyMath
{
    public static int Plus(int number1, int number2)
    {
        return Plus(number1, number2, 0);
    }

    public static int Plus(int number1, int number2, int number3)
    {
        return number1 + number2 + number3;
    }
}

Egy Plus metódus két különböző verzióját definiáljuk. Az első két paramétert kaphat, két szám összeadására, a második pedig hármat. A lényegi munka az utóbbiban történik - amikor csak kettő számot akarunk összeadni, akkor is valóban a három paraméteres verziót használjuk, csupán a harmadik paraméter helyett nullát adunk meg. Tudom, ez egy buta példa, ahogy azt az osztály neve is mutatja, de ezzel láthatod, hogyan is működhet a metódus túlterhelés.

Most már bármikor is szükséged van felsőfokú matekozásra, ahol négy számot adsz össze, könnyedén hozzáírhatsz még egy túlterhelést:

class SillyMath
{
    public static int Plus(int number1, int number2)
    {
        return Plus(number1, number2, 0);
    }

    public static int Plus(int number1, int number2, int number3)
    {
        return Plus(number1, number2, number3, 0);
    }

    public static int Plus(int number1, int number2, int number3, int number4)
    {
        return number1 + number2 + number3 + number4;
    }
}

A legjobb dolog ebben az egészben, hogy a létező Plus metódus hívásaid változatlanul működni fognak, mintha mi sem változott volna. Minél többet használod a C#-ot, annál jobban fogod értékelni a metódus túlterhelést.