Dela via

C#-funktioner som stöder LINQ

Frågeuttryck

Frågeuttryck använder en deklarativ syntax som liknar SQL eller XQuery för att köra frågor mot System.Collections.Generic.IEnumerable<T> samlingar. Vid kompileringen konverterar kompilatorn frågesyntaxen till metodanrop till en LINQ-providers implementering av standardfrågemetoderna. Program styr de vanliga frågeoperatorer som finns i omfånget genom att ange lämpligt namnområde med ett using direktiv. Följande frågeuttryck tar en array av strängar, grupperar dem enligt det första tecknet i strängen och ordnar grupperna.

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

Implicit inskrivna variabler (var)

Du kan använda var-modifieraren för att instruera kompilatorn att härleda och tilldela typen, enligt följande:

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

Variabler som deklareras som var är strängt typade, liksom variabler vars typ du uttryckligen anger. Med hjälp av var gör det möjligt att skapa anonyma typer, men bara för lokala variabler. Mer information finns i Implicit inskrivna lokala variabler.

Initierare för objekt och samlingar

Initiatorer för objekt och samling gör det möjligt att initiera objekt utan att uttryckligen anropa en konstruktor för objektet. Du använder vanligtvis initierare i frågeuttryck när de projicerar källdata till en ny datatyp. Om du antar en klass med namnet Customer med offentliga Name egenskaper och Phone egenskaper kan du använda objektinitieraren som i följande kod:

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

Om du fortsätter med klassen Customer antar du att det finns en datakälla med namnet IncomingOrders, och att du för varje order med en stor OrderSize, vill skapa en ny Customer baserad av den ordningen. Du kan köra en LINQ-fråga på den här datakällan och använda objektinitiering för att fylla en samling:

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

Datakällan kan ha fler egenskaper definierade än Customer klassen, OrderSizetill exempel , men med objektinitiering formas data som returneras från frågan till önskad datatyp. Du väljer de data som är relevanta för din klass. Som ett resultat har du nu en System.Collections.Generic.IEnumerable<T> fylld med de nya Customers du ville ha. Du kan också skriva föregående exempel i LINQ:s metodsyntax:

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

Från och med C# 12 kan du använda ett samlingsuttryck för att initiera en samling.

Mer information finns i:

Anonyma typer

Kompilatorn skapar en anonym typ. Endast kompilatorn kan komma åt typnamnet. Anonyma typer är ett bekvämt sätt att gruppera en uppsättning egenskaper tillfälligt i ett frågeresultat utan att behöva definiera en separat namngiven typ. Du initierar anonyma typer med ett nytt uttryck och en objektinitierare, som du ser här:

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

Från och med C# 7 kan du använda tupplar för att skapa namnlösa typer.

Utvidgningsmedlemmar

En tilläggsmedlem är en statisk medlem i en statisk klass som är associerad med en typ som kallas mottagartyp. Du kan anropa en tilläggsmedlem som om den vore medlem i mottagartypen. Med den här funktionen kan du "lägga till" nya medlemmar i befintliga typer utan att ändra dem. Standardfrågeoperatorerna är en uppsättning tilläggsmetoder som tillhandahåller LINQ-frågefunktioner för alla typer som implementerar IEnumerable<T>.

Lambda-uttryck

Ett lambda-uttryck är en infogad funktion som använder operatorn => för att separera indataparametrar från funktionstexten och kan konverteras vid kompileringstid till ett ombud eller ett uttrycksträd. I LINQ-programmering får du lambda-uttryck när du gör direkta metodanrop till standardfrågeoperatorerna.

Uttryck som data

Frågeobjekt är skrivbara, vilket innebär att du kan returnera en fråga från en metod. Objekt som representerar frågor lagrar inte den resulterande samlingen, utan snarare stegen för att generera resultatet när det behövs. Fördelen med att returnera frågeobjekt från metoder är att du kan skriva eller ändra dem ytterligare. Därför måste ett returvärde eller out en parameter för en metod som returnerar en fråga också ha den typen. Om en metod materialiserar en sökning till en konkret List<T> eller Array typ returneras sökresultatet i stället för själva sökningen. Du kan fortfarande skriva eller ändra en frågevariabel som returneras från en metod.

I följande exempel returnerar den första metoden QueryMethod1 en fråga som ett returvärde, och den andra metoden QueryMethod2 returnerar en fråga som en out parameter (returnQ i exemplet). I båda fallen är det en fråga som returneras, inte frågeresultat.

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);

foreach Följande loop kör frågan myQuery1.

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

Vila muspekaren över myQuery1 för att se dess typ.

Du kan också köra frågan som returneras direkt QueryMethod1 , utan att använda myQuery1.

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

Håll muspekaren över anropet till QueryMethod1 för att se dess returtyp.

QueryMethod2 returnerar en fråga som värdet för parametern out :

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

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

Du kan ändra en fråga med hjälp av frågesammansättning. I det här fallet används det tidigare frågeobjektet för att skapa ett nytt frågeobjekt. Det här nya objektet returnerar andra resultat än det ursprungliga frågeobjektet.

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);
}
  • Last updated on