ReadOnlyCollection<T> Klasa

Definicja

Dostarcza klasę bazową dla ogólnej kolekcji tylko do odczytu.Provides the base class for a generic read-only collection.

generic <typename T>
public ref class ReadOnlyCollection : System::Collections::Generic::ICollection<T>, System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IList<T>, System::Collections::Generic::IReadOnlyCollection<T>, System::Collections::Generic::IReadOnlyList<T>, System::Collections::IList
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class ReadOnlyCollection<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.IReadOnlyList<T>, System.Collections.IList
type ReadOnlyCollection<'T> = class
    interface IList<'T>
    interface IList
    interface IReadOnlyList<'T>
    interface ICollection<'T>
    interface seq<'T>
    interface IEnumerable
    interface ICollection
    interface IReadOnlyCollection<'T>
Public Class ReadOnlyCollection(Of T)
Implements ICollection(Of T), IEnumerable(Of T), IList, IList(Of T), IReadOnlyCollection(Of T), IReadOnlyList(Of T)

Parametry typu

T

Typ elementów w kolekcji.The type of elements in the collection.

Dziedziczenie
ReadOnlyCollection<T>
Pochodne
Atrybuty
Implementuje

Przykłady

Poniższy przykład kodu demonstruje kilka elementów członkowskich ReadOnlyCollection<T> klasy.The following code example demonstrates several members of the ReadOnlyCollection<T> class. Przykładowy kod tworzy List<T> ciągi i dodaje cztery nazwy dinozaurów.The code example creates a List<T> of strings and adds four dinosaur names to it. Przykład kodu otacza listę w ReadOnlyCollection<T>.The code example then wraps the list in a ReadOnlyCollection<T>.

Po Countdemonstrowaniu elementów, Contains, Item[Int32]i IList.IndexOf , przykład kodu pokazuje, że ReadOnlyCollection<T> List<T> jest tylko otoką dla oryginału List<T> przez dodanie nowego elementu do i Wyświetlanie zawartości ReadOnlyCollection<T>.After demonstrating the Count, Contains, Item[Int32], and IList.IndexOf members, the code example shows that the ReadOnlyCollection<T> is just a wrapper for the original List<T> by adding a new item to the List<T> and displaying the contents of the ReadOnlyCollection<T>.

Na koniec kod tworzy tablicę większą niż kolekcja i używa CopyTo metody, aby wstawić elementy kolekcji do środka tablicy.Finally, the code example creates an array larger than the collection and uses the CopyTo method to insert the elements of the collection into the middle of the array.

using namespace System;
using namespace System::Collections::Generic;
using namespace System::Collections::ObjectModel;

void main()
{
    List<String^>^ dinosaurs = gcnew List<String^>();

    dinosaurs->Add("Tyrannosaurus");
    dinosaurs->Add("Amargasaurus");
    dinosaurs->Add("Deinonychus");
    dinosaurs->Add("Compsognathus");

    ReadOnlyCollection<String^>^ readOnlyDinosaurs = 
        gcnew ReadOnlyCollection<String^>(dinosaurs);

    Console::WriteLine();
    for each(String^ dinosaur in readOnlyDinosaurs )
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nCount: {0}", readOnlyDinosaurs->Count);

    Console::WriteLine("\nContains(\"Deinonychus\"): {0}", 
        readOnlyDinosaurs->Contains("Deinonychus"));

    Console::WriteLine("\nreadOnlyDinosaurs[3]: {0}", 
        readOnlyDinosaurs[3]);

    Console::WriteLine("\nIndexOf(\"Compsognathus\"): {0}", 
        readOnlyDinosaurs->IndexOf("Compsognathus"));

    Console::WriteLine("\nInsert into the wrapped List:");
    Console::WriteLine("Insert(2, \"Oviraptor\")");
    dinosaurs->Insert(2, "Oviraptor");

    Console::WriteLine();
    for each( String^ dinosaur in readOnlyDinosaurs )
    {
        Console::WriteLine(dinosaur);
    }

    array<String^>^ dinoArray = 
        gcnew array<String^>(readOnlyDinosaurs->Count + 2);
    readOnlyDinosaurs->CopyTo(dinoArray, 1);

    Console::WriteLine("\nCopied array has {0} elements:", 
        dinoArray->Length);
    for each( String^ dinosaur in dinoArray )
    {
        Console::WriteLine("\"{0}\"", dinosaur);
    }
}

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Deinonychus
Compsognathus

