Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.

Tradução

Original

Este tópico ainda não foi avaliado como - Avalie este tópico

Classe Collection<T>

.NET Framework 4.5

Outras versões

Fornece o classe base para um Genérico coleção.test--approve this one

Hierarquia de herança

System.Object
System.Collections.ObjectModel.Collection<T>
Mais...

Namespace: System.Collections.ObjectModel
Assembly: mscorlib (em mscorlib.dll)

Sintaxe

C++

[SerializableAttribute]
[ComVisibleAttribute(false)]
public class Collection<T> : IList<T>, 
	ICollection<T>, IList, ICollection, IReadOnlyList<T>, IReadOnlyCollection<T>, 
	IEnumerable<T>, IEnumerable

Parâmetros de tipo

T: O tipo de elementos na coleção.

O tipo Collection<T> expõe os membros a seguir.

Construtores

	Nome	Descrição
	Collection<T>()	Inicializa uma nova instância da Collection<T> classe que está vazia.
	Collection<T>(IList<T>)	Inicializa uma nova instância da Collection<T> classe como um wrapper para a lista especificada.

Superior

Propriedades

	Nome	Descrição
	Count	Obtém o número de elementos contidos na verdade na Collection<T>.
	Item	Obtém ou define o elemento no índice especificado.
	Items	Obtém um IList<T> wrapper em torno do Collection<T>.

Superior

Métodos

	Nome	Descrição
	Add	Adiciona um objeto para o fim do Collection<T>.
	Clear	Remove todos os elementos da Collection<T>.
	ClearItems	Remove todos os elementos da Collection<T>.
	Contains	Determina se um elemento está na Collection<T>.
	CopyTo	Copia todo o Collection<T> para um compatível unidimensional Array, inicial no índice da matriz de destino especificado.
	Equals(Object)	Verifica se o objeto especificado é igual ao objeto atual. (Herdado de Object.)
	Finalize	Permite que um objeto tente liberar recursos e executar outras operações de limpeza antes que ele seja recuperado pela coleta de lixo. (Herdado de Object.)
	GetEnumerator	Retorna um enumerador que itera por meio do Collection<T>.
	GetHashCode	Serve como uma função hash para um tipo específico. (Herdado de Object.)
	GetType	Obtém o Type da instância atual. (Herdado de Object.)
	IndexOf	Procura o objeto especificado e retorna o índice baseado em zero da primeira ocorrência dentro de toda a Collection<T>.
	Insert	Insere um elemento para o Collection<T> no índice especificado.
	InsertItem	Insere um elemento para o Collection<T> no índice especificado.
	MemberwiseClone	Cria uma cópia superficial do Object atual. (Herdado de Object.)
	Remove	Remove a primeira ocorrência de um objeto específico a partir do Collection<T>.
	RemoveAt	Remove o elemento no índice especificado da Collection<T>.
	RemoveItem	Remove o elemento no índice especificado da Collection<T>.
	SetItem	Substitui o elemento no índice especificado.
	ToString	Retorna uma string que representa o objeto atual. (Herdado de Object.)

Superior

Métodos de extensão

	Nome	Descrição
	Aggregate<T>(Func<T, T, T>)	Sobrecarregado. Aplica uma função acumuladora em uma seqüência. (Definido por Enumerable.)
	Aggregate<T, TAccumulate>(TAccumulate, Func<TAccumulate, T, TAccumulate>)	Sobrecarregado. Aplica uma função acumuladora em uma seqüência. O valor de propagação especificado é usado como o valor inicial de acumulação. (Definido por Enumerable.)
	Aggregate<T, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, T, TAccumulate>, Func<TAccumulate, TResult>)	Sobrecarregado. Aplica uma função acumuladora em uma seqüência. O valor de propagação especificado é usado como o valor inicial de acumulação e a função especificada é usada para selecionar o valor resultado. (Definido por Enumerable.)
	All<T>	Determina se todos os elementos de uma seqüência satisfazem uma condição. (Definido por Enumerable.)
	Any<T>()	Sobrecarregado. Determina se uma seqüência contém elementos. (Definido por Enumerable.)
	Any<T>(Func<T, Boolean>)	Sobrecarregado. Determina se qualquer elemento de uma seqüência satisfaz uma condição. (Definido por Enumerable.)
	AsEnumerable<T>	Retorna a entrada digitada como IEnumerable<T>. (Definido por Enumerable.)
	AsParallel()	Sobrecarregado. Permite que o parallelization de uma consulta. (Definido por ParallelEnumerable.)
	AsParallel<T>()	Sobrecarregado. Permite que o parallelization de uma consulta. (Definido por ParallelEnumerable.)
	AsQueryable()	Sobrecarregado. Converts an IEnumerable to an IQueryable. (Definido por Queryable.)
	AsQueryable<T>()	Sobrecarregado. Converte um IEnumerable<T> genérico para um IQueryable<T> genérico. (Definido por Queryable.)
	Average<T>(Func<T, Decimal>)	Sobrecarregado. Calcula a média de uma seqüência de valores Decimal que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Average<T>(Func<T, Nullable<Decimal>>)	Sobrecarregado. Calcula a média de uma seqüência de valores Decimal anuláveis que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Average<T>(Func<T, Double>)	Sobrecarregado. Calcula a média de uma seqüência de valores Double que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Average<T>(Func<T, Nullable<Double>>)	Sobrecarregado. Calcula a média de uma seqüência de valores Double anuláveis que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Average<T>(Func<T, Int32>)	Sobrecarregado. Calcula a média de uma seqüência de valores Int32 que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Average<T>(Func<T, Nullable<Int32>>)	Sobrecarregado. Calcula a média de uma seqüência de valores Int32 anuláveis que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Average<T>(Func<T, Int64>)	Sobrecarregado. Calcula a média de uma seqüência de valores Int64 que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Average<T>(Func<T, Nullable<Int64>>)	Sobrecarregado. Calcula a média de uma seqüência de valores Int64 anuláveis que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Average<T>(Func<T, Single>)	Sobrecarregado. Calcula a média de uma seqüência de valores Single que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Average<T>(Func<T, Nullable<Single>>)	Sobrecarregado. Calcula a média de uma seqüência de valores Single anuláveis que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Cast<TResult>	Projeta os elementos de um IEnumerable para o tipo especificado. (Definido por Enumerable.)
	Concat<T>	Concatena duas seqüências. (Definido por Enumerable.)
	Contains<T>(T)	Sobrecarregado. Determina se uma seqüência contém um elemento especificado, usando o comparador de igualdade padrão. (Definido por Enumerable.)
	Contains<T>(T, IEqualityComparer<T>)	Sobrecarregado. Determina se uma seqüência contém um elemento especificado por meio de um especificado IEqualityComparer<T>. (Definido por Enumerable.)
	Count<T>()	Sobrecarregado. Retorna o número de elementos em uma seqüência. (Definido por Enumerable.)
	Count<T>(Func<T, Boolean>)	Sobrecarregado. Retorna um número que representa quantos elementos na sequência especificada satisfazem uma condição. (Definido por Enumerable.)
	DefaultIfEmpty<T>()	Sobrecarregado. Retorna os elementos da seqüência especificada ou o valor padrão do parâmetro de tipo em uma coleção singleton se a seqüência estiver vazia. (Definido por Enumerable.)
	DefaultIfEmpty<T>(T)	Sobrecarregado. Retorna os elementos da seqüência especificada ou o valor especificado em uma coleção singleton se a seqüência estiver vazia. (Definido por Enumerable.)
	Distinct<T>()	Sobrecarregado. Retorna os elementos distintos de uma seqüência usando o comparador de igualdade padrão para comparar valores. (Definido por Enumerable.)
	Distinct<T>(IEqualityComparer<T>)	Sobrecarregado. Retorna os elementos distintos de uma seqüência, usando um especificado IEqualityComparer<T> para comparar valores. (Definido por Enumerable.)
	ElementAt<T>	Retorna o elemento em um índice especificado em uma seqüência. (Definido por Enumerable.)
	ElementAtOrDefault<T>	Retorna o elemento em um índice especificado em uma seqüência ou um valor padrão se o índice está fora do intervalo. (Definido por Enumerable.)
	Except<T>(IEnumerable<T>)	Sobrecarregado. Produz a diferença do conjunto de duas seqüências usando o comparador de igualdade padrão para comparar valores. (Definido por Enumerable.)
	Except<T>(IEnumerable<T>, IEqualityComparer<T>)	Sobrecarregado. Produz o conjunto com a diferença entre duas sequências usando o IEqualityComparer<T> especificado para comparar valores. (Definido por Enumerable.)
	First<T>()	Sobrecarregado. Retorna o primeiro elemento de uma seqüência. (Definido por Enumerable.)
	First<T>(Func<T, Boolean>)	Sobrecarregado. Retorna o primeiro elemento em uma seqüência que satisfaz uma condição especificada. (Definido por Enumerable.)
	FirstOrDefault<T>()	Sobrecarregado. Retorna o primeiro elemento de uma sequência, ou um valor padrão se a sequência não contiver elementos. (Definido por Enumerable.)
	FirstOrDefault<T>(Func<T, Boolean>)	Sobrecarregado. Retorna o primeiro elemento da seqüência que satisfaz uma condição ou um valor padrão se nenhum elemento for encontrado. (Definido por Enumerable.)
	GroupBy<T, TKey>(Func<T, TKey>)	Sobrecarregado. Agrupa os elementos de uma seqüência de acordo com uma função de seleção de chave especificada. (Definido por Enumerable.)
	GroupBy<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Sobrecarregado. Agrupa os elementos de uma seqüência de acordo com a uma função de seleção de chave especificada e compara as chaves usando um comparador especificado. (Definido por Enumerable.)
	GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	Sobrecarregado. Agrupa os elementos de uma seqüência de acordo com a uma função de seleção de chave especificada e projeta os elementos para cada grupo usando uma função especificada. (Definido por Enumerable.)
	GroupBy<T, TKey, TResult>(Func<T, TKey>, Func<TKey, IEnumerable<T>, TResult>)	Sobrecarregado. Agrupa os elementos de uma seqüência de acordo com uma função de seleção de chave especificada e cria um valor de resultado de cada grupo e sua chave. (Definido por Enumerable.)
	GroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	Sobrecarregado. Agrupa os elementos de uma seqüência de acordo com uma função de seleção de chave. As chaves são comparadas usando um comparador e cada elementos do grupo é projetado usando uma função especificada. (Definido por Enumerable.)
	GroupBy<T, TKey, TResult>(Func<T, TKey>, Func<TKey, IEnumerable<T>, TResult>, IEqualityComparer<TKey>)	Sobrecarregado. Agrupa os elementos de uma seqüência de acordo com uma função de seleção de chave especificada e cria um valor de resultado de cada grupo e sua chave. As chaves são comparadas usando um comparador especificado. (Definido por Enumerable.)
	GroupBy<T, TKey, TElement, TResult>(Func<T, TKey>, Func<T, TElement>, Func<TKey, IEnumerable<TElement>, TResult>)	Sobrecarregado. Agrupa os elementos de uma seqüência de acordo com uma função de seleção de chave especificada e cria um valor de resultado de cada grupo e sua chave. Os elementos de cada grupo estão projetados por meio de uma função especificada. (Definido por Enumerable.)
	GroupBy<T, TKey, TElement, TResult>(Func<T, TKey>, Func<T, TElement>, Func<TKey, IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)	Sobrecarregado. Agrupa os elementos de uma seqüência de acordo com uma função de seleção de chave especificada e cria um valor de resultado de cada grupo e sua chave. Valores de chave são comparados usando um comparador especificado e os elementos de cada grupo são projetados usando uma função especificada. (Definido por Enumerable.)
	GroupJoin<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, IEnumerable<TInner>, TResult>)	Sobrecarregado. Correlaciona os elementos de duas seqüências com base na igualdade de chaves e agrupa os resultados. O comparador de igualdade padrão é usado para comparar as chaves. (Definido por Enumerable.)
	GroupJoin<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)	Sobrecarregado. Correlaciona os elementos de duas seqüências com base na igualdade de chave e agrupa os resultados. O IEqualityComparer<T> especificado é usado para comparar as chaves. (Definido por Enumerable.)
	Intersect<T>(IEnumerable<T>)	Sobrecarregado. Produz a interseção de duas seqüências usando o comparador de igualdade padrão para comparar valores. (Definido por Enumerable.)
	Intersect<T>(IEnumerable<T>, IEqualityComparer<T>)	Sobrecarregado. Produz a interseção de duas seqüências conjunto usando o especificado IEqualityComparer<T> para comparar valores. (Definido por Enumerable.)
	Join<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, TInner, TResult>)	Sobrecarregado. Correlaciona os elementos de duas sequências com base em chaves coincidentes. O comparador de igualdade padrão é usado para comparar as chaves. (Definido por Enumerable.)
	Join<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, TInner, TResult>, IEqualityComparer<TKey>)	Sobrecarregado. Correlaciona os elementos de duas sequências com base em chaves coincidentes. O IEqualityComparer<T> especificado é usado para comparar as chaves. (Definido por Enumerable.)
	Last<T>()	Sobrecarregado. Retorna o último elemento de uma seqüência. (Definido por Enumerable.)
	Last<T>(Func<T, Boolean>)	Sobrecarregado. Retorna o último elemento de uma seqüência que satisfaz uma condição especificada. (Definido por Enumerable.)
	LastOrDefault<T>()	Sobrecarregado. Retorna o último elemento de uma seqüência ou um valor padrão se a seqüência não contém elementos. (Definido por Enumerable.)
	LastOrDefault<T>(Func<T, Boolean>)	Sobrecarregado. Retorna o último elemento de uma seqüência que satisfaz uma condição ou um valor padrão se nenhum elemento for encontrado. (Definido por Enumerable.)
	LongCount<T>()	Sobrecarregado. Retorna um Int64 que representa o número total de elementos em uma seqüência. (Definido por Enumerable.)
	LongCount<T>(Func<T, Boolean>)	Sobrecarregado. Retorna um Int64 que representa a quantidade de elementos em uma seqüência que satisfazem uma condição. (Definido por Enumerable.)
	Max<T>()	Sobrecarregado. Retorna o valor máximo em uma seqüência de genérica. (Definido por Enumerable.)
	Max<T>(Func<T, Decimal>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o valor máximo Decimal valor. (Definido por Enumerable.)
	Max<T>(Func<T, Nullable<Decimal>>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o valor máximo anulável Decimal valor. (Definido por Enumerable.)
	Max<T>(Func<T, Double>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o valor máximo Double valor. (Definido por Enumerable.)
	Max<T>(Func<T, Nullable<Double>>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o valor máximo anulável Double valor. (Definido por Enumerable.)
	Max<T>(Func<T, Int32>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o valor máximo Int32 valor. (Definido por Enumerable.)
	Max<T>(Func<T, Nullable<Int32>>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o valor máximo anulável Int32 valor. (Definido por Enumerable.)
	Max<T>(Func<T, Int64>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o valor máximo Int64 valor. (Definido por Enumerable.)
	Max<T>(Func<T, Nullable<Int64>>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o valor máximo anulável Int64 valor. (Definido por Enumerable.)
	Max<T>(Func<T, Single>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o valor máximo Single valor. (Definido por Enumerable.)
	Max<T>(Func<T, Nullable<Single>>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o valor máximo anulável Single valor. (Definido por Enumerable.)
	Max<T, TResult>(Func<T, TResult>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma genérico seqüência e retorna o máximo valor resultante. (Definido por Enumerable.)
	Min<T>()	Sobrecarregado. Retorna o valor mínimo em uma seqüência de genérica. (Definido por Enumerable.)
	Min<T>(Func<T, Decimal>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o mínimo Decimal valor. (Definido por Enumerable.)
	Min<T>(Func<T, Nullable<Decimal>>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o mínimo anulável Decimal valor. (Definido por Enumerable.)
	Min<T>(Func<T, Double>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o mínimo Double valor. (Definido por Enumerable.)
	Min<T>(Func<T, Nullable<Double>>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o mínimo anulável Double valor. (Definido por Enumerable.)
	Min<T>(Func<T, Int32>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o mínimo Int32 valor. (Definido por Enumerable.)
	Min<T>(Func<T, Nullable<Int32>>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o mínimo anulável Int32 valor. (Definido por Enumerable.)
	Min<T>(Func<T, Int64>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o mínimo Int64 valor. (Definido por Enumerable.)
	Min<T>(Func<T, Nullable<Int64>>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o mínimo anulável Int64 valor. (Definido por Enumerable.)
	Min<T>(Func<T, Single>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o mínimo Single valor. (Definido por Enumerable.)
	Min<T>(Func<T, Nullable<Single>>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma seqüência e retorna o mínimo anulável Single valor. (Definido por Enumerable.)
	Min<T, TResult>(Func<T, TResult>)	Sobrecarregado. Chama uma função de transformação em cada elemento de uma genérico seqüência e retorna o valor mínimo de resultante. (Definido por Enumerable.)
	OfType<TResult>	Filtra os elementos de um IEnumerable com base em um tipo especificado. (Definido por Enumerable.)
	OrderBy<T, TKey>(Func<T, TKey>)	Sobrecarregado. Classifica os elementos de uma seqüência em ordem crescente de acordo com para uma chave. (Definido por Enumerable.)
	OrderBy<T, TKey>(Func<T, TKey>, IComparer<TKey>)	Sobrecarregado. Classifica os elementos de uma seqüência em ordem crescente, usando um comparador especificado. (Definido por Enumerable.)
	OrderByDescending<T, TKey>(Func<T, TKey>)	Sobrecarregado. Classifica os elementos de uma seqüência em decrescente ordem de acordo com uma chave. (Definido por Enumerable.)
	OrderByDescending<T, TKey>(Func<T, TKey>, IComparer<TKey>)	Sobrecarregado. Classifica os elementos de uma seqüência em ordem decrescente usando um comparador especificado. (Definido por Enumerable.)
	Reverse<T>	Inverte a ordem dos elementos em uma seqüência. (Definido por Enumerable.)
	Select<T, TResult>(Func<T, TResult>)	Sobrecarregado. Projeta cada elemento de uma seqüência em um novo formulário. (Definido por Enumerable.)
	Select<T, TResult>(Func<T, Int32, TResult>)	Sobrecarregado. Projeta cada elemento de uma seqüência em um novo formulário incorporando o índice do elemento. (Definido por Enumerable.)
	SelectMany<T, TResult>(Func<T, IEnumerable<TResult>>)	Sobrecarregado. Projeta cada elemento de uma seqüência para um IEnumerable<T> e nivela as seqüências resultantes em uma só. (Definido por Enumerable.)
	SelectMany<T, TResult>(Func<T, Int32, IEnumerable<TResult>>)	Sobrecarregado. Projeta cada elemento de uma seqüência para um IEnumerable<T>e nivela as seqüências resultantes em uma só. O índice de cada elemento de origem é usado no formulário projetado desse elemento. (Definido por Enumerable.)
	SelectMany<T, TCollection, TResult>(Func<T, Int32, IEnumerable<TCollection>>, Func<T, TCollection, TResult>)	Sobrecarregado. Projeta cada elemento de uma seqüência para um IEnumerable<T>, nivela as seqüências resultantes em uma só e invoca uma função de seletor de resultado em cada elemento aí. O índice de cada elemento de origem é usado no formulário intermediário projetado desse elemento. (Definido por Enumerable.)
	SelectMany<T, TCollection, TResult>(Func<T, IEnumerable<TCollection>>, Func<T, TCollection, TResult>)	Sobrecarregado. Projeta cada elemento de uma seqüência para um IEnumerable<T>, nivela as seqüências resultantes em uma só e invoca uma função de seletor de resultado em cada elemento aí. (Definido por Enumerable.)
	SequenceEqual<T>(IEnumerable<T>)	Sobrecarregado. Determina se duas seqüências são iguais, comparando os elementos usando o comparador de igualdade padrão para seu tipo. (Definido por Enumerable.)
	SequenceEqual<T>(IEnumerable<T>, IEqualityComparer<T>)	Sobrecarregado. Determina se duas seqüências são iguais, comparando seus elementos usando um especificado IEqualityComparer<T>. (Definido por Enumerable.)
	Single<T>()	Sobrecarregado. Retorna um único elemento de uma seqüência e lança uma exceção se não houver exatamente um elemento na seqüência. (Definido por Enumerable.)
	Single<T>(Func<T, Boolean>)	Sobrecarregado. Retorna um único elemento de uma seqüência que satisfaz uma condição especificada e lança uma exceção se houver mais de uma tal elemento. (Definido por Enumerable.)
	SingleOrDefault<T>()	Sobrecarregado. Retorna o único elemento de uma seqüência ou um valor padrão se a seqüência está vazia. Este método lança uma exceção se houver mais de um elemento na seqüência. (Definido por Enumerable.)
	SingleOrDefault<T>(Func<T, Boolean>)	Sobrecarregado. Retorna um único elemento de uma seqüência que satisfaz uma condição especificada ou um valor padrão se nenhum elemento tal existir. Este método lança uma exceção se mais de um elemento satisfaça à condição. (Definido por Enumerable.)
	Skip<T>	Ignora um número especificado de elementos em uma seqüência e retorna os elementos restantes. (Definido por Enumerable.)
	SkipWhile<T>(Func<T, Boolean>)	Sobrecarregado. Ignora os elementos de uma seqüência, desde que uma condição especificada for verdadeira e, em seguida, retorna os elementos restantes. (Definido por Enumerable.)
	SkipWhile<T>(Func<T, Int32, Boolean>)	Sobrecarregado. Ignora os elementos de uma seqüência, desde que uma condição especificada for verdadeira e, em seguida, retorna os elementos restantes. Índice do elemento é usado na lógica da função de predicado. (Definido por Enumerable.)
	Sum<T>(Func<T, Decimal>)	Sobrecarregado. Calcula a soma da seqüência de Decimal valores que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Sum<T>(Func<T, Nullable<Decimal>>)	Sobrecarregado. Calcula a soma da seqüência de anulável Decimal valores que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Sum<T>(Func<T, Double>)	Sobrecarregado. Calcula a soma da seqüência de Double valores que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Sum<T>(Func<T, Nullable<Double>>)	Sobrecarregado. Calcula a soma da seqüência de anulável Double valores que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Sum<T>(Func<T, Int32>)	Sobrecarregado. Calcula a soma da seqüência de Int32 valores que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Sum<T>(Func<T, Nullable<Int32>>)	Sobrecarregado. Calcula a soma da seqüência de anulável Int32 valores que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Sum<T>(Func<T, Int64>)	Sobrecarregado. Calcula a soma da seqüência de Int64 valores que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Sum<T>(Func<T, Nullable<Int64>>)	Sobrecarregado. Calcula a soma da seqüência de anulável Int64 valores que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Sum<T>(Func<T, Single>)	Sobrecarregado. Calcula a soma da seqüência de Single valores que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Sum<T>(Func<T, Nullable<Single>>)	Sobrecarregado. Calcula a soma da seqüência de anulável Single valores que são obtidos chamando uma função de transformação em cada elemento da seqüência de entrada. (Definido por Enumerable.)
	Take<T>	Retorna um número especificado de elementos contíguos desde o início de uma seqüência. (Definido por Enumerable.)
	TakeWhile<T>(Func<T, Boolean>)	Sobrecarregado. Retorna os elementos de uma seqüência enquanto uma condição especificada for verdadeira. (Definido por Enumerable.)
	TakeWhile<T>(Func<T, Int32, Boolean>)	Sobrecarregado. Retorna os elementos de uma seqüência enquanto uma condição especificada for verdadeira. Índice do elemento é usado na lógica da função de predicado. (Definido por Enumerable.)
	ToArray<T>	Cria uma matriz de um IEnumerable<T>. (Definido por Enumerable.)
	ToDictionary<T, TKey>(Func<T, TKey>)	Sobrecarregado. Cria um Dictionary<TKey, TValue> de um IEnumerable<T> de acordo com a uma função de seletor de chave especificado. (Definido por Enumerable.)
	ToDictionary<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Sobrecarregado. Cria um Dictionary<TKey, TValue> de um IEnumerable<T> acordo com a um comparador de função e uma chave de seletor de chave especificado. (Definido por Enumerable.)
	ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	Sobrecarregado. Cria um Dictionary<TKey, TValue> de um IEnumerable<T> acordo com a seletor de chave especificado e funções do seletor de elemento. (Definido por Enumerable.)
	ToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	Sobrecarregado. Cria um Dictionary<TKey, TValue> de um IEnumerable<T> de acordo com a uma função de seletor de chave especificado, um comparador e uma função de seletor de elemento. (Definido por Enumerable.)
	ToList<T>	Creates a List<T> from an IEnumerable<T>. (Definido por Enumerable.)
	ToLookup<T, TKey>(Func<T, TKey>)	Sobrecarregado. Cria um Lookup<TKey, TElement> de um IEnumerable<T> de acordo com a uma função de seletor de chave especificado. (Definido por Enumerable.)
	ToLookup<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)	Sobrecarregado. Cria um Lookup<TKey, TElement> de um IEnumerable<T> acordo com a um comparador de função e uma chave de seletor de chave especificado. (Definido por Enumerable.)
	ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)	Sobrecarregado. Cria um Lookup<TKey, TElement> de um IEnumerable<T> acordo com a seletor de chave especificado e funções do seletor de elemento. (Definido por Enumerable.)
	ToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)	Sobrecarregado. Cria um Lookup<TKey, TElement> de um IEnumerable<T> acordo com a uma função de seletor de chave especificado, um comparador e uma função de seletor de elemento. (Definido por Enumerable.)
	Union<T>(IEnumerable<T>)	Sobrecarregado. Produz a união de conjunto de duas seqüências usando o comparador de igualdade padrão. (Definido por Enumerable.)
	Union<T>(IEnumerable<T>, IEqualityComparer<T>)	Sobrecarregado. Produz a união de duas seqüências usando um IEqualityComparer<T> especificado. (Definido por Enumerable.)
	Where<T>(Func<T, Boolean>)	Sobrecarregado. Filtra uma seqüência de valores com base em um predicado. (Definido por Enumerable.)
	Where<T>(Func<T, Int32, Boolean>)	Sobrecarregado. Filtra uma seqüência de valores com base em um predicado. Índice de cada elemento é usado na lógica da função de predicado. (Definido por Enumerable.)
	Zip<T, TSecond, TResult>	Mescla as duas seqüências usando a função de predicado especificada. (Definido por Enumerable.)

Superior

Implementações explícitas da interface

	Nome	Descrição
	ICollection.CopyTo	Copia os elementos da ICollection para um Array, inicial de um determinado Array índice.
	ICollection<T>.IsReadOnly	Obtém um valor indicando se a ICollection<T> é somente leitura.
	ICollection.IsSynchronized	Obtém um valor indicando se acessar para a ICollection é sincronizado (segmento seguro).
	ICollection.SyncRoot	Obtém um objeto que pode ser usado para sincronizar o acesso para o ICollection.
	IEnumerable.GetEnumerator	Retorna um enumerador que itera por meio de uma coleção.
	IList.Add	Adiciona um item para o IList.
	IList.Contains	Determina se a IList contém um valor específico.
	IList.IndexOf	Determina o índice de um item específico na IList.
	IList.Insert	Insere um item para o IList no índice especificado.
	IList.IsFixedSize	Obtém um valor indicando se a IList tem um tamanho fixo.
	IList.IsReadOnly	Obtém um valor que indica se o IList é somente leitura.
	IList.Item	Obtém ou define o elemento no índice especificado.
	IList.Remove	Remove a primeira ocorrência de um objeto específico a partir do IList.

Superior

Comentários

O Collection<T> classe pode ser usada imediatamente, criando uma instância de um de seus tipos construídos; tudo o que você precisa fazer é especificar o tipo de objeto a ser contidos na coleção. Além disso, você pode derivar seu próprio tipo de coleção de qualquer tipo construído ou derivar de um tipo de coleção genérica a partir do Collection<T> própria classe.

O Collection<T> classe fornece métodos protegidos que podem ser usados para personalizar seu comportamento quando adicionando e removendo itens, limpando a coleção ou definindo o valor de um item existente.

A maioria dos Collection<T> objetos podem ser modificados. No entanto, um Collection<T> objeto que é inicializado com somente leitura IList<T> objeto não pode ser modificado. Consulte ReadOnlyCollection<T> para obter uma versão somente leitura dessa classe.

Elementos nesta coleção podem ser acessados usando um índice inteiro. Índices nessa coleção são baseados em zero.

Collection<T> aceita null como um valor válido para referência tipos e permita elementos duplicados.

Observações para implementadores

Essa classe base é fornecida para facilitar implementadores criar uma coleção personalizada. Implementadores são incentivados a estender essa classe base em vez de criar seus próprios.

Exemplos

Esta seção contém dois exemplos de código. O primeiro exemplo demonstra várias propriedades e métodos para o Collection<T> classe. O segundo exemplo mostra como para derivar uma classe de coleção de um tipo construído de Collection<T>e como substituir os métodos protegidos de Collection<T> para fornecer um comportamento personalizado.

Exemplo 1

O exemplo de código a seguir demonstra a muitas das propriedades e métodos do Collection<T>. O exemplo de código cria uma coleção de seqüências de caracteres, usa a Add método para adicionar várias cadeias de caracteres, exibe o Counte lista as seqüências de caracteres. O exemplo usa a IndexOf método para encontrar o índice de uma seqüência de caracteres e o Contains método para determinar se uma seqüência de caracteres está na coleção. O exemplo insere uma seqüência de caracteres usando o Insert método e recupera e define seqüências de caracteres usando o padrão Item propriedade (o indexador em C#). O exemplo removerá seqüências de caracteres, identidade de seqüência de caracteres usando o Remove método e usando o índice a RemoveAt método. Finalmente, o Clear método é usado para limpar todas as seqüências da coleção.

C++


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
 */

Exemplo 2

O exemplo de código a seguir mostra como derivar uma classe de coleção de um tipo construído do Collection<T> classe genérica e como substituir o protegido InsertItem, RemoveItem, ClearItems, e SetItem métodos para fornecer um comportamento personalizado para o Add, Insert, Remove, e Clear métodos e para configuração do Item propriedade.

O comportamento personalizado fornecido por este exemplo é um Changed evento de notificação que é disparado no final de cada um dos métodos protegidos. O Dinosaurs herda da classe Collection<string> (Collection(Of String) em Visual Basic) e define o Changed evento, que usa um DinosaursChangedEventArgs classe para as informações de evento e uma enumeração para identificar o tipo de alteração.

O exemplo de código chama várias propriedades e métodos do Collection<T> para demonstrar o 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
 */

Informações sobre versão

.NET Framework

Com suporte em: 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Com suporte em: 4, 3.5 SP1

Biblioteca de Classes Portátil

Com suporte em: Biblioteca de Classes Portátil

.NET para aplicativos da Windows Store

Com suporte em: Windows 8

Plataformas

Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Função Server Core sem suporte), Windows Server 2008 R2 (Função Server Core com suporte com o SP1 ou posterior, Itanium sem suporte)

O .NET Framework não oferece suporte a todas as versões de cada plataforma. Para obter uma lista das versões com suporte, consulte .Requisitos de sistema do NET Framework.

Acesso thread-safe

Membro público estático (Shared em Visual Basic) membros desse tipo são thread-safe. Os membros da instâncianão estãogarantias de serem thread safe.

A Collection<T> pode suportar vários leitores simultaneamente, desde que a coleção não é modificada. Mesmo assim, enumerando através de uma coleção intrinsecamente não é um procedimento de thread-safe. Para garantir segurança de segmentos durante enumeração, você pode bloquear a coleção durante toda a enumeração. Para permitir que a coleção seja acessada por vários segmentos de leitura e gravação, você deve implementar sua sincronização.

Consulte também

Referência

Namespace System.Collections.ObjectModel

ICollection<T>

Outros recursos

Efetuar operações de cadeia de caracteres com diferenciação de cultura em coleções

Hierarquia de herança

Isso foi útil para você? Sim Não

Impreciso

Sem profundidade suficiente

Mais exemplos de código são necessários

A tradução precisa ser aprimorada

(1500 caracteres restantes)

Contribuições da comunidade

ADICIONAR