C# PARA CONCURSOS

BIZU PARA PROGRAMADORES JAVA/C++

www.patreon.com/almeidajunior

A sintaxe de C# é muito parecida com a de Java e C++. Abaixo segue um HelloWorld em Java e
outro em C#.

EM JAVA

public class HelloWorld {

public static void main(String[] args){
System.out.println("Hello, World!");
}
}
EM C#

public class Program {

public static void Main(string[] args){
System.Console.WriteLine("Hello, World!");

}
}

Note que em ambos os casos, um programa começa executando um método chamado

“Main()”. Isso na verdade é uma herança/cópia do C/C++.

Tipos de valor em C#

Os tipos em C# podem ser Structs ou Enumarations. As Structs podem ser numérica (inteiras
ou ponto flutuante), bool ou definidas pelo usuário.

Para iniciar uma variável além de declarar a variável é preciso iniciar esta variável com seu
construtor. Ou seja, essa variável no fundo é um objeto.

int myInt;

myInt = new int();

myInt = 10;

Um varíavel bool pode receber os valores true ou false. Há também o tipo bool? que, além de
true e false, aceita o valor null.

O tipo byte é inteiro de 0 a 255

O tipo sbyte é inteiro com sinal -129 a 127

O tipo char representa caracteres unicode de 16-bit

O tipo int é para inteiros 32 bits

O tipo long é um inteiro de 64 bits

O tipo short para inteiros de 16 bits

O tipo uint é um inteiro sem sinal de 32 bits (0 até 4,294,967,295)

O tipo ulong é um inteiro sem sinal de 64 bits (0 até 18,446,744,073,709,551,615)

O tipo ushort é um inteiro sem sinal de 16 bits (0 até 65.535)

O tipo decimal é um ponto flutuante com precisão maiores para um faixa curta. Isso faz ele
mais apropriado para cálculos financeiros

O tipo float é um ponto flutuante de 32 bits

O tipo double é um ponto flutuante de precisão dupla (64 bits)

Um grupo de variáveis podem ser encapsuladas usando uma struct. É um estrutura herdada
do C/C++.
public struct Book
{
public decimal price;
public string title;
public string author;
}

Diferente do C, um struct pode ter também métodos e campos.

A palavra-chave enum é usado para enumerações. Exemplos:

enum Day {Sat, Sun, Mon, Tue, Wed, Thu, Fri};

enum Day {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri};

Tipos de Referência

Além dos tipos de valor, existem tipo para as referências.

class: usando para declarar uma classe

delegate: pode receber um método anônimo. Faz o mesmo papel dos ponteiros para funções
em C++. De forma análoga, a um ponteiro para uma variável, você pode acessar um
determinado método.

dynamic: ativa operações a serem resolvidas em tempo de execução.

Interface: uma interface possui apenas a assinatura de métodos, propriedades, eventos ou

indexadores

object: É um alias para Object. Variáveis desse tipo aceitam valores de qualquer tipo, já que
que todos os tipos são filhos diretos ou indiretos do tipo Object.

string: É uma alias para String. Representa uma sequência de caracteres Unicode. Para
concatenar duas strings basta usar +
string a = "good " + "morning";

Um tipo string não pode ter seu conteúdo modificado após sua inicialização. Para acessar um
determinado caractere usamos []; Note que o primeiro caráter está em [0].
string str = "test";
char x = str[2]; // x = 's';

Tipos Void

void representa vazio. É quando um método não retorna nada

Tipos Var

A partir do C# 3.0 variáveis podem ser declaradas baseado no seu escopo. Ou seja, recebem
um tipo implícito. As declarações a seguir são equivalentes. O computador sabe que um int no
primeiro caso, pois foi atribuído o valor 10.
var i = 10; // Implicitly typed.

int i = 10; // Explicitly typed.

Avaliação preguiçosa

Os operadores lógicos && (e lógico) e || (ou lógico) fazem uma avaliação preguiçosa ou de
curto-circuito. Ou seja, o segundo operando será avaliado somente se necessário. Isso pode
ser um problema se sua lógica foi criando esperando que o segundo operando fosse avaliado
(por exemplo, esse operador poderia ser o resultado de uma chamada a um método que faz
executa passos importantes para sua lógica independente do resultado devolvido). O operador
de negação (not) e indicado por !

Operadores Bit a Bit

& => “e” bit a bit

| => “ou” bit a bit

^ => XOR bit a bit

~ => Not

<< deslocamento de bits para esquerda

>> deslocamento de bits para direita

undo operando será avaliado somente se necessário. Isso pode

Outros operadores

Operador Descrição Exemplo

+ Soma A + B = 30

- Subtração A - B = -10

* Multiplicação A * B = 200

/ Divisão B/A=2

% Resto B%A=0

++ Incremento de 1 A++ = 11

-- Decremento de 1 A-- = 9

Operador Descrição

== Igual a

!= Diferente de

> Maior

< Menor

>= Maior ou igual

<= Menor ou igual

Indexadores

Um indexador permite que um objeto seja indexado, como um array. Quando você define um
indexador para uma classe, essa classe se comporta de maneira semelhante a um array. Você
pode acessar a instância dessa classe usando o operador de acesso ao array ([]).

Modificadores de Acesso

internal: tipo ou membro é acessível dentro de um determinado escopo (ou seja, dentro do
mesmo arquivo)

private: membros podem ser acessados somente dentro do corpo da classe ou da estrutura
em que foram declarados

protected: dentro da classe que foi criada e também nas classe derivadas

public: Não há restrição de acesss

Propriedades

Para o usuário de um objeto, uma propriedade parece ser um campo. Acessar a propriedade
requer a mesma sintaxe. Para o implementador de uma classe, uma propriedade consiste em
um ou dois blocos de código, que representam um get e/ou um set.

class Person
{
private string name; // the name field
public string Name // the Name property
{
get
{
return name;
}
set
{
name = value;
}
}
}

Person person = new Person();

person.Name = "Joe"; // the set accessor is invoked here
System.Console.Write(person.Name); // the get accessor is invoked here
Coleta de Lixo

O coletor de lixo procura objetos que não estão mais sendo usados. Se considerar um objeto
qualificado para finalização, ele chamará o finalizador (se houver) e recuperará a memória usada
para armazenar o objeto.

Finalizadores

Finalizadores são usados para destruir instâncias de classes.

class Car
{
~Car() // destructor
{
// cleanup statements...
}
}

O programador não tem controle sobre quando o finalizador é chamado porque isso é
determinado pelo coletor de lixo.

sealed e readonly

Em Java, final faz com que uma classe não seja estendida. Além disso, um método ou variável
final não pode ter seu valor alterado. Em C# existem as palavras chave sealed e readonly.

Quando uma classe recebe o modificador sealed isso evita que outra classe possa herdar dela.
Exemplo:

class A {}

sealed class B : A {}

B é filha de A, mas nenhuma outra class pode ser herdeira de B. Se o programador tentar
fazer:

class C : B {}

Receberá a mensagem C: “cannot derive from sealed type 'SealedClass'”

O pode ser usado em 3 contextos:

1) Na declaração de campo, readonly indica que a atribuição ao campo não pode ser alterada
public readonly int y = 5;

2) Na uma definição struct, readonly indica que a estrutura é imutável.

public readonly struct Point
{
public double X { get; }
public double Y { get; }
public Point(double x, double y) => (X, Y) = (x, y);

}
3) No retorno de uma referência, readonly indica que o método retorna uma referência e não
é possível gravar.
private static readonly Point origin = new Point(0, 0);

public static ref readonly Point Origin => ref origin;