O C# seria uma evolução do C++ (seria quatro + formando um #), mas de uma forma mais simplificada e fácil de trabalhar, e se assemelha com o Java em muita coisa. O C# permite criar aplicações para Windows facilmente, mas necessita ter o framework .NET instalado.
Para começar a criar programas em C#, primeiro abra o Visual Studio, abra um projeto novo C# e escolha o template Console Application (aplicação de console). Para visualizar os arquivos dele, vá em exibir e em gerenciador de soluções (ou solution explorer).
Como pode ver essa é a estrutura básica de um programa em C#:
using System;
namespace OlaMundo {
class Program {
static void Main(string[] args) {
}
}
}
O namespace (espaço de nome), é derivado do nome do projeto (seria o equivalente ao pacote do Java), dentro dela tem uma classe denominada Program, e dentro dessa o método main, que é o método principal do programa.
Para exibir uma mensagem, usamos a classe Console, no caso o objeto, Console.WriteLine(), dessa forma:
using System;
namespace OlaMundo {
class Program {
static void Main(string[] args) {
Console.WriteLine("Olá Mundo!");
Console.ReadLine();
}
}
}
PS: Podemos escrever apenas cw e dar um tab para escrever Console.WriteLine().
Como visto acima, usamos um Console.ReadLine() no programa, isso é para pausar o programa de forma que podemos visualizar ele.
Para não ter que colocar ele, podemos usar Ctrl F5 para executar os programas.
PS: O WriteLine e o ReadLine pulam uma linha, se não quiser que pule linhas, use Console.Write() e Console.Read().
Os comentários de uma linha se colocam ao lado de //, e de várias linhas entre /* */, por exemplo:
// Comentário de uma linha
/*
Comentário
de
várias
linhas
*/
PS: Para personalizar o editor, impedindo que ele quebre a linha em condicionais, laços e funções, vá em Ferramentas, Opções, Editor de Texto, C# e Geral, e vá em "Desativar quebra automática de linha". Também vá em Ferramentas, Opções, Editor de Texto, C#, Estilo do Código, Formatação e Geral e vá em "Desativar formatar automaticamente ao digitar". Ainda em Editor, C#, Estilo do Código, Formatação, Novas Linhas, desmarque todas as opções.
Para compilar um programa em C# sem depender do Visual Studio, use no CMD o comando C:\Windows\Microsoft.NET\Framework\v3.5\csc.exe /out:Aplicacao.exe Aplicacao.cs.
O namespace é usado para organizar tipos e classes, evitando colisões de nomes (diferente do namespace do C++, na verdade seria algo mais próximo do package do Java). Basicamente, um namespace é uma coleção nomeada de classes, e todas as classes devem estar dentro desse namespace.
A classe Console, por exemplo, pertence ao namespace System, que é chamado pelo using no programa, o nome completo dela seria System.Console. Se criarmos uma classe Console no nosso projeto, ela será diferenciada pelo namespace, por exemplo:
System.Console.WriteLine("Padrão do C#");
MinhasClasses.Console.FuncaoInventada();
A diretiva using traz o namespace para o escopo do nosso projeto, assim não é necessário qualificar explicitamente os objetos com o respectivo namespace (o Console.WriteLine(), por exemplo, com o using, não precisa ter escrito o nome completo System.Console.WriteLine()). Ou seja, inclui outros namespaces no programa (de forma parecida com o import do Java ou o include do C/C++). Veja abaixo um exemplo de Olá, Mundo sem o using:
namespace OlaMundo {
class Program {
static void Main(string[] args) {
System.Console.WriteLine("Olá Mundo!");
System.Console.ReadLine();
}
}
}
As classes sempre são compiladas em assemblies (montagens), os assemblies são containers para as classes, que são arquivos usualmente com a extensão .dll (bibliotecas de vínculo dinâmico do Windows). As classes mais comuns, como a System.Console pertencem ao assembly mscorlib.dll (presente na plataforma .NET), que permite o reuso de código para que funcione corretamente nos programas em C#.
Uma montagem (assembly) pode conter classes definitdas em muitos namespaces, e um namespace também podem ocupar vários assemblies (principalmente quando tem muitas classes). Para que possamos usar as classes de um assembly, devemos adicionar uma referência no projeto e incluir a diretiva using adequada.
Uma referência permite que utilizemos tipos disponível em outros assemblies, tanto do FCL (Framework Class Library, as classes padrões do C#) quanto de terceiros.
No gerenciador de soluções, podemos ver que tem uma pasta com o nome referências, que mostra todas as referências vinculadas a nossa aplicação, podemos adicionar outras referências por ali mesmo ou pelo menu em projeto.
Vamos fazer um exemplo de como adicionar uma referência, no caso, para utilizar o MessageBox.show(), que abrirá uma caixinha gráfica, veja o código abaixo. Para o código funcionar, vamos em projeto, adicionar referência, e em .NET, procuraremos System.Windows.Forms, que é para interfaces gráficas.
Para utilizar essa referência, chame ela com a diretiva using System.Windows.Forms, veja o código completo abaixo:
using System;
using System.Windows.Forms;
namespace OlaMundo {
class Program {
static void Main(string[] args) {
Console.WriteLine("Olá Mundo!");
MessageBox.Show("Apredendo a Utilizar Referências", "Referências");
}
}
}
Podemos exibir outras opções nas MessageBox, como por exemplo:
MessageBox.Show("Ocorreu um Erro no aplicativo!", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error); // Para erros
MessageBox.Show("Aviso do aplicativo!", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning); // Para avisos
MessageBox.Show("Informação do aplicativo!", "Informação", MessageBoxButtons.OK, MessageBoxIcon.Information); // Para informações
Podemos também gerar caixas de pergunta, como nesse exemplo:
DialogResult resultado = MessageBox.Show("Pergunta do aplicativo!", "Pergunta", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if(resultado == DialogResult.Yes) {
MessageBox.Show("Foi escolhido o sim!", "Informação", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else {
MessageBox.Show("Foi escolhido o não!", "Informação", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
Esse é um exemplo básico de criação de variáveis comuns em C#:
int numero;
string nome;
Para atribuir valores também não há segredo, igual outras linguagens, utilizamos o =, dessa forma:
int numero;
string nome;
numero = 30;
nome = "Teste";
PS: O = é usado para atribuição, se formos comparar igualdade de valores numéricos usaremos ==, se for strings e objetos usaremos o método Equals().
E assim como em outras linguagens semelhantes, também podemos atribuir junto com a declaração, e declarar variáveis do mesmo tipo juntas, dessa forma:
int num2 = 50;
int x = 20, y = 40;
int x = 20;
bool a = true;
Esses são os tipos de variáveis usadas em C#:
| Tipo | Descrição | Tamanho (bytes) | Faixa |
|---|---|---|---|
| int (Int32) | Números Inteiros | 4 | -2147483648 a 2147483647 |
| int (Int64) | Números Inteiros | 8 | -263 até 263 - 1 |
| float | Ponto Flutuante | 4 | +- 1,5 x 10-45 a +- 3,4 x 1038 |
| double | Ponto Flutuante | 8 | +- 5,0 x 10-324 a +- 1,7 x 10308 |
| decimal | Valores Monetários | 16 | 28 Dígitos Significativos |
| string | Sequência de Catacteres | 2 p/ caractere | Infinita |
| char | Caractere Único | 2 | 0 até 216 - 1 |
| bool | Lógico | 1 | true ou false |
| DateTime | Data e Hora | Indefinido | Precisão até 100ns |
PS: Letras únicas em char se coloca entre aspas simples, cadeias de caracteres se coloca entre aspas duplas.
Lembrando que, em números float, pode ser necessário colocar um f após ele, principalmente em parâmetros, como 45.9f, e o char só permite uma letra e deve usar aspas simples.
Existem outros tipos de variáveis em C#, mas esses são os mais comuns. No C# todo tipo primitivo é um objeto, igual as classes invólucro, diferente do Java que nele os tipos primitivos não são objetos.
Veja um exemplo prático de código em C#:
using System;
namespace Variaveis {
class Program {
static void Main(string[] args) {
int x = 20;
bool a = true;
Console.WriteLine("O número é " + x);
Console.WriteLine("E o valor lógico é: " + a);
Console.Read();
}
}
}
Pode ver no código acima que a concatenação de variáveis é feita utilizando o +.
PS: Pode ser que seja necessário converter a variável antes de exibir, nesse caso basta usar o método assim:
Console.WriteLine("O número é " + x.ToString());
Console.WriteLine("E o valor lógico é: " + a.ToString());
Veja o código completo e mais detalhado abaixo:
using System;
namespace Variaveis {
class Program {
static void Main(string[] args) {
int x = 90;
bool a = true;
int y;
y = x;
Console.WriteLine("O número é " + x.ToString());
Console.WriteLine("E o valor lógico é: " + a.ToString());
Console.WriteLine("O número é: " + y.ToString());
Console.Read();
}
}
}
PS: Para declarar constantes (que não podem ser alteradas), basta colocar const antes do nome e tipo e inicializar elas, por exemplo:
const double PI = 3.14159;
Podemos também criar variáveis com classes invólucros, como objetos, por exemplo:
Int32 numero = new Int32();
Double real = new Double();
Boolean logico = new Boolean();
Char letra = new Char();
String texto;
numero = 30;
real = 9.85;
logico = true;
letra = 'A';
texto = "Texto com Classe Invólucro";
Console.WriteLine(numero);
Console.WriteLine(real);
Console.WriteLine(logico);
Console.WriteLine(letra);
Console.WriteLine(texto);
Tirando os casos de int e bool, as outras classes invólucro são basicamente com o mesmo nome do tipo primitivo, só que com a primeira maiúscula.
Os operadores aritméticos usados em C# são os mesmos da maioria das outras linguagens, e a ordem de procedência também. Veja um exemplo de utilização logo abaixo:
using System;
namespace OperadoresAritmeticos {
class Program {
static void Main(string[] args) {
int num1 = 20;
int num2 = 11;
Console.WriteLine("Soma: " + (num1 + num2));
Console.WriteLine("Subtração: " + (num1 - num2));
Console.WriteLine("Multiplicação: " + (num1 * num2));
Console.WriteLine("Divisão: " + (num1 / num2));
Console.WriteLine("Módulo: " + (num1 % num2));
Console.ReadLine();
}
}
}
PS: Cuidado para não confundir o + da concatenação com o + da soma, por isso, as operações são feitas dentro de um parênteses, quando existem concatenações. O + só é reconhecido como soma quanto só existem números.
Lembrando que pode ser necessário usar o método ToString nesse caso, dessa forma:
Console.WriteLine("Soma: " + (num1 + num2).ToString());
Lembrando que divisão por zero retorna infinito, se fizermos 5.0 / 0.0 ele retornará infinito, isso é usado pelo double e float para representar esse valor, só que dividir 0 por 0 retorna NaN (not a number).
Veja um exemplo disso abaixo:
using System;
namespace OperadoresAritmeticos {
class Program {
static void Main(string[] args) {
double a = 5.0;
double b = 0.0;
Console.WriteLine("Valor dividido por zero: " + (a / b));
Console.WriteLine("Zero dividido por algum valor: " + (b / a));
Console.WriteLine("Zero dividido por zero: " + (b / b));
Console.WriteLine("Soma de NaN com um valor qualquer, como 15: " + (15 + (b / b)));
Console.WriteLine("Soma de Infinity com um valor qualquer, como 15: " + (15 + (a / b)));
Console.WriteLine("Zero vezes Infinity: " + (0 * (a / b)));
Console.WriteLine("Zero vezes NaN: " + (0 * (b / b)));
Console.ReadLine();
}
}
}
A ordem de procedência dos operadores, é a mesma de qualquer linguagem e da matemática em geral, parênteses, depois multiplicação, divisão e módulo, e por último adição e subtração.
Podemos usar o Random para gerar números aleatórios, assim:
Random aleatorio = new Random();
Console.WriteLine(aleatorio.Next(12, 14 + 1)); // Gera de 12 a 14.
Ele gera números especificando o mínimo e o máximo (excluindo ele mesmo). Com apenas um número no Next(), ele só retorna números menores que este, sem número ele gerará aleatoriamente números inteiros.
Temos também métodos matemáticos para utilizar no C#, esses são alguns deles:
Math.Abs() para pegar o valor absoluto de um número.Math.Pow() para criar uma potencialização entre dois números.Math.Sqrt() para mostrar a raiz quadrada.Math.Cbrt() para mostrar a raiz cúbica.Math.Round() para mostrar o número arredondado para o inteiro mais próximo. Para cima se usa Math.Ceiling() e para baixo Math.Floor().Temos também o método Int32.Parse() para converter strings em inteiros, dessa forma:
using System;
namespace OperadoresAritmeticos {
class Program {
static void Main(string[] args) {
string valor = "25";
int num = Int32.Parse(valor);
int res = num * 2;
Console.WriteLine("Resultado: " + res.ToString());
Console.ReadLine();
}
}
}
PS: Também podemos converter para double usando o método Parse de Double (e podemos usar um typecast para forçar conversão para float), e converter para char usando o método Parse de Char. Veja um exemplo de uso:
string dinheiro = "R$ 125,94";
float grana = (float)Double.Parse(dinheiro.Replace(",", ".").Replace("R$", "").Trim());
Console.WriteLine(grana);
PS: Isso de colocar o tipo entre parênteses, é chamado de typecast, pode ser feito com qualquer tipo pra forçar uma conversão, mas só funciona quando é de tipos semelhantes (como forçar conversão de float para int, por exemplo).