Enumerable.Union Méthode

Définition

Espace de noms:

System.Linq

Assembly:

System.Linq.dll

Produit l’union définie de deux séquences.

Surcharges

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Produit l’union définie de deux séquences à l’aide du comparateur d’égalité par défaut.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Produit l’union définie de deux séquences à l’aide d’une IEqualityComparer<T>spécifiée.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Source:

Union.cs

Produit l’union définie de deux séquences à l’aide du comparateur d’égalité par défaut.

C#

public static System.Collections.Generic.IEnumerable<TSource> Union<TSource> (this System.Collections.Generic.IEnumerable<TSource> first, System.Collections.Generic.IEnumerable<TSource> second);

Paramètres de type

TSource

Type des éléments des séquences d’entrée.

Paramètres

first

IEnumerable<TSource>

Un IEnumerable<T> dont les éléments distincts forment le premier jeu pour l’union.

second

IEnumerable<TSource>

Un IEnumerable<T> dont les éléments distincts forment le deuxième jeu pour l’union.

Retours

IEnumerable<TSource>

Un IEnumerable<T> qui contient les éléments des deux séquences d’entrée, à l’exclusion des doublons.

Exceptions

ArgumentNullException

first ou second est null.

Exemples

L’exemple de code suivant montre comment utiliser Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) pour obtenir l’union de deux séquences d’entiers.

C#

int[] ints1 = { 5, 3, 9, 7, 5, 9, 3, 7 };
int[] ints2 = { 8, 3, 6, 4, 4, 9, 1, 0 };

IEnumerable<int> union = ints1.Union(ints2);

foreach (int num in union)
{
    Console.Write("{0} ", num);
}

/*
 This code produces the following output:

 5 3 9 7 8 6 4 1 0
*/

Si vous souhaitez comparer des séquences d’objets d’un type de données personnalisé, vous devez implémenter l’interface générique IEquatable<T> dans une classe d’assistance. L’exemple de code suivant montre comment implémenter cette interface dans un type de données personnalisé et remplacer les méthodes GetHashCode et Equals.

C#

public class ProductA : IEquatable<ProductA>
{
    public string Name { get; set; }
    public int Code { get; set; }

    public bool Equals(ProductA other)
    {
        if (other is null)
            return false;

        return this.Name == other.Name && this.Code == other.Code;
    }

    public override bool Equals(object obj) => Equals(obj as ProductA);
    public override int GetHashCode() => (Name, Code).GetHashCode();
}

Après avoir implémenté cette interface, vous pouvez utiliser des séquences d’objets ProductA dans la méthode Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>), comme illustré dans l’exemple suivant :

C#

ProductA[] store1 = { new ProductA { Name = "apple", Code = 9 },
                       new ProductA { Name = "orange", Code = 4 } };

ProductA[] store2 = { new ProductA { Name = "apple", Code = 9 },
                       new ProductA { Name = "lemon", Code = 12 } };

C#

//Get the products from the both arrays
//excluding duplicates.

IEnumerable<ProductA> union =
  store1.Union(store2);

foreach (var product in union)
    Console.WriteLine(product.Name + " " + product.Code);

/*
    This code produces the following output:

    apple 9
    orange 4
    lemon 12
*/

Remarques

Cette méthode est implémentée à l’aide de l’exécution différée. La valeur de retour immédiate est un objet qui stocke toutes les informations requises pour effectuer l’action. La requête représentée par cette méthode n’est pas exécutée tant que l’objet n’est pas énuméré en appelant directement sa méthode GetEnumerator ou en utilisant foreach en C# ou For Each en Visual Basic.

Cette méthode exclut les doublons du jeu de retour. Il s’agit d’un comportement différent de la méthode Concat, qui retourne tous les éléments dans les séquences d’entrée, y compris les doublons.

Le comparateur d’égalité par défaut, Default, est utilisé pour comparer les valeurs des types qui implémentent l’interface générique IEqualityComparer<T>. Pour comparer un type de données personnalisé, vous devez implémenter cette interface et fournir vos propres méthodes GetHashCode et Equals pour le type.

Lorsque l’objet retourné par cette méthode est énuméré, Union énumère first et second dans cet ordre et génère chaque élément qui n’a pas déjà été généré.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Source:

Union.cs

Produit l’union définie de deux séquences à l’aide d’une IEqualityComparer<T>spécifiée.

C#

public static System.Collections.Generic.IEnumerable<TSource> Union<TSource> (this System.Collections.Generic.IEnumerable<TSource> first, System.Collections.Generic.IEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer);

Paramètres de type

TSource

Type des éléments des séquences d’entrée.

Paramètres

first

IEnumerable<TSource>

Un IEnumerable<T> dont les éléments distincts forment le premier jeu pour l’union.

second

IEnumerable<TSource>

Un IEnumerable<T> dont les éléments distincts forment le deuxième jeu pour l’union.

comparer

IEqualityComparer<TSource>

La IEqualityComparer<T> à comparer les valeurs.

Retours

IEnumerable<TSource>

Un IEnumerable<T> qui contient les éléments des deux séquences d’entrée, à l’exclusion des doublons.

Exceptions

ArgumentNullException

first ou second est null.

Exemples

L’exemple suivant montre comment implémenter un comparateur d’égalité qui peut être utilisé dans la méthode Union.

C#

public class Product
{
    public string Name { get; set; }
    public int Code { get; set; }
}

// Custom comparer for the Product class
class ProductComparer : IEqualityComparer<Product>
{
    // Products are equal if their names and product numbers are equal.
    public bool Equals(Product x, Product y)
    {

        //Check whether the compared objects reference the same data.
        if (Object.ReferenceEquals(x, y)) return true;

        //Check whether any of the compared objects is null.
        if (Object.ReferenceEquals(x, null) || Object.ReferenceEquals(y, null))
            return false;

        //Check whether the products' properties are equal.
        return x.Code == y.Code && x.Name == y.Name;
    }

    // If Equals() returns true for a pair of objects
    // then GetHashCode() must return the same value for these objects.

    public int GetHashCode(Product product)
    {
        //Check whether the object is null
        if (Object.ReferenceEquals(product, null)) return 0;

        //Get hash code for the Name field if it is not null.
        int hashProductName = product.Name == null ? 0 : product.Name.GetHashCode();

        //Get hash code for the Code field.
        int hashProductCode = product.Code.GetHashCode();

        //Calculate the hash code for the product.
        return hashProductName ^ hashProductCode;
    }
}

Après avoir implémenté ce comparateur, vous pouvez utiliser des séquences d’objets Product dans la méthode Union, comme illustré dans l’exemple suivant :

C#

Product[] store10 = { new Product { Name = "apple", Code = 9 },
                       new Product { Name = "orange", Code = 4 } };

Product[] store20 = { new Product { Name = "apple", Code = 9 },
                       new Product { Name = "lemon", Code = 12 } };

//Get the products from the both arrays
//excluding duplicates.

IEnumerable<Product> union =
  store10.Union(store20, new ProductComparer());

foreach (Product product in union)
    Console.WriteLine(product.Name + " " + product.Code);

/*
    This code produces the following output:

    apple 9
    orange 4
    lemon 12
*/

Remarques

Cette méthode est implémentée à l’aide de l’exécution différée. La valeur de retour immédiate est un objet qui stocke toutes les informations requises pour effectuer l’action. La requête représentée par cette méthode n’est pas exécutée tant que l’objet n’est pas énuméré en appelant directement sa méthode GetEnumerator ou en utilisant foreach en C# ou For Each en Visual Basic.

Si comparer est null, le comparateur d’égalité par défaut, Default, est utilisé pour comparer les valeurs.

Lorsque l’objet retourné par cette méthode est énuméré, Union énumère first et second dans cet ordre et génère chaque élément qui n’a pas déjà été généré.

La méthode Concat diffère de la méthode Union, car la méthode Concat retourne tous les éléments des séquences d’entrée, y compris les doublons, tandis que Union retourne uniquement des valeurs uniques.

Voir aussi

• méthode UnionBy