Metódusok – alapértelmezett és nevesített paraméterek, változó paraméterszám

Metódusok esetén lehetőségünk van alapértelmezett értéket adni a paramétereknek. Az alapértelmezett értékek segítségével a kódunkat egyszerűsíthetjük. Tételezzük fel, hogy van egy metódusunk, ami valami számolást végez egy adott érték segítségével. Később, valamilyen igény miatt módosítani kell a metódust úgy, hogy egy belső, eddig fix értéket kívülről, argumentumként is meg lehessen adni.

Itt hagyományos úton három lehetőségünk van a probléma megoldására. Első opció az, hogy módosítjuk a metódus definíciót és kötelező paramétert várunk el. Ennek a megoldásnak a hátránya, hogy az összes metódus hívásunkat át kell írni és később nem biztos, hogy tudni fogjuk, miért az a szám szerepel a hívás helyén az argumentumban.

Másik megoldás az, hogy lemásoljuk a metódus logikáját és ugyanazon a néven készítünk egy paraméteres változatot. Ez elegáns megoldás, mert az eddigi kód érintetlen marad, viszont ez sem teljesen jó megoldás, mivel majdnem ugyanaz a kód kétszer szerepel a programban. Ez azért káros, mert ha az eredeti metódusban hiba van, akkor a hibajavítást kétszer kell elvégezni, vagyis plusz munkát adunk magunknak.

A harmadik opció az alapértelmezett paraméter értékek használata. Lényegében az első megoldásról van szó olyan módosítással, hogy adunk egy alapértelmezett értéket a paraméternek, így opcionálissá téve annak a megadását.

Az opcionális paraméterek szabálya, hogy csak a kötelezÅ‘ paraméterek után szerepelhetnek. Vagyis nem kezdhetünk úgy egy metódus definíciót, hogy opcionális paraméter, majd kötelezÅ‘ paraméter, mivel híváskor nem lenne egyértelmű a fordítónak, hogy mit hova helyettesítsen be. További fontos szabály, hogy az opcionális paraméternek adott értéknek fordítási idÅ‘ben ismertnek kell lenni. Ez azt jelenti, hogy az olyan típusok, amik a new operátorral példányosodnak (osztályok) nem alkalmazhatóak.

Az alábbi példa az opcionális paraméter használatát mutatja be:

using System;

namespace PeldaAlapertelmezettertek
{
    class Program
    {
        private static int Osszegez(int meddig=10)
        {
            int osszeg = 0;
            for (int i=1; i<=meddig; i++)
            {
                osszeg += i;
            }
            return osszeg;
        }

        /*private static void Nemfordul(int opcionalis=10, int valami)
        {
            ez nem fog lefordulni, mivel a valami kötelező paraméter, az
            opcionális paraméter pedig csak a kötelező paraméterek után
            szerepelhet
        }*/

        static void Main(string[] args)
        {
            int t1 = Osszegez(); //első 10 szám összege
            int t2 = Osszegez(100); //első 100 szám összege
            Console.WriteLine(t1);
            Console.WriteLine(t2);
            Console.ReadKey();
        }
    }
}

A program kimenete:

55
5050

Nevesített paraméterek

A C# újabb verziói lehetőséget adnak rá, hogy a metódus meghívásakor a paraméter nevére hivatkozva adjuk meg azok értékeit. Ez akkor jön jól, ha a metódus számos paramétert vár el. Példaként rendelkezzen ez a metódus az alábbi deklarációval:

void SokParameteres(string s1, string s2, string s3, string s4, string s5);

Tételezzük fel, hogy a metódust meg szeretnénk hívni úgy, hogy csak az s4 értékét módosítjuk. A többi paraméter értékének null értéket szeretnénk adni. Ebben az esetben meghívhatjuk a metódust a korábban ismertetett módon:

SokParameteres(null, null, null, "ténylegesen átadott paraméter", null);

Ennél szebb, olvashatóbb kódot eredményez azonban, ha s4 nevére direkt hivatkozunk:

SokParameteres(s4: "ténylegesen átadott paraméter");

Ez a metódus hívási módszer leginkább COM+ alkalmazások komponenseinek hívásakor hasznos. Akadnak olyan COM+ komponensek (Pl: Excel), melyek metódusai akár 20 paraméterrel is rendelkezhetnek.

Változó argumentumszámú metódusok

Változó argumentumszámú metódusra remek példa a Console osztály WriteLine és Write metódusa. Ezeknek opcionálisan argumentumokat adhatunk meg, amiket a formázott szövegbe beillesztenek. Ilyen metódusokat mi is készíthetünk. C# esetén ezek a metódusok tömbök segítségével vannak megoldva. Az alábbi példa egy változó argumentum számú metódust mutat be:

using System;

namespace PeldaValtozoargumentumok
{
    class Program
    {
        private static int Osszegez(params int[] szamok)
        {
            int osszeg = 0;
            foreach (var szam in szamok)
            {
                osszeg += szam;
            }
            return osszeg;
        }

        static void Main(string[] args)
        {
            int t1 = Osszegez(1, 2); //3
            int t2 = Osszegez(5, 10, 15, 30); //60
            Console.WriteLine(t1);
            Console.WriteLine(t2);
            Console.ReadKey();
        }
    }
}

A program kimenete:

3
60

A változó argumentumszámú metódusunk lényegében egy tömböt vesz át. A params kulcsszó azt csinálja, hogy a hívás esetén használt értékeket egy tömbbe csomagolja, amit aztán a metóduson belül úgy használunk, ahogy szeretnénk. Itt is ugyanaz a szabály, mint az opcionális paraméterek esetén. Változó paraméterek csak a kötelezÅ‘ek után állhatnak. Lényeges különbség azonban, hogy a params kulcsszó csak egyszer szerepelhet a metódus argumentum listájában. Vagyis az alábbi definíció fordítási hibát okoz:

//fordítási hibát okozó definíció
void teszt(params int[] szamok, params string[] szovegek) {}

C# 13 elÅ‘tt a params kulcsszó csak tömbökkel működött együtt. C# 13 óta azonban bármilyen beépített kollekcióval működnek, ami megfelel az alábbi két kritériumnak:

• Implementálja az IEnumerable<T> interfészt
• Rendelkezik egy Add metódussal, ami elemek hozzáadását teszi lehetÅ‘vé

//C# 13 előtt fordítási hiba.
void teszt(params HashSet<int> szamok) {}

A fenti példában szereplÅ‘ kódot meghívhatjuk például a teszt(1, 2, 3, 3) paraméterekkel. Mivel ezeket a paramétereket egy halmazként kezeljük a metódusban, ezért csak az 1, 2, 3 elemeket fogjuk tudni használni. A kollekciókról a következÅ‘ fejezetben lesz részletesebben szó.