---
# System prepended metadata

title: Operators

---

# Operators

### - Eduardo:

## typeof

- O operador <i><b>`typeof`</b></i> pega o System.Type de uma variável.
- O argumento recebido pelo typeof tem que ser um tipo, ou um parametro de um tipo.

<b>code:
```csharp=
void PrintType<T>() => Console.WriteLine(typeof(T));

Console.WriteLine(typeof(List<string>)); 
// output System.Collections.Generic.List`1[System.String]

PrintType<int>();
// System.Int32

PrintType<System.Int32>();
// System.Int32

PrintType<Dictionary<int, char>>();
// System.Collections.Generic.Dictionary`2[System.Int32,System.Char]
```
</b>
- Também pode ser utilizado com tipos genéricos não associados;

<b>code:
```csharp=
Console.WriteLine(typeof(Dictionary<,>));
// System.Collections.Generic.Dictionary`2[TKey,TValue]
```
</b>


## checked

O <i><b>`checked`</b></i> é usado para determinar se o estouro aritmético será considerado como um erro. Então se o valor passar do limite que o tipo suporta uma exceção será lançada impedindo que o valor seja usado inadvertidamente. Por razões de performance o padrão é não emitir exceção e deixar o código correr errado.
<b>code:
```csharp=
// Checked block.
checked
{
    int i3 = 2147483647 + ten;
    Console.WriteLine(i3);
}
``` 
</b>

São raros os casos que ele é necessário. Ele pode ser útil em casos que quase nunca ocorrerá o problema, mas quando ocorrer é bom que não "passe batido".

## unchecked

A palavra-chave <i><b>`unchecked`</b></i> é usada para suprimir a verificação estouro para conversões e operações aritméticas de tipo integral.

- Por estar em um contexto `unchecked` o estouro não será sinalizado;
- Será atribuido o valor de: -2.147.483.639 para não estourar.

<b>code:
```csharp=
int int1;
		
unchecked
{
   int1 = 2147483647 + 10;
}

int1 = 2147483647 + 10;
```
</b>

- Em tempo de compilação, será identificado o "estouro" de limite do tipo int.


## stackalloc

- Uma <i><b>`stackalloc`</b></i> expressão aloca um bloco de memória na pilha;
- O único motivo de uso stackalloc é o desempenho (para cálculos ou interoperabilidade);
- Você pode atribuir o resultado de uma stackalloc expressão a uma variável de um dos seguintes tipos:

<b>code:
```csharp=
int length = 3;
Span<int> numbers = stackalloc int[length];
for (var i = 0; i < length; i++)
{
    numbers[i] = i;
}
```
</b>
- Em termos de desempenho, se você usar stackalloc, aumentará muito a chance de acertos do cache na CPU devido à localidade dos dados.

Curiosidade sobre a segurança:

- O uso de stackalloc habilita automaticamente os recursos de detecção de estouro de buffer no CLR (Common Language Runtime). Se for detectada uma estouro de buffer, o processo será encerrado assim que possível para minimizar a chance de o código mal-intencionado ser executado.

## default

Uma expressão de valor padrão produz o valor padrão de um tipo. Há dois tipos de expressões de valor padrão: a chamada de operador padrão e um literal padrão.

- O argumento do operador default deve ser o nome de um tipo ou um parâmetro de tipo:

<b>code:
```csharp=
Console.WriteLine(default(int));  // output: 0
Console.WriteLine(default(object) is null);  // output: True

void DisplayDefaultOf<T>()
{
    var val = default(T);
    Console.WriteLine($"Default value of {typeof(T)} is {(val == null ? "null" : val.ToString())}.");
}

DisplayDefaultOf<int?>();
DisplayDefaultOf<System.Numerics.Complex>();
DisplayDefaultOf<System.Collections.Generic.List<int>>();
// Output:
// Default value of System.Nullable`1[System.Int32] is null.
// Default value of System.Numerics.Complex is (0, 0).
// Default value of System.Collections.Generic.List`1[System.Int32] is null.
```
</b>

Literal padrão:

- Na atribuição ou inicialização de uma variável.
- Na declaração do valor padrão para um parâmetro de método opcional.
- Em uma chamada de método para fornecer um valor de argumento.
- Em uma return instrução ou como uma expressão em um membro apto para expressão.

EX:

<b>code:
```csharp=
Console.WriteLine(default(int));  // output: 0
Console.WriteLine(default(object) is null);  // output: True

void DisplayDefaultOf<T>()
{
    var val = default(T);
    Console.WriteLine($"Default value of {typeof(T)} is {(val == null ? "null" : val.ToString())}.");
}

DisplayDefaultOf<int?>();
DisplayDefaultOf<System.Numerics.Complex>();
DisplayDefaultOf<System.Collections.Generic.List<int>>();
// Output:
// Default value of System.Nullable`1[System.Int32] is null.
// Default value of System.Numerics.Complex is (0, 0).
// Default value of System.Collections.Generic.List`1[System.Int32] is null.
```
</b>


Nameof: é o nome que dá a uma váriavel tipo ou membro de uma constante 
de cadeia de caractere:

Uma nameof expressão é avaliada em tempo de compilação e não tem nenhum efeito no tempo de execução, pode ser usada 
para tornar o código de verificação de argumento mais passivel de manutenção.


Delegate
Esse operador cria um método anonimo que pode ser convertido em um método em 
um tipo delegado