Count: 4

Contains("Deinonychus"): True

readOnlyDinosaurs[3]: Compsognathus

IndexOf("Compsognathus"): 3

Insert into the wrapped List:
Insert(2, "Oviraptor")

Tyrannosaurus
Amargasaurus
Oviraptor
Deinonychus
Compsognathus

Copied array has 7 elements:
""
"Tyrannosaurus"
"Amargasaurus"
"Oviraptor"
"Deinonychus"
"Compsognathus"
""
 */
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();

        dinosaurs.Add("Tyrannosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Deinonychus");
        dinosaurs.Add("Compsognathus");

        ReadOnlyCollection<string> readOnlyDinosaurs = 
            new ReadOnlyCollection<string>(dinosaurs);

        Console.WriteLine();
        foreach( string dinosaur in readOnlyDinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nCount: {0}", readOnlyDinosaurs.Count);

        Console.WriteLine("\nContains(\"Deinonychus\"): {0}", 
            readOnlyDinosaurs.Contains("Deinonychus"));

        Console.WriteLine("\nreadOnlyDinosaurs[3]: {0}", 
            readOnlyDinosaurs[3]);

        Console.WriteLine("\nIndexOf(\"Compsognathus\"): {0}", 
            readOnlyDinosaurs.IndexOf("Compsognathus"));

        Console.WriteLine("\nInsert into the wrapped List:");
        Console.WriteLine("Insert(2, \"Oviraptor\")");
        dinosaurs.Insert(2, "Oviraptor");

        Console.WriteLine();
        foreach( string dinosaur in readOnlyDinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        string[] dinoArray = new string[readOnlyDinosaurs.Count + 2];
        readOnlyDinosaurs.CopyTo(dinoArray, 1);

        Console.WriteLine("\nCopied array has {0} elements:", 
            dinoArray.Length);
        foreach( string dinosaur in dinoArray )
        {
            Console.WriteLine("\"{0}\"", dinosaur);
        }
    }
}

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Deinonychus
Compsognathus

Count: 4

Contains("Deinonychus"): True

readOnlyDinosaurs[3]: Compsognathus

IndexOf("Compsognathus"): 3

Insert into the wrapped List:
Insert(2, "Oviraptor")

Tyrannosaurus
Amargasaurus
Oviraptor
Deinonychus
Compsognathus

Copied array has 7 elements:
""
"Tyrannosaurus"
"Amargasaurus"
"Oviraptor"
"Deinonychus"
"Compsognathus"
""
 */
Imports System.Collections.Generic
Imports System.Collections.ObjectModel

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs As New List(Of String)

        dinosaurs.Add("Tyrannosaurus")
        dinosaurs.Add("Amargasaurus")
        dinosaurs.Add("Deinonychus")
        dinosaurs.Add("Compsognathus")

        Dim readOnlyDinosaurs As _
            New ReadOnlyCollection(Of String)(dinosaurs)

        Console.WriteLine()
        For Each dinosaur As String In readOnlyDinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & "Count: {0}", _
            readOnlyDinosaurs.Count)

        Console.WriteLine(vbLf & "Contains(""Deinonychus""): {0}", _
            readOnlyDinosaurs.Contains("Deinonychus"))

        Console.WriteLine(vbLf & _
            "readOnlyDinosaurs(3): {0}", readOnlyDinosaurs(3))

        Console.WriteLine(vbLf & "IndexOf(""Compsognathus""): {0}", _
            readOnlyDinosaurs.IndexOf("Compsognathus"))

        Console.WriteLine(vbLf & "Insert into the wrapped List:")
        Console.WriteLine("Insert(2, ""Oviraptor"")")
        dinosaurs.Insert(2, "Oviraptor")

        Console.WriteLine()
        For Each dinosaur As String In readOnlyDinosaurs
            Console.WriteLine(dinosaur)
        Next

        Dim dinoArray(readOnlyDinosaurs.Count + 1) As String
        readOnlyDinosaurs.CopyTo(dinoArray, 1)

        Console.WriteLine(vbLf & "Copied array has {0} elements:", _
            dinoArray.Length)
        For Each dinosaur As String In dinoArray
            Console.WriteLine("""{0}""", dinosaur)
        Next

   End Sub
