A LINQ-t támogató C#-funkciók

Lekérdezési kifejezések

A lekérdezési kifejezések az SQL-hez vagy az XQueryhez hasonló deklaratív szintaxist használnak a gyűjtemények lekérdezéséhez System.Collections.Generic.IEnumerable<T> . Fordítási időben a fordító a lekérdezés szintaxisát metódushívássá alakítja, hogy a LINQ-szolgáltató standard lekérdezési metódusait implementálja. Az alkalmazások a szabványos lekérdezési operátorok hatókörben lévő irányítását a megfelelő névtér using direktívával megadva szabályozzák. Az alábbi lekérdezési kifejezés egy sztringek tömbjét veszi, a sztringek első karaktere szerint csoportosítja őket, és rendezi a csoportokat.

var query = from str in stringArray
            group str by str[0] into stringGroup
            orderby stringGroup.Key
            select stringGroup;

Implicit módon beírt változók (var)

A var módosítóval arra utasíthatja a fordítót, hogy következtetsen és rendelje hozzá a típust, ahogy az itt látható:

var number = 5;
var name = "Virginia";
var query = from str in stringArray
            where str[0] == 'm'
            select str;

A var változók erősen típusosak, éppúgy, mint azok a változók, amelyek típusát kifejezetten megadja. A használatával var névtelen típusok hozhatók létre, de csak helyi változókhoz. További információ: Implicit módon beírt helyi változók.

Objektum- és gyűjtemény inicializálók

Az objektum- és gyűjtemény-inicializálók lehetővé teszik az objektumok inicializálását anélkül, hogy explicit módon konstruktort hívna meg az objektumhoz. A lekérdezési kifejezésekben általában inicializálókat használ, amikor a forrásadatokat új adattípusba vetik. Egy Customer nevű osztály nyilvános Name és Phone tulajdonsággal feltételezve az objektum inicializálót a következő módon használhatja:

var cust = new Customer { Name = "Mike", Phone = "555-1212" };

Az Customer osztály folytatásaként tételezzük fel, hogy van egy IncomingOrders nevű adatforrás, és hogy minden olyan megrendeléshez, amelynek nagy a OrderSize-e, létre szeretne hozni egy új Customer-t az adott megrendelés alapján. Ezen az adatforráson linq-lekérdezést hajthat végre, és objektum-inicializálással kitölthet egy gyűjteményt:

var newLargeOrderCustomers = from o in IncomingOrders
                            where o.OrderSize > 5
                            select new Customer { Name = o.Name, Phone = o.Phone };

Előfordulhat, hogy az adatforrás több tulajdonsággal rendelkezik, mint az Customer osztály, például OrderSizeaz objektum inicializálásával azonban a lekérdezésből visszaadott adatok a kívánt adattípusba vannak formázva. Ön az osztály szempontjából releváns adatokat választja ki. Ennek eredményeképpen most már tele van System.Collections.Generic.IEnumerable<T> a kívánt újakkal Customer. Az előző példát a LINQ metódusszintaxisában is megírhatja:

var newLargeOrderCustomers = IncomingOrders.Where(x => x.OrderSize > 5).Select(y => new Customer { Name = y.Name, Phone = y.Phone });

A C# 12-től kezdődően gyűjteménykifejezéssel inicializálhatja a gyűjteményeket.

További információkért lásd:

• Objektum- és gyűjtemény-inicializálók
• Lekérdezési kifejezés szintaxisa standard lekérdezési operátorokhoz

Névtelen típusok

A fordító névtelen típust hoz létre. Csak a fordító férhet hozzá a típusnévhez. A névtelen típusokkal kényelmesen csoportosíthat tulajdonságokat ideiglenesen egy lekérdezés eredményében anélkül, hogy külön elnevezett típust kellene definiálnia. A névtelen típusokat egy új kifejezéssel és egy objektum inicializálójával inicializálja, ahogy az itt látható:

select new {name = cust.Name, phone = cust.Phone};

C# 7-t,öl kezdődően használhatja a tuple-öket névtelen típusok létrehozására.

Bővítménytagok

A bővítménytag a vevőtípushoz társított statikus osztály statikus tagja. Úgy hívhat meg egy bővítménytagot, mintha a fogadótípus tagja lenne. Ez a funkció lehetővé teszi új tagok hozzáadását a meglévő típusokhoz anélkül, hogy ténylegesen módosítaná őket. A standard lekérdezési operátorok olyan bővítménymetelyek, amelyek linq lekérdezési funkciót biztosítanak minden implementált IEnumerable<T>típushoz.

Lambda-kifejezések

A lambda kifejezés egy beágyazott függvény, amely az operátort használja a => bemeneti paraméterek elválasztására a függvény törzsétől, és fordításkor delegált vagy kifejezésfává alakítható. A LINQ-programozásban lambdakifejezésekkel találkozhat, amikor közvetlen metódushívásokat indít a standard lekérdezési operátorokhoz.

Kifejezések adatként

A lekérdezési objektumok összeállíthatók, ami azt jelenti, hogy egy lekérdezést egy metódusból adhat vissza. A lekérdezéseket ábrázoló objektumok nem az eredményként kapott gyűjteményt tárolják, hanem az eredmények szükség esetén történő előállításának lépéseit. A lekérdezési objektumok metódusokból való visszaadásának előnye, hogy tovább lehet őket összeállítani vagy módosítani. Ezért a lekérdezést visszaadó metódusok visszatérési értékének vagy out paraméterének is ilyen típusúnak kell lennie. Ha egy metódus konkrét List<T> vagy Array típusú lekérdezést hoz létre, a lekérdezés eredményeit adja vissza, nem magát a lekérdezést. A metódusból visszaadott lekérdezési változók írása vagy módosítása továbbra is lehetséges.

Az alábbi példában az első metódus QueryMethod1 visszaad egy lekérdezést visszatérési értékként, a második metódus QueryMethod2 pedig paraméterként out adja vissza a lekérdezést (returnQ a példában). Mindkét esetben ez egy visszaadott lekérdezés, nem pedig a lekérdezés eredményei.

IEnumerable<string> QueryMethod1(int[] ints) =>
    from i in ints
    where i > 4
    select i.ToString();

void QueryMethod2(int[] ints, out IEnumerable<string> returnQ) =>
    returnQ = from i in ints
              where i < 4
              select i.ToString();

int[] nums = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ];

var myQuery1 = QueryMethod1(nums);

Az alábbi foreach ciklus lekérdezést myQuery1hajt végre.

foreach (var s in myQuery1)
{
    Console.WriteLine(s);
}

Vigye az egérmutatót a myQuery1 fölé, hogy meglássa a típusát.

Közvetlenül végrehajthatja a QueryMethod1 által visszaadott lekérdezést, anélkül hogy a myQuery1-t használná.

foreach (var s in QueryMethod1(nums))
{
    Console.WriteLine(s);
}

Tartsa az egérmutatót a "QueryMethod1" hívás fölött, hogy megtekinthesse a visszatérési típust.

QueryMethod2 egy lekérdezést ad vissza a paraméter értékeként out :

QueryMethod2(nums, out IEnumerable<string> myQuery2);

// Execute the returned query.
foreach (var s in myQuery2)
{
    Console.WriteLine(s);
}

A lekérdezéseket a lekérdezésösszeállítással módosíthatja. Ebben az esetben a rendszer az előző lekérdezési objektumot használja egy új lekérdezési objektum létrehozásához. Ez az új objektum az eredeti lekérdezési objektumtól eltérő eredményeket ad vissza.

myQuery1 = from item in myQuery1
           orderby item descending
           select item;

// Execute the modified query.
Console.WriteLine("\nResults of executing modified myQuery1:");
foreach (var s in myQuery1)
{
    Console.WriteLine(s);
}