SortedSet<T> Classe

Définition

Représente une collection d’objets tenue à jour en ordre trié.Represents a collection of objects that is maintained in sorted order.

generic <typename T>
public ref class SortedSet : System::Collections::Generic::ICollection<T>, System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IReadOnlyCollection<T>, System::Collections::Generic::ISet<T>, System::Collections::ICollection, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable
[System.Serializable]
public class SortedSet<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.ISet<T>, System.Collections.ICollection, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
type SortedSet<'T> = class
    interface ISet<'T>
    interface ICollection<'T>
    interface ICollection
    interface ISerializable
    interface IDeserializationCallback
    interface IReadOnlyCollection<'T>
    interface seq<'T>
    interface IEnumerable
Public Class SortedSet(Of T)
Implements ICollection, ICollection(Of T), IDeserializationCallback, IEnumerable(Of T), IReadOnlyCollection(Of T), ISerializable, ISet(Of T)

Paramètres de type

T

Type d'éléments de l'ensemble.The type of elements in the set.

Héritage
SortedSet<T>
Attributs
Implémente

Exemples

L’exemple suivant illustre une classe SortedSet<T> qui est créée avec le constructeur qui prend un IComparer<T> comme paramètre.The following example demonstrates a SortedSet<T> class that is created with the constructor that takes an IComparer<T> as a parameter. Ce comparateur (ByFileExtension) est utilisé pour trier une liste de noms de fichiers en fonction de leurs extensions.This comparer (ByFileExtension) is used to sort a list of file names by their extensions.

