ReadOnlyCollection<T> Clase

Definición

Proporciona la clase base para una colección genérica de sólo lectura.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)

Parámetros de tipo

T

Tipo de los elementos de la colección.The type of elements in the collection.

Herencia
ReadOnlyCollection<T>
Derivado
Atributos
Implementaciones

Ejemplos

En el ejemplo de código siguiente se muestran varios ReadOnlyCollection<T> miembros de la clase.The following code example demonstrates several members of the ReadOnlyCollection<T> class. En el ejemplo de código List<T> se crea un de cadenas y se le agregan cuatro nombres de dinosaurio.The code example creates a List<T> of strings and adds four dinosaur names to it. A continuación, el ejemplo de código encapsula la lista ReadOnlyCollection<T>en un.The code example then wraps the list in a ReadOnlyCollection<T>.

CountDespués de mostrar los miembros, Contains, Item[Int32]y IList.IndexOf , el ejemplo de código muestra que ReadOnlyCollection<T> List<T> es simplemente un contenedor para el original List<T> agregando un nuevo elemento a y Mostrar el contenido de 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>.

Por último, en el ejemplo de código se crea una matriz mayor que la CopyTo colección y se usa el método para insertar los elementos de la colección en el medio de la matriz.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"
'""

Comentarios

Una instancia de la ReadOnlyCollection<T> clase genérica siempre es de solo lectura.An instance of the ReadOnlyCollection<T> generic class is always read-only. Una colección de solo lectura es simplemente una colección con un contenedor que impide modificar la colección; por consiguiente, si se realizan cambios en la colección subyacente, la colección de solo lectura refleja esos cambios.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. Vea Collection<T> para obtener una versión modificable de esta clase.See Collection<T> for a modifiable version of this class.

Notas a los desarrolladores de herederos

Esta clase base se proporciona para facilitar a los implementadores la creación de una colección personalizada genérica de solo lectura.This base class is provided to make it easier for implementers to create a generic read-only custom collection. Se recomienda a los implementadores que amplíen esta clase base en lugar de crear las suyas propias.Implementers are encouraged to extend this base class instead of creating their own.

Constructores

ReadOnlyCollection<T>(IList<T>)

Inicializa una nueva instancia de la clase ReadOnlyCollection<T> que es un contenedor de solo lectura para la lista especificada.Initializes a new instance of the ReadOnlyCollection<T> class that is a read-only wrapper around the specified list.

Propiedades

Count

Obtiene el número de elementos incluidos en la instancia de ReadOnlyCollection<T>.Gets the number of elements contained in the ReadOnlyCollection<T> instance.

Item[Int32]

Obtiene el elemento en el índice especificado.Gets the element at the specified index.

Items

Devuelve la interfaz IList<T> incluida en la colección ReadOnlyCollection<T>.Returns the IList<T> that the ReadOnlyCollection<T> wraps.

Métodos

Contains(T)

Determina si un elemento se encuentra en ReadOnlyCollection<T>.Determines whether an element is in the ReadOnlyCollection<T>.

CopyTo(T[], Int32)

Copia la totalidad de ReadOnlyCollection<T> en una matriz Array unidimensional compatible, comenzando en el índice especificado de la matriz de destino.Copies the entire ReadOnlyCollection<T> to a compatible one-dimensional Array, starting at the specified index of the target array.

Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Heredado de Object)
GetEnumerator()

Devuelve un enumerador que recorre en iteración la colección ReadOnlyCollection<T>.Returns an enumerator that iterates through the ReadOnlyCollection<T>.

GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Heredado de Object)
GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
IndexOf(T)

Busca el objeto especificado y devuelve el índice de base cero de la primera aparición en todo el objeto ReadOnlyCollection<T>.Searches for the specified object and returns the zero-based index of the first occurrence within the entire ReadOnlyCollection<T>.

MemberwiseClone()

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
ToString()

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Heredado de Object)

Implementaciones de interfaz explícitas

ICollection.CopyTo(Array, Int32)

Copia los elementos de ICollection en Array, empezando por un índice determinado de Array.Copies the elements of the ICollection to an Array, starting at a particular Array index.

ICollection.IsSynchronized

Obtiene un valor que indica si el acceso a la interfaz ICollection está sincronizado (es seguro para subprocesos).Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

Obtiene un objeto que se puede usar para sincronizar el acceso a ICollection.Gets an object that can be used to synchronize access to the ICollection.

ICollection<T>.Add(T)

Agrega un elemento a ICollection<T>.Adds an item to the ICollection<T>. Esta implementación siempre produce una excepción NotSupportedException.This implementation always throws NotSupportedException.

ICollection<T>.Clear()

Quita todos los elementos de ICollection<T>.Removes all items from the ICollection<T>. Esta implementación siempre produce una excepción NotSupportedException.This implementation always throws NotSupportedException.

ICollection<T>.IsReadOnly

Obtiene un valor que indica si ICollection<T> es de solo lectura.Gets a value indicating whether the ICollection<T> is read-only.

ICollection<T>.Remove(T)

Quita la primera aparición de un objeto específico de la interfaz ICollection<T>.Removes the first occurrence of a specific object from the ICollection<T>. Esta implementación siempre produce una excepción NotSupportedException.This implementation always throws NotSupportedException.

IEnumerable.GetEnumerator()

Devuelve un enumerador que recorre en iteración una colección.Returns an enumerator that iterates through a collection.

IList.Add(Object)

Agrega un elemento a IList.Adds an item to the IList. Esta implementación siempre produce una excepción NotSupportedException.This implementation always throws NotSupportedException.

IList.Clear()

Quita todos los elementos de IList.Removes all items from the IList. Esta implementación siempre produce una excepción NotSupportedException.This implementation always throws NotSupportedException.

IList.Contains(Object)

Determina si IList contiene un valor específico.Determines whether the IList contains a specific value.

IList.IndexOf(Object)

Determina el índice de un elemento específico de IList.Determines the index of a specific item in the IList.

IList.Insert(Int32, Object)

Inserta un elemento en la interfaz IList, en el índice especificado.Inserts an item to the IList at the specified index. Esta implementación siempre produce una excepción NotSupportedException.This implementation always throws NotSupportedException.

IList.IsFixedSize

Obtiene un valor que indica si la interfaz IList tiene un tamaño fijo.Gets a value indicating whether the IList has a fixed size.

IList.IsReadOnly

Obtiene un valor que indica si IList es de solo lectura.Gets a value indicating whether the IList is read-only.

IList.Item[Int32]

Obtiene el elemento en el índice especificado.Gets the element at the specified index. Se produce NotSupportedException si se intenta establecer el elemento en el índice especificado.A NotSupportedException occurs if you try to set the item at the specified index.

IList.Remove(Object)

Quita la primera aparición de un objeto específico de la interfaz IList.Removes the first occurrence of a specific object from the IList. Esta implementación siempre produce una excepción NotSupportedException.This implementation always throws NotSupportedException.

IList.RemoveAt(Int32)

Quita el elemento de la interfaz IList que se encuentra en el índice especificado.Removes the IList item at the specified index. Esta implementación siempre produce una excepción NotSupportedException.This implementation always throws NotSupportedException.

IList<T>.Insert(Int32, T)

Inserta un elemento en la interfaz IList<T>, en el índice especificado.Inserts an item to the IList<T> at the specified index. Esta implementación siempre produce una excepción NotSupportedException.This implementation always throws NotSupportedException.

IList<T>.Item[Int32]

Obtiene el elemento en el índice especificado.Gets the element at the specified index. Se produce NotSupportedException si se intenta establecer el elemento en el índice especificado.An NotSupportedException occurs if you try to set the item at the specified index.

IList<T>.RemoveAt(Int32)

Quita el elemento de la interfaz IList<T> que se encuentra en el índice especificado.Removes the IList<T> item at the specified index. Esta implementación siempre produce una excepción NotSupportedException.This implementation always throws NotSupportedException.

Métodos de extensión

CopyToDataTable<T>(IEnumerable<T>)

Devuelve un objeto DataTable que contiene copias de los objetos DataRow, dado un objeto IEnumerable<T> de entrada donde el parámetro T genérico es 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)

Copia objetos DataRow en el objeto DataTable especificado, dado un objeto IEnumerable<T> de entrada donde el parámetro T genérico es 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)

Copia objetos DataRow en el objeto DataTable especificado, dado un objeto IEnumerable<T> de entrada donde el parámetro T genérico es DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Convierte los elementos de IEnumerable en el tipo especificado.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtra los elementos de IEnumerable en función de un tipo especificado.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Habilita la paralelización de una consulta.Enables parallelization of a query.

AsQueryable(IEnumerable)

Convierte una interfaz IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Devuelve una colección de elementos que contiene los antecesores de todos los nodos de la colección de origen.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

Devuelve una colección de elementos filtrada que contiene los antecesores de todos los nodos de la colección de origen.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. En la colección sólo se incluyen los elementos que tienen un objeto XName coincidente.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Devuelve una colección de los nodos descendientes de todos los documentos y elementos de la colección de origen.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Devuelve una colección de elementos que contiene los elementos descendientes de todos los elementos y documentos de la colección de origen.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

Devuelve una colección filtrada de elementos que contiene los elementos descendientes de todos los elementos y documentos de la colección de origen.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. En la colección sólo se incluyen los elementos que tienen un objeto XName coincidente.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Devuelve una colección de los elementos secundarios de todos los elementos y documentos de la colección de origen.Returns a collection of the child elements of every element and document in the source collection.

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

Devuelve una colección filtrada de los elementos secundarios de todos los elementos y documentos de la colección de origen.Returns a filtered collection of the child elements of every element and document in the source collection. En la colección sólo se incluyen los elementos que tienen un objeto XName coincidente.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Devuelve una colección de nodos que contiene todos los nodos de la colección de origen, clasificados por documento.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Devuelve una colección de los nodos secundarios de todos los documentos y elementos de la colección de origen.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Quita todos los nodos de la colección de origen de su nodo primario.Removes every node in the source collection from its parent node.

Se aplica a

Seguridad para subprocesos

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para subprocesos.Public static (Shared in Visual Basic) members of this type are thread safe. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.Any instance members are not guaranteed to be thread safe.

Un ReadOnlyCollection<T> puede admitir varios lectores simultáneamente, siempre y cuando no se modifique la colección.A ReadOnlyCollection<T> can support multiple readers concurrently, as long as the collection is not modified. Aun así, la enumeración a través de una colección no es intrínsecamente un procedimiento seguro para subprocesos.Even so, enumerating through a collection is intrinsically not a thread-safe procedure. A fin de garantizar la seguridad de los subprocesos, se puede bloquear la colección durante toda la enumeración.To guarantee thread safety during enumeration, you can lock the collection during the entire enumeration. Para permitir que varios subprocesos obtengan acceso de lectura y escritura a la colección, debe implementar su propia sincronización.To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

Consulte también: