C# Language
Linq till objekt

Introduktion

Hur LINQ to Object kör frågor

LINQ-frågor körs inte omedelbart. När du bygger frågan lagrar du helt enkelt frågan för framtida körning. Endast när du faktiskt begär att iterera frågan körs frågan (t.ex. i en för-loop, när du ringer till ToList, Count, Max, Average, First, etc.)

Detta betraktas som uppskjuten utförande . Detta gör att du kan bygga upp frågan i flera steg, eventuellt ändra den baserat på villkorade uttalanden och sedan köra den senare bara när du behöver resultatet.

Med koden:

var query = from n in numbers 
            where n % 2 != 0
            select n;

Exemplet ovan lagrar bara frågan i query . Det kör inte själva frågan.

foreach uttalandet tvingar foreach av frågan:

foreach(var n in query) {
    Console.WriteLine($"Number selected {n}");
}

Vissa LINQ-metoder kommer också att utlösa frågeställningen, Count , First , Max , Average . De returnerar enskilda värden. ToList och ToArray samlar resultat och vänder dem till en lista respektive en array.

Var medveten om att det är möjligt för dig att iterera över frågan flera gånger om du anropar flera LINQ-funktioner på samma fråga. Detta kan ge dig olika resultat vid varje samtal. Om du bara vill arbeta med en datauppsättning ska du spara den i en lista eller grupp.

Använda LINQ för att objekt i C #

En enkel SELECT-fråga i Linq

static void Main(string[] args)
{
    string[] cars = { "VW Golf", 
                        "Opel Astra", 
                        "Audi A4", 
                        "Ford Focus", 
                        "Seat Leon", 
                        "VW Passat", 
                        "VW Polo", 
                        "Mercedes C-Class" };

    var list = from car in cars
               select car;

    StringBuilder sb = new StringBuilder();

    foreach (string entry in list)
    {
        sb.Append(entry + "\n");
    }

    Console.WriteLine(sb.ToString());
    Console.ReadLine();
}

I exemplet ovan används en rad strängar (bilar) som en samling av objekt som ska fråges med LINQ. I en LINQ-fråga kommer från-klausulen först för att introducera datakällan (bilar) och intervallvariabeln (bil). När frågan körs kommer intervallvariabeln att fungera som en referens till varje successivt element i bilar. Eftersom kompilatorn kan dra slutsatsen om biltypen behöver du inte ange den uttryckligen

När koden ovan kompileras och körs ger den följande resultat:

VÄLJ med en VAR-klausul

var list = from car in cars
           where car.Contains("VW")
           select car;

WHERE-klausulen används för att fråga stränggruppen (bilar) för att hitta och returnera en delmängd av array som uppfyller WHERE-klausulen.

När koden ovan kompileras och körs ger den följande resultat:

Generera en beställd lista

var list = from car in cars
           orderby car ascending 
           select car;

Ibland är det bra att sortera de returnerade uppgifterna. Beställningsklausulen gör att elementen sorteras enligt standardjämföraren för den typ som sorteras.

När koden ovan kompileras och körs ger den följande resultat:

Arbetar med en anpassad typ

I det här exemplet skapas, fylls och skrivs en typlista

public class Car
{
    public String Name { get; private set; }
    public int UnitsSold { get; private set; }

    public Car(string name, int unitsSold)
    {
        Name = name;
        UnitsSold = unitsSold;
    }
}

class Program
{
    static void Main(string[] args)
    {

        var car1 = new Car("VW Golf", 270952);
        var car2 = new Car("Opel Astra", 56079);
        var car3 = new Car("Audi A4", 52493);
        var car4 = new Car("Ford Focus", 51677);
        var car5 = new Car("Seat Leon", 42125);
        var car6 = new Car("VW Passat", 97586);
        var car7 = new Car("VW Polo", 69867);
        var car8 = new Car("Mercedes C-Class", 67549);

        var cars = new List<Car> { 
            car1, car2, car3, car4, car5, car6, car7, car8 };
        var list = from car in cars
                   select car.Name;

        foreach (var entry in list)
        {
            Console.WriteLine(entry);
        }
        Console.ReadLine();
    }
}

När koden ovan kompileras och körs ger den följande resultat:

Hittills verkar exemplen inte fantastiska eftersom man bara kan iterera genom matrisen för att i princip göra detsamma. Men med de få exemplen nedan kan du se hur du skapar mer komplexa frågor med LINQ to Objects och uppnår mer med mycket mindre kod.

I exemplet nedan kan vi välja bilar som har sålts över 60000 enheter och sortera dem på antalet sålda enheter:

var list = from car in cars
           where car.UnitsSold > 60000 
           orderby car.UnitsSold descending 
           select car;

StringBuilder sb = new StringBuilder();

foreach (var entry in list)
{
    sb.AppendLine($"{entry.Name} - {entry.UnitsSold}");
}
Console.WriteLine(sb.ToString());

När koden ovan kompileras och körs ger den följande resultat:

I exemplet nedan kan vi välja bilar som har sålt ett udda antal enheter och beställa dem alfabetiskt över dess namn:

var list = from car in cars
           where car.UnitsSold % 2 != 0 
           orderby car.Name ascending 
           select car;

När koden ovan kompileras och körs ger den följande resultat: