Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Enumerable.Except<TSource> méthode (IEnumerable<TSource>, IEnumerable<TSource>)

 

Date de publication : novembre 2016

Produit la différence définie entre deux séquences à l’aide du comparateur d’égalité par défaut pour comparer les valeurs.

Espace de noms:   System.Linq
Assembly:  System.Core (dans System.Core.dll)

public static IEnumerable<TSource> Except<TSource>(
	this IEnumerable<TSource> first,
	IEnumerable<TSource> second
)

Paramètres

first
Type: System.Collections.Generic.IEnumerable<TSource>

Une IEnumerable<T> dont les éléments qui ne se trouvent pas également dans second sera retourné.

second
Type: System.Collections.Generic.IEnumerable<TSource>

Une IEnumerable<T> dont les éléments qui figurent également dans la première séquence provoque ces éléments à supprimer de la séquence retournée.

Valeur de retour

Type: System.Collections.Generic.IEnumerable<TSource>

Séquence qui contient la différence entre les éléments de deux séquences.

Paramètres de type

TSource

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

Exception Condition
ArgumentNullException

first ou second a la valeur null.

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

La différence entre deux jeux est défini en tant que membres du premier jeu qui n’apparaissent pas dans le deuxième jeu.

System_CAPS_noteRemarque

Cette méthode retourne les éléments de first qui n’apparaissent pas dans second. Elle ne retourne pas les éléments de second qui n’apparaissent pas dans first.

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

L’exemple de code suivant montre comment utiliser le Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) méthode pour comparer deux séquences de nombres et de retourner les éléments qui apparaissent uniquement dans la première séquence.

double[] numbers1 = { 2.0, 2.0, 2.1, 2.2, 2.3, 2.3, 2.4, 2.5 };
double[] numbers2 = { 2.2 };

IEnumerable<double> onlyInFirstSet = numbers1.Except(numbers2);

foreach (double number in onlyInFirstSet)
    Console.WriteLine(number);

/*
 This code produces the following output:

 2
 2.1
 2.3
 2.4
 2.5
*/

Si vous souhaitez comparer des séquences d’objets d’un type de données personnalisé, vous devez implémenter le IEqualityComparer<T> interface générique dans un helperclass. L’exemple de code suivant montre comment implémenter cette interface dans un type de données personnalisé et fournir GetHashCode et Equals méthodes.

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

public class ProductComparer : IEqualityComparer<ProductA>
{

    public bool Equals(ProductA x, ProductA y)
    {
        //Check whether the objects are the same object. 
        if (Object.ReferenceEquals(x, y)) return true;

        //Check whether the products' properties are equal. 
        return x != null && y != null && x.Code.Equals(y.Code) && x.Name.Equals(y.Name);
    }

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

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

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

Après avoir implémenté cette interface, vous pouvez utiliser des séquences de ProductA des objets dans le Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) méthode, comme indiqué dans l’exemple suivant.

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

ProductA[] fruits2 = { new ProductA { Name = "apple", Code = 9 } };

//Get all the elements from the first array
//except for the elements from the second array.

IEnumerable<ProductA> except =
    fruits1.Except(fruits2);

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

/*
  This code produces the following output:

  orange 4
  lemon 12
*/

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 3.5
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1
Retour au début
Afficher: