Exportar (0) Imprimir
Expandir todo

Clase genérica Collection

Proporciona la clase base para una colección genérica.

Espacio de nombres: System.Collections.ObjectModel
Ensamblado: mscorlib (en mscorlib.dll)

[SerializableAttribute] 
[ComVisibleAttribute(false)] 
public class Collection<T> : IList<T>, ICollection<T>, 
	IEnumerable<T>, IList, ICollection, IEnumerable
J# admite el uso de métodos y tipos genéricos, pero no admite la declaración de métodos y tipos nuevos.
JScript no admite el uso de métodos y tipos genéricos.
No aplicable.

Parámetros de tipo

T

Tipo de los elementos de la colección.

La clase Collection se puede utilizar de forma inmediata creando una instancia de uno de sus tipos construidos; todo lo que hay que hacer es especificar el tipo de objeto que va a contener la colección. Además, puede derivar su propio tipo de colección de cualquier tipo construido o derivar un tipo de colección genérico de la propia clase Collection.

La clase Collection proporciona métodos protegidos que se pueden utilizar para personalizar su comportamiento al agregar y quitar elementos, borrar la colección o establecer el valor de un elemento existente.

La mayor parte de los objetos Collection se pueden modificar. Sin embargo, un objeto Collection que se inicializa con un objeto IList de sólo lectura no se puede modificar. Vea ReadOnlyCollection para obtener una versión de sólo lectura de esta clase.

Se puede obtener acceso a los elementos de esta colección utilizando un índice de tipo entero. Los índices de esta colección están basados en cero.

Collection acepta referencia null (Nothing en Visual Basic) como valor válido para los tipos de referencia y admite elementos duplicados.

Notas para los implementadores: Esta clase base se proporciona para facilitar a los implementadores la creación de una colección personalizada. Se recomienda a los implementadores ampliar esta clase base en lugar de crear una clase propia.

Esta sección contiene dos ejemplos de código. En el primer ejemplo se muestra varias propiedades y métodos de la clase Collection. En el segundo, se muestra cómo derivar una clase de colección de un tipo construido de Collection, y cómo reemplazar los métodos protegidos de Collection para proporcionar un comportamiento personalizado.

Ejemplo 1

En el ejemplo de código siguiente se muestran muchos métodos y propiedades de Collection. En este ejemplo de código se crea una colección de cadenas, se utiliza el método Add para agregar varias cadenas, se muestra Count y se confecciona una lista de las cadenas. También se utiliza el método IndexOf para localizar el índice de una cadena y el método Contains para determinar si una cadena se encuentra en la colección. En el ejemplo se inserta una cadena mediante el método Insert y se recuperan y establecen cadenas mediante la propiedad Item predeterminada (el indizador en C#). Se quitan cadenas a partir de la identidad de cadena, utilizando el método Remove, y a partir del índice, utilizando el método RemoveAt. Por último, se usa el método Clear para borrar todas las cadenas de la colección.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;

public class Demo
{
    public static void Main()
    {
        Collection<string> dinosaurs = new Collection<string>();

        dinosaurs.Add("Psitticosaurus");
        dinosaurs.Add("Caudipteryx");
        dinosaurs.Add("Compsognathus");
        dinosaurs.Add("Muttaburrasaurus");

        Console.WriteLine("{0} dinosaurs:", dinosaurs.Count);
        Display(dinosaurs);
    
        Console.WriteLine("\nIndexOf(\"Muttaburrasaurus\"): {0}", 
            dinosaurs.IndexOf("Muttaburrasaurus"));

        Console.WriteLine("\nContains(\"Caudipteryx\"): {0}", 
            dinosaurs.Contains("Caudipteryx"));

        Console.WriteLine("\nInsert(2, \"Nanotyrannus\")");
        dinosaurs.Insert(2, "Nanotyrannus");
        Display(dinosaurs);

        Console.WriteLine("\ndinosaurs[2]: {0}", dinosaurs[2]);

        Console.WriteLine("\ndinosaurs[2] = \"Microraptor\"");
        dinosaurs[2] = "Microraptor";
        Display(dinosaurs);

        Console.WriteLine("\nRemove(\"Microraptor\")");
        dinosaurs.Remove("Microraptor");
        Display(dinosaurs);

        Console.WriteLine("\nRemoveAt(0)");
        dinosaurs.RemoveAt(0);
        Display(dinosaurs);

        Console.WriteLine("\ndinosaurs.Clear()");
        dinosaurs.Clear();
        Console.WriteLine("Count: {0}", dinosaurs.Count);
    }
    
    private static void Display(Collection<string> cs)
    {
        Console.WriteLine();
        foreach( string item in cs )
        {
            Console.WriteLine(item);
        }
    }
}

/* This code example produces the following output:

4 dinosaurs:

Psitticosaurus
Caudipteryx
Compsognathus
Muttaburrasaurus

IndexOf("Muttaburrasaurus"): 3

Contains("Caudipteryx"): True

Insert(2, "Nanotyrannus")

Psitticosaurus
Caudipteryx
Nanotyrannus
Compsognathus
Muttaburrasaurus

dinosaurs[2]: Nanotyrannus

dinosaurs[2] = "Microraptor"

Psitticosaurus
Caudipteryx
Microraptor
Compsognathus
Muttaburrasaurus

Remove("Microraptor")

Psitticosaurus
Caudipteryx
Compsognathus
Muttaburrasaurus

RemoveAt(0)

Caudipteryx
Compsognathus
Muttaburrasaurus

dinosaurs.Clear()
Count: 0
 */

Ejemplo 2

En el ejemplo de código siguiente se muestra cómo derivar una clase de colección a partir del tipo construido de la clase genérica Collection y cómo reemplazar los métodos protegidos InsertItem, RemoveItem, ClearItems y SetItem para proporcionar un comportamiento personalizado a los métodos Add, Insert, Remove y Clear y para establecer la propiedad Item.

El comportamiento personalizado que proporciona este ejemplo es un evento de notificación Changed que se provoca al final de cada uno de los métodos protegidos. La clase Dinosaurs hereda Collection<string> (Collection(Of String) en Visual Basic) y define el evento Changed, que utiliza una clase DinosaursChangedEventArgs para la información de evento y una enumeración para identificar el tipo de cambio.

En el ejemplo de código se llama a varias propiedades y métodos de Collection para mostrar el evento personalizado.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;

public class Dinosaurs : Collection<string>
{
    public event EventHandler<DinosaursChangedEventArgs> Changed;

    protected override void InsertItem(int index, string newItem)
    {
        base.InsertItem(index, newItem);

        EventHandler<DinosaursChangedEventArgs> temp = Changed;
        if (temp != null)
        {
            temp(this, new DinosaursChangedEventArgs(
                ChangeType.Added, newItem, null));
        }
    }

    protected override void SetItem(int index, string newItem)
    {
        string replaced = Items[index];
        base.SetItem(index, newItem);

        EventHandler<DinosaursChangedEventArgs> temp = Changed;
        if (temp != null)
        {
            temp(this, new DinosaursChangedEventArgs(
                ChangeType.Replaced, replaced, newItem));
        }
    }

    protected override void RemoveItem(int index)
    {
        string removedItem = Items[index];
        base.RemoveItem(index);

        EventHandler<DinosaursChangedEventArgs> temp = Changed;
        if (temp != null)
        {
            temp(this, new DinosaursChangedEventArgs(
                ChangeType.Removed, removedItem, null));
        }
    }

    protected override void ClearItems()
    {
        base.ClearItems();

        EventHandler<DinosaursChangedEventArgs> temp = Changed;
        if (temp != null)
        {
            temp(this, new DinosaursChangedEventArgs(
                ChangeType.Cleared, null, null));
        }
    }
}

// Event argument for the Changed event.
//
public class DinosaursChangedEventArgs : EventArgs
{
    public readonly string ChangedItem;
    public readonly ChangeType ChangeType;
    public readonly string ReplacedWith;

    public DinosaursChangedEventArgs(ChangeType change, string item, 
        string replacement)
    {
        ChangeType = change;
        ChangedItem = item;
        ReplacedWith = replacement;
    }
}

public enum ChangeType
{
    Added, 
    Removed, 
    Replaced, 
    Cleared
};

public class Demo
{
    public static void Main()
    {
        Dinosaurs dinosaurs = new Dinosaurs();

        dinosaurs.Changed += ChangedHandler; 

        dinosaurs.Add("Psitticosaurus");
        dinosaurs.Add("Caudipteryx");
        dinosaurs.Add("Compsognathus");
        dinosaurs.Add("Muttaburrasaurus");

        Display(dinosaurs);
    
        Console.WriteLine("\nIndexOf(\"Muttaburrasaurus\"): {0}", 
            dinosaurs.IndexOf("Muttaburrasaurus"));

        Console.WriteLine("\nContains(\"Caudipteryx\"): {0}", 
            dinosaurs.Contains("Caudipteryx"));

        Console.WriteLine("\nInsert(2, \"Nanotyrannus\")");
        dinosaurs.Insert(2, "Nanotyrannus");

        Console.WriteLine("\ndinosaurs[2]: {0}", dinosaurs[2]);

        Console.WriteLine("\ndinosaurs[2] = \"Microraptor\"");
        dinosaurs[2] = "Microraptor";

        Console.WriteLine("\nRemove(\"Microraptor\")");
        dinosaurs.Remove("Microraptor");

        Console.WriteLine("\nRemoveAt(0)");
        dinosaurs.RemoveAt(0);

        Display(dinosaurs);
    }
    
    private static void Display(Collection<string> cs)
    {
        Console.WriteLine();
        foreach( string item in cs )
        {
            Console.WriteLine(item);
        }
    }

    private static void ChangedHandler(object source, 
        DinosaursChangedEventArgs e)
    {

        if (e.ChangeType==ChangeType.Replaced)
        {
            Console.WriteLine("{0} was replaced with {1}", e.ChangedItem, 
                e.ReplacedWith);
        }
        else if(e.ChangeType==ChangeType.Cleared)
        {
            Console.WriteLine("The dinosaur list was cleared.");
        }
        else
        {
            Console.WriteLine("{0} was {1}.", e.ChangedItem, e.ChangeType);
        }
    }
}

/* This code example produces the following output:

Psitticosaurus was Added.
Caudipteryx was Added.
Compsognathus was Added.
Muttaburrasaurus was Added.

Psitticosaurus
Caudipteryx
Compsognathus
Muttaburrasaurus

IndexOf("Muttaburrasaurus"): 3

Contains("Caudipteryx"): True

Insert(2, "Nanotyrannus")
Nanotyrannus was Added.

dinosaurs[2]: Nanotyrannus

dinosaurs[2] = "Microraptor"
Nanotyrannus was replaced with Microraptor

Remove("Microraptor")
Microraptor was Removed.

RemoveAt(0)
Psitticosaurus was Removed.

Caudipteryx
Compsognathus
Muttaburrasaurus
 */

System.Object
  System.Collections.ObjectModel.Collection
     Clases derivadas

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Collection puede admitir varios sistemas de lectura a la vez, siempre y cuando no se modifique la colección. Aun así, por su naturaleza, la enumeración mediante una colección no es un procedimiento seguro para la ejecución de subprocesos. Para garantizar la seguridad para la ejecución de subprocesos durante la enumeración, puede bloquear la colección durante toda la enumeración. Para permitir que varios subprocesos obtengan acceso de lectura y escritura a la colección, debe implementar su propia sincronización.

Windows 98, Windows 2000 Service Pack 4, Windows CE, Windows Millennium, Windows Mobile para Pocket PC, Windows Mobile para Smartphone, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter

Microsoft .NET Framework 3.0 es compatible con Windows Vista, Microsoft Windows XP SP2 y Windows Server 2003 SP1.

.NET Framework

Compatible con: 3.0, 2.0

.NET Compact Framework

Compatible con: 2.0

XNA Framework

Compatible con: 1.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft