Enumerable.Intersect Méthode

Définition

Espace de noms:

System.Linq

Assembly:

System.Linq.dll

Produit l'intersection de deux séquences.

Surcharges

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Produit l'intersection de deux séquences à l'aide du comparateur d'égalité par défaut pour comparer les valeurs.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Produit l'intersection entre deux séquences à l'aide du IEqualityComparer<T> spécifié pour comparer les valeurs.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Source:

Intersect.cs

Produit l'intersection de deux séquences à l'aide du comparateur d'égalité par défaut pour comparer les valeurs.

C#

public static System.Collections.Generic.IEnumerable<TSource> Intersect<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>

IEnumerable<T> dont les éléments distincts qui apparaissent également dans second seront retournés.

second

IEnumerable<TSource>

IEnumerable<T> dont les éléments distincts qui apparaissent également dans la première séquence seront retournés.

Retours

IEnumerable<TSource>

Séquence qui contient les éléments constituant l'intersection de les deux séquences.

Exceptions

ArgumentNullException

first ou second est null.

Exemples

L’exemple de code suivant montre comment utiliser Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) pour retourner les éléments qui apparaissent dans chacune des deux séquences d’entiers.

C#

int[] id1 = { 44, 26, 92, 30, 71, 38 };
int[] id2 = { 39, 59, 83, 47, 26, 4, 30 };

IEnumerable<int> both = id1.Intersect(id2);

foreach (int id in both)
    Console.WriteLine(id);

/*
 This code produces the following output:

 26
 30
*/

Si vous souhaitez comparer des séquences d’objets d’un type de données personnalisé, vous devez implémenter l’interface IEquatable<T> générique 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 GetHashCode des méthodes 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 Intersect méthode, 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 first array
// that have duplicates in the second array.

IEnumerable<ProductA> duplicates =
    store1.Intersect(store2);

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

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

Remarques

Cette méthode est implémentée à l’aide d’une exécution différée. La valeur de retour immédiat est un objet qui stocke toutes les informations nécessaires à l’exécution de 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é soit en appelant directement sa GetEnumerator méthode, soit en utilisant foreach en C# ou For Each en Visual Basic.

L’intersection de deux ensembles A et B est définie comme l’ensemble qui contient tous les éléments de A qui apparaissent également dans B, mais aucun autre élément.

Lorsque l’objet retourné par cette méthode est énuméré, Intersect génère des éléments distincts se produisant dans les deux séquences dans l’ordre dans lequel ils apparaissent dans first.

Le comparateur d’égalité par défaut, Default, est utilisé pour comparer les valeurs des types. Pour comparer un type de données personnalisé, vous devez remplacer les Equals méthodes et GetHashCode et et implémenter éventuellement l’interface IEquatable<T> générique dans le type personnalisé. Pour plus d'informations, consultez la propriété Default.

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

Source:

Intersect.cs

Produit l'intersection entre deux séquences à l'aide du IEqualityComparer<T> spécifié pour comparer les valeurs.

C#

public static System.Collections.Generic.IEnumerable<TSource> Intersect<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>

IEnumerable<T> dont les éléments distincts qui apparaissent également dans second seront retournés.

second

IEnumerable<TSource>

IEnumerable<T> dont les éléments distincts qui apparaissent également dans la première séquence seront retournés.

comparer

IEqualityComparer<TSource>

IEqualityComparer<T> pour comparer les valeurs.

Retours

IEnumerable<TSource>

Séquence qui contient les éléments constituant l'intersection de les deux séquences.

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 Intersect méthode .

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 Intersect méthode, comme illustré dans l’exemple suivant :

C#

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

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

// Get the products from the first array
// that have duplicates in the second array.

IEnumerable<Product> duplicates =
    store1.Intersect(store2, new ProductComparer());

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

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

Remarques

Cette méthode est implémentée à l’aide d’une exécution différée. La valeur de retour immédiat est un objet qui stocke toutes les informations nécessaires à l’exécution de 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é soit en appelant directement sa GetEnumerator méthode, soit en utilisant foreach en C# ou For Each en Visual Basic.

L’intersection de deux ensembles A et B est définie comme l’ensemble qui contient tous les éléments de A qui apparaissent également dans B, mais aucun autre élément.

Lorsque l’objet retourné par cette méthode est énuméré, Intersect génère des éléments distincts se produisant dans les deux séquences dans l’ordre dans lequel ils apparaissent dans first.

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