ConcurrentDictionary<T>, coleções imutáveis
Use ConcurrentDictionary para atualizações seguras em ambientes com várias threads e aprenda abordagens imutáveis simples: visões somente leitura e cópia ao escrever.
ConcurrentDictionary<T>, coleções imutáveis é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 2 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 3 aulas no total.
Noções básicas de segurança de threads e imutabilidade
Hoje:
- ConcurrentDictionary<TKey,TValue>: atualizações seguras a partir de várias threads
- Visões de somente leitura em oposição à verdadeira imutabilidade
- Ideia de cópia na escrita para obter segurança simples
Operações atómicas: GetOrAdd/AddOrUpdate
Utilize GetOrAdd e AddOrUpdate para operações atómicas; utilize TryGetValue para ler com segurança.
using System;
using System.Collections.Concurrent;
public class Program
{
public static void Main(string[] args)
{
ConcurrentDictionary<string, int> counts = new ConcurrentDictionary<string, int>();
// Add if missing
int a = counts.GetOrAdd("apple", 0); // 0
// Increment safely
int newVal = counts.AddOrUpdate("apple", 1, (key, oldValue) => oldValue + 1);
Console.WriteLine("apple was " + a + ", now " + newVal);
int value;
bool ok = counts.TryGetValue("apple", out value);
Console.WriteLine("Has apple? " + ok + " -> " + value);
}
}
Ideia de incremento sem condições de corrida
AddOrUpdate evita a condição de corrida clássica de leitura-modificação-escrita ao atualizar atomicamente.
using System;
using System.Collections.Concurrent;
public class Program
{
static int Inc(int oldValue) { return oldValue + 1; }
public static void Main(string[] args)
{
ConcurrentDictionary<string, int> clicks = new ConcurrentDictionary<string, int>();
// Simulate multiple updates
for (int i = 0; i < 5; i++)
{
clicks.AddOrUpdate("home", 1, delegate(string k, int v) { return Inc(v); });
}
Console.WriteLine("home clicks = " + clicks["home"]); // 5 (starting at 1 then +4)
}
}
Visão somente de leitura (não imutável)
AsReadOnly devolve uma visão somente de leitura, não uma coleção verdadeiramente imutável: as alterações na origem aparecem na visão.
using System;
using System.Collections.Generic;
public class Program
{
public static void Main(string[] args)
{
List<string> items = new List<string>(new string[] { "A", "B" });
var ro = items.AsReadOnly(); // ReadOnlyCollection<string>
foreach (string s in ro) Console.WriteLine(s); // A, B
// ro.Add("C"); // not available: read-only view has no Add
// But changing the source list reflects in the view:
items.Add("C");
Console.WriteLine("After source change:");
foreach (string s in ro) Console.WriteLine(s); // A, B, C
}
}
Fotografia com cópia na escrita
Cópia na escrita: devolva uma nova lista para efetuar alterações. Os chamadores que mantiverem a lista antiga verão uma fotografia estável.
using System;
using System.Collections.Generic;
public class Program
{
static List<int> AddWithoutTouchingOriginal(List<int> original, int item)
{
// create a copy and modify the copy
List<int> copy = new List<int>(original);
copy.Add(item);
return copy;
}
public static void Main(string[] args)
{
List<int> a = new List<int>(new int[] { 1, 2 });
List<int> b = AddWithoutTouchingOriginal(a, 3);
Console.WriteLine("Original:");
foreach (int x in a) Console.WriteLine(x); // 1,2
Console.WriteLine("Copy:");
foreach (int x in b) Console.WriteLine(x); // 1,2,3
}
}
Dicas e compromissos
Dicas:
- Utilize ConcurrentDictionary para contadores e caches partilhados.
- AsReadOnly evita alterações acidentais por parte dos consumidores.
- Para obter uma visão estável, copie a lista antes de a modificar.
- As coleções verdadeiramente imutáveis encontram-se em System.Collections.Immutable (pacote); não são utilizadas aqui para manter o código autónomo.
Escolha de dicionário seguro para threads
Recapitulação
Recapitulação: utilize ConcurrentDictionary para atualizações concorrentes. Exponha visões somente de leitura aos chamadores e utilize cópia na escrita quando precisar de fotografias estáveis.
Perguntas Frequentes
A aula “ConcurrentDictionary<T>, coleções imutáveis” é grátis?
Sim — o texto completo de “ConcurrentDictionary<T>, coleções imutáveis” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 3 aulas no total.
O que vou aprender em “ConcurrentDictionary<T>, coleções imutáveis”?
Use ConcurrentDictionary para atualizações seguras em ambientes com várias threads e aprenda abordagens imutáveis simples: visões somente leitura e cópia ao escrever. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar C# Academy?
Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 3.
Quanto tempo leva a aula “ConcurrentDictionary<T>, coleções imutáveis”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de C# Academy?
Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- HashSet , SortedSet , Queue , Stack
- ConcurrentDictionary , coleções imutáveis
- Igualdade e hashing (valor versus referência)