Observação
O acesso a essa página exige autorização. Você pode tentar entrar ou alterar diretórios.
O acesso a essa página exige autorização. Você pode tentar alterar os diretórios.
Tip
Este artigo faz parte da seção Conceitos Básicos para desenvolvedores que já conhecem pelo menos uma linguagem de programação e estão aprendendo C#. Se você é novo em programação, comece com os tutoriais Comece agora. Para obter mais informações sobre coleções, consulte Coleções na referência de idioma. Para obter mais informações sobre arrays, consulte o tipo de referência de matriz na referência da linguagem. Para obter mais informações sobre expressões de coleção, consulte Expressões de coleção (literais de coleção) na referência de linguagem.
Vindo de outro idioma? Arrays em C# são coleções ordenadas de tamanho fixo, como arrays em Java ou C++.
List<T> é a sequência redimensionável comum, como o ArrayList do Java, arrays do JavaScript ou listas de Python.
Dictionary<TKey,TValue> armazena valores por chave, como mapas ou dicionários em muitos idiomas.
Uma coleção é um objeto que armazena vários valores relacionados. Cada valor em uma coleção é um elemento. Escolha um array quando o conjunto for fixo, como os nomes de status que seu rastreador de item de trabalho sempre usa. Escolha um List<T> quando os itens vierem e forem, como uma lista de pendências que obtém novos itens de trabalho e descarta os itens concluídos. Escolha um Dictionary<TKey,TValue> quando procurar valores por uma chave, como localizar um item de trabalho por ID ou uma configuração por nome. A próxima seção transforma esses exemplos em um modelo de decisão rápida.
Escolha um tipo de coleção
Escolha a coleção que corresponde à forma como o código usa os dados. Uma sequência armazena elementos na ordem para que você possa alcançá-los por posição. Use uma matriz, que é representada por Array, quando você souber o número de posições que a sequência precisa. O comprimento de uma matriz não pode ser alterado depois de criá-la, mas você pode substituir o elemento armazenado em uma posição existente. Use List<T> quando precisar de uma sequência que possa adicionar ou remover elementos. Um dicionário armazena valores que você alcança por chave em vez de por posição. Use Dictionary<TKey,TValue> quando cada elemento tiver uma chave de consulta, como nome, ID ou código. Os exemplos usam uma expressão de coleção, que cria uma coleção a partir de expressões entre colchetes. A seção Criar coleções com expressões de coleção explica essa sintaxe com mais detalhes.
string[] sprintPlan = ["design", "code", "test"];
List<string> backlog = ["design", "code"];
Dictionary<string, int> priorities = new()
{
["docs"] = 2,
["tests"] = 1
};
backlog.Add("test");
Console.WriteLine($"Array: {string.Join(", ", sprintPlan)}");
Console.WriteLine($"List count: {backlog.Count}");
Console.WriteLine($"Priority for docs: {priorities["docs"]}");
// This example produces the following output:
//
// Array: design, code, test
// List count: 3
// Priority for docs: 2
//
List<T> e Dictionary<TKey,TValue> são tipos genéricos. Um tipo genérico usa um argumento de tipo, como string ou int, para dizer que tipo de valores ele armazena. Os genéricos permitem reutilizar a mesma forma de coleção, como uma lista ou dicionário, com tipos de elementos diferentes, como string, intou um tipo personalizado. Eles também fornecem segurança de tipo: o compilador garante que cada elemento seja o tipo declarado, portanto, você não precisa de conversões e não pode armazenar acidentalmente o tipo errado. Para obter mais informações sobre tipos genéricos, consulte Tipos e métodos genéricos em Fundamentos.
Armazenar dados de tamanho fixo em arrays
Um array é uma coleção ordenada com um comprimento fixo. Você acessa um elemento de array por seu índice, que é sua posição baseada em zero no array. Index 0 é o primeiro elemento, index 1 é o segundo elemento e assim por diante.
string[] stages = ["design", "code", "test", "review"];
Console.WriteLine($"First: {stages[0]}");
Console.WriteLine($"test index: {Array.IndexOf(stages, "test")}");
// This example produces the following output:
//
// First: design
// test index: 2
//
Use foreach quando quiser ler todos os elementos em ordem. Use um índice quando a posição for importante, como quando você precisar do primeiro elemento, do último elemento ou da posição retornada por Array.IndexOf.
O comprimento de um array é fixo, mas os elementos nesse array podem ser alterados. Atribua um novo valor a um índice existente quando a posição permanecer a mesma, mas o valor armazenado precisar de uma atualização:
string[] stages = ["design", "code", "test"];
stages[0] = "plan";
Console.WriteLine(string.Join(", ", stages));
Console.WriteLine($"Length: {stages.Length}");
// This example produces the following output:
//
// plan, code, test
// Length: 3
//
Aumentar e reduzir uma sequência com List<T>
Um List<T> armazena elementos em ordem e pode crescer ou reduzir conforme o programa é executado. Use Add para acrescentar um elemento, Remove remover um elemento correspondente, Contains testar se um elemento existe e IndexOf localizar a posição de um elemento. Use o indexador de lista para substituir o valor em uma posição existente.
List<string> workItems = ["design", "code", "test"];
workItems.Add("review");
workItems.Remove("code");
workItems[1] = "verify";
Console.WriteLine(string.Join(", ", workItems));
Console.WriteLine($"Has review: {workItems.Contains("review")}");
Console.WriteLine($"Index of verify: {workItems.IndexOf("verify")}");
// This example produces the following output:
//
// design, verify, review
// Has review: True
// Index of verify: 1
//
Um List<T> mantém os elementos restantes em ordem quando você adiciona ou remove itens. Quando você remove um elemento, os elementos posteriores se movem para índices inferiores.
Use Insert para adicionar um elemento em uma posição específica, InsertRange adicionar vários elementos em uma posição e RemoveAt remover um elemento por índice:
List<string> workItems = ["design", "test"];
workItems.Insert(1, "code");
Console.WriteLine($"Insert middle: {string.Join(", ", workItems)}");
workItems.Insert(0, "plan");
Console.WriteLine($"Insert front: {string.Join(", ", workItems)}");
workItems.InsertRange(workItems.Count, ["review", "deploy"]);
Console.WriteLine($"Insert range at end: {string.Join(", ", workItems)}");
workItems.RemoveAt(workItems.Count - 1);
Console.WriteLine($"Remove end: {string.Join(", ", workItems)}");
workItems.RemoveAt(2);
Console.WriteLine($"Remove middle: {string.Join(", ", workItems)}");
workItems.RemoveAt(0);
Console.WriteLine($"Remove front: {string.Join(", ", workItems)}");
// This example produces the following output:
//
// Insert middle: design, code, test
// Insert front: plan, design, code, test
// Insert range at end: plan, design, code, test, review, deploy
// Remove end: plan, design, code, test, review
// Remove middle: plan, design, test, review
// Remove front: design, test, review
//
Adicionar ou remover no final de um List<T> é rápido. Adicionar com Add é uma operação O(1) em média, e remover o último elemento com RemoveAt é O(1). Inserir ou remover na frente ou no meio é O(n) porque cada elemento posterior muda para um novo índice. Se o código frequentemente insere ou remove na frente, uma List<T> pode ser a forma de coleção errada.
Tip
A notação Big-O descreve como o trabalho cresce à medida que o tamanho da coleção, n, aumenta. O(1), pronunciado "order one", significa que a operação usa a mesma quantidade de trabalho, não importa quantos elementos a coleção contenha. O(n), pronunciado "order n", significa que o trabalho cresce aproximadamente em proporção ao número de elementos na coleção.
Associar um valor a uma chave com Dictionary<TKey,TValue>
Um Dictionary<TKey,TValue> armazena pares chave/valor. Um par chave/valor é uma chave e o valor associado a essa chave; .NET representa um par com KeyValuePair<TKey,TValue>. Use o indexador de dicionário para adicionar ou atualizar um valor por chave e use TryGetValue quando a chave possa não existir.
Dictionary<string, int> priorities = new()
{
["docs"] = 2,
["tests"] = 1
};
priorities["review"] = 3;
priorities.Remove("review");
if (priorities.TryGetValue("docs", out int docsPriority))
{
Console.WriteLine($"docs priority: {docsPriority}");
}
else
{
Console.WriteLine("docs missing");
}
if (priorities.TryGetValue("deploy", out int deployPriority))
{
Console.WriteLine($"deploy priority: {deployPriority}");
}
else
{
Console.WriteLine("deploy missing");
}
Console.WriteLine($"count: {priorities.Count}");
// This example produces the following output:
//
// docs priority: 2
// deploy missing
// count: 2
//
Um indexador permite que você use a sintaxe de colchete para acessar um valor de um objeto. O indexador de dicionário é útil quando a chave deve existir ou quando você está atribuindo um valor. TryGetValue verifica se uma chave existe e fornece o valor quando ela existe. Para obter mais informações sobre o operador indexador, consulte operadores de acesso de membro na referência de idioma.
Você também pode alterar o valor associado a uma chave que já existe. Atribua por meio do indexador para adicionar uma chave ou substituir o valor de uma chave existente. Se a substituição depender do valor atual, leia o valor primeiro e atribua o novo valor:
Dictionary<string, int> priorities = new()
{
["docs"] = 2,
["tests"] = 1
};
priorities["docs"] = 1;
if (priorities.TryGetValue("tests", out int testsPriority))
{
priorities["tests"] = testsPriority + 1;
}
priorities["deploy"] = 3;
Console.WriteLine($"docs priority: {priorities["docs"]}");
Console.WriteLine($"tests priority: {priorities["tests"]}");
Console.WriteLine($"deploy priority: {priorities["deploy"]}");
// This example produces the following output:
//
// docs priority: 1
// tests priority: 2
// deploy priority: 3
//
Criar coleções com expressões de coleção
Uma expressão de coleção cria uma coleção a partir de expressões entre colchetes. Expressões de coleção podem criar arrays, listas e outros tipos de coleção. Um elemento spread copia os elementos de outra coleção para a nova coleção.
string[] planned = ["design", "code"];
// The spread element .. planned copies each element from planned.
string[] upcoming = [.. planned, "test"];
List<string> blocked = ["docs"];
Console.WriteLine($"Upcoming: {string.Join(", ", upcoming)}");
Console.WriteLine($"Blocked: {string.Join(", ", blocked)}");
// This example produces the following output:
//
// Upcoming: design, code, test
// Blocked: docs
//
As expressões de coleção mantêm a inicialização concisa. Uma expressão de coleção não tem nenhum tipo próprio. O compilador converte a expressão na forma de coleção que o contexto exige. A variável ou parâmetro de recebimento pode transformá-la em um array, um List<T> ou outro tipo de coleção com suporte.
Ler de posições com índices e intervalos
Índices respondem "qual elemento único?" Intervalos respondem "qual fatia contígua?" Use índices quando o código precisar de um elemento e intervalos quando a subseção fizer parte dos dados com os quais você está trabalhando. Matrizes e List<T> suportam índices e intervalos.
Index pode contar a partir do início ou do fim de uma sequência. Use o número diretamente para contar desde o início: phases[0] lê o primeiro elemento e phases[1] lê o segundo elemento. Use ^ para contar a partir do final: phases[^1] lê o último elemento e phases[^2] lê o penúltimo elemento.
Um Range seleciona uma fatia com .. (dois ponto). O operador de intervalo não é o mesmo que o elemento de propagação que você viu anteriormente em expressões de coleção, mesmo que ambos usem pontos. Use um intervalo a..b quando quiser elementos do índice a até, mas sem incluir , índice b. A expressão phases[1..3] cria uma nova matriz que contém os elementos no índice 1 e no índice 2.
Você pode omitir um ou ambos os índices de intervalo. Omita o índice inicial quando a fatia começar no início, como em phases[..2] para os dois primeiros elementos. Omita o índice final quando a fatia vai até o último elemento, como em phases[2..] para os elementos do índice 2 até o final. Omita ambos os índices quando quiser uma cópia de todo o array, como em phases[..]. Um intervalo pode misturar tipos de índice. A expressão phases[1..^1] combina um índice de início e um índice de ponta para retornar os elementos intermediários code e test.
string[] phases = ["design", "code", "test", "deploy"];
List<string> checklist = ["design", "test", "review"];
Console.WriteLine($"Last: {phases[^1]}");
Console.WriteLine($"Middle: {string.Join(", ", phases[1..3])}");
Console.WriteLine($"Last two: {string.Join(", ", phases[^2..])}");
Console.WriteLine($"Without ends: {string.Join(", ", phases[1..^1])}");
Console.WriteLine($"First two: {string.Join(", ", phases[..2])}");
Console.WriteLine($"From third: {string.Join(", ", phases[2..])}");
Console.WriteLine($"All phases: {string.Join(", ", phases[..])}");
Console.WriteLine($"List last: {checklist[^1]}");
Console.WriteLine($"List first two: {string.Join(", ", checklist[0..2])}");
// This example produces the following output:
//
// Last: deploy
// Middle: code, test
// Last two: test, deploy
// Without ends: code, test
// First two: design, code
// From third: test, deploy
// All phases: design, code, test, deploy
// List last: review
// List first two: design, test
//
Para obter mais informações sobre índices e intervalos, consulte Explorar intervalos de dados usando índices e intervalos nos tutoriais.