# ICollection

ICollection<T> is the standard interface for countablecollections of objects. It provides the ability to determine the size ofa collection (Count), determine whether an item exists in thecollection (Contains), copy the collection into an array(ToArray), and determine whether the collection is read-only(IsReadOnly). For writable collections, you can also Add,Remove, and Clear items from the collection.
> Página 742 (Livro 6 - C# 9.0 in a Nutshell)

## Queue

Queue - Queue<T> and Queue are first-in, first-out (FIFO) data structures, providing methods to Enqueue(add an item to the tail of the queue) and Dequeue (retrieve and remove the item at the head of thequeue).
> Página 778 (Livro 6 - C# 9.0 in a Nutshell)

Queues are implemented internally using an array that’s resized asrequired—much like the generic List class. The queue maintains indexes that point directly to the head and tail elements; therefore,enqueuing and dequeuing are extremely quick operations (exceptwhen an internal resize is required).
> Página 779 (Livro 6 - C# 9.0 in a Nutshell)

#### Exemplo

Queue<int> queue = new Queue<int>();
            
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);

var num = queue.Peek();
Console.WriteLine(num); // 1

Console.WriteLine($"Na lista há {queue.Count} elemento(s)."); // Na lista há 3 elemento(s).

var numRemovedFromQueue = queue.Dequeue();
Console.WriteLine(numRemovedFromQueue); // 1

Console.WriteLine($"Na lista há {queue.Count} elemento(s)."); // Na lista há 2 elemento(s).

## Stack

Stack are last-in, first-out (LIFO) data structures, providing methods to Push (add an item to the top of the stack) and Pop (retrieve and remove an element from the top of the stack).
> Página 779 (Livro 6 - C# 9.0 in a Nutshell)

#### Exemplo

//Criando a pilha
Stack<int> stack = new Stack<int>();

//Adicionando itens na pilha
stack.Push(111);
stack.Push(222);
stack.Push(333);

//Removendo o item do topo da pilha
stack.Pop();

//Exibindo itens da pilha
foreach (int i in stack) 
{
  Console.WriteLine(i); 
}

# ISet

This interface provides methods for implementing sets, which are collections that have unique elements and specific operations. The HashSet<T> and SortedSet<T> collections implement this interface.

Implements: ICollection<T>, IEnumerable<T>, IEnumerable

## HashSet

O HashSet é uma coleção de alto desempenho onde seus elementos são únicos e não são ordenados.

Isso é extremamente útil em processos onde temos uma situação crítica com milhões de dados a serem inseridos em um Set.

Por outro lado, a garantia de continuidade na ordem dos elementos inseridos é zero, ou seja, esse tipo de estrutura é indicada se você precisa apenas garantir a alta performance sem se importar com a ordem com que os elementos estão ordenados.

#### Principais características
- Fornece operações com alto desempenho, como exemplo os métodos contains
- Não permite armazenar elementos duplicados, sendo ignorado silenciosamente.
- Não permite acessar um elemento por posição.
- Não há capacidade máxima para os elementos no HashSet. A capacidade aumenta à medida que o número de elementos aumenta.
- Não há uma ordem específica dos elementos do HashSet.

#### Principais métodos
- Add - Este método adiciona o elemento especificado ao conjunto.
- Clear - Este método remove todos os elementos de um objeto HashSet.
- Contains - Este método determina se um objeto HashSet contém o elemento especificado.
- Remove - Este método remove o elemento especificado do objeto HashSet.
- TryGetValue - Este método pesquisa o conjunto para um determinado valor e retorna o valor igual se o encontrar.
- UnionWith - Este método modifica o objeto HashSet atual para conter todos os elementos que estão presentes em si mesmo, a coleção especificada ou ambos.
- IntersectWith - Este método modifica o objeto HashSet atual para conter apenas os elementos presentes nesse objeto e na coleção especificada.

#### Exemplo

var set1 = new HashSet<string>();
var set2 = new HashSet<string>() { "Feijão", "Café", "Açúcar" };

set1.Add("Maça");
set1.Add("Banana");
set1.Add("Uva");
set1.Add("Arroz");
set1.Add("Maça"); // Ignorado

// remove o elemento "Arroz"
set1.Remove("Arroz");

// adiciona os elemento do set2 no set1
set1.UnionWith(set2);

// remove o elemento "Açúcar"
set1.Remove("Açúcar");

Console.WriteLine("Os elemetnos no HashSet são: ");

foreach (var i in set1)
    Console.WriteLine($"- {i}");
/*
 * Maça
 * Banana
 * Uva
 * Feijão
 * Café
 */

// determina se o HashSet contém o elemento especificado
Console.WriteLine("Uva está presente no HashSet? " + set1.Contains("Uva")); // True
Console.WriteLine("Arroz está presente no HashSet? " + set1.Contains("Arroz")); // False

> C# 9.0 in a Nutshell - HashSet<T> and SortedSet<T> - Página 782
> [C# HashSet Tutorial - Understanding HashSet in C# (knowledgehut.com)](https://www.knowledgehut.com/tutorials/csharp/csharp-hashset-collection)
> [HashSet<T> Classe (System.Collections.Generic) | Microsoft Docs](https://docs.microsoft.com/pt-br/dotnet/api/system.collections.generic.hashset-1?view=net-5.0)

## SortedSet
#### Namespace: System.Collections.Generic

#### Principais características

- O ```SortedSet``` implementa as interfaces ICollection, IEnumerable, IReadOnlyCollection, ISet, ICollection, IEnumerable, IDeserializationCallback, and ISerializable.
- A capacidade de um SortedSet é o número de elementos que ele pode conter.
- Em SortedSet, os elementos devem ser exclusivos.
- Em SortedSet, a ordem do elemento é crescente.
- O SortedSet pode ser usado se você tiver que armazenar elementos únicos e manter a ordem crescente.
- No SortedSet, o usuário só pode armazenar o mesmo tipo de elementos.

#### Principais métodos
- Add - Este método adiciona o elemento especificado ao conjunto.
- Clear - Este método remove todos os elementos de um objeto ```SortedSet```.
- Contains - Este método determina se um objeto ```SortedSet``` contém o elemento especificado.
- Remove - Este método remove o elemento especificado do objeto ```SortedSet```.
- TryGetValue - Este método pesquisa o conjunto para um determinado valor e retorna o valor igual se o encontrar.
- UnionWith - Este método modifica o objeto ```SortedSet``` atual para conter todos os elementos que estão presentes em si mesmo, a coleção especificada ou ambos.
- IntersectWith - Este método modifica o objeto ```SortedSet``` atual para conter apenas os elementos presentes nesse objeto e na coleção especificada.
- GetViewBetween(T, T) -
Retorna uma exibição de um subconjunto em um ```SortedSet<T>```.

#### Exemplo

public sealed class Pessoa: IComparable<Pessoa>
{
    public Pessoa(string nome, int idade)
    {
        Nome = nome;
        Idade = idade;
    }

    public string Nome { get; set; }
    public int Idade { get; set; }

    public int CompareTo(Pessoa other)
    {
        // Ordenação padrão : da maior idade para o menor
        return other.Idade.CompareTo(this.Idade);
    }
}

var set1 = new SortedSet<Pessoa>();
var pessoa01 = new Pessoa("Marduquenadinaqui", 55);
var pessoa02 = new Pessoa("Eanasarrausur", 80);
var pessoa03 = new Pessoa("Nabopolassar", 19);
var pessoa04 = new Pessoa("Nabucodonosor", 33);

set1.Add(pessoa01);
set1.Add(pessoa02);
set1.Add(pessoa03);
set1.Add(pessoa04);
set1.Add(pessoa01);

Console.WriteLine("Os elemetnos no SortedSet são: ");

foreach (var i in set1)
    Console.WriteLine($"- Nome:{i.Nome} Idade:{i.Idade}");

/*
 * - Nome:Eanasarrausur Idade: 80
 * - Nome:Marduquenadinaqui Idade: 55
 * - Nome:Nabucodonosor Idade: 33
 * - Nome:Nabopolassar Idade: 19
 */

> C# 9.0 in a Nutshell - HashSet<T> and SortedSet<T> - Página 782
> [SortedSet in C# with Examples (www.geeksforgeeks.org)](https://www.geeksforgeeks.org/sortedset-in-c-sharp-with-examples/)
> [HashSet<T> Classe (System.Collections.Generic) | Microsoft Docs](https://docs.microsoft.com/pt-br/dotnet/api/system.collections.generic.sortedset-1?view=net-5.0)