Cet exemple montre comment créer un ensemble trié de noms de fichiers multimédias, supprimer des éléments indésirables, afficher une plage d’éléments et comparer l’ensemble avec un autre ensemble trié.This example demonstrates how to create a sorted set of media file names, remove unwanted elements, view a range of elements, and compare the set with another sorted set.

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        try
        {
            // Get a list of the files to use for the sorted set.
            IEnumerable<string> files1 =
                Directory.EnumerateFiles(@"\\archives\2007\media",
                "*", SearchOption.AllDirectories);

            // Create a sorted set using the ByFileExtension comparer.
            var mediaFiles1 = new SortedSet<string>(new ByFileExtension());

            // Note that there is a SortedSet constructor that takes an IEnumerable,
            // but to remove the path information they must be added individually.
            foreach (string f in files1)
            {
                mediaFiles1.Add(f.Substring(f.LastIndexOf(@"\") + 1));
            }

            // Remove elements that have non-media extensions.
            // See the 'IsDoc' method.
            Console.WriteLine("Remove docs from the set...");
            Console.WriteLine($"\tCount before: {mediaFiles1.Count}");
            mediaFiles1.RemoveWhere(IsDoc);
            Console.WriteLine($"\tCount after: {mediaFiles1.Count}");


            Console.WriteLine();

            // List all the avi files.
            SortedSet<string> aviFiles = mediaFiles1.GetViewBetween("avi", "avj");

            Console.WriteLine("AVI files:");
            foreach (string avi in aviFiles)
            {
                Console.WriteLine($"\t{avi}");
            }

            Console.WriteLine();

            // Create another sorted set.
            IEnumerable<string> files2 =
                Directory.EnumerateFiles(@"\\archives\2008\media",
                    "*", SearchOption.AllDirectories);

            var mediaFiles2 = new SortedSet<string>(new ByFileExtension());

            foreach (string f in files2)
            {
                mediaFiles2.Add(f.Substring(f.LastIndexOf(@"\") + 1));
            }

            // Remove elements in mediaFiles1 that are also in mediaFiles2.
            Console.WriteLine("Remove duplicates (of mediaFiles2) from the set...");
            Console.WriteLine($"\tCount before: {mediaFiles1.Count}");
            mediaFiles1.ExceptWith(mediaFiles2);
            Console.WriteLine($"\tCount after: {mediaFiles1.Count}");

            Console.WriteLine();

            Console.WriteLine("List of mediaFiles1:");
            foreach (string f in mediaFiles1)
            {
                Console.WriteLine($"\t{f}");
            }

            // Create a set of the sets.
            IEqualityComparer<SortedSet<string>> comparer =
                SortedSet<string>.CreateSetComparer();

            var allMedia = new HashSet<SortedSet<string>>(comparer);
            allMedia.Add(mediaFiles1);
            allMedia.Add(mediaFiles2);
        }
        catch(IOException ioEx)
        {
            Console.WriteLine(ioEx.Message);
        }

        catch (UnauthorizedAccessException AuthEx)
        {
            Console.WriteLine(AuthEx.Message);

        }
    }

    // Defines a predicate delegate to use
    // for the SortedSet.RemoveWhere method.
    private static bool IsDoc(string s)
    {
        s = s.ToLower();
        return (s.EndsWith(".txt") ||
            s.EndsWith(".xls") ||
            s.EndsWith(".xlsx") ||
            s.EndsWith(".pdf") ||
            s.EndsWith(".doc") ||
            s.EndsWith(".docx"));
    }


}

// Defines a comparer to create a sorted set
// that is sorted by the file extensions.
public class ByFileExtension : IComparer<string>
{
    string xExt, yExt;

    CaseInsensitiveComparer caseiComp = new CaseInsensitiveComparer();

    public int Compare(string x, string y)
    {
        // Parse the extension from the file name. 
        xExt = x.Substring(x.LastIndexOf(".") + 1);
        yExt = y.Substring(y.LastIndexOf(".") + 1);

        // Compare the file extensions. 
        int vExt = caseiComp.Compare(xExt, yExt);
        if (vExt != 0)
        {
            return vExt;
        }
        else
        {
            // The extension is the same, 
            // so compare the filenames. 
            return caseiComp.Compare(x, y);
        }
    }
}
Imports System.Collections
Imports System.Collections.Generic
Imports System.IO

Module Module1

    Sub Main()
        Try
            ' Get a list of the files to use for the sorted set.
            Dim files1 As IEnumerable = _
                Directory.EnumerateFiles("\\archives\2007\media", "*", _
                                                          SearchOption.AllDirectories)
            ' Create a sorted set using the ByFileExtension comparer.
            Dim mediaFiles1 As New SortedSet(Of String)(New ByFileExtension)
        
            ' Note that there is a SortedSet constructor that takes an IEnumerable,
            ' but to remove the path information they must be added individually.
            For Each f As String In files1
                mediaFiles1.Add(f.Substring((f.LastIndexOf("\") + 1)))
            Next
            
            ' Remove elements that have non-media extensions. See the 'IsDoc' method.
            Console.WriteLine("Remove docs from the set...")
            Console.WriteLine($"{vbTab}Count before: {mediaFiles1.Count}")
            mediaFiles1.RemoveWhere(AddressOf IsDoc)
            Console.WriteLine($"{vbTab}Count after: {mediaFiles1.Count}")
        
            Console.WriteLine()
            
            ' List all the avi files.
            Dim aviFiles As SortedSet(Of String) = mediaFiles1.GetViewBetween("avi", "avj")
            Console.WriteLine("AVI files:")
            For Each avi As String In aviFiles
                Console.WriteLine($"{vbTab}{avi}")
            Next

            Console.WriteLine()

            ' Create another sorted set.
            Dim files2 As IEnumerable = _
                Directory.EnumerateFiles("\\archives\2008\media", "*", _
                                      SearchOption.AllDirectories)
            Dim mediaFiles2 As New SortedSet(Of String)(New ByFileExtension)
            For Each f As String In files2
                mediaFiles2.Add(f.Substring((f.LastIndexOf("\") + 1)))
            Next
            
            ' Remove elements in mediaFiles1 that are also in mediaFiles2.
            Console.WriteLine("Remove duplicates (of mediaFiles2) from the set...")
            Console.WriteLine($"{vbTab}Count before: {mediaFiles1.Count}")
            mediaFiles1.ExceptWith(mediaFiles2)
            Console.WriteLine($"{vbTab}Count after: {mediaFiles1.Count}")

            Console.WriteLine()

            Console.WriteLine("List of mediaFiles1:")
            For Each f As String In mediaFiles1
                Console.WriteLine($"{vbTab}{f}")
            Next
            
            ' Create a set of the sets.
            Dim comparer As IEqualityComparer(Of SortedSet(Of String)) = _
                SortedSet(Of String).CreateSetComparer()
            Dim allMedia As New HashSet(Of SortedSet(Of String))(comparer)
            allMedia.Add(mediaFiles1)
            allMedia.Add(mediaFiles2)

        Catch ioEx As IOException
            Console.WriteLine(ioEx.Message)
        Catch AuthEx As UnauthorizedAccessException
            Console.WriteLine(AuthEx.Message)
        End Try


    End Sub

    ' Defines a predicate delegate to use
    ' for the SortedSet.RemoveWhere method.
    Private Function IsDoc(s As String) As Boolean
        s = s.ToLower()
        Return s.EndsWith(".txt") OrElse 
                s.EndsWith(".doc") OrElse 
                s.EndsWith(".xls") OrElse
                s.EndsWith(".xlsx") OrElse
                s.EndsWith(".pdf") OrElse
                s.EndsWith(".doc") OrElse
                s.EndsWith(".docx")
    End Function
    
    ' Defines a comparer to create a sorted set
    ' that is sorted by the file extensions.
    Public Class ByFileExtension
        Implements IComparer(Of String)
        Dim xExt, yExt As String

        Dim caseiComp As CaseInsensitiveComparer = _
                            New CaseInsensitiveComparer
        Public Function Compare(x As String, y As String) _
            As Integer Implements IComparer(Of String).Compare
            ' Parse the extension from the file name.
            xExt = x.Substring(x.LastIndexOf(".") + 1)
            yExt = y.Substring(y.LastIndexOf(".") + 1)

            ' Compare the file extensions.
            Dim vExt As Integer = caseiComp.Compare(xExt, yExt)
            If vExt <> 0 Then
                Return vExt
            Else
                ' The extension is the same, 
                ' so compare the filenames. 
                Return caseiComp.Compare(x, y)
            End If
        End Function        
        
    End Class
End Module

Remarques

Un objet SortedSet<T> gère un ordre trié sans affecter les performances, car les éléments sont insérés et supprimés.A SortedSet<T> object maintains a sorted order without affecting performance as elements are inserted and deleted. Les éléments en double ne sont pas autorisés.Duplicate elements are not allowed. La modification des valeurs de tri des éléments existants n’est pas prise en charge et peut entraîner un comportement inattendu.Changing the sort values of existing items is not supported and may lead to unexpected behavior.

Pour une alternative thread safe à SortedSet<T>, consultez ImmutableSortedSet<T>For a thread safe alternative to SortedSet<T>, see ImmutableSortedSet<T>

Constructeurs

SortedSet<T>()

Initialise une nouvelle instance de la classe SortedSet<T>.Initializes a new instance of the SortedSet<T> class.

SortedSet<T>(IComparer<T>)

Initialise une nouvelle instance de la classe SortedSet<T> qui utilise un comparateur spécifié.Initializes a new instance of the SortedSet<T> class that uses a specified comparer.

SortedSet<T>(IEnumerable<T>)

Initialise une nouvelle instance de la classe SortedSet<T> qui contient des éléments copiés d'une collection énumérable spécifiée.Initializes a new instance of the SortedSet<T> class that contains elements copied from a specified enumerable collection.

SortedSet<T>(IEnumerable<T>, IComparer<T>)

Initialise une nouvelle instance de la classe SortedSet<T> qui contient des éléments copiés d'une collection énumérable spécifiée et qui utilise un comparateur spécifié.Initializes a new instance of the SortedSet<T> class that contains elements copied from a specified enumerable collection and that uses a specified comparer.

SortedSet<T>(SerializationInfo, StreamingContext)

Initialise une nouvelle instance de la classe SortedSet<T> qui contient des données sérialisées.Initializes a new instance of the SortedSet<T> class that contains serialized data.

Propriétés

Comparer

Obtient l’objet IComparer<T> qui est utilisé pour ordonner les valeurs du SortedSet<T>.Gets the IComparer<T> object that is used to order the values in the SortedSet<T>.

Count

Obtient le nombre d’éléments dans SortedSet<T>.Gets the number of elements in the SortedSet<T>.

Max

Obtient la valeur maximale de SortedSet<T>, tel que défini par le comparateur.Gets the maximum value in the SortedSet<T>, as defined by the comparer.

Min

Obtient la valeur minimale de SortedSet<T>, tel que défini par le comparateur.Gets the minimum value in the SortedSet<T>, as defined by the comparer.

Méthodes

Add(T)

Ajoute un élément à l'ensemble et retourne une valeur qui indique si l'ajout a réussi.Adds an element to the set and returns a value that indicates if it was successfully added.

Clear()

Supprime tous les éléments de l'ensemble.Removes all elements from the set.

Contains(T)

Détermine si l'ensemble contient un élément spécifique.Determines whether the set contains a specific element.

CopyTo(T[])

Copie l'ensemble du SortedSet<T> dans un tableau unidimensionnel compatible, en commençant au début du tableau cible.Copies the complete SortedSet<T> to a compatible one-dimensional array, starting at the beginning of the target array.

CopyTo(T[], Int32)

Copie l'ensemble du SortedSet<T> dans un tableau unidimensionnel compatible, en commençant au niveau de l'index spécifié du tableau.Copies the complete SortedSet<T> to a compatible one-dimensional array, starting at the specified array index.

CopyTo(T[], Int32, Int32)

Copie un nombre d'éléments spécifié à partir de SortedSet<T> dans un tableau unidimensionnel compatible en commençant au niveau de l'index spécifié du tableau.Copies a specified number of elements from SortedSet<T> to a compatible one-dimensional array, starting at the specified array index.

CreateSetComparer()

Retourne un objet IEqualityComparer qui peut être utilisé pour créer une collection qui contient des jeux individuels.Returns an IEqualityComparer object that can be used to create a collection that contains individual sets.

CreateSetComparer(IEqualityComparer<T>)

Retourne un objet IEqualityComparer, d'après un comparateur spécifié, qui peut être utilisé pour créer une collection qui contient des ensembles individuels.Returns an IEqualityComparer object, according to a specified comparer, that can be used to create a collection that contains individual sets.

Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
ExceptWith(IEnumerable<T>)

Supprime tous les éléments figurant dans la collection spécifiée de l'objet SortedSet<T> actuel.Removes all elements that are in a specified collection from the current SortedSet<T> object.

GetEnumerator()

Retourne un énumérateur qui itère au sein de SortedSet<T>.Returns an enumerator that iterates through the SortedSet<T>.

GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetObjectData(SerializationInfo, StreamingContext)

Implémente l'interface ISerializable et retourne les données requises pour sérialiser un objet SortedSet<T>.Implements the ISerializable interface and returns the data that you must have to serialize a SortedSet<T> object.

GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
GetViewBetween(T, T)

Retourne une vue d'un sous-ensemble dans un SortedSet<T>.Returns a view of a subset in a SortedSet<T>.

IntersectWith(IEnumerable<T>)

Modifie l'objet SortedSet<T> actuel afin qu'il contienne uniquement les éléments qui figurent également dans une collection spécifiée.Modifies the current SortedSet<T> object so that it contains only elements that are also in a specified collection.

IsProperSubsetOf(IEnumerable<T>)

Détermine si un objet SortedSet<T> est un sous-ensemble propre à la collection spécifiée.Determines whether a SortedSet<T> object is a proper subset of the specified collection.

IsProperSupersetOf(IEnumerable<T>)

Détermine si un objet SortedSet<T> est un sur-ensemble propre à la collection spécifiée.Determines whether a SortedSet<T> object is a proper superset of the specified collection.

IsSubsetOf(IEnumerable<T>)

Détermine si un objet SortedSet<T> est un sous-ensemble de la collection spécifiée.Determines whether a SortedSet<T> object is a subset of the specified collection.

IsSupersetOf(IEnumerable<T>)

Détermine si un objet SortedSet<T> est un sur-ensemble de la collection spécifiée.Determines whether a SortedSet<T> object is a superset of the specified collection.

MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
OnDeserialization(Object)

Implémente l'interface ISerializable et déclenche l'événement de désérialisation une fois que la désérialisation est terminée.Implements the ISerializable interface, and raises the deserialization event when the deserialization is completed.

Overlaps(IEnumerable<T>)

Détermine si l'objet SortedSet<T> actuel et une collection spécifiée partagent des éléments communs.Determines whether the current SortedSet<T> object and a specified collection share common elements.

Remove(T)

Supprime un élément spécifié de SortedSet<T>.Removes a specified item from the SortedSet<T>.

RemoveWhere(Predicate<T>)

Supprime tous les éléments qui correspondent aux conditions définies par le prédicat spécifié de la collection SortedSet<T>.Removes all elements that match the conditions defined by the specified predicate from a SortedSet<T>.

Reverse()

Retourne un IEnumerable<T> qui itère dans l'ordre inverse au sein de SortedSet<T>.Returns an IEnumerable<T> that iterates over the SortedSet<T> in reverse order.

SetEquals(IEnumerable<T>)

Détermine si l'objet SortedSet<T>actif et la collection spécifiée contiennent les mêmes éléments.Determines whether the current SortedSet<T> object and the specified collection contain the same elements.

SymmetricExceptWith(IEnumerable<T>)

Modifie l'objet SortedSet<T> actuel afin qu'il contienne uniquement les éléments présents dans l'objet actuel ou dans la collection spécifiée, mais pas dans les deux à la fois.Modifies the current SortedSet<T> object so that it contains only elements that are present either in the current object or in the specified collection, but not both.

ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Hérité de Object)
TryGetValue(T, T)

Recherche dans l’ensemble une valeur donnée et retourne la valeur égale qu’il trouve, le cas échéant.Searches the set for a given value and returns the equal value it finds, if any.

UnionWith(IEnumerable<T>)

Modifie l'objet SortedSet<T> actuel afin qu'il contienne tous les éléments présents dans l'objet actif ou dans la collection spécifiée.Modifies the current SortedSet<T> object so that it contains all elements that are present in either the current object or the specified collection.

Implémentations d’interfaces explicites

ICollection.CopyTo(Array, Int32)

Copie l'ensemble du SortedSet<T> dans un tableau unidimensionnel compatible, en commençant au niveau de l'index spécifié du tableau.Copies the complete SortedSet<T> to a compatible one-dimensional array, starting at the specified array index.

ICollection.IsSynchronized

Obtient une valeur qui indique si l'accès à ICollection est synchronisé (thread safe).Gets a value that indicates whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

Obtient un objet qui peut être utilisé pour synchroniser l'accès à ICollection.Gets an object that can be used to synchronize access to the ICollection.

ICollection<T>.Add(T)

Ajoute un élément à un objet ICollection<T>.Adds an item to an ICollection<T> object.

ICollection<T>.IsReadOnly

Obtient une valeur qui indique si ICollection est en lecture seule.Gets a value that indicates whether a ICollection is read-only.

IDeserializationCallback.OnDeserialization(Object)

Implémente l'interface IDeserializationCallback et déclenche l'événement de désérialisation une fois que la désérialisation est terminée.Implements the IDeserializationCallback interface, and raises the deserialization event when the deserialization is completed.

IEnumerable.GetEnumerator()

Retourne un énumérateur qui itère au sein d’une collection.Returns an enumerator that iterates through a collection.

IEnumerable<T>.GetEnumerator()

Retourne un énumérateur qui itère au sein d’une collection.Returns an enumerator that iterates through a collection.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Implémente l'interface ISerializable et retourne les données requises pour sérialiser l'instance de SortedSet<T>.Implements the ISerializable interface, and returns the data that you need to serialize the SortedSet<T> instance.

Méthodes d’extension

CopyToDataTable<T>(IEnumerable<T>)

Retourne un DataTable qui contient des copies des objets DataRow, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Active la parallélisation d'une requête.Enables parallelization of a query.

AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Retourne une collection d'éléments qui contient les ancêtres de chaque nœud de la collection source.Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName)

Retourne une collection d'éléments filtrée qui contient les ancêtres de chaque nœud de la collection source.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Retourne une collection des nœuds descendants de chaque document et élément de la collection source.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Retourne une collection d'éléments qui contient les éléments descendants de tous les éléments et tous les documents de la collection source.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName)

Retourne une collection d'éléments filtrée qui contient les éléments descendants de tous les éléments et tous les documents de la collection source.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Retourne une collection des éléments enfants de chaque élément et document de la collection source.Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName)

Retourne une collection filtrée des éléments enfants de chaque élément et document de la collection source.Returns a filtered collection of the child elements of every element and document in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Retourne une collection de nœuds qui contient tous les nœuds de la collection source, triés selon l'ordre des documents.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Retourne une collection des nœuds enfants de chaque document et élément de la collection source.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Supprime chaque nœud de la collection source de son nœud parent.Removes every node in the source collection from its parent node.

S’applique à

Voir aussi