Číst v angličtině

Sdílet prostřednictvím


Přehled LINQ

Language-Integrated Query (LINQ) poskytuje možnosti dotazování na úrovni jazyka a rozhraní API funkcí s vyšším pořadím pro C# a Visual Basic, které umožňují psát expresní deklarativní kód.

Syntaxe dotazů na úrovni jazyka

Toto je syntaxe dotazů na úrovni jazyka:

var linqExperts = from p in programmers
                  where p.IsNewToLINQ
                  select new LINQExpert(p);

Toto je stejný příklad použití IEnumerable<T> rozhraní API:

var linqExperts = programmers.Where(p => p.IsNewToLINQ)
                             .Select(p => new LINQExpert(p));

LINQ je výrazná

Imagine máte seznam domácích mazlíčků, ale chcete jej převést na slovník, kde můžete přistupovat k domácímu mazlíčku přímo podle jeho RFID hodnoty.

Toto je tradiční imperativní kód:

var petLookup = new Dictionary<int, Pet>();

foreach (var pet in pets)
{
    petLookup.Add(pet.RFID, pet);
}

Záměrem kódu není vytvořit nový Dictionary<int, Pet> a přidat ho přes smyčku, je převést existující seznam do slovníku. LINQ zachovává záměr, zatímco imperativní kód ne.

Toto je ekvivalentní výraz LINQ:

var petLookup = pets.ToDictionary(pet => pet.RFID);

Kód využívající LINQ je cenný, protože i hrací pole mezi záměrem a kódem při odůvodnění jako programátor. Dalším bonusem je stručnost kódu. Imagine snížení velkých částí základu kódu o 1/3, jak je uvedeno výše. Sladká dohoda, že?

Zprostředkovatelé LINQ zjednodušují přístup k datům.

U významného kusu softwaru ve volné přírodě se všechno točí kolem práce s daty z nějakého zdroje (Databáze, JSON, XML atd.). Často se to týká učení nového rozhraní API pro každý zdroj dat, což může být nepříjemné. LINQ to zjednodušuje tím, že abstrahuje běžné prvky přístupu k datům do syntaxe dotazu, která vypadá stejně bez ohledu na to, jaký zdroj dat vyberete.

Vyhledá všechny elementy XML s konkrétní hodnotou atributu:

public static IEnumerable<XElement> FindAllElementsWithAttribute(XElement documentRoot, string elementName,
                                           string attributeName, string value)
{
    return from el in documentRoot.Elements(elementName)
           where (string)el.Element(attributeName) == value
           select el;
}

Psaní kódu pro ruční procházení dokumentu XML k tomuto úkolu by bylo mnohem náročnější.

Interakce s XML není jediná věc, kterou můžete dělat s poskytovateli LINQ. Linq to SQL je poměrně holá Object-Relational mapovač (ORM) pro databázi serveru MSSQL. Knihovna Json.NET poskytuje efektivní procházení dokumentů JSON prostřednictvím LINQ. Pokud navíc není knihovna, která dělá to, co potřebujete, můžete také napsat vlastního zprostředkovatele LINQ!

Důvody použití syntaxe dotazu

Proč používat syntaxi dotazu? To je otázka, která se často objevuje. Koneckonců následující kód:

var filteredItems = myItems.Where(item => item.Foo);

je mnohem stručnější než toto:

var filteredItems = from item in myItems
                    where item.Foo
                    select item;

Není syntaxe rozhraní API jen stručnější způsob, jak syntaxi dotazu provést?

No. Syntaxe dotazu umožňuje použití klauzule let , která umožňuje zavést a svázat proměnnou v rámci rozsahu výrazu a použít ji v následných částech výrazu. Reprodukování stejného kódu pouze se syntaxí rozhraní API je možné provést, ale s největší pravděpodobností povede k obtížně čitelnému kódu.

Takže se jedná o otázku, měli byste použít jenom syntaxi dotazu?

Odpověď na tuto otázku je ano , pokud:

  • Váš stávající základ kódu už používá syntaxi dotazu.
  • Proměnné v rámci dotazů potřebujete oborovat kvůli složitosti.
  • Dáváte přednost syntaxi dotazu a nebude vás rušit od základu kódu.

Odpověď na tuto otázku není, pokud...

  • Váš stávající základ kódu už používá syntaxi rozhraní API.
  • Proměnné v rámci dotazů nemusíte oborovat.
  • Dáváte přednost syntaxi rozhraní API a nebudete rušit od základu kódu.

Základní LINQ

Úplný seznam ukázek LINQ najdete v 101 ukázkách LINQ.

Následující příklady představují rychlou ukázku některých základních částí LINQ. To není nijak komplexní, protože LINQ poskytuje více funkcí, než je zde prezentováno.

