Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez aussi afficher la version anglaise dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte.
Traduction
Anglais
Cette documentation est archivée et n’est pas conservée.

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

Détermine si deux séquences sont égales par une comparaison des types d'élément réalisée à l'aide du comparateur d'égalité par défaut.

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

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

Paramètres de type

TSource

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

Paramètres

first
Type : System.Collections.Generic.IEnumerable<TSource>
IEnumerable<T> à comparer à second.
second
Type : System.Collections.Generic.IEnumerable<TSource>
IEnumerable<T> à comparer à la première sequence.

Valeur de retour

Type : System.Boolean
true si les deux séquences source sont de même longueur et si les types de leurs éléments correspondants sont égaux selon le comparateur d'égalité par défaut ; sinon, false.

Remarque sur l'utilisation

En Visual Basic et C#, vous pouvez appeler cette méthode comme une méthode d'instance sur n'importe quel objet de type IEnumerable<TSource>. Lorsque vous utilisez la syntaxe des méthodes d'instance pour appeler cette méthode, omettez le premier paramètre. Pour plus d'informations, consultez Méthodes d'extension (Visual Basic) ou Méthodes d'extension (Guide de programmation C#).

ExceptionCondition
ArgumentNullException

first ou second est null.

La méthode SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) énumère les deux séquences source en parallèle et compare les éléments correspondants à l'aide du comparateur d'égalité par défaut pour TSource, Default. 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.

L'exemple de code suivant montre comment utiliser SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) pour déterminer si deux séquences sont égales. Dans les deux premiers exemples, la méthode détermine si les séquences comparées contiennent des références aux mêmes objets. Dans les troisième et quatrièmes exemples, la méthode compare les données réelles des objets dans les séquences.

Dans cet exemple, les séquences sont égales.


            class Pet
            {
                public string Name { get; set; }
                public int Age { get; set; }
            }

            public static void SequenceEqualEx1()
            {
                Pet pet1 = new Pet { Name = "Turbo", Age = 2 };
                Pet pet2 = new Pet { Name = "Peanut", Age = 8 };

                // Create two lists of pets.
                List<Pet> pets1 = new List<Pet> { pet1, pet2 };
                List<Pet> pets2 = new List<Pet> { pet1, pet2 };

                bool equal = pets1.SequenceEqual(pets2);

                Console.WriteLine(
                    "The lists {0} equal.",
                    equal ? "are" : "are not");
            }

            /*
             This code produces the following output:

             The lists are equal.
            */



L'exemple de code suivant compare deux séquences non égales. Notez que les séquences contiennent des données identiques, mais étant donné que les objets qu'ils contiennent ont des références différentes, les séquences ne sont pas considérées comme égales.


            class Pet
            {
                public string Name { get; set; }
                public int Age { get; set; }
            }

            public static void SequenceEqualEx2()
            {
                Pet pet1 = new Pet() { Name = "Turbo", Age = 2 };
                Pet pet2 = new Pet() { Name = "Peanut", Age = 8 };

                // Create two lists of pets.
                List<Pet> pets1 = new List<Pet> { pet1, pet2 };
                List<Pet> pets2 =
                    new List<Pet> { new Pet { Name = "Turbo", Age = 2 }, 
                                    new Pet { Name = "Peanut", Age = 8 } };

                bool equal = pets1.SequenceEqual(pets2);

                Console.WriteLine("The lists {0} equal.", equal ? "are" : "are not");
            }

            /*
             This code produces the following output:

             The lists are not equal.
            */



Si vous souhaitez comparer les données réelles des objets dans les séquences au lieu de comparer juste leurs références, vous devez implémenter l'interface générique IEqualityComparer<T> dans votre classe. L'exemple de code suivant montre comment implémenter cette interface dans un type de données personnalisé et fournir des méthodes GetHashCode et Equals.


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

    public bool Equals(Product 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 des séquences d'objets Product dans la méthode SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>), comme indiqué dans l'exemple suivant.



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

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

        bool equalAB = storeA.SequenceEqual(storeB);

        Console.WriteLine("Equal? " + equalAB);

        /*
            This code produces the following output:

            Equal? True
        */



.NET Framework

Pris en charge dans : 4, 3.5

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Pris en charge dans :

Windows 7, Windows Vista SP1 ou ultérieur, Windows XP SP3, Windows Server 2008 (installation minimale non prise en charge), Windows Server 2008 R2 (installation minimale prise en charge avec SP1 ou version ultérieure), Windows Server 2003 SP2

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.
Afficher: