<C# Essentials>
?? > Coalescência nula (retorna da esquerda se n for null) ex. i = e ?? z ?? "1";
* funciona com tipos numéricos apenas nullable
Descarte IDisposable e Garbage Collector
Dispose > método p/ liberar memória usada antes do Garbage Collector
* outra alternativa é o Destructor.
* p/ usar a classe deve implementar IDisposable.
* pode, por ex. chamar método do Garbage Collector.
* ao usar palavra chave using c/ p/ definir escopo, chama
Dispose implícitamente
* importante para gerenciamento de recursos que não são gerenciados pela CLR.
* ao implementar usar [Link](), evitar chamar novamente para o recurso.
Garbage Collector > automação de gerenciamento de memória
* classe GC pode ser usada p/ forçar a coleta.
Memória : Heap (classes) | Stack (variáveis)
Ao instanciar classe, objeto de referência é gerado no Heap. As variáveis desse
objeto
ficam no Stack. Elas apontam para o Heap, a medida que possuem um endereço para o
objeto
de referência.
Membros Static
Membros de CLASSE, n são membros de instância.
ex.
public static ClassExample MyProperty = null;
public static ClassExample GlobalAcess { get { return MyProperty; } }
Usos: classes utilitárias, constantes
Classe estática: possui somente membros estáticos, n pode ser instanciada.
IMPORTANTE: Em métodos Static, n se pode chamar membros de instância.
Aula 11
Sobrecarga: Permite que métodos e construtores de classes possam ter diferentes
assinaturas.
Aula 12: Encapsulamento
Esconder detalhes de implementação, expondo apenas o NECESSÁRIO.
Objetivo: manter estado consistente.
What is a struct?
Aula 15: Desalocação de Memória
Garbage Collector > automatiza gerenciamento de memória, monitorando objetos no
Heap.
* no stack desaloca ao fim do escopo.
Aula 17: 1. Boxing x 2. Unboxing
1. conversão objeto valor > referência
2. conversão objeto referência > valor
* objetos devem ser compatíveis
1. ex.
int i = 1;
object obj = i;
2. ex.
object obj = 1;
int i = Convert.ToInt32(obj);
* há prejuízo de processamento em ambas as práticas
Modificadores de Acesso
private > impede referência.
protected > apenas classes subclasses.
private protected > apenas subclasses no assembly
internal > classes no assembly.
public > referência em qualquer lugar.
Aula 23: Upcasting e Downcasting
* conversão e atribuição entre classes bases e derivadas.
Up > subclasse para a superclasse
* ex. a variável base pode receber um objeto de uma classe herdada
Account acc1 = new Account("Fernando", 12.2);
BusinesAccount acc2 = new BusinesAccount(12.4, "Maria", 12.3);
acc1 = acc2;
Account acc3 = new BusinesAccount(12.4, "Maria", 12.3);
uso: polimorfismo
ex.
Down > superclasse para subclasse
uso: métodos que recebem parâmetros genéricos, ex. Equals()
* operação insegura
Palavras as e is
Is > verifica se uma variável é uma instância de um tipo ex.
if (acc1 is Account)
[Link]("acc1 é uma instância de Account");
As > outro modo de fazer um casting
GameObject spawnPoint = Instantiate(SpawnPoint, point, [Link])
as GameObject;
* o retorno do método Instantiate é um object, ao usar as, garante conversão em um
gameObject, classe que implementa object
* necessário que sejam classes intercambiáveis.
Aula 24: Sobreposição (palavras virtual, override e base)
Implementação de um método da superclasse na subclasse.
virtual > permite que um método seja sobrescrito.
override > usado para sobrescrever um método.
base > chama a implementação da superclasse/referência à superclasse.
Aula 25: Sealed (Classes e métodos selados)
Classe > evita que seja herdada, proteção de regra de negócio
ex. sealed class SavingsAccount {}
Método: evita que um método sobreposto (override) possa ser sobreposto novamente.
sealed internal override double WithDraw(double value)
{
double tax = Balance * 0.05f;
double diference = value + tax;
Balance -= diference;
return [Link](Balance);
}
* convém selar métodos sobrepostos
* processamento mais rápido + PERFORMACE
Aula 26: Polimorfismo
Recurso que permite com que variáveis de um mesmo tipo mais genérico possam apontar
para objetos de tipos específicos diferentes, assumindo comportamentos diferentes.
ex. objetos diferentes de mesmo tipo
Account acc1 = new SavingsAccount(1.2, "Xavier", 100);
Account acc2 = new BusinesAccount(1.2, "Maria", 100);
Aula 27: Classes Abstratas : garante herança total
Não podem ser instanciadas
ex. abstract class Course {}
Vantagens: reuso, polimorfismo, manutenção
Aula 28: Métodos Abstratos : não possuem implementação
ex. quando a classe é genérica demais para conter a implementação
Base FormaGeometrica > Derivadas Retângulo e Circulo
Define método abstrato Área, sem implementação.
public abstract double Area();
Uso: polimorfismo
IMPORANTE: Se a classe possuir pelo menos um método abstrato, então ela é
abstrata.
As classes derivadas devem implementar os seus métodos abstratos.
Subscrita do método com override.
Aula 29: Interfaces
Tipo que define um conjunto de operações (contrato)que uma classe ou struct deve
implementar.
IMPORANTE: define apenas o contrato.
Vantagens
1. Baixo Acomplamento/Polimorfismo.
2. Flexíveis.
Aula 30: Injeção de Dependência (- Acoplamento)
Padrões de design: Facade, Simple Factory, Factory e Abstract Factory.
- Inversão de Controle.
Consiste em retirar da classe a responsabilidade de instanciar
suas dependências
ex. Injeção de Dependência
antes) classe ServicoImposto tinha um atributo ImpostoBrasil, que retorna a taxa
relativa ao país.
Porém, se a solução precisar englobar outro país?
agora) classe ServicoImposto tem um atributo ImpostoPais (classe base para
ImpostoBrasil), null.
O atributo é instanciado com QUALQUER ImpostoPaisEspecifico que herda de
ImpostoPais, via
CONSTRUTOR da classe. Desse modo INVERTE o controle e injeta a dependência
na classe que
instancia o ServicoImposto.
* Classe n instancia a sua dependência.
Outros modos: objetos de instanciação (build factory), ou Containar/Framework
Aula 31: Métodos Genéricos, Método<T>()
[Link]
Aula 32: Estruturas de Armazenamento de Dados
Array: Vetor, Matriz > Possui tamanho fixo dado na instanciação do objeto. (Memória
Alocada Sequencialmente + PERFORMACE)
Itens das coleções dentro de um LOOP disponibilizados SOMENTE
LEITURA
Posições fixas.
No momento em que instancia a lista com as posições, o espaço já
foi reservado, com dados vazios.
- Flexível/ + Simples
ArrayList (Coleções): List<T> > (Memória alocada dinâmicamente - PERFORMACE)
Pode adicionar e remover, se redimensionamento dinâmicamente.
Pode ALETERAR os itens da coleção em um LOOP
Vt[n1] > array unidimensional sendo n = indicie
Matriz[n1, n2] > bi/tridimensional
Obs: Vetor + DESEMPENHO em relação à list<T>
IEnumerable x IQueryable
IEnumerable > ex. List<T>, coleção de objetos ENUMERADOS.
IQueryable > deriva de IEnumerable, admite Lazy Loading, usado p/ consulta
database.
Conjuntos
Aula 33: Generics<T>
ex.
static object DisplayAndReturnInputObject<T>(string displayText)
{
[Link](displayText);
switch ([Link](typeof(T)))
{
case TypeCode.Int64:
return [Link]([Link]());
case TypeCode.Int32:
return [Link]([Link]());
case [Link]:
return [Link]([Link]());
default:
return null;
}
}
Aula 34: 1. Herança x 2. Cumprir Contrato
1. REUSO
2. CONTRATO
ex. Interface apenas DEFINE operações a serem cumpridas, as classes
derivadas N HERDAM as propriedades/atributos.
para Definir Impletamentação que combina as duas, ex.
Interface (contrato) <- Classe Abstrata (atributos) <- Classes derivadas
* Define o contrato e permite o reuso.
* é possível implementar uma Interface de forma abstrata.
Aula 35: Herança Múltipla
Problema do Diamente: Ambiguidade gerada pela existência de um mesmo método em mais
de uma super classe.
* n é permitida no c#.
* é possível implementar uma classe + INTERFACEs
Aula 37: Delegates
É como um classe que carregar uma assinatura padrão, podendo referenciar
um ou mais métodos, com assinatura semelhante. Pode invocar o método de
referência a partir desta classe.
Atalho para execução de um método sem conhecer a classe que o implementa.
Elemento do C# que permite fazer referência a um método.
É uma classe na qual quando criamos a sua instância passamos como parâmetro no
construtor uma função.
IMPORTANTE: usado por exemplo em eventos/interface de usuário (Onclick, etc.)
Etapas de Uso:
1. Declaração
2. Instanciação
3. Invocação
ex.
-----------------------------------------------------------------------------------
-------
static void Main(string[] args)
{
RetornarNumero retorno1 = new RetornarNumero(Retornar1Se2); //
instanciação
[Link](retorno1(2)); // invocação
[Link]();
}
delegate int? RetornarNumero(int numero); // declaração
public static int? Retornar1Se2(int numero)
{
if (numero == 2)
return 1;
else
return null;
}
-----------------------------------------------------------------------------------
-------
* todo delegate possui uma assinatura, ex.
Delegate int ExemploDeDelegate(string nome, bool b);
Método: private int ExemploDeFunction(string str, bool bln)
{...} pode ser passado para o Delegate assim:
ExemploDeDelegate macoratti = new ExemploDeDelegate(ExemploDeFunction);
Vantagem: implementar qualquer funcionalidade em tempo de execução.
Aula 38: Generics
Permitem que classes, interfaces e métodos possam ser parametrizados por tipo.
Vantagens: reuso, type safety (programação defensiva), performace
Uso comum: coleções
ex.
class PrintService<T>
{
T[] values;
int count = 0;
int NumberSpacesInVector;
public PrintService(int numberSpacesInVector)
{
NumberSpacesInVector = numberSpacesInVector;
values = new T[NumberSpacesInVector];
}
public void AddValue(T value)
{
if (count == NumberSpacesInVector)
throw new InvalidOperationException("Vetor está cheio");
values[count] = value;
count++;
}
public void Print()
{
[Link]("[");
for (int i = 0; i < [Link]; i++)
{
if (i != NumberSpacesInVector - 1)
[Link]([Link](values[i], ", "));
elsemét
[Link]([Link](values[i], "]"));
}
}
public T First()
{
if (count == 0)
throw new InvalidOperationException("Vetor está vazio.");
return values[0];
}
}
* IMPORANTE: erro comum ao criar métodos de aplicação genérica, usar object, porém:
- Sem type safety, não sabe qual tipo do retorno, COMPILADOR N AJUDA, pode dar
erro.
- Dispensa processamento ao regularmennte fazer box/unboxing entre object e
derivados
Restrições: A classe/método genérico terá alguma restrição,
ex. deverá implementar a interface IComparable
public class PrintService<T> where T : IComparable
Aula 39: GetHashCode() (de object)
- Compara se um objeto é igual a outro. + Rápido que Equals, - Precisão
- retorna int gerado a partir das informações do objeto.
- Gera um HashCode diferente a cada execução, mas serve para comparar.
! Para ter certeza, utiliza o HashCode e o equals apenas se validar no hash code
primeiro
IMPORANTE: possívell override esse método, e o Equals()
Aula 40: Conjuntos, 1. HashSet<T> e 2. SortedSet<T>
Using [Link];
Representam conjuntos algébricos.
- N adimitem repetições
- Elementos sem posição
- + Rápido em acessar, inserir e remover
- Oferece operações eficientes de conjunto: inserção, união e diferença
- No foreach dados readonly
- N adiciona dados repetidos. IMPORTANTE: Equals valida se é repetido ou não
1. Armazena em tabela Hash, + rápido, MAS n garante a ordem dos elementos.
- elementos indexados com base em seu valor hash.
2. Armazena em árvore (arvore binária), ordendados conforme implementação
IComparer<T>
Métodos: Add(), Clear(), Contains(),
UnionWith(other) > adiciona no conjunto os elementos do other > UNIAO
IntersectWith(other) > remove do conjunto os elementos n contidos em ohter >
INTERSECCAO
ExceptWith(other) > remove os elementos contidos em other > DIFERENCA
Remove(T)
RemoveWhere(Predicate)