Nastavení operací (C#)

Operace sady v LINQ odkazují na operace dotazu, které vytvářejí sadu výsledků na základě přítomnosti nebo nepřítomnosti ekvivalentních prvků ve stejné nebo samostatné kolekci.

Názvy metod	Popis	Syntaxe výrazu dotazu jazyka C#	Více informací
Distinct nebo DistinctBy	Odebere duplicitní hodnoty z kolekce.	Nevztahuje se.	Enumerable.Distinct Enumerable.DistinctBy Queryable.Distinct Queryable.DistinctBy
Except nebo ExceptBy	Vrátí set rozdíl, což znamená prvky jedné kolekce, které se nezobrazují v druhé kolekci.	Nevztahuje se.	Enumerable.Except Enumerable.ExceptBy Queryable.Except Queryable.ExceptBy
Intersect nebo IntersectBy	Vrátí průnik množiny, což znamená prvky, které se zobrazují v každé ze dvou kolekcí.	Nevztahuje se.	Enumerable.Intersect Enumerable.IntersectBy Queryable.Intersect Queryable.IntersectBy
Union nebo UnionBy	Vrátí sjednocení množiny, což znamená jedinečné prvky, které se zobrazují v některé ze dvou kolekcí.	Nevztahuje se.	Enumerable.Union Enumerable.UnionBy Queryable.Union Queryable.UnionBy

Distinct a DistinctBy

Následující příklad znázorňuje chování Enumerable.Distinct metody v posloupnosti řetězců. Vrácená sekvence obsahuje jedinečné prvky ze vstupní sekvence.

string[] words = ["the", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog"];

IEnumerable<string> query = from word in words.Distinct()
                            select word;

foreach (var str in query)
{
    Console.WriteLine(str);
}

/* This code produces the following output:
 *
 * the
 * quick
 * brown
 * fox
 * jumped
 * over
 * lazy
 * dog
 */

Jedná se DistinctBy o alternativní přístup, Distinct který bere keySelector. Používá keySelector se jako srovnávací diskriminátor typu zdroje. V následujícím kódu jsou slova diskriminována na základě jejich Lengtha první slovo každé délky se zobrazí:

string[] words = ["the", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog"];

foreach (string word in words.DistinctBy(p => p.Length))
{
    Console.WriteLine(word);
}

// This code produces the following output:
//     the
//     quick
//     jumped
//     over

Except a ExceptBy

Následující příklad znázorňuje chování Enumerable.Except. Vrácená sekvence obsahuje pouze prvky z první vstupní sekvence, které nejsou ve druhé vstupní sekvenci.

Následující příklady v tomto článku používají běžné zdroje dat pro tuto oblast:

public enum GradeLevel
{
    FirstYear = 1,
    SecondYear,
    ThirdYear,
    FourthYear
};

public class Student
{
    public required string FirstName { get; init; }
    public required string LastName { get; init; }
    public required int ID { get; init; }

    public required GradeLevel Year { get; init; }
    public required List<int> Scores { get; init; }

    public required int DepartmentID { get; init; }
}

public class Teacher
{
    public required string First { get; init; }
    public required string Last { get; init; }
    public required int ID { get; init; }
    public required string City { get; init; }
}
public class Department
{
    public required string Name { get; init; }
    public int ID { get; init; }

    public required int TeacherID { get; init; }
}

Každý z nich Student má úroveň známek, primární oddělení a řadu výsledků. A Teacher má City také vlastnost, která identifikuje areál, kde učitel má předměty. A Department má jméno a odkaz na Teacher toho, kdo slouží jako vedoucí oddělení.

string[] words1 = ["the", "quick", "brown", "fox"];
string[] words2 = ["jumped", "over", "the", "lazy", "dog"];

IEnumerable<string> query = from word in words1.Except(words2)
                            select word;

foreach (var str in query)
{
    Console.WriteLine(str);
}

/* This code produces the following output:
 *
 * quick
 * brown
 * fox
 */

Metoda ExceptBy je alternativní přístupExcept, který přebírá dvě sekvence pravděpodobně heterogenních typů a .keySelector Jedná se keySelector o stejný typ jako typ první kolekce. Zvažte vyloučení následujících Teacher ID polí a učitelů. Pokud chcete najít učitele v první kolekci, která není ve druhé kolekci, můžete id učitele promítnout do druhé kolekce:

int[] teachersToExclude =
[
    901,    // English
    965,    // Mathematics
    932,    // Engineering
    945,    // Economics
    987,    // Physics
    901     // Chemistry
];

foreach (Teacher teacher in
    teachers.ExceptBy(
        teachersToExclude, teacher => teacher.ID))
{
    Console.WriteLine($"{teacher.First} {teacher.Last}");
}

V předchozím kódu jazyka C#:

• Pole teachers se filtruje jenom na učitele, kteří nejsou v teachersToExclude poli.
• Pole teachersToExclude obsahuje ID hodnotu pro všechny vedoucí oddělení.
• Výsledkem volání je ExceptBy nová sada hodnot, které jsou zapsány do konzoly.

Nová sada hodnot je typu Teacher, což je typ první kolekce. Každý teacher v teachers poli, který nemá odpovídající hodnotu ID v teachersToExclude poli, se zapíše do konzoly.

Intersect a IntersectBy

Následující příklad znázorňuje chování Enumerable.Intersect. Vrácená sekvence obsahuje prvky, které jsou společné pro obě vstupní sekvence.

string[] words1 = ["the", "quick", "brown", "fox"];
string[] words2 = ["jumped", "over", "the", "lazy", "dog"];

IEnumerable<string> query = from word in words1.Intersect(words2)
                            select word;

foreach (var str in query)
{
    Console.WriteLine(str);
}

/* This code produces the following output:
 *
 * the
 */

Metoda IntersectBy je alternativní přístupIntersect, který přebírá dvě sekvence pravděpodobně heterogenních typů a .keySelector Používá keySelector se jako srovnávací diskriminátor typu druhé kolekce. Zvažte následující pole studentů a učitelů. Dotaz odpovídá položkám v jednotlivých sekvencích podle jména, aby našli ty studenty, kteří nejsou také učiteli:

foreach (Student person in
    students.IntersectBy(
        teachers.Select(t => (t.First, t.Last)), s => (s.FirstName, s.LastName)))
{
    Console.WriteLine($"{person.FirstName} {person.LastName}");
}

V předchozím kódu jazyka C#:

• Dotaz vytvoří průsečík a TeacherStudent porovnává názvy.
• Ve výsledné sekvenci se nacházejí pouze lidé, které jsou nalezeny v obou polích.
• Student Výsledné instance se zapisují do konzoly.

Union a UnionBy

Následující příklad znázorňuje sjednocovací operaci na dvou sekvencích řetězců. Vrácená sekvence obsahuje jedinečné prvky z obou vstupních sekvencí.

string[] words1 = ["the", "quick", "brown", "fox"];
string[] words2 = ["jumped", "over", "the", "lazy", "dog"];

IEnumerable<string> query = from word in words1.Union(words2)
                            select word;

foreach (var str in query)
{
    Console.WriteLine(str);
}

/* This code produces the following output:
 *
 * the
 * quick
 * brown
 * fox
 * jumped
 * over
 * lazy
 * dog
*/

Metoda UnionBy je alternativní přístup k Union tomu, že přebírá dvě sekvence stejného typu a .keySelector Používá keySelector se jako srovnávací diskriminátor typu zdroje. Následující dotaz vytvoří seznam všechlidích Studenti, kteří jsou také učitelé, se přidají do sjednocovací sady pouze jednou:

foreach (var person in
    students.Select(s => (s.FirstName, s.LastName)).UnionBy(
        teachers.Select(t => (FirstName: t.First, LastName: t.Last)), s => (s.FirstName, s.LastName)))
{
    Console.WriteLine($"{person.FirstName} {person.LastName}");
}

V předchozím kódu jazyka C#:

• Pole teachers a students pole jsou sváděna pomocí jejich názvů jako selektor klíčů.
• Výsledné názvy se zapisují do konzoly.

Viz také

• System.Linq
• Jak najít nastavený rozdíl mezi dvěma seznamy (LINQ) (C#)