Enumerable.Distinct Méthode

Définition

Espace de noms:

System.Linq

Assembly:

System.Linq.dll

Retourne des éléments distincts d'une séquence.

Surcharges

Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Retourne des éléments distincts d'une séquence et utilise le IEqualityComparer<T> spécifié pour comparer les valeurs.
Distinct<TSource>(IEnumerable<TSource>)	Retourne des éléments distincts d'une séquence et utilise le comparateur d'égalité par défaut pour comparer les valeurs.

Remarques

La séquence de résultats n’est pas triée.

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

Source:

Distinct.cs

Retourne des éléments distincts d'une séquence et utilise le IEqualityComparer<T> spécifié pour comparer les valeurs.

C#

public static System.Collections.Generic.IEnumerable<TSource> Distinct<TSource> (this System.Collections.Generic.IEnumerable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource>? comparer);

Paramètres de type

TSource

Le type des éléments de source.

Paramètres

source

IEnumerable<TSource>

Séquence de laquelle supprimer les éléments en double.

comparer

IEqualityComparer<TSource>

IEqualityComparer<T> pour comparer les valeurs.

Retours

IEnumerable<TSource>

IEnumerable<T> qui contient des éléments distincts de la séquence source.

Exceptions

ArgumentNullException

source a la valeur null.

Exemples

L’exemple suivant montre comment implémenter un comparateur d’égalité qui peut être utilisé dans la Distinct 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 une séquence d’objets Product dans la Distinct méthode, comme illustré dans l’exemple suivant :

C#

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

// Exclude duplicates.

IEnumerable<Product> noduplicates =
    products.Distinct(new ProductComparer());

foreach (var product in noduplicates)
    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é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.

La Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) méthode retourne une séquence non triée qui ne contient aucune valeur en double. Si comparer est null, le comparateur d’égalité par défaut, Default, est utilisé pour comparer des valeurs.

Distinct<TSource>(IEnumerable<TSource>)

Source:

Distinct.cs

Retourne des éléments distincts d'une séquence et utilise le comparateur d'égalité par défaut pour comparer les valeurs.

C#

public static System.Collections.Generic.IEnumerable<TSource> Distinct<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);

Paramètres de type

TSource

Le type des éléments de source.

Paramètres

source

IEnumerable<TSource>

Séquence de laquelle supprimer les éléments en double.

Retours

IEnumerable<TSource>

IEnumerable<T> qui contient des éléments distincts de la séquence source.

Exceptions

ArgumentNullException

source a la valeur null.

Exemples

L’exemple de code suivant montre comment utiliser Distinct<TSource>(IEnumerable<TSource>) pour retourner des éléments distincts à partir d’une séquence d’entiers.

C#

List<int> ages = new List<int> { 21, 46, 46, 55, 17, 21, 55, 55 };

IEnumerable<int> distinctAges = ages.Distinct();

Console.WriteLine("Distinct ages:");

foreach (int age in distinctAges)
{
    Console.WriteLine(age);
}

/*
 This code produces the following output:

 Distinct ages:
 21
 46
 55
 17
*/

Si vous souhaitez retourner des éléments distincts à partir de séquences d’objets d’un type de données personnalisé, vous devez implémenter l’interface IEquatable<T> générique dans la classe . L’exemple de code suivant montre comment implémenter cette interface dans un type de données personnalisé et fournir des GetHashCode méthodes et Equals .

C#

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

    public bool Equals(MyProduct other)
    {
        //Check whether the compared object is null.
        if (Object.ReferenceEquals(other, null)) return false;

        //Check whether the compared object references the same data.
        if (Object.ReferenceEquals(this, other)) return true;

        //Check whether the products' properties are equal.
        return Code.Equals(other.Code) && Name.Equals(other.Name);
    }

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

    public override int GetHashCode()
    {

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

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

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

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

C#

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

// Exclude duplicates.

IEnumerable<MyProduct> noduplicates =
    products.Distinct();

foreach (var product in noduplicates)
    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é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.

La Distinct<TSource>(IEnumerable<TSource>) méthode retourne une séquence non triée qui ne contient aucune valeur en double. Il utilise le comparateur d’égalité par défaut, Default, pour comparer les valeurs.

Dans la syntaxe d’expression de requête Visual Basic, une Distinct clause se traduit par un appel de Distinct.

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

Pour obtenir un exemple qui utilise IEqualityComparer<T> pour définir un comparateur personnalisé, consultez Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>).

Voir aussi

• Distinct, clause (Visual Basic)