Chléb a máslo - Where, Selecta Aggregate

// Filtering a list.
var germanShepherds = dogs.Where(dog => dog.Breed == DogBreed.GermanShepherd);

// Using the query syntax.
var queryGermanShepherds = from dog in dogs
                          where dog.Breed == DogBreed.GermanShepherd
                          select dog;

// Mapping a list from type A to type B.
var cats = dogs.Select(dog => dog.TurnIntoACat());

// Using the query syntax.
var queryCats = from dog in dogs
                select dog.TurnIntoACat();

// Summing the lengths of a set of strings.
int seed = 0;
int sumOfStrings = strings.Aggregate(seed, (s1, s2) => s1.Length + s2.Length);

Zploštění seznamu seznamů

// Transforms the list of kennels into a list of all their dogs.
var allDogsFromKennels = kennels.SelectMany(kennel => kennel.Dogs);

Sjednocení mezi dvěma sadami (s vlastním komparátorem)

public class DogHairLengthComparer : IEqualityComparer<Dog>
{
    public bool Equals(Dog a, Dog b)
    {
        if (a == null && b == null)
        {
            return true;
        }
        else if ((a == null && b != null) ||
                 (a != null && b == null))
        {
            return false;
        }
        else
        {
            return a.HairLengthType == b.HairLengthType;
        }
    }

    public int GetHashCode(Dog d)
    {
        // Default hashcode is enough here, as these are simple objects.
        return d.GetHashCode();
    }
}
...

// Gets all the short-haired dogs between two different kennels.
var allShortHairedDogs = kennel1.Dogs.Union(kennel2.Dogs, new DogHairLengthComparer());

Průnik mezi dvěma sadami

// Gets the volunteers who spend share time with two humane societies.
var volunteers = humaneSociety1.Volunteers.Intersect(humaneSociety2.Volunteers,
                                                     new VolunteerTimeComparer());

Řazení

// Get driving directions, ordering by if it's toll-free before estimated driving time.
var results = DirectionsProcessor.GetDirections(start, end)
              .OrderBy(direction => direction.HasNoTolls)
              .ThenBy(direction => direction.EstimatedTime);

Rovnost vlastností instance

A konečně pokročilejší ukázka: určení, jestli jsou hodnoty vlastností dvou instancí stejného typu stejné (Vypůjčené a změněné z tohoto příspěvku StackOverflow):

public static bool PublicInstancePropertiesEqual<T>(this T self, T to, params string[] ignore) where T : class
{
    if (self == null || to == null)
    {
        return self == to;
    }

    // Selects the properties which have unequal values into a sequence of those properties.
    var unequalProperties = from property in typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance)
                            where !ignore.Contains(property.Name)
                            let selfValue = property.GetValue(self, null)
                            let toValue = property.GetValue(to, null)
                            where !Equals(selfValue, toValue)
                            select property;
    return !unequalProperties.Any();
}

PLINQ

PLINQ nebo Parallel LINQ je modul paralelního spouštění pro výrazy LINQ. Jinými slovy, regulární výraz LINQ lze triviálně paralelizovat napříč libovolným počtem vláken. To se provádí voláním AsParallel() předcházejícího výrazu.

Zvažte použití těchto zdrojů:

public static string GetAllFacebookUserLikesMessage(IEnumerable<FacebookUser> facebookUsers)
{
    var seed = default(UInt64);

    Func<UInt64, UInt64, UInt64> threadAccumulator = (t1, t2) => t1 + t2;
    Func<UInt64, UInt64, UInt64> threadResultAccumulator = (t1, t2) => t1 + t2;
    Func<Uint64, string> resultSelector = total => $"Facebook has {total} likes!";

    return facebookUsers.AsParallel()
                        .Aggregate(seed, threadAccumulator, threadResultAccumulator, resultSelector);
}

Tento kód podle potřeby rozdělí oddíly facebookUsers napříč systémovými vlákny, sečte celkový součet lajků na každém vlákně paralelně, sčítá výsledky vypočítané jednotlivými vlákny a projektuje výsledek do pěkného řetězce.

Ve formuláři diagramu:

PLINQ diagram

Paralelizovatelné úlohy vázané na procesor, které lze snadno vyjádřit prostřednictvím LINQ (jinými slovy, jsou čisté funkce a nemají žádné vedlejší účinky) jsou skvělým kandidátem pro PLINQ. U úloh, které mají vedlejší účinek, zvažte použití paralelní knihovny úloh.

Další zdroje informací

  • 101 Ukázky LINQ
  • Linqpad, prostředí pro dětské hřiště a dotazovací modul databáze pro C#/F#/Visual Basic
  • EduLinq, elektronická kniha pro seznámení s implementací LINQ-to-objects