Iniciando Em C# (Com Mono)

Iniciando em C# Este módulo dá uma visão geral do C#.

Última revisão: 10/07/2003

Página do projeto: http://tux.lcc.ufrn.br/~iuri/projeto

Criando o primeiro programa em C#

Abra seu editor de textos preferido e escreva o seguinte programa:

Compile e execute. Ao longo desse módulo, será descrito alguns aspectos deste primeiro programa.

Observe a saída do programa:

Definindo uma classe

Classes são os ingredientes básicos das linguagens orientadas a objetos. As classes em C# são declaradas com a palavra reservada class seguida do nome da classe e um bloco de comandos entre chaves. Nosso primeiro programa possuía somente uma classe e seu nome era FirstCSharpClass.

C#, como a maioria das linguagens orientadas a objetos, suporta métodos e variáveis membro.

Observe a classe abaixo:

Esta classe possui três métodos e duas variáveis membro. Possui o construtor Employee e dois outros métodos getFirstName e getLastName,

Classes e membros podem ter modificadores associados aos mesmos que definem sua visibilidade.

Modificador de acesso Visibilidade

public Acessível de qualquer lugar.

protected Acessível somente pela própria classe ou qualquer classe derivada desta.

internal Acessível somente pelo programa em que foi declarada.

protected internal

Acessível somente pela própria classe ou qualquer classe derivada desta no mesmo programa.

private (padrão) Acessível somente pela própria classe.

static (em métodos)

Indica que o método não está associado a nenhum objeto e é chamado no contexto da classe com a sintaxe

classe.método em vez de objeto.método

Você não precisa se preocupar em fazer um destrutor para sua classe, pois a .NET CLR usa um coletor de lixo que automaticamente limpa a memória.

O ponto de entrada do programa, o método Main

Todo programa em C# deve ter o método Main, aqui alguns exemplos de declaração do método Main:

static void Main( string[] args )

static int Main( )

static int Main( string[] args )

Quando o programa é executado, ele sempre chama o método Main. O método Main é sempre declarado como static. Note que ele é sempre declarado dentro de uma classe, isto é sempre será um método. Em outras linguagens como C++, o ponto de entrada do programa é sempre uma função global. Funções globais não são permitidas em C#.

O método Main, pode obter os argumentos de linha de comando passados ao programa em forma de um vetor de strings. Em nosso primeiro programa, nós checamos se foram passados alguns argumentos:

if (args.Length > 0 ) { [...] }

Aplicativos para console

Nosso primeiro exemplo é um aplicativo para console, uma aplicação deste tipo, não tem um interface com o usuário(UI), não há caixas de opções, botões ou janelas. A entrada e a saída do texto vem do console, que no windows o prompt do MS-DOS. Aplicativos para console simplificam os exemplos dados nos módulos.

Namespaces

Namespaces são usados em .NET para organizar as bibliotecas de classes em uma estrutura hierárquica, a .NET Framework SDK possui

diversos namespaces como System, System.Windows.Forms, System.IO, System.Web.Forms.

O operador "." é usado para separar namespaces que estão dentro de outros, como também é usado para separar classes que estão contidas dentro de namespaces. Por exemplo, no namespace System.IO, temos uma classe chamada File, para criarmos uma instância dessa classe devemos proceder assim:

System.IO.File file = new System.IO.File();

Outra utilidade dos namespace´s é resolver os possíveis conflitos de classes de mesmo nome.

A palavra reservada using

Você pode estar pensando que vai escrever uma porção de código para declarar um objeto, felizmente existe um atalho, a palavra reservado using.

Você pode criar uma nova instância de uma classe desse jeito:

using System.IO; File file = new File();

Mais sobre o operador "."

O operador . também é usado para acessar um método (o um dado) em uma classe (no caso do método WriteLine() da classe Console) e para restringir uma classe a um específico Namespace (como em System.IO.File, onde File é exclusivamente uma classe do namespace System.IO), esta restrição é para termos certeza que estamos chamando uma classe de certo namespace.

Adicionando comentários

C# suporta 3 tipos diferentes de comentários, comentários de uma linha, comentários de múltiplas linhas e comentários de documentação de código.

Comentários de uma linha começam com // e tudo que estiver apos ele não será interpretado até o final da linha. Comentários de múltiplas linhas começam com /* e terminam com */ e se expandem por múltiplas linhas, texto entre eles constituem um comentário.

exemplo de comentários de uma linha:

// Atributo que contém o nome do usuário. public string usuario = "João Medeiros"; // Atributo que contem a idade do usuario. public int idade = 26; System.Console.WriteLine("Usuario: " + usuario); //escreve o nome do usuario System.Console.WriteLine("Idade: {0} anos", idade.ToString() );

Exemplo de comentários de múltiplas linhas:

/* O seguinte código não é executado, Console.WriteLine( hoje.ToString() ); */

Documentando seu código

Comentários que começam com ///, constituem a documentação XML do seu código. Documentando seu código com este tipo de comentário, o compilador pode gerar automaticamente toda a documentação para ser aproveitada por outras pessoas.

Tratamento de erros

Observando nosso primeiro programa exemplo, vemos que uma parte do código foi declarada em um bloco try e outra parte em um bloco catch. Pois bem C# pois controle e tratamento de erro, todo código que pode gerar um erro deve ser declarando num bloco try e caso este gere o erro, o código declarado no bloco catch é automaticamente chamado e executado.

Case-sensitive

C# é case-sensitive, isto quer dizer que writeline não é a mesma coisa de WriteLine, que não é a mesma coisa de WRITELINE.

Variáveis em C# Este módulo especifica como C# trata os tipo de dados da .NET Framework.



Tipos de variáveis em .NET

Variáveis são espaços na memória do computador que um programa usa para guardar algumas informações que serão utilizadas por ele, são chamadas de variáveis porque podem a qualquer momento mudar o conteúdo da informação guardada.

Em .NET existem dois tipos de variáveis, tipos por valor ou por referência. Tipos por valor, são variáveis que contém as informações diretamente e tipos por referência são variáveis que contém informações sobre onde um certo dado está armazenado. Quando você chama uma variável do tipo por valor ela devolve o dado real, diferente do tipo por valor, que devolve onde o dado está localizado na memória do computador e a partir daí o programa acessa este endereço de memória e obtém o dado.

Tabela de tipos por valor inclusos em C#:

Alguns tipos por referência inclusos da .NET Framework:

Declaração de variáveis

A declaração de uma variável tem sempre a seguinte notação:

Tipo NomeDaVariável;

Você não é obrigado a declarar suas variáveis no início de cada bloco.

Nomes de variáveis devem começar com uma letra ou um sublinhado("_") e podem conter números, letras e sublinhado. Variáveis em letras maiúsculas são diferentes de variáveis de letras minúsculas, nOmE e Nome são variáveis diferentes.

Nenhuma variável pode ter o mesmo nome de uma palavra reservada da linguagem. Segue as palavras reservadas de C#:

Tipo Base

Todas as variáveis em C# são objetos de alguma classe de tipos da .NET(veja a primeira tabela) e derivam da classe base object. Como todas as variáveis são objetos, naturalmente elas possuem métodos e propriedades:

int x = 16; Console.WriteLine( x.ToString() );

Variáveis inteiras

Variáveis do tipo inteiro guardam dados numéricos não fracionários, isto é, sem ponto decimal.

Os tipos são:

byte, sbyte, int, uint, long, ulong, short, ushort.

Exemplos:

sbyte num = 12; byte valor = 255; int valor = 123; uint resultado= 42024124386; long resultado = - 4445680; ulong matricula = 12312362532173421743; short index = 32767; ushort index = 65535;

Lógicos

São utilizados em comparações e podem assumir verdadeiro ou falso(true ou false).

Tipo:

bool

Exemplos:

bool masculino = true; bool ativado = false;

Caracteres

Armazenam um caractere formato unicode.

Tipo:

char

Exemplos:

char CaractereY = 'Y'; // armazena Y char CaractereY = '\x0057'; // armazena Y usando seu valor hexadecimal char CaractereY = (char) 87; // armazena Y convertido de um inteiro char CaractereY = '\u0057'; // armazena Y usando seu valor Unicode

Ponto flutuante

Armazenam números reais.

Observações:

As operações envolvendo pontos flutuantes não geram exceções:

Uma operação com um resultado muito pequeno para ser representado torna-se zero

Uma operação com um resultado muito positivo/negativo para ser representado produz um resultado +/- "infinito"

Uma divisão por zero gera um resultado "infinito" Uma operação inválida gera como resultado um NaN(Não é um número - Not a Number).

Se um dos operadores for um NaN, então o resultado será um NaN.

Resultado da divisão de 0 por 0

Resultado da divisão de 3 por 0

Tipos:

double, float, decimal

Exemplos:

float x = 3.5; double y = 3; decimal z = 300.5;

String

Uma string pode conter até 1 gigabyte de caracteres e é alocada dinamicamente.

Tipo:

string

Exemplos:

string FraseA = "Que dia "; string FraseB = "lindo"; Console.WriteLine( "Esta é a minha frase: " + FraseA + FraseB );

Incialização de variáveis

Todas as variáveis são inicializadas automaticamente para um valor padrão do tipo, normalmente zero.

Conversões

Converter diferentes diferentes tipos de dados é uma tarefa comum em programação, converter números reais para inteiros, números inteiros para reais, strings para números, números para strings. As conversões podem ser automáticas ou manuais. As conversões automáticas são feitas quando o tipo a receber o valor ( do lado esquerdo da atribuição) puder conter TODOS os possíveis valores da expressão (do lado direito do operador de atribuição)

Conversões chamando métodos.

Você pode utilizar de métodos ao fazer suas conversões de valores, elas são necessárias entre os seguintes tipos de dados:

inteiro para string ponto flutuante para string string para inteiro string para ponto flutuante

Para converter um inteiro ou um ponto flutuante para uma string basta chamar o método .ToString(), exemplo:

int x = 16; float y = 20; string meusNumeros = "Estes são meus números: " + x.ToString() + " e " + y.ToString();

para converter uma string para inteiro ou um ponto flutuante chamamos o método estático .Parse(string s) do tipo de dado em questão, exemplo:

Console.Write("Escreva um número: "); string temporario = Console.ReadLine(); int numero = int.Parse(temporario);

Conversões com o operador de cast.

Para converter realizar conversões em cast, você chama o operador assim:

(tipo) dado;

Exemplo:

int n = 16; double m = 15.6; double k = 14.4;

double y; y = (double) n; // y vale 16 y = (int) m; // y vale 15 y = (int) k; // y vale 14 y = (int) m + (int) k; // y vale 29 y = (int)( m + k ); // y vale 30

Checked

Se ao aplicarmos uma conversão e o valor não couber no dado, não geramos um erro. Observe o seguinte código

int N; byte B; N = 10; // Esta conversão funciona, pois 10 cabe em um byte B = (byte) N; N = 1000; // Esta conversão não funciona, mas não gera erro B = (byte) N;

Caso quiséssemos que a conversão gere uma exceção. Devemos colocá-la num bloco checked

int N; byte B; N = 1000; checked { // Esta conversão irá gerar uma exceção do tipo: "Number overflow". B = (byte) N; }

Sufixos

Sufixo são maneiras de garantir que constantes sejam de um certo tipo:

Exemplos:

// constantes do tipo long ou ulong long valor1 = 10L; ulong valor 2 = 10L;

// constantes do tipo uint ou ulong uint valor3 = 10u; ulong valor4 = 10u; // constantes do tipo ulong ulong valor5 = 10ul; ulong valor6 = 10LU; // constantes do tipo float float x = 10.7f; // constantes do tipo double double y = 100.704d; // constantes do tipo decimal; decimal d = 100.123312M;

Seqüências de escape em strings:

Seqüências de escape são utilizadas para representar caracteres que não possui representação no teclado ou que não são possíveis o uso direto em strings.

Além destas seqüências a seqüência \uNNNN, onde NNNN é o código unicode de um caractere.

Você pode entretanto usar uma string iniciada por @, assim ela irá ignorar as seqüências de escape da string;

Exemplos:

string a = "c:\\windows\\command.com"; // a vale c:\windows\command.com string a = @"Numero1\nNumero2\n"; // a vale Numero1\nNumero2\n

Operadores

Os operadores disponíveis em C#, são os seguintes e eles possuem a mesma função que em C++:

Enum

Enum é um tipo definido pelo usuário que associa nomes a números pois fazem mais sentido para qualquer um ler o código. Enums se comportam tanto como strings como inteiros.

exemplo:

Struct

Permite declarar tipos que contêm diversos valores identificados pelo nome.

Como em C++, as estruturas podem ter métodos e construtores. Não é possível declarar um construtor que não aceite argumentos

New

Independente do tipo, todas as variáveis podem ser inicializadas com o operador new.

Exemplos:

int N2 = new int(); bool Socio = new bool();

Arrays

Arrays são coleções de um certo tipo de dados. São como matrizes com contém elementos que podem ser acessados em tempo de execução.

Sempre que um array for declarado com um certo tipo, ele será válido para todos os itens do array. A declaração de um array sempre tem um [] depois do tipo da variável.

O array pode ter diversas dimensões, mas o primeiro índice é sempre zero.

Todo array deve ser inicializado, e para qualquer índice referenciado fora da faixa será gerado uma exception.

Um array de várias dimensões pode ser declarado colocando vígulas dentro dos colchetes. Outra possibilidade é declarar um array de outro array.

exemplos:

double[] Notas = new double[5]; int[] numeros = new int[100]; Notas[0] = 6; Notas[1] = 10; int[] a1; //uma dimensão int[,] a2; //duas dimensões int[,,] a3; //três dimensões int[][] a4; // aninhamento, array de array int[][][] a5; //array de array de array int[] b1 = new int[] { 1, 2, 3}; int[,] b2 = new int[,] {{1,2,3}, {4,5,6}}; int[][] b3 = new int[3][]; b3[0] = new int[] { 1,2,3 }; b3[1] = new int[] { 4,5,6 }; b3[2] = new int[] { 7,8,9,10 }; int[] c1 = {1,2,3};

Blocos de código Neste módulo você verá blocos e instruções de seleção, de repetição, de desvio e de tratamento de erro.



Instruções

Um programa consiste em uma seqüência de instruções, quando o programa é chamado, estas instruções são executadas uma após a outra, como elas estão dispostas no programa, da esquerda para a direita, de cima para baixo.

Blocos

Quando você desenvolve aplicações em C#, você precisa agrupar instruções como em outras linguagens de programação. Para isto, você usa a sintaxe de linguagens como C, C++, Perl e Java, isto é, você agrupa suas instruções entre chaves: { e }. Você não usa uma palavra para delimitar como If..End If do Microsoft Visual Basic.

Um bloco pode conter um simples instrução, várias instruções ou outro bloco.

Cada bloco possui um escopo. Uma variável declarada em um bloco é chamada de variável local. O escopo(validade) da variável local se estende desde sua declaração até o } que finaliza o bloco que contém ela.

Em C#, você não pode declarar uma variável em um bloco interno com o mesmo nome de uma variável em um bloco externo. Exemplo:

int i; { int i; // Erro: variável já declarada no bloco pai. }

Entretanto, você pode declarar variáveis do mesmo nome, em blocos paralelos. Blocos paralelos são bloco que então contidos um mesmo bloco pai e estão no mesmo nível. Exemplo:

{ int i; }

{ int i; }

Você pode declarar variáveis em qualquer lugar em um bloco.

Blocos de seleção

As instruções if e switch são conhecidas como instruções de seleção. Eles fazem escolhas baseadas no valor das expressões e seletivamente executam outras instruções a partir das escolhas.

if...else

sintaxe:

if ( Expressão-Boleana ) instrução/bloco-se-verdadeiro else instrução/bloco-se-falso

Exemplos :

if ( numero % 2 == 0 ) Console.WriteLine("Número par"); if (minutos == 60 ) { minutos = 0; horas ++; }

Convertendo inteiros para boleanos

Conversões implícitas de inteiros para boleanos é uma potencial fontes de bugs. Para evitar isto, C# não suporta conversões de inteiros para boleanos . Esta é uma diferença significante entre C# e outras linguagens similares, os exemplos seguintes são inválidos:

int x; if (x) ... // Deveria ser x != 0 in C# if (x = valor()) ... //Deveria ser (x = valor) != 0 em C#.

switch

sintaxe:

switch (expressão) { case valor1:

instruções; break; case valor2: instruções; break; case valor3: case valor4: instruções; break; case valor5: instruções; break; case valor6: instruções; goto case valor1; default: instruções; break; }

A instrução switch é executada assim:

1. Se uma das constantes especificadas em case é igual ao valor da expressão, o controle é transferido para a lista de instruções do case.

2. Se nenhum das constantes de cada case é igual ao valor da expressão e o switch contém uma etiqueta default, o controle é transferido para a lista de instruções dela.

3. Se nenhum das constantes de cada case é igual ao valor da expressão e o switch não contém uma etiqueta default, o controle é transferido para o fim do switch.

Você pode usar o comando switch com os seguintes tipos retorno de expressões: quaisquer valores inteiros, caracteres, um enum, ou uma string.

Nota: Diferente de Java, C ou C++, o switch aceita o tipo string e o valor null é permitido para uma constante de etiqueta do case.

Usando o comando break

Diferente de Java, C ou C++, C# não aceita uma transferência de controle silenciosa para a próxima etiqueta de case, isto gera um erro ao se compilar o programa, em outras palavras você deve sempre especificar uma regra para o final de cada case, as instruções que não geram erro são: a instrução break(a mais comum), a instrução goto(muito rara), a instrução return, a instrução throw, ou um loop infinito.

Blocos de repetição

As instruções while, do, for e foreach são conhecidas como instruções de interação. Você deve usá-las quando quer que certas operações sejam executadas enquanto uma condição é verdadeira.

while

O laço while é o mais simples de todos os laços. Ele executa repetidamente as instruções internas enquanto (while, em inglês) uma expressão boleana é verdadeira.

Sintaxe:

while ( expressão-boleana) instrução/bloco

Ele é executado como se segue:

1. A expressão boleana de controle do while é avaliada. 2. Se a expressão for verdadeira o controle é transferido para as

instruções internas do while, quando executar todas as instruções o controle é transferido novamente para o início do while e a expressão é novamente avaliada.

3. Se a expressão for falsa, o controle é transferido para o fim a próxima instrução fora do while.

Exemplos:

while ( i < 10) Console.WriteLine(i++); while (true) Console.WriteLine("Laço infinito");

do

O laço do sempre vem junto de uma instrução while, ele é muito similar ao laço while, exceto que a expressão boleana é avaliada no final de cada interação.

sintaxe:

do instrução/bloco-de-código while ( expressão boleana );

Ele é executado como se segue:

1. O controle é transferido para as instruções internas do do. 2. Quando forem executadas todas as instruções, a expressão

boleana é avaliada. 3. Se a expressão for verdadeira, o controle é transferido ao início do

do. 4. Se a expressão for falsa o controle é transferido para a primeira

instrução após o do.

Exemplos:

do Console.WriteLine(i++); while ( i < 10 ); do { Console.WriteLine(i); i++; } while ( i < 10 );

for

Quando usamos o laço while, desenvolvedores podem esquecer de atualizar o conteúdo da variável de controle, como no código seguinte:

int i = 0; while ( i < 10 ) Console.WriteLine(i); // isto gera um laço infinito, // pois i não muda

Você pode minimizar os erros usando um laço for. O laço for contorna este problema movendo o código de atualização e inicialização para o início do laço, onde é mais difícil de se esquecer.

Sintaxe:

for ( inicialização; condição; atualização) instrução/bloco

esta sintaxe é idêntica ao seguinte código:

inicialização while (condição) { instrução/instruções atualização }

exemplos:

for ( ; ; ) { Console.WriteLine("Laço infinito"); } for (int i = 0; i < 10; i++) Console.WriteLine(i); for (int i = 0; i < 10; i++){ Console.WriteLine(i); Console.WriteLine(10 - i); }

foreach

A .Net Framework contém várias classes de coleções no namespace System.Collections, uma destas classes de coleções é a ArrayList. Você pode usar um ArrayList para criar uma coleção de variáveis e adicionar elementos a ela. Observe o seguinte código:

ArrayList numeros = new ArrayList(); for (int i = 0; i < 10; I++) { numeros.Add(i); }

mostrando cada elemento depois:

for (int i = 0; i < numeros.Count; i++) { int numero = (int) numeros[i]; Console.WriteLine(numero); }

Mas você pode melhorar este código usando o loop foreach. O loop foreach permite que você interaja com cada elemento de uma lista a cada loop.

Sintaxe:

foreach (Tipo variável-receptora in coleção) instrução/bloco

O loop foreach atribui à variável -receptora um valor da coleção a cada interação do laço enquanto houver elementos na coleção que não foram atribuídos a variável-receptora.

exemplo:

foreach (int numero in numeros) Console.WriteLine(numero);

Diferente de Perl, em C# você não pode modificar os elementos em uma coleção usando um foreach porque a variável de interação é implicitamente declarada como readonly.

foreach (int numero em numeros) { numero++; //Erro em tempo de compilação Console.WriteLine(numero); }

Instruções de desvio

As instruções goto, break e continue são conhecidas como instruções de desvio. Você usa elas para transferir o controle de um ponto para outro do programa.

goto

Esta instrução é a mais primitiva instrução de desvio em C#, ela transfere o controle para uma etiqueta. A etiqueta deve existir e estar no mesmo escopo da instrução goto. Mais de um goto pode transferir o controle para uma mesma etiqueta. Exemplo:

if ( (numero % 2) == 0 ) goto Par; Console.WriteLine("ímpar"); goto Fim; Par: Console.WriteLine("Par"); Fim:

O goto pode transferir o controle para fora de um bloco, mas nunca pode transferir o controle para dentro de um bloco.

A instrução goto e a etiqueta alvo devem ficar a parte do código, pois podem facilmente obscurecer a lógica de fluxo em programa, esta uma razão dos livros de programação não recomendarem o uso do goto.

As únicas situações onde o goto é recomendado é na instrução switch ou para transferir o controle para o início de um laço, a fim de repetir a interação sem passar para a próxima, funcionando como o comando redo de Perl.

break e continue

O break consiste em parar um laço ou sair de um switch. O continue inicia uma nova interação de um laço. Exemplo:

int i = 0; while (true) { Console.WriteLine(i); i++; if ( i < 10) continue; else break; Console.WriteLine("esta instrução nunca é chamada"); }

O break e o continue não são muito diferentes de um goto, pois podem obscurecer o fluxo lógico do programa. O mesmo código acima pode ser reescrito assim:

int i = 0; while ( i < 10 ) { Console.WriteLine(numeros[i]); i+=; }

Exceções

Como programador, você as vezes perde muito mais tempo procurando por erros e corrigindo-os do que pensando na lógica do programa.

Nas linguagens procedimentais você freqüentemente mistura tratamento de erro com a lógica do programa. Exemplo:

using System; class Teste { public static int Main() { // lógica do programa string entrada; int numero1, numero2; Console.Write("Insira um numero: "); entrada = Console.ReadLine(); numero1 = int.Parse(entrada); Console.Write("Insira outro numero: "); entrada = Console.ReadLine(); numero2 = int.Parse(entrada); //misturando tratamento de erros if (numero2 == 0) { Console.WriteLine("Não posso dividir por 0"); return(1); } // continuando a lógica do programa Console.WriteLine("O resultado da divisao é {0} ",

numero1 / numero2 ); return(0); } }

Tratando erros

sintaxe:

try { código-que-pode-gerar-um-erro } catch { rotina-de-tratamento-de-erro }

Sempre que ocorrer um erro na execução do código entre try{ e }, a .Net Framework chama catch. Exemplo:

using System; class Teste { public static int Main() { // lógica do programa string entrada; int numero1, numero2; Console.Write("Insira um numero: "); entrada = Console.ReadLine(); numero1 = int.Parse(entrada); Console.Write("Insira outro numero: "); entrada = Console.ReadLine(); numero2 = int.Parse(entrada); try { Console.WriteLine("O resultado da divisão é {0} ", numero1 / numero2 ); return (0); } // tratamento de erro catch { Console.WriteLine("Ocorreu um erro de divisão"); return(1); } } }

o código antigo ainda pode gerar um erro na conversão de string para inteiro, então podemos reescrevê-lo assim:

using System; class Teste { public static int Main() { string entrada; int numero1, numero2; Console.Write("Insira um numero: "); entrada = Console.ReadLine(); try { numero1 = int.Parse(entrada); } catch { Console.WriteLine("Conversão inválida"); } Console.Write("Insira outro numero: "); entrada = Console.ReadLine(); try { numero2 = int.Parse(entrada); } catch { Console.WriteLine("Conversão inválida"); } try { Console.WriteLine("O resultado da divisão é {0} ", numero1 / numero2 ); return (0); } catch { Console.WriteLine("Ocorreu um erro de divisão"); return(1); } } }

mas fazendo isto estaríamos misturando a lógica com o tratamento de erros, você poderia então fazer assim:

using System; class Teste { public static int Main() { // lógica do programa try { string entrada; int numero1, numero2; Console.Write("Insira um numero: "); entrada = Console.ReadLine(); numero1 = int.Parse(entrada);

Console.Write("Insira outro numero: "); entrada = Console.ReadLine(); numero2 = int.Parse(entrada); Console.WriteLine("O resultado da divisão é {0} ", numero1 / numero2 ); return (0); } // tratamento dos erros catch { Console.WriteLine("Ocorreu um erro"); return(1); } } }

Mas escrevendo-o desse jeito, um erro ocorrre e o usuário não sabe por que erro ocorreu. Para contornar isto você pode usar múltiplos catch's, cada um tratando de erro específico:

using System; class Teste { public static int Main() { // lógica do programa try { string entrada; int numero1, numero2; Console.Write("Insira um numero: "); entrada = Console.ReadLine(); numero1 = int.Parse(entrada); Console.Write("Insira outro numero: "); entrada = Console.ReadLine(); numero2 = int.Parse(entrada); Console.WriteLine("O resultado da divisão é {0} ", numero1 / numero2 ); return (0); } // tratamento dos erros catch (FormatException) { Console.WriteLine("Número inválido"); return(1); } catch (DivideByZeriException) { Console.WriteLine("Não posso dividir por zero"); return(1); }

} }

Os blocos try e catch são usados para tratar de erros gerados por programas em C#. Ao invés de setar variáveis globais para conter erros, as rotinas de C# lançam exceções que são transferidas para uma apropriada instrução catch.

Gerando exceções

Quando precisamos gerar um exceção chamamos uma instrução throw. Isto imediatamente suspende a execução normal de um programa e o controle é transferido para o primeiro catch que pode tratar da exceção. Exemplo:

if (minutos < 0 || minutos >= 60) { string erro = minutos + " não é um minuto válido"; throw new InvalidTimeException(erro); }

Neste exemplo, a instrução throw é usada para gerar um exceção definida pelo programador, InvalidTimeException, se o minutos passados não forem minutos válidos, a mensagem passada no argumento da exceção é mostrada.

Liberando recursos

C# também possui uma cláusula finally a fim de se executar instruções ao final de um fluxo terminado normalmente ou terminado com um erro, isto pode ser muito útil por exemplo para fechar arquivos ou desconectar banco de dados ao final de um bloco, ou para evitar a duplicação de instruções entre o bloco try e o bloco catch.

Documentação XML Este módulo descreve algumas tags da documentação de código em C#.



Os comentários de documentação ///

Você tem o costume de documentar seus códigos? Com certeza não é uma tarefa muito apreciada pelos desenvolvedores, sendo que custa muito dinheiro para criar e principalmente documentar devido ao tempo gasto. Mas, se você for pensar assim, quando precisar realizar uma manutenção em um código, terá de vasculhar todos os vínculos, desvios, enfim, tudo o que implica no respectivo código.

Para isso, a Microsoft criou uma forma de documentação automática, adotando o padrão XML. Assim, qualquer estrutura de código pode seguir as regras que o XML se encarrega de exibir. Estamos falando aqui de uma simples documentação de códigos, não de fluxo de informações de um aplicativo.

Você pode inserir qualquer comentário no código, inserindo as ///(três barras), e com isso o programa XML saberá do que se trata.

Há tags XML que são sugeridas para serem usadas(você também pode criar as suas), veja algumas:

<summary> [...] </summary>

Para uma descrição rápida.

<remarks> […] </remarks>

Para uma descrição detalhada, esta tag pode conter parágrafos, listas e outros tipos de tags.

<para> [...] </para>

Esta tag permite parágrafos em uma estrutura <remarks>

<example> [...] </example>

Para demonstrar um exemplo de um método, propriedade ou como um membro deve ser usado, utilize com a tag <code>.

<code> [...] </code>

Para indicar que é o texto seguinte é código de aplicativo.

<seealso cref="membro" />

Para indicar uma referencia a outro membro ou campo, o compilador checa se de fato o "membro" existe.

<param name="nome"> […] </param>

Para prover uma descrição para um parâmetro de um dado método.

<returns> […] </returns>

Para documentar um valor de retorno e um tipo de método.

<value> […] </value>

Para descrever uma propriedade.

A classe System.Console Este módulo dá explica como usar a classe System.Console para leitura e escrita em consoles, a classe é apresentada em C#, mas pode este documento pode facilmente ser estendido para outras linguagens .NET



Métodos Write e WriteLine

Console.Write e Console.WriteLine escrevem informações na tela do console

WriteLine gera uma nova linha. Ambos os métodos são sobrecarregados. Uma string de formato e parâmetros podem ser usados para:

Formatar texto. Formatar números.

Você pode usar Console.Write e Console.WriteLine para mostrar informações na tela de console. Estes dois métodos são muito similares, a diferença principal é que WriteLine inclui um caractere de nova linha no final da saída e Write não faz isto.

Ambos os métodos são sobrecarregados, você pode chamá-los com variáveis numéricas ou strings. Por exemplo você pode usar o seguinte código para escrever "99" na tela:

Console.WriteLine(99);

Você pode usar o código seguinte para escrever a mensagem "Oi vocês" na tela:

Console.WriteLine("Oi vocês");

Formatando Textos

Você pode usar as formas poderosas de Write e WriteLine que pegam uma string de formato e parâmetros adicionais. A string de formato especifica como os dados iram para a saída, e ela contém marcadores que são substituídos em ordem pelos parâmetros que se seguem, por exemplo:

Console.WriteLine("A soma de {0} com {1} é igual a {2}", 147, 68, 147+48);

que retorna: "A soma de 127 com 68 é igual a 195"

obs: O primeiro parâmetro da string de formato é sempre referido como parâmetro zero: {0}

Você pode usar os parâmetros string de formato para especificar quantos caracteres devem ser usados e se estes devem ser justificados a esquerda ou a direita, observe os códigos:

Console.WriteLine("Justificado a esquerda e com tamanho 10: {0,-10}", "oi"); Console.WriteLine("Justificado a direita e com tamanho 10: {0,10}", 99);

este código retorna as seguintes strings, respectivamente:

"Justificado a esquerda e com tamanho 10:oi " "Justificado a direita e com tamanho 10: 99"

Formatando Números

Você pode também usar a string de formato para especificar com os dados numéricos serão formatados, a sintaxe completa é: {N,M:StringDeFormato}, onde N ]e o parâmetro M é serve para ditar o tamanho do campo e se ele deve ser justificado a direita ou a esquerda, e StringDeFormato especifica como o dado numérico será mostrado.

Observe a tabela, em todos os formatos o número de dígitos a serem mostrados, ou arrendondados, pode opcionalmente ser especificado.

Tipo Significado

C Mostra em formato de moeda utilizando a localidade setada como padrão.

D Mostra um numero como um inteiro E Escreve em notação científica

F Mostra com um ponto fixo separando parte inteira e parte decimal

G Mostra o texto com um inteiro, ponto fixo ou notação científica, dependendo de qual deles é mais compacto

N Mostra o número com separadores de milhares, milhões, etc.

X Mostra o número em hexadecimal

Exemplos:

Console.WriteLine("Formato de moeda atual- {0:C} {1:C4}", 88.8, -888.8); Console.WriteLine("Formato de Inteiro - {0:D5}", 88); Console.WriteLine("Notação científica - {0:E}", 888.8); Console.WriteLine("Com ponto fixo - {0:F3}",888.8888); Console.WriteLine("Formato geral - {0:G}", 888.8888); Console.WriteLine("Formato numérico - {0:N}", 8888888.8); Console.WriteLine("Formato Hexadeciaml - {0:X4}", 88);

Saídas:

Formato de moeda - $88.800000000000000 ($888.8000) Formato de Inteiro - 00088 Notação científica - 8.888000000000000E+002 Com ponto fixo - 888.889 Formato geral - 888.8888 Formato numérico atual - 8,888,888.800000000000000 Formato Hexadeciaml - 0058

Métodos Read e ReadLine

Console.Read e Console.ReadLine lêem a entrada do usuário. Read lê o próximo caractere. ReadLine lê até o final da linha.

Você pode obter uma entrada vinda do teclado usando os métodos Console.Read e Console.ReadLine

O método Read

Read lê o próximo caractere da entrada padrão (teclado), ele retorna um inteiro contendo o número do caractere do formato Unicode, se não houver mais entrada a ser lida, ele retorna -1.

O método ReadLine

ReadLine lê todos os caracteres até chegar no final da linha, ele retorna uma string com os caracteres lidos. Observe o código seguinte, ele lê uma linha do teclado e em seguida a mostra na tela.

string input = Console.ReadLine( ); Console.WriteLine("{0}", input);

Iniciando Em C# (Com Mono)

Documents

Transcript of Iniciando Em C# (Com Mono)