End Class

' This code example produces the following output:
'
'Tyrannosaurus
'Amargasaurus
'Deinonychus
'Compsognathus
'
'Count: 4
'
'Contains("Deinonychus"): True
'
'readOnlyDinosaurs(3): Compsognathus
'
'IndexOf("Compsognathus"): 3
'
'Insert into the wrapped List:
'Insert(2, "Oviraptor")
'
'Tyrannosaurus
'Amargasaurus
'Oviraptor
'Deinonychus
'Compsognathus
'
'Copied array has 7 elements:
'""
'"Tyrannosaurus"
'"Amargasaurus"
'"Oviraptor"
'"Deinonychus"
'"Compsognathus"
'""

Uwagi

Wystąpienie ReadOnlyCollection<T> klasy generycznej jest zawsze tylko do odczytu.An instance of the ReadOnlyCollection<T> generic class is always read-only. Kolekcja, która jest tylko do odczytu, jest po prostu zbiorem z otoką uniemożliwiającą zmianę kolekcji; w związku z tym, jeśli zmiany zostaną wprowadzone do podstawowej kolekcji, kolekcja tylko do odczytu uwzględni te zmiany.A collection that is read-only is simply a collection with a wrapper that prevents modifying the collection; therefore, if changes are made to the underlying collection, the read-only collection reflects those changes. Zobacz Collection<T> , aby uzyskać modyfikowalną wersję tej klasy.See Collection<T> for a modifiable version of this class.

Uwagi dotyczące dziedziczenia

Ta klasa bazowa jest udostępniana w celu ułatwienia implementowania tworzenia ogólnej kolekcji niestandardowej tylko do odczytu.This base class is provided to make it easier for implementers to create a generic read-only custom collection. Zachęcamy do przeciągnięcia tej klasy bazowej zamiast tworzenia własnych.Implementers are encouraged to extend this base class instead of creating their own.

Konstruktory

ReadOnlyCollection<T>(IList<T>)

Inicjuje nowe wystąpienie ReadOnlyCollection<T> klasy, która jest otoką tylko do odczytu otaczającą określoną listę.Initializes a new instance of the ReadOnlyCollection<T> class that is a read-only wrapper around the specified list.

Właściwości

Count

Pobiera liczbę elementów zawartych w ReadOnlyCollection<T> wystąpieniu.Gets the number of elements contained in the ReadOnlyCollection<T> instance.

Item[Int32]

Pobiera element wskazywany przez określony indeks.Gets the element at the specified index.

Items

IList<T> ZwracaReadOnlyCollection<T> przewinięcie.Returns the IList<T> that the ReadOnlyCollection<T> wraps.

Metody

Contains(T)

Określa, ReadOnlyCollection<T>czy element znajduje się w.Determines whether an element is in the ReadOnlyCollection<T>.

CopyTo(T[], Int32)

Kopiuje cały ReadOnlyCollection<T> do zgodnego jednowymiarowego Array, rozpoczynając od określonego indeksu tablicy docelowej.Copies the entire ReadOnlyCollection<T> to a compatible one-dimensional Array, starting at the specified index of the target array.

Equals(Object)

Określa, czy określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
GetEnumerator()

Zwraca moduł wyliczający, który wykonuje iterację przez ReadOnlyCollection<T>.Returns an enumerator that iterates through the ReadOnlyCollection<T>.

GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetType()

Type Pobiera bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
IndexOf(T)

Wyszukuje określony obiekt i zwraca indeks (liczony od zera) pierwszego wystąpienia w całości ReadOnlyCollection<T>.Searches for the specified object and returns the zero-based index of the first occurrence within the entire ReadOnlyCollection<T>.

MemberwiseClone()

Tworzy skróconą kopię bieżącego Objectelementu.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
ToString()

Zwraca ciąg, który reprezentuje bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)

Jawne implementacje interfejsu

ICollection.CopyTo(Array, Int32)

Kopiuje elementy ICollection Arraydo, zaczynając od określonego Array indeksu.Copies the elements of the ICollection to an Array, starting at a particular Array index.

ICollection.IsSynchronized

Pobiera wartość wskazującą, ICollection czy dostęp do elementu jest synchronizowany (bezpieczny wątkowo).Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

Pobiera obiekt, który może służyć do synchronizowania dostępu do ICollection.Gets an object that can be used to synchronize access to the ICollection.

ICollection<T>.Add(T)

Dodaje element do ICollection<T>elementu.Adds an item to the ICollection<T>. Ta implementacja zawsze zgłasza NotSupportedException.This implementation always throws NotSupportedException.

ICollection<T>.Clear()

Usuwa wszystkie elementy z ICollection<T>.Removes all items from the ICollection<T>. Ta implementacja zawsze zgłasza NotSupportedException.This implementation always throws NotSupportedException.

ICollection<T>.IsReadOnly

Pobiera wartość wskazującą, czy jest ICollection<T> tylko do odczytu.Gets a value indicating whether the ICollection<T> is read-only.

ICollection<T>.Remove(T)

Usuwa pierwsze wystąpienie określonego obiektu z ICollection<T>.Removes the first occurrence of a specific object from the ICollection<T>. Ta implementacja zawsze zgłasza NotSupportedException.This implementation always throws NotSupportedException.

IEnumerable.GetEnumerator()

Zwraca moduł wyliczający, który dokonuje iteracji w kolekcji.Returns an enumerator that iterates through a collection.

IList.Add(Object)

Dodaje element do IListelementu.Adds an item to the IList. Ta implementacja zawsze zgłasza NotSupportedException.This implementation always throws NotSupportedException.

IList.Clear()

Usuwa wszystkie elementy z IList.Removes all items from the IList. Ta implementacja zawsze zgłasza NotSupportedException.This implementation always throws NotSupportedException.

IList.Contains(Object)

Określa, IList czy zawiera konkretną wartość.Determines whether the IList contains a specific value.

IList.IndexOf(Object)

Określa indeks określonego elementu w IList.Determines the index of a specific item in the IList.

IList.Insert(Int32, Object)

Wstawia element do IList obiektu o określonym indeksie.Inserts an item to the IList at the specified index. Ta implementacja zawsze zgłasza NotSupportedException.This implementation always throws NotSupportedException.

IList.IsFixedSize

Pobiera wartość wskazującą, IList czy ma stały rozmiar.Gets a value indicating whether the IList has a fixed size.

IList.IsReadOnly

Pobiera wartość wskazującą, czy jest IList tylko do odczytu.Gets a value indicating whether the IList is read-only.

IList.Item[Int32]

Pobiera element wskazywany przez określony indeks.Gets the element at the specified index. Występuje NotSupportedException , gdy spróbujesz ustawić element pod określonym indeksem.A NotSupportedException occurs if you try to set the item at the specified index.

IList.Remove(Object)

Usuwa pierwsze wystąpienie określonego obiektu z IList.Removes the first occurrence of a specific object from the IList. Ta implementacja zawsze zgłasza NotSupportedException.This implementation always throws NotSupportedException.

IList.RemoveAt(Int32)

IList Usuwa element o określonym indeksie.Removes the IList item at the specified index. Ta implementacja zawsze zgłasza NotSupportedException.This implementation always throws NotSupportedException.

IList<T>.Insert(Int32, T)

Wstawia element do IList<T> obiektu o określonym indeksie.Inserts an item to the IList<T> at the specified index. Ta implementacja zawsze zgłasza NotSupportedException.This implementation always throws NotSupportedException.

IList<T>.Item[Int32]

Pobiera element wskazywany przez określony indeks.Gets the element at the specified index. Występuje NotSupportedException , gdy spróbujesz ustawić element pod określonym indeksem.An NotSupportedException occurs if you try to set the item at the specified index.

IList<T>.RemoveAt(Int32)

IList<T> Usuwa element o określonym indeksie.Removes the IList<T> item at the specified index. Ta implementacja zawsze zgłasza NotSupportedException.This implementation always throws NotSupportedException.

Metody rozszerzania

CopyToDataTable<T>(IEnumerable<T>)

DataRow T IEnumerable<T> Zwraca obiekt, DataRow który zawiera kopie obiektów, z uwzględnieniem obiektu wejściowego, w którym parametr generyczny jest. DataTableReturns 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)

Kopiuje DataRow obiekty do określonego DataTable, przy użyciu obiektu wejściowego IEnumerable<T> , w którym jest T DataRowparametr generyczny.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)

Kopiuje DataRow obiekty do określonego DataTable, przy użyciu obiektu wejściowego IEnumerable<T> , w którym jest T DataRowparametr generyczny.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Rzutuje elementy IEnumerable do określonego typu.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtruje elementy IEnumerable w oparciu o określony typ.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Włącza przetwarzanie równoległe zapytania.Enables parallelization of a query.

AsQueryable(IEnumerable)

IEnumerable KonwertujeIQueryabledo.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Zwraca kolekcję elementów, które zawierają elementy nadrzędne każdego węzła w kolekcji źródłowej.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

Zwraca przefiltrowany kolekcji elementów, które zawierają elementy nadrzędne każdego węzła w kolekcji źródłowej.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Zwraca kolekcję elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

Zwraca przefiltrowany kolekcji elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Zwraca kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej.Returns a collection of the child elements of every element and document in the source collection.

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

Zwraca filtrowaną kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej.Returns a filtered collection of the child elements of every element and document in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Zwraca kolekcję węzłów, która zawiera wszystkie węzły w kolekcji źródłowej, posortowane w kolejności dokumentu.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Usuwa każdy węzeł w kolekcji źródłowej z węzła nadrzędnego.Removes every node in the source collection from its parent node.

Dotyczy

Bezpieczeństwo wątkowe

Publiczne statyczne (Shared w Visual Basic) członkowie tego typu są bezpieczne wątkowo.Public static (Shared in Visual Basic) members of this type are thread safe. Wystąpienia elementów członkowskich nie dają gwarancji bezpieczeństwa wątków.Any instance members are not guaranteed to be thread safe.

ReadOnlyCollection<T> Może obsługiwać wielu czytników współbieżnie, o ile kolekcja nie jest modyfikowana.A ReadOnlyCollection<T> can support multiple readers concurrently, as long as the collection is not modified. Nawet w ten sposób Wyliczanie za pomocą kolekcji nie jest w sposób wewnętrzny bezpieczny dla wątków.Even so, enumerating through a collection is intrinsically not a thread-safe procedure. Aby zagwarantować bezpieczeństwo wątków podczas wyliczania, można zablokować kolekcję podczas całego procesu wyliczania.To guarantee thread safety during enumeration, you can lock the collection during the entire enumeration. Aby zezwolić wielu wątkom na dostęp do kolekcji w celu odczytu i zapisu danych, należy zaimplementować własny mechanizm synchronizacji.To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

Zobacz też