C# -ban a "+= () =>" operátorok közül milyen szerepet tölt be a " () "?

Ezek az ún. lambda kifejezések vagy névtelen függvények. A () helyére mennek a függvény bemenő paraméterei. Egy paraméter esetén a zárójel elhagyható. Ennek viszont most nincsenek bemenő paraméterei, ezért üres a zárójel közti rész.

[link]

Naszóval, van az az eset, amikor valamilyen furcsa dolog miatt azt akarjuk, hogy legyen egy változónk, ami egy metódusra mutat, és ezt a változót, mint metódust meghívhassuk, valahogy így:

void Metodus(int i) {

.. Console.WriteLine(i);

}

var valtozo = Metodus;

valtozo(5);

Adódik is a kérdés: a változónak kell valamilyen típust adnom. Ismersz már típusokat, elvégre használtad az int-et, a string-et és a többit, és ennek az volt a szerepe, hogy egy megkötést tesz arra, hogy milyen értéket adhatsz neki - például egy int típusú változónak nem lehet string értéke. Érezheted, hogy a metódusok esetében sem olyan egyszerű az eset, hiszen ha ezt meg lehetne csinálni:

void Metodus1(int i) {...}

void Metodus2(int i, int j) {...}

var valtozo = Metodus1;

valtozo = Metodus2;

akkor nagy bajban lennénk, mert nem tudjuk, hogy hogyan kell meghívni a metódust, amire a változónk mutat. Szóval szükségünk van egy új nyelvi elemre, amivel leírhatjuk az elfogadott metódusok alakját, és ezt fel tudjuk használni típusként. Ennek az eszköze lesz a delegate.

Egy metódus alakját három dolog határozza meg:

1. A paramétereinek száma

2. A paramétereinek típusai

3. A visszatérési értékének a típusa

Tehát, ha van egy metódusod: int Add(int a, int b) {...}, akkor

- ez egy két paraméteres metódus

- az első paraméterének típusa int, míg a második paraméterének a típusa int

- az eredménye int

Ezt lehet leírni delegate-tel az alábbi módon:

delegate [eredmény_típusa] [delegate_neve]([paraméter típusa] [paraméter neve], ...);

Vagyis:

delegate int BinaryOperation(int a, int b);

Megjegyzés: a paraméterek neve tökmindegy, micsoda. Nem kell megegyeznie a tényleges metódus paramétereinek nevével.

Innentől kezdve tudunk BinaryOperation típusú változókat csinálni:

BinaryOperation valtozo = Add;

int eredmeny = valtozo(5,3);

De nem minden esetben akarod teleszemetelni az osztályodat metódusokkal, csak azért, hogy egyszer egy változónak átadhasd értékül. Helyette jó lenne, ha egy delegate típusú változóhoz azonnal, ott helyben tudnánk implementációt írni. Erre három eszközt lehet bevetni:

1. Az ősidőkben, a lambda kifejezések előtt létezett (és még most is létezik) a delegate kulcsszó:

BinaryOperation valtozo = delegate(int a, int b) {

.. return a+b;

};

2. Használhatsz lambda kifejezést:

BinaryOperation valtozo = (a, b) => a+b;

3. Vagy lambda blokkot:

BinaryOperation valtozo = (a, b) => {

.. return a+b;

};

A lambda kifejezés és a lambda blokk között van egy olyan különbség, hogy a lambda blokk kifejezésfában nem használható - ez akkor lesz érdekes, ha valami olyan LINQ dolgot használsz, ami nem IEnumerable-t használ, hanem IQueryable-t (ilyen például a LINQ to SQL, ha Microsoft SQL Servert használsz adatbázisnak).

A kérdésedre válaszolva, hogy mikor lehet elhagyni a zárójelpárt a lambda kifejezés/blokk paraméterei körül:

- csak akkor hagyhatod el, ha pontosan egy paramétere van a lambda kifejezésnek/blokknak

- minden más esetben kötelező kitenni. Akkor is, ha nincs paramétere a lambdának, ugyanis ezzel jelzed, hogy nincs paramétere.