Bewerkingen instellen (C#)

Setbewerkingen in LINQ verwijzen naar querybewerkingen die een resultatenset produceren op basis van de aanwezigheid of afwezigheid van equivalente elementen in dezelfde of afzonderlijke verzamelingen.

Distinct en DistinctBy

In het volgende voorbeeld ziet u het gedrag van de Enumerable.Distinct methode op een reeks tekenreeksen. De geretourneerde reeks bevat de unieke elementen uit de invoerreeks.

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
 */

Het DistinctBy is een alternatieve benadering voor Distinct, waarbij een keySelector betrokken is. De keySelector wordt gebruikt als de vergelijkende discriminator van het brontype. In de volgende code worden woorden gediscrimineerd op basis van hun Length, en het eerste woord van elke lengte wordt weergegeven:

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 en ExceptBy

In het volgende voorbeeld ziet u het gedrag van Enumerable.Except. De geretourneerde reeks bevat alleen de elementen uit de eerste invoerreeks die zich niet in de tweede invoerreeks bevinden.

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

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
 */

De ExceptBy-methode is een alternatieve benadering voor Except die twee reeksen van mogelijk heterogene typen en een keySelector vereist. Het keySelector is hetzelfde type als het type van de eerste verzameling. Houd rekening met de volgende Teacher array en docent-ID's die moeten worden uitgesloten. Als u docenten in de eerste verzameling wilt zoeken die zich niet in de tweede verzameling bevinden, kunt u de id van de docent projecteren op de tweede verzameling:

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

In de voorgaande C#-code:

• De teachers array wordt gefilterd om alleen die docenten uit te sluiten die zich niet in de teachersToExclude array bevinden.
• De teachersToExclude matrix bevat de ID waarde voor alle afdelingshoofden.
• De aanroep van ExceptBy resulteert in een nieuwe set waarden die naar de console worden geschreven.

De nieuwe set waarden is van het type Teacher, het type van de eerste verzameling. Elk teacher in de teachers matrix die geen overeenkomende id-waarde in de teachersToExclude matrix heeft, wordt naar de console geschreven.

Intersect en IntersectBy

In het volgende voorbeeld ziet u het gedrag van Enumerable.Intersect. De geretourneerde reeks bevat de elementen die gebruikelijk zijn voor beide invoerreeksen.

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
 */

De IntersectBy-methode is een alternatieve benadering voor Intersect die twee reeksen van mogelijk heterogene typen en een keySelector vereist. De keySelector wordt gebruikt als de vergelijkende discriminator van het type van de tweede verzameling. Houd rekening met de volgende matrices voor leerlingen/studenten en docenten. De query stemt items in elke reeks af op naam om die studenten te vinden die ook docenten zijn.

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

In de voorgaande C#-code:

• De query produceert het snijpunt van de Teacher en Student door namen te vergelijken.
• Alleen personen die in beide matrices voorkomen, zijn aanwezig in de resulterende volgorde.
• De resulterende Student exemplaren worden naar de console geschreven.

Union en UnionBy

In het volgende voorbeeld ziet u een unie-bewerking op twee tekenreeksen. De geretourneerde reeks bevat de unieke elementen van beide invoerreeksen.

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
*/

De UnionBy methode is een alternatieve benadering bij Union die twee reeksen van hetzelfde type en een keySelector neemt. De keySelector wordt gebruikt als de vergelijkende discriminator van het brontype. De volgende query produceert de lijst met alle personen die leerlingen/studenten of docenten zijn. Studenten die ook als docenten werken, worden slechts één keer aan de verenigingsverzameling toegevoegd.

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

In de voorgaande C#-code:

• De teachers en students matrices worden geweven met behulp van hun namen als de sleutelkiezer.
• De resulterende namen worden naar de console geschreven.

Zie ook

• System.Linq
• Het ingestelde verschil tussen twee lijsten (LINQ) (C#) vinden