C# A Linguagem de Programação CSharp básico

Prévia do material em texto

C#: A Linguagem de Programação 
CSharp básico 
 
por 
 
Prof. Dr. Paulo Roberto Gomes Luzzardi 
 
 
 
 
 
 
facebook: Paulo Roberto Gomes Luzzardi 
WhatsApp: 91648037 
e-mail: pluzzardi@gmail.com e pluzzardi@yahoo.com.br 
e-mail (Senac): prgomesluzzardi@senacrs.edu.br 
DropBox: https://www.dropbox.com/sh/kea9kr4j2qttnjg/4xXvw0pvxX?m 
Hostinger: http://pluzzardi.w.pw e http://pluzzardi.zz.mu (Home Page) 
OS X Server (Apple): http://pluzzardi.no-ip.info:8080 (Home Page) 
 
 
 
Versão 1.04 
06-10-2014 
 
 
 
Bibliografia recomendada: 
 
 
DEITEL, H. M. and DEITEL, P. J. Java: como programar, 8. ed.: São 
Paulo: Pearson, 2010 (ISBN 85-363-0123-6). 
 
 
 
 
Pelotas, segunda-feira, 6 de outubro de 2014 (11:25:58 am) 
2 
Sumário 
 
1. Arquitetura de um programa em C# .......................................................................................... 5	
  
1.1 Elementos básicos de um programa em C# .............................................................. 5	
  
1.2 Elementos básicos de um método estático em C# ............................................. 6	
  
1.3 Como compilar um programa em C# via Terminal ............................................... 6	
  
1.4 Como executar um programa em C# via Terminal ............................................... 6	
  
1.5 Pasta contendo os projetos/arquivos em C# ....................................................... 6	
  
2. Estrutura de um programa em C# ............................................................................................... 6	
  
2.1 Identificadores em C# ....................................................................................................... 6	
  
2.2 Comentários do programador em C# ............................................................................ 7	
  
2.3 Regras gerais para escrever um programa em C# ............................................. 7	
  
2.4 Palavras reservadas do C# ............................................................................................. 8	
  
2.5 Declaração de variáveis em C# .................................................................................... 8	
  
2.5.1 Onde as variáveis podem ser declaradas em C# ....................................... 8	
  
2.5.2 Inicialização de variáveis em C# .................................................................. 10	
  
2.6 Constantes em C# ................................................................................................................. 10	
  
2.6.1 Constantes hexadecimais e octais em C# ................................................... 10	
  
2.6.2 Constantes Strings em C# ..................................................................................... 11	
  
2.6.3 Constantes especiais em C# ................................................................................ 12	
  
2.7 Comandos do pré-processador do C# ........................................................................ 12	
  
2.7.1 O comando using .......................................................................................................... 12	
  
3. Tipos de dados em C# ..................................................................................................................... 12	
  
3.1 Tipos básicos em C# .......................................................................................................... 12	
  
3.2 Escrevendo uma classe em C# ...................................................................................... 13	
  
3.2.1 Conceitos básicos sobre orientação à objetos ......................................... 13	
  
3.2.2 Referência this em C# ................................................................................................ 19	
  
3.2.3 Lista de Exercícios sobre Classes em C# ..................................................... 20	
  
3.3 Sobrecarga de métodos em C# ...................................................................................... 31	
  
3.4 Ponteiros, referências e endereços em C# ....................................................... 31	
  
Operadores de ponteiros .......................................................................................................... 33	
  
4. Métodos de entrada e saída de dados ................................................................................. 33	
  
4.1 Entrada e saída de dados usando TextReader e TextWriter ................... 33	
  
4.2 Entrada e saída de dados utilizando Console ................................................ 34	
  
4.3 Leitura de uma tecla em C# (pausa por teclado) ......................................... 34	
  
5. Operadores em C# .............................................................................................................................. 35	
  
5.1 Operadores aritméticos em C# .................................................................................... 35	
  
5.2 Operadores relacionais em C# .................................................................................... 35	
  
5.3 Operadores lógicos em C# .............................................................................................. 35	
  
5.4 Incremento e decremento em C# .................................................................................. 36	
  
5.5 Operador de atribuição em C# .................................................................................... 36	
  
5.6 Casts em C# ............................................................................................................................. 37	
  
5.7 Expressões em C# ................................................................................................................. 38	
  
6. Métodos para funções matemáticas padrões em C# ...................................................... 38	
  
6.1 Math.Abs .................................................................................................................................... 38	
  
6.2 Math.Asin .................................................................................................................................. 38	
  
6.3 Math.Acos .................................................................................................................................. 38	
  
6.4 Math.Atan .................................................................................................................................. 39	
  
6.5 Math.Sin .................................................................................................................................... 39	
  
6.6 Math.Cos .................................................................................................................................... 39	
  
6.7 Math.Tan .................................................................................................................................... 39	
  
6.8 Math.Exp .................................................................................................................................... 39	
  
6.9 Math.Pow .................................................................................................................................... 39	
  
6.10 Math.Sqrt ............................................................................................................................... 39	
  
6.11 Math.Log .................................................................................................................................. 39	
  
6.12 Convert.ToDouble .............................................................................................................. 40	
  
3 
6.13 Convert.Int?? (16, 32 ou 64) .................................................................................. 40	
  
6.14 Convert.ToByte ................................................................................................................... 40	
  
6.15 Math.Log10 .............................................................................................................................40	
  
6.16 Random ...................................................................................................................................... 40	
  
6.17 Math.PI .................................................................................................................................... 40	
  
6.18 Conversão de graus para radianos ........................................................................ 41	
  
7. Comandos em C# ................................................................................................................................... 41	
  
7.1 Tipos de comandos em C# ................................................................................................ 41	
  
7.1.1 Sequência em C# .......................................................................................................... 41	
  
7.1.2 Seleção em C# ............................................................................................................... 41	
  
7.1.3 Repetição em C# .......................................................................................................... 43	
  
7.2 Comando if em C# ................................................................................................................. 43	
  
7.2.1 if encadeados em C# ................................................................................................. 44	
  
7.3 O comando switch em C# .................................................................................................. 45	
  
7.4 Comando while no C# .......................................................................................................... 48	
  
7.5 O comando for no C# .......................................................................................................... 50	
  
7.6 O loop do { } while no C# ........................................................................................... 52	
  
7.7 Interrupção de loops em C# ......................................................................................... 52	
  
7.7.1 O comando break em C# ............................................................................................ 52	
  
7.7.2 O comando continue no C# ..................................................................................... 53	
  
7.8 O método Environment.Exit () .................................................................................... 54	
  
8. Saída formatada com String.Format ..................................................................................... 54	
  
9. Lista de exercícios (comandos) ............................................................................................. 57	
  
10. Vetores, Matrizes e Strings em C# ................................................................................... 60	
  
10.1 Vetores em C# ...................................................................................................................... 61	
  
10.2 Strings em C# ...................................................................................................................... 62	
  
10.3 Matrizes (Multidimensional) em C# ...................................................................... 63	
  
10.4 Vetor de Strings em C# ................................................................................................ 64	
  
10.5 Inicialização de matrizes e vetores em C# .................................................. 65	
  
10.6 Inicialização de um vetor de caracteres em C# ......................................... 65	
  
10.7 Inicialização de matrizes multidimensionais em C# ............................... 65	
  
10.8 Inicialização de vetores e matrizes sem tamanho em C# ..................... 65	
  
10.9 Classificação de dados ou ordenação (sort) em C# ................................. 67	
  
10.10 Lista de exercícios (vetores) ............................................................................. 69	
  
11. Manipulação de Strings em C# ............................................................................................... 72	
  
11.1 Métodos para manipular Strings em C# .............................................................. 72	
  
11.2 Lista de exercícios (Strings) ............................................................................... 74	
  
12. Métodos estáticos definidos pelo programador em C# .......................................... 76	
  
12.1 Valores de retorno em C# ........................................................................................... 77	
  
12.2 Passagem de parâmetros por valor em C# ......................................................... 80	
  
12.3 Passagem de parâmetros por referênciaem C# ................................................ 80	
  
12.4 Métodos que devolvem valores não-inteiros em C# .................................... 82	
  
12.5 Argumentos do Main (String [] args) em C# .................................................. 82	
  
12.6 Recursividade em C# ....................................................................................................... 84	
  
12.7 Lista de Exercícios (métodos) ............................................................................... 86	
  
13. Classes existentes em C# ......................................................................................................... 88	
  
13.1 Object (classe base de objetos) em C# ............................................................ 89	
  
13.2 List (lista tipada de objetos) em C# .............................................................. 89	
  
13.3 ArrayList (lista de arrays) em C# ...................................................................... 91	
  
13.4 IList (lista de objetos indexados) em C# ..................................................... 92	
  
13.5 Stack (Pilha) em C# ....................................................................................................... 93	
  
13.6 Queue (Fila) em C# .......................................................................................................... 94	
  
14. Entrada e saída em disco (Arquivos) em C# ................................................................ 95	
  
14.1 Métodos para manipular arquivos em C# ............................................................ 95	
  
14.2 Abertura de um arquivo texto em C# ................................................................... 95	
  
14.3 Listar um diretório em C# ......................................................................................... 96	
  
4 
14.4 Manipulação de um arquivo texto de palavras em C# ............................... 98	
  
14.5 Arquivo Texto em C# ..................................................................................................... 101	
  
14.6 Lista de exercícios (arquivos) ........................................................................... 105	
  
14.7 Arquivos binários em C# ............................................................................................ 109	
  
15. Conceitos diversos em C# ....................................................................................................... 111	
  
15.1 Operadores bit a bit em C# .................................................................................... 111	
  
15.2 Formas abreviadas de C# ............................................................................................ 112	
  
16. Listas Lineares: Pilha, Fila e Fila Circular em C# ........................................ 112	
  
16.1 Implementação de um lista em vetor em C# ................................................... 113	
  
16.2 Implementação de uma Pilha em C# ...................................................................... 116	
  
16.3 Implementação de uma Fila em C# ........................................................................ 118	
  
16.4 Implementação de uma Fila Circular em C# ................................................... 119	
  
17. Tratamentode erros em C# .................................................................................................... 121	
  
17.1 Tratamento de exceções em C# ................................................................................ 122	
  
17.2 Tratamento de erros na entrada de número inteiro em C# ................. 122	
  
17.3 Tratamento de erros: Divisão por zero em C# ........................................... 123	
  
18. Herança em C# ................................................................................................................................. 124	
  
18.1 Herança simples em C# ................................................................................................ 124	
  
18.2 Controle de acesso na definição de uma classe derivada em C# ... 125	
  
18.3 Tipos de acessos (especificadores de acesso) em C# ........................... 126	
  
18.4 Lista de exercícios sobre Herança em C# ..................................................... 128	
  
18.4.1 Herança (primeiro) em C# .................................................................................... 128	
  
18.4.2 Herança (segundo) em C# ....................................................................................... 129	
  
18.4.3 Herança (terceiro) em C# .................................................................................... 130	
  
19. Coletor de Lixo (Garbage Collector) em C# .............................................................. 132	
  
20. Construtor e finalizador em C# ........................................................................................ 133	
  
21. Data e Hora em C# ....................................................................................................................... 135	
  
22. Eliminar problemas na conversão na entrada de dados ...................................... 135	
  
 
 
5 
1. Arquitetura de um programa em C# 
 
1.1 Elementos básicos de um programa em C# 
 
using diretiva; 
 
namespace nomePrograma 
{ 
 class nome_da_classe 
 { 
 
 public static void Main(string[] args) // método principal 
 { 
 corpo_da_classe; 
 } 
 } 
} 
 
Exemplos: 
 
// -------------------------------------------- Fonte: ProgA.cs 
 
using System; 
 
namespace ProgA 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 float x = 3, y = 4, t = x + y; 
 
 Console.WriteLine ("Soma: " + t); // imprimir na tela 
 } 
 } 
} 
 
Resultado do Programa: 
 
Soma: 7 
 
// -------------------------------------------- Fonte: ProgB.cs 
 
using System; 
 
namespace ProgB 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 float x, y, t; 
 
 Console.Write ("x = "); 
 x = float.Parse (Console.ReadLine()); // ler do teclado 
 Console.Write ("y = "); 
 y = float.Parse (Console.ReadLine()); // ler do teclado 
 t = x + y; 
 Console.WriteLine ("Soma: {0}", t); // forma alternativa de imprimir na tela 
 } 
 } 
} 
 
Resultado do Programa: 
 
x = 3 
y = 4 
Soma: 7 
 
Programa Fonte: nome_da_classe.cs // ProgA.cs e ProgB.cs 
 
6 
1.2 Elementos básicos de um método estático em C# 
 
static tipo_de_retorno nome_do_método(tipo_do_agumento nome_do_argumento, ...) 
{ 
 corpo_do_método; 
 return(valor_de_retorno); 
} 
 
1.3 Como compilar um programa em C# via Terminal 
 
$ gmcs Prog1.cs <enter> // gera o arquivo “Prog1.exe” 
$ 
 
1.4 Como executar um programa em C# via Terminal 
 
$ mono Prog1.exe <enter> 
$ 
 
1.5 Pasta contendo os projetos/arquivos em C# 
 
/Users/pluzzardi/Projects // MacOsX 
 
2. Estrutura de um programa em C# 
 
2.1 Identificadores em C# 
 
 São os nomes criados pelo programador para fazer referência a 
namespaces, variáveis, constantes, argumentos, atributos e métodos. 
 
Regras para a criação de identificadores: 
 
ü O primeiro caracter pode ser uma letra ou sublinha ( _ ); 
ü Os caracteres seguintes devem ser letras, números ou sublinhas; 
ü Não é permitido a utilização de caracteres em branco (caracter 
espaço); 
ü Podem ser letras maiúsculas e minúsculas. 
 
Exemplos em variáveis: int numeroDentes = 32; 
 double inflacao; 
 char a, _a; 
 
Exemplos em constantes: final char letra = ‘A’; 
 final int tamanho = 10; 
 final double d = 123.45; 
 
Exemplos de argumentos: public int Div(int x, int y) { 
 public bool strChr(String s, char ch) { 
 
Exemplos de atributos: private int numElementos; 
 private int []vetor; 
 private int topo; 
 
Exemplos em métodos: x = raizQuadrada(y); 
 Console.WriteLine(“Valor: {0}”, inverso(n)); 
 
Observação: o método “inverso” é definido pelo programador (1/n). 
 
 
 
7 
2.2 Comentários do programador em C# 
 
 Os comentários do programador são linhas de código que não são 
compiladas pelo compilador, ou seja, servem apenas como anotações 
(documentação) para serem lembradas mais tarde (por exemplo, quando 
forem feitas manutenções no programa). Em C# os comentários podem ser 
feitos de duas formas: 
 
 /* Assim pode ser usado para comentário de várias linhas */ 
 // Isto é um comentário de uma linha apenas 
 
 Um comentário, pode ainda, utilizar várias linhas do programa. 
Veja o exemplo abaixo: 
 
/* ---------------------------------------------------- 
 Método: STRING 
 Argumentos de entrada: x, y 
 Argumentos de saída: c[], t[] 
 Retorno: Sem Retorno 
------------------------------------------------------- */ 
 
2.3 Regras gerais para escrever um programa em C# 
 
 Um programa em CSharp é constituído de uma ou mais classes 
delimitadas por chaves { }, onde uma destas classes, obrigatoriamente 
possui um método chamada Main(). As principais regras são: 
 
ü Letras maiúsculas e minúsculas são tratadas como caracteres diferentes; 
ü O formato do texto é livre; 
ü O método Main(){} especifica onde o programa começa e termina de ser 
executado; 
ü Todos os comandos são terminados por ponto e vírgula; 
ü Todas as variáveis devem ser declaradas; 
ü { método começa a ser executado; 
ü } método termina de ser executado. 
 
Programa exemplo: Imprimir a data no seguinte formato: [Data: 
dd/mm/aaaa]. 
 
// -------------------------------------------- Fonte: Prog1.cs 
 
using System; 
 
namespace Prog1 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 int dia, mes, ano; 
 
 dia = 16; 
 mes = 11; 
 ano = 2013; 
 // Console.WriteLine ("Data: " + dia + "/" + mes + "/" + ano); // forma alternativa de imprimir na tela 
 Console.WriteLine ("Data: {0}/{1}/{2}", dia, mes, ano); 
 } 
 } 
} 
 
Resultado do Programa: 
 
Data: 16/11/2013 
 
 
 
8 
2.4 Palavras reservadas do C# 
 
 As palavras reservadas não podem ser utilizadas como identificadores 
pelo programador para nomes de namespaces, variáveis, constantes, argumentos, 
atributos ou métodos. 
 
abstract event new struct 
as explicit null switch 
base extern object this 
bool false operator throw 
break finally out true 
byte fixed override try 
case float params typeof 
catch for private uint 
char foreach protected ulong 
checked goto public unchecked 
class if readonly unsafe 
const implicit ref ushort 
continue in return using 
decimal int sbyte virtual 
default interface sealed volatile 
delegate internal short void 
do is sizeof while 
double lock stackalloc 
else long static 
enum namespace string 
 
Palavras reservadas não específicas ao C# 
 
from join select yield 
get let set group 
orderby value into partial 
 
2.5 Declaração de variáveis em C# 
 
Sintaxe: tipo_dado_base lista_de_variáveis; 
tipo_dado_base: deve ser um tipo de dado válido (bool, byte, sbyte, 
char, decimal, double, float, int, uint, long, ulong, object, short, 
ushort e String) 
lista_de_variáveis: um ou mais identificadores separados por vírgulas. 
 
Exemplos: 
 
 int i, j ,k;float a, b; 
 char ch; 
 
2.5.1 Onde as variáveis podem ser declaradas em C# 
 
ü Definidas fora de todas os métodos, incluindo o método Main() 
são chamadas de variáveis globais e podem ser acessadas em 
qualquer parte do programa. Estas variáveis são alocadas 
estaticamente na memória RAM (Random Access Memory – Memória de 
acesso randômico). 
ü Quando definidas dentro de um método são chamadas de variáveis 
locais e só podem ser acessadas dentro deste método. Estas 
variáveis são alocadas dinamicamente na memória RAM. 
ü Na declaração de parâmetros formais (argumentos) de um método. 
Sendo estas locais e alocadas dinamicamente na memória RAM. 
 
Observação: Memória ROM (Read Only Memory – Memória somente de leitura). 
9 
 
Alocação de memória: Forma de reservar espaço de memória (RAM) para 
alocar uma informação (estática ou dinâmica). 
 
ü Alocação estática de memória: Tipo de alocação de memória em que 
uma variável é alocada (tem um espaço reservado) na memória RAM 
durante toda a execução do programa. Este espaço de memória é 
desalocado somente quando o programa acaba. 
ü Alocação dinâmica de memória: Tipo de alocação de memória em que 
uma variável é alocada (tem um espaço reservado) na memória RAM 
temporariamente. Este espaço de memória é desalocado quando o 
espaço não é mais necessário (coleta automática de lixo – garbage 
collector). 
 
Coletor de lixo explícito em C#: GC.Collect(); 
 
Programa exemplo: O programa realiza uma operação de potência Xy. 
 
// -------------------------------------------- Fonte: Prog2.cs 
 
using System; 
 
namespace Prog2 
{ 
 
 class MainClass 
 { 
 static double resultado; // variável global 
 
 // ---------------------------------- método estático POTENCIA 
 
 static double POTENCIA (double x, double y) 
 { 
 // corpo do método POTENCIA definido pelo programador 
 // os argumentos x e y são variáveis locais 
 
 // definição de uma variável local 
 double resp; 
 
 resp = Math.Exp (Math.Log (x) * y); 
 return(resp); // retorno do método 
 } 
 
 public static void Main(String[] args) 
 { 
 
 // definição das variáveis locais 
 double Base, Expoente; 
 
 // método que permite imprimir na tela em modo texto 
 Console.Write ("Base: "); 
 
 // método que permite entrada de dados via teclado em terminal texto 
 String s = Console.ReadLine (); 
 
 // método que converte String em float 
 Base = float.Parse (s); 
 
 Console.Write ("Expoente: "); 
 s = Console.ReadLine (); 
 Expoente = float.Parse (s); 
 
 // chamada do método POTENCIA 
 resultado = POTENCIA (Base, Expoente); 
 
 // método que imprime a resposta na tela 
 Console.WriteLine ("Resposta = {0}\n", resultado); 
 } 
 } 
} 
 
10 
Resultado do Programa: 
 
Base: 3 
Expoente: 4 
Resposta = 81 
 
 Variáveis globais: resultado 
 Variáveis locais: base, expoente, resp, x, y 
 
Compilar por linha de comandos (via terminal): 
 
$ gmcs Prog2.cs <enter> // gera arquivo Prog2.exe 
$ 
 
Executar por linha de comandos (via terminal): 
 
$ mono Prog2.exe <enter> // executa o arquivo Prog2.exe 
 
2.5.2 Inicialização de variáveis em C# 
 
 Em CSharp é possível fornecer valores iniciais a maioria das 
variáveis ao mesmo tempo em que elas são declaradas, colocando um 
sinal de igual e uma constante após o nome da variável. 
 
 tipo_dado_base nome_da_variável = constante; 
Exemplos: 
 
char ch = 'a'; // tipo_dado_base nome_da_variável = constante_caracter 
String s = “Pelotas”; // tipo_dado_base nome_da_variável = constante_string 
int n = 0; // tipo_dado_base nome_da_variável = constante_inteira 
float y = 123.45f; // tipo_dado_base nome_da_variável = constante_real 
double z = 123.45; 
int [] v = {10, 20, 30}; // vetor unidimensional 
int [,] t = {{1, 2}, {3, 4}, {5, 6}}; // matriz bidimensional 
String [] cidade = {“Pelotas”, “Rio Grande”, “Poa”}; 
char [] caracter = {‘S’, ‘s’, ‘N’, ‘n’}; 
 
2.6 Constantes em C# 
 
 Valores fixos que o programa não pode alterar. As constantes 
podem ser de qualquer tipo básico. 
 
 Tipo Exemplos de constantes 
 
 char 'a' 'n' '9' 
 int 1 123 2100 -234 
 float 123.23 4.34e-3 
 String "CSharp" (classe String) 
 
Forma de declarar uma constante tipada em C#: 
 
const int numeroElementos = 10; 
const char ch = 'A'; 
const float f = 1.234f; 
 
2.6.1 Constantes hexadecimais e octais em C# 
 
 A linguagem de programação CSharp permite especificar constantes 
inteiras em octal. Uma constante octal começa com um 0 (zero) antes 
dos demais números. 
 
Exemplos: 
 
int hexadecimal = 0xf; // 15 em decimal 
int octal = 011; // 9 em decimal 
11 
 
Observações: 
 
ü Qualquer número octal é formado por oito números ( 0 .. 7 ). 
ü Qualquer número hexadecimal é formado por dezesseis números (0 
..9, A, B, C, D, E, F). 
 
// ------------------------------------------------------- Fonte: Hexadecimal.cs 
 
using System; 
 
namespace Hexadecimal 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 for (int valorDecimal = 0;valorDecimal < 16; valorDecimal++) { 
 string valorHexadecimal = valorDecimal.ToString("X"); 
 Console.WriteLine ("Hexadecimal: "+ valorHexadecimal); 
 // int hexaToDecimal = int.Parse(valorHexadecimal, System.Globalization.NumberStyles.HexNumber); 
 // Console.WriteLine("Hexadecimal para Decimal: " + hexaToDecimal); 
 } 
 } 
 } 
} 
 
Resultado do Programa: 
 
Hexadecimal: 0 
Hexadecimal: 1 
Hexadecimal: 2 
Hexadecimal: 3 
Hexadecimal: 4 
Hexadecimal: 5 
Hexadecimal: 6 
Hexadecimal: 7 
Hexadecimal: 8 
Hexadecimal: 9 
Hexadecimal: A 
Hexadecimal: B 
Hexadecimal: C 
Hexadecimal: D 
Hexadecimal: E 
Hexadecimal: F 
 
2.6.2 Constantes Strings em C# 
 
 Uma String é um conjunto de caracteres delimitados por aspas 
duplas. Em C# existe uma classe específica para trabalhar com Strings 
(classe String). 
 
 Uma String é finalizada pelo caracter especial ‘\0’ (chamado de 
null). 
 
Exemplo: String s = "Senac"; 
‘\0’ é igual a null 
0 1 2 3 4 5 
‘S’ ‘e’ ‘n’ ‘a’ ‘c’ null 
Figura 1: String 
Memória ocupada: 6 bytes 
 
Observação: 'a' é diferente de "a" 
 
'a' ocupa 1 byte na memória RAM (é do tipo char) 
"a" ocupa 2 bytes na memória (toda String é terminada com o caracter null) 
 
 A palavra null quer dizer nulo. 
12 
 
Vetor de Strings: 
 
String [] s = {“Paulo”, “Roberto”, “Gomes”, “Luzzardi”}; 
 
Vetor de caracteres: 
 
char [] s = {'U', 'C', 'P', 'e', 'l'}; char ch = ‘\0’; 
 
2.6.3 Constantes especiais em C# 
 
 As constantes especiais são usadas para representar caracteres 
que não podem ser inseridos pelo teclado. São elas: 
Tabela 1: Constantes especiais 
 
 
2.7 Comandos do pré-processador do C# 
 
2.7.1 O comando using 
 
 O comando using faz o compilador incluir um pacote de classes 
dentro do programa fonte. Cada pacote possui diversas classes. 
 
using System; 
 
 Na URL abaixo você encontra as diversas api C#: 
 
URL: http://msdn.microsoft.com/en-us/library/d11h6832%28v=vs.71%29.aspx 
 
3. Tipos de dados em C# 
 
3.1 Tipos básicos em C# 
 
 A tabela abaixo exibe os quinze (15) tipos de dados básicos que 
podem ser utilizados pelo programador para definir suas variáveis e 
constantes em C#. Na Tabela 2 são exibidos os tipos básicos, a faixa 
de valores válida, a quantidade de bits, e o tipo de framework (using) 
que cada tipo de dados ocupa ou representa na memória RAM (memória 
principal) ou em disco (quando armazenados na memória secundária). 
 
Tabela 2: Tipos de dados 
 
Tipo Faixa de valores Bits bytes Tipo de FrameWork 
bool verdadeiro ou falso System.Boolean 
byte 0 à 255 8 1 System.Byte 
sbyte -128 à 127 8 1 System.SByte 
char um caracter 16 2 System.Chardecimal ±1.0 × 10−28 à ±7.9 × 1028 128 16 System.Decimal 
double ±5.0 × 10−324 à ±1.7 × 10308 64 8 System.Double 
float ±1.5 × 10−45 à ±3.4 × 1038 32 4 System.Single 
int -2147483648 à 2147483647 32 4 System.Int32 
uint 0 à 4294967295 32 4 System.UInt32 
Constante Significado 
‘\b’ Retrocesso 
‘\f’ Alimentação de formulário 
‘\n’ Nova linha 
‘\r’ Retorno de carro <CR> 
‘\t’ Tab horizontal 
‘\”’ Aspas duplas 
‘\’’ Aspas simples 
‘\\’ Barra invertida 
‘\o’ Constante octal 
‘\x’ Constante hexadecimal 
13 
long –9223372036854775808 à 
9223372036854775807 
64 8 System.Int64 
ulong 0 à 18446744073709551615 64 8 System.UInt64 
object qualquer tipo System.Object 
short 32768 à 32767 16 2 System.Int16 
ushort 0 à 65535 16 2 System.UInt16 
string Seqüência de caracteres 
 
16 
(cada) 
2 System.String 
 
 
3.2 Escrevendo uma classe em C# 
 
3.2.1 Conceitos básicos sobre orientação à objetos 
 
 O paradigma orientado à objetos possui cinco componentes 
básicos: objetos (possui atributos e métodos), mensagens (chamada dos 
métodos), classes (tipo de dado), instâncias (criação de objetos de 
uma classe específica - new) e métodos (funções definidas pelo 
programador que manipulam os atributos). 
 
Objetos, mensagens, classes, instâncias e métodos 
 
Objetos são entidades lógicas que contém atributos (dados 
armazenados em variáveis) e métodos (funções) que manipulam estes 
dados. Um objeto pode ser definido através de um tipo de dado chamado 
classe (class). 
 
Resumo: 
 
a) Atributos: São as variáveis definidas e declaradas para cada 
objeto. 
b) Métodos: São as funções definidas pelo programador que servirão 
para manipular os atributos. 
c) Mensagens: São as chamadas dos métodos. 
d) Classe: É um tipo de dado definido por class. Uma classe não é 
um objeto, é sim uma descrição do objeto. 
e) Instância: Os objetos são instâncias de uma classe, ou seja, é 
criado um objeto pertencente a uma classe específica. O objeto 
pode responder chamadas dos métodos e armazenar informações nos 
atributos. 
 
Resumidamente, objetos são instâncias de classes que respondem 
as mensagens através dos métodos escritos pelo programador. 
 
 Uma linguagem de programação orientada à objetos pode suportar 
ou implementar seis propriedades: abstração, encapsulamento, 
polimorfismo, herança, associação (agregação e composição) e classes 
abstratas e concretas. 
 
Exemplo de uma classe “Vetor” em C#: 
 
// -------------------------------------------------------- Prog3.cs 
 
using System; 
 
namespace Prog3 
{ 
 public class Vetor 
 { 
 // -------------------------- atributos 
 
 private int[] vetor; 
 private int n; 
 private int max; 
14 
 
 // ------------------------------ construtor 
 
 public Vetor(int tam) // obrigado o modificador de acesso public 
 { 
 max = tam; 
 vetor = new int[max]; 
 n = 0; 
 } 
 
 // ------------------------------ add 
 
 public void add(int valor) 
 { 
 if (n < max) { 
 vetor[n] = valor; 
 n++; 
 } else { 
 Console.WriteLine("Erro: Vetor excedeu Limite"); 
 } 
 } 
 
 // ------------------------------ exibe 
 
 public void exibe() 
 { 
 Console.Write("Vetor: ["); 
 for (int i = 0; i < n; i++) { 
 Console.Write(vetor[i] + " "); 
 } 
 Console.WriteLine("]"); 
 } 
 } 
} 
 
// ----------------------------------------------- Prog3.cs 
 
using System; 
 
namespace Prog3 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 Vetor v = new Vetor (5); // declaração do objeto “v” da classe Vetor 
 
 v.add (10); 
 v.add (20); 
 v.add (30); 
 v.add (40); 
 v.add (50); 
 v.exibe (); 
 v.add (60); // testar o limite do vetor de 5 elementos 
 v.exibe (); 
 } 
 } 
} 
 
Resultado do Programa: 
 
Vetor: [10 20 30 40 50 ] 
Erro: Vetor excedeu Limite 
Vetor: [10 20 30 40 50 ] 
 
Tente implementar os seguintes métodos para a classe Vetor: 
 
 v.remove(); 
 v.exibe(); 
 Console.WriteLine("Total de Elementos: " + v.length()); 
 int pri = v.primeiro(); 
 Console.WriteLine("Primeiro: " + pri); 
 int ult = v.ultimo(); 
 Console.WriteLine("Último: " + ult); 
 int elemento = 20; 
15 
 bool flag = v.existe(elemento); 
 if (flag) { 
 Console.WriteLine("Status: Existe elemento 20"); 
 } else { 
 Console.WriteLine("Status: Não Existe elemento 20"); 
 } 
 v.removeElemento(elemento); 
 flag = v.existe(elemento); 
 if (flag) { 
 Console.WriteLine("Status: Existe elemento " + elemento); 
 } else { 
 Console.WriteLine("Status: Não Existe elemento " + elemento); 
 } 
 v.exibe(); 
 v.removePosicao(1); 
 v.exibe(); 
 
Resultado do Programa: 
 
Vetor: [10 20 30 40 50 ] 
Erro: Vetor excedeu Limite 
Vetor: [10 20 30 40 50 ] 
Vetor: [10 20 30 40 ] 
Total de Elementos: 4 
Primeiro: 10 
Último: 40 
Status: Existe elemento 20 
Status: Não Existe elemento 20 
Vetor: [10 30 40 ] 
Vetor: [10 40 ] 
 
// -------------------------------------------------------- Prog3a.cs 
 
using System; 
 
namespace Prog3a 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 Vetor v = new Vetor (5); 
 
 v.add (10); 
 v.add (20); 
 v.add (30); 
 v.add (40); 
 v.add (50); 
 v.exibe (); 
 v.add (60); // testa o limite do vetor de 5 elementos 
 v.exibe (); 
 v.remove(); 
 v.exibe(); 
 Console.WriteLine("Total de Elementos: " + v.length()); 
 int pri = v.primeiro(); 
 Console.WriteLine("Primeiro: " + pri); 
 int ult = v.ultimo(); 
 Console.WriteLine("Último: " + ult); 
 int elemento = 20; 
 bool flag = v.existe(elemento); 
 if (flag) { 
 Console.WriteLine("Status: Existe elemento 20"); 
 } else { 
 Console.WriteLine("Status: Não Existe elemento 20"); 
 } 
 v.removeElemento(elemento); 
 flag = v.existe(elemento); 
 if (flag) { 
 Console.WriteLine("Status: Existe elemento " + elemento); 
 } else { 
 Console.WriteLine("Status: Não Existe elemento " + elemento); 
 } 
 v.exibe(); 
 v.removePosicao(1); 
 v.exibe(); 
16 
 } 
 } 
} 
 
Solução do Problema: 
 
using System; 
 
namespace Prog3a 
{ 
 public class Vetor 
 { 
 // -------------------------- atributos 
 
 private int[] vetor; 
 private int n; 
 private int max; 
 
 // ------------------------------ construtor 
 
 public Vetor(int tam) // é obrigado o modificador de acesso public 
 { 
 max = tam; 
 vetor = new int[max]; 
 n = 0; 
 } 
 
 // ------------------------------ add 
 
 public void add(int valor) 
 { 
 if (n < max) { 
 vetor[n] = valor; 
 n++; 
 } else { 
 Console.WriteLine("Erro: Vetor excedeu Limite"); 
 } 
 } 
 
 // ------------------------------ remove 
 
 public void remove() 
 { 
 if (n > 0) { 
 n--; 
 } else { 
 Console.WriteLine("Erro: Vetor vazio"); 
 } 
 } 
 
 // ------------------------------ removeElemento 
 
 public voidremoveElemento(int num) 
 { 
 if (n == 0) { 
 Console.WriteLine ("Erro: Vetor vazio"); 
 } else { 
 for (int i = 0; i < n; i++) { 
 if (num == vetor[i]) { 
 for (int j = i; j < n; j++) { 
 vetor [j] = vetor [j + 1]; 
 } 
 n--; 
 break; 
 } 
 } 
 } 
 } 
 
 // ------------------------------ removePosicao 
 
 public void removePosicao(int pos) 
 { 
 int fim = length (); 
 if (pos < 0 || pos > fim) { 
17 
 Console.WriteLine ("Erro: Posição Inválida"); 
 } else { 
 for (int i = pos; i < n; i++) { 
 vetor [i] = vetor [i + 1]; 
 } 
 n--; 
 } 
 } 
 
 // ------------------------------ exibe 
 
 public void exibe() 
 { 
 Console.Write("Vetor: ["); 
 for (int i = 0; i < n; i++) { 
 Console.Write(vetor[i] + " "); 
 } 
 Console.WriteLine("]"); 
 } 
 
 // ------------------------------- length 
 
 public int length() 
 { 
 return(n); 
 } 
 
 // ------------------------------- primeiro 
 
 public int primeiro() 
 { 
 return(vetor[0]); 
 } 
 
 // ------------------------------- ultimo 
 
 public int ultimo() 
 { 
 return(vetor[n-1]); 
 } 
 
 // ------------------------------- existe 
 
 public bool existe(int num) 
 { 
 bool exist = false; 
 
 for (int i = 0; i < n; i++) { 
 if (num == vetor[i]) { 
 exist = true; 
 break; 
 } 
 } 
 return(exist); 
 } 
 } 
} 
 
Resultado do Programa: 
 
Vetor: [10 20 30 40 50 ] 
Erro: Vetor excedeu Limite 
Vetor: [10 20 30 40 50 ] 
Vetor: [10 20 30 40 ] 
Total de Elementos: 4 
Primeiro: 10 
Último: 40 
Status: Existe elemento 20 
Status: Não Existe elemento 20 
Vetor: [10 30 40 ] 
Vetor: [10 40 ] 
 
 Uma linguagem de programação, orientada à objetos, pode suportar 
e/ou implementar seis (6) propriedades: abstração, encapsulamento, 
18 
polimorfismo, herança, associação (agregação e composição) e classes 
abstratas e concretas. 
 
 
Abstração 
 
 Objetos devem representar dados do mundo real. 
 
Encapsulamento (“encapsulação”) 
 
 Os objetos possuem internamente atributos e métodos agrupados no 
mesmo local, onde os métodos manipulam os atributos. Esta 
característica protege os dados (atributos) de alterações indevidas, 
somente os membros da classe podem acessar os atributos, desde que 
eles sejam privados (private) ou protegidos (protected) (caso das 
classes derivadas, que herdam o direito de acesso aos atributos). 
 
Polimorfismo (grego: “muitas formas”) 
 
É a capacidade de objetos diferentes reagirem segundo a sua 
função a uma ordem padrão. Significa que o nome de um objeto pode ser 
utilizado para vários propósitos ligeiramente diferentes, ou seja, “ 
... uma interface, vários métodos ... ”. A característica de 
polimorfismo é utilizada principalmente na sobrecarga de métodos, 
sobrecarga de operadores e nas classes abstratas, onde os métodos são 
declarados mas não definidos. Como tipos de polimorfismo tem-se: (a) 
Universal (inclusão [como em Java, por exemplo, List lista = new 
LinkedList();] e paramétrico [templates como em C++]) e (b) ad-hoc 
(sobrecarga de métodos e operadores). 
 
• Sobrecarga de operador: Permite sobrecarregar operadores para 
realizar diferentes tipos de operações; 
 
• Sobrecarga de método: Permite que um método retorne diferentes 
tipos de informações e aceite argumentos de vários tipos, 
inclusive com quantidade diferentes de argumentos; 
 
• Classes abstratas e concretas: Permite representar entidades e 
conceitos abstratos, sendo sempre uma superclasse (ou classe 
Base) e não permite ser instanciada, a classe abstrata apenas 
define um modelo (template) para uma funcionalidade e fornece 
uma implementação incompleta que é herdada pelas classes 
derivadas. Cada classe derivada implementa as funcionalidades da 
classe abstrata. Uma classe abstrata pode possuir métodos 
abstratos, mas os métodos são escritos nas classes derivadas 
concretas. Métodos abstratos definem apenas a forma do método 
não contendo nenhum tipo de código. Classes concretas 
implementam todos os métodos e podem ser instanciadas. 
 
Herança 
 
É o processo pelo qual uma classe de objetos pode adquirir as 
propriedades de outra classe de objetos, em outras palavras, um objeto 
herda as características de outro (herança simples) ou vários objetos 
(herança múltipla). A classe Base é chamada de superclasse, enquanto a 
classe derivada pode ser chamada de subclasse. 
 
Associação 
 
É um vínculo que permite que objetos de uma ou mais classes se 
relacionem entre si. Esta associação pode ser: unária (o vínculo é 
19 
entre objetos da mesma classe), binária (vínculo ocorre entre dois 
objetos de classes diferentes) ou múltipla (vínculo ocorre entre mais 
de 2 objetos de classes diferentes). Cada associação pode possuir 
características de (a) cardinalidade ou multiplicidade (indica quantos 
objetos são possíveis em cada associação) e (b) navegação (existe a 
possibilidade dos objetos acessarem outros objetos da mesma 
associação). 
Uma associação pode ser de duas formas: agregação 
(Relacionamento com características onde existe um grau menos intenso 
de coesão entre os elementos, pode haver um certo grau de 
independência) ou composição (relacionamento com características onde 
existe um alto grau de coesão e total grau de dependência entre os 
elementos). 
 
Classes Abstratas e Concretas 
 
Criada para representar entidades e conceitos abstratos. Uma 
classe abstrata é sempre uma superclasse ou classe base que não possui 
instâncias. Ela define apenas o modelo (como um template em C++) para 
uma funcionalidade e fornece uma implementação incompleta chamada de 
parte genérica sendo compartilhada por um conjunto de classes 
derivadas ou subclasses. As classes derivadas completam as funcionali-
dades da classe abstrata anexando um comportamento específico. Classes 
abstratas possuem métodos abstratos. Esses métodos são implementados 
nas suas classes derivadas concretas com o objetivo de definir o 
comportamento específico. O método abstrato define apenas a assinatura 
do método não contendo nenhum código. Classes concretas implementam 
seus métodos e permitem instanciar objetos. Classes concretas não 
possuem métodos abstratos quando são classes derivadas de uma classe 
abstrata. 
 
Vantagens da Orientação a Objetos: (a) reutilização de código, (b) 
proteção aos dados; (c) organização ou estruturação dos dados em forma 
de classes e objetos; (d) sobrecarga de métodos e de operadores; (e) 
criação de pacotes de classes; (f) ter um conjunto de pacotes pré-
definidos e (g) permitir ao desenvolvedor criar seus próprios pacotes. 
 
 Em C#, o programador pode criar suas próprias classes. Uma 
classe possui duas partes distintas: atributos (variáveis) e métodos 
(funções ou procedimentos) que manipulam estes atributos. 
 
3.2.2 Referência this em C# 
 
 Em C#, quando um método de uma classe é chamado, é passado 
automaticamente um argumento que é uma referência para o objeto que 
gerou a chamada. Esta referência é chamada “this”, ou seja, a 
referência “this” referencia o objeto que chamou o método. 
 Cada objeto tem acesso a uma referência a ele próprio, chamada 
this. Esta referência faz referências aos atributos e métodos de um 
objeto. 
 
Exemplo da utilização da referência this em C#: 
 
// -------------------------------------------------------- Data.cs 
 
using System; 
 
namespace Prog4 
{ 
 public class Data{ 
 // ------------------------------- atributos 
 
20 
 private int dia, mes, ano; 
 
 // ------------------------------- construtor 
 
 public Data(int dia, int mes, int ano) { 
 this.dia = dia; 
 this.mes = mes; 
 this.ano = ano; 
 } 
 
 public String toString() 
 { 
 String data = "Data: " + String.Format("{0:00}", dia) + "/"; 
 data = data + String.Format ("{0:00}", mes) + "/"; 
 data = data + String.Format ("{0:0000}", ano) ; 
 return(data); 
 } 
 } 
} 
 
// ----------------------------------------------------------- Prog4.cs 
 
using System; 
 
namespace Prog4 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 Data data = new Data(7, 6, 2013); 
 
 Console.WriteLine (data.toString ()); 
 } 
 } 
} 
 
Resultado do Programa: 
 
Data: 07/06/2013 
 
3.2.3 Lista de Exercícios sobre Classes em C# 
 
3.2.3.1 Dado o seguinte programa principal, implemente a classe 
Circulo e seus métodos: 
 
// ------------------------------------------ TestaCirculo.cs 
 
using System; 
 
namespace TestaCirculo 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 Circulo circ = new Circulo(); 
 
 circ.setaRaio(3); 
 circ.calculaArea(); 
 double area = circ.getArea(); 
 Console.WriteLine("Área: " + area); 
 } 
 } 
} 
 2 
Observação: area = pi . raio onde pi é 3.1416 
 
 
Círculo 
double area, raio 
setaRaio 
calculaArea 
21 
getArea 
 Diagrama de classe 
 
3.2.3.2 Dado o seguinte programa principal, implemente a classe 
PesoIdeal e seus métodos: 
 
// --------------------------------------------- Peso.cs 
 
using System; 
 
namespace Peso 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 PesoIdeal piHomem = new PesoIdeal('H', 1.67); 
 PesoIdeal piMulher = new PesoIdeal('m', 1.65); 
 
 piHomem.calculaPesoIdeal(); 
 Console.WriteLine("Peso Ideal Homem: " + piHomem.getPesoIdeal()); 
 
 piMulher.calculaPesoIdeal(); 
 Console.WriteLine("Peso Ideal Mulher: " + piMulher.getPesoIdeal()); 
 } 
 } 
} 
 
Resultado do Programa: 
 
Peso Ideal Homem: 63,41 
Peso Ideal Mulher: 57,77 
 
Cálculo do Peso Ideal: 
 
PIH = 72,7 x altura – 58 
PIM = 62,1 x altura – 44,7 
 
PesoIdeal 
double altura, pi 
char sexo 
calculaPesoIdeal 
getPesoIdeal 
 Diagrama de classe 
 
3.2.3.3 Dado o seguinte programa principal, implemente a classe 
CPF e seus métodos: 
 
// --------------------------------------------------------------- ValidaCPF.cs 
 
using System; 
 
namespace ValidaCPF 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 String s = "123456789"; 
 CPF cpf = new CPF(s); 
 
 int digitoVerificador = cpf.verificaCPF(); 
 Console.WriteLine("Digito verificador: {0:00} ", digitoVerificador); 
 Console.WriteLine("CPF: {0}-{1:00}", s , digitoVerificador); 
 } 
 } 
} 
 
Resultado do Programa: 
 
Digito verificador: 09 
CPF: 123456789-09 
 
22 
 
CPF 
String cpf 
int digito 
verificaCPF 
 Diagrama de classe 
	
  
Como calcular os Dígitos do CPF: 
 
Entrada: CPF: 123456789 
 
1) Primeiramente pega-se os dígitos da base do CPF e se faz a soma da multiplicação 
individual dos dígitos, iniciando por 10 e indo até 2 como exemplificado abaixo: 
 
 1 2 3 4 5 6 7 8 9 
 x x x x x x x x x 
 10 9 8 7 6 5 4 3 2 
 -- -- -- -- -- -- -- -- -- 
10 + 18 + 24 + 28 + 30 + 30 + 28 + 24 + 18 = 210 
 
2) O valor do primeiro dígito é o resultado da subtração de 11 pelo resto da divisão da 
soma acima por 11. Se este valor for 10 ou 11, o dígito é 0 (zero), do contrário é o 
próprio valor. No exemplo em questão o dígito encontrado é calculado conforme vê-se a 
seguir: 
 
11 - (210 % 11) = 10 
 
3) O cálculo do segundo dígito é feito da mesma forma que o primeiro, porém com os 9 
dígitos da base do CPF e o primeiro dígito verificador encontrado, iniciando por 11 e 
indo até 2. 
 
 1 2 3 4 5 6 7 8 9 0 
 x x x x x x x x x x 
11 10 9 8 7 6 5 4 3 2 
-- -- -- -- -- -- -- -- -- -- 
11 + 20 + 27 + 32 + 35 + 36 + 35 + 32 + 27 + 0 = 255 
 
4) O valor do segundo dígito é o resultado da subtração de 11 pelo resto da divisão da 
soma acima por 11. Se este valor for 10 ou 11, o dígito é 0 (zero), do contrário é o 
próprio valor. No exemplo em questão o dígito encontrado é calculado conforme vê-se a 
seguir: 
 
11 - (255 % 11) = 9 
 
Saída: CPF válido é 123.456.789-09 ou 123456789-09 
 
3.2.3.4 Dado o seguinte programa principal, implemente a classe 
DiaSemana e seus métodos: 
 
// ------------------------------------------------------- TestaDiaSemana.cs 
 
using System; 
 
namespace TestaDiaSemana 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 DiaSemana dia = new DiaSemana(17, 11, 2013); 
 
 dia.verificaDiaSemana(); 
 dia.exibeDiaSemana(); 
 } 
 } 
} 
 
Resultado do Programa: 
 
Dia da Semana: Terça-Feira 
 
DiaSemana 
int dia, mes, ano 
String semama 
23 
verificaDiaSemana 
exibeDiaSemana 
 Diagrama de classe 
 
Como calcular o Dia da Semana: 
 
Deve-se calcular o Dia do Século: 
 
Para qualquer cálculo com datas é essencial que se disponha do Dia do Século para a(s) 
data(s) em questão. O Dia do século é o número de dias decorridos desde o inicio do 
século (1º de janeiro de 1901) até a data em questão. Se usa como referência 1901 porque 
a maioria das datas com as quais se trabalha ainda são do século passado. Lá por 2040 ou 
mais poderá se mudar para 2001. 
 
A fórmula (válida para datas entre 1901 e 2099) é a seguinte: 
 
Dia_do_Seculo = (ano - 1901) * 365 + (ano - 1901) DIV 4 + dia + (mês - 1) *31 - [(mês * 
4 + 23) DIV 10] * [(mês + 12) DIV 15] + [(4 - ano MOD 4) DIV 4) * [(mês + 12) DIV 15] 
 
Entrada: Dia [1..31]: 18 
 Mês [1..12]: 12 
 Ano [1901..2099]: 2007 
 
Dia_do_Seculo = 39.068 (para a data acima) 
 
Verificação do Dia da Semana: 
 
Para saber o Dia_da_Semana basta dividir por 7 e entrar com o resto na tabela abaixo: 
 
0 Segunda 
1 Terça 
2 Quarta 
3 Quinta 
4 Sexta 
5 Sábado 
6 Domingo 
 
Saída: 18/12/2007 é uma Terça-Feira 
 
Observação: DIV é divisão inteira de dois números e MOD é o resto inteiro da divisão de 
dois números 
 
3.2.3.5 Dado o seguinte programa principal, implemente a classe 
Data e seus métodos: 
 
// ------------------------------------------------- TestData.cs 
 
using System; 
 
namespace TestData 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 Data data = new Data(); 
 
 data.setaData(17, 11, 2013); 
 data.extenso(); 
 } 
 } 
} 
 
Resultado do Programa: 
 
Data: 17 de novembro de 2013 
 
Data 
int dia, mes, ano 
setaData 
extenso 
 Diagrama de classe 
24 
 
3.2.3.6 Implemente os métodos “sortForcaBruta” e “bubleSort” na 
classe Vetor vista no item 3.2. 
 
// --------------------------------------------------- Ordena.cs 
 
using System; 
 
namespace Ordena 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 Vetor v = new Vetor (5); 
 
 v.add (30); 
 v.add (20); 
 v.add (10); 
 v.add (50); 
 v.add (40); 
 v.exibe (); 
 v.add (60); // testar o limite do vetor de 5 elementos 
 v.exibe (); 
 v.sortForcaBruta(); 
 v.exibe(); 
 // v.bubbleSort(); 
 // v.exibe(); 
 } 
 } 
} 
 
3.2.3.7Dado o seguinte programa principal, implemente a classe 
Pessoa e seus métodos. 
 
// --------------------------------------------------- TestaPessoa.cs 
 
using System; 
 
namespace TestaPessoa 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 Pessoa p1 = new Pessoa(); 
 Pessoa p2 = new Pessoa(); 
 Pessoa p3 = new Pessoa(); 
 
 p1.setaDados("Paulo Roberto", 1962, 'm'); 
 p2.setaDados("Renato Luis", 1965, 'm'); 
 p3.setaDados("Francisco Carlos", 1959, 'm'); 
 p1.calculaIdade(); 
 p2.calculaIdade(); 
 p3.calculaIdade(); 
 p1.exibePessoa(); 
 p2.exibePessoa(); 
 p3.exibePessoa(); 
 } 
 } 
} 
 
Resultado do Programa: 
 
Nome: Paulo Roberto 
Idade: 51 ano(s) 
Sexo: Masculino 
Nome: Renato Luis 
Idade: 48 ano(s) 
Sexo: Masculino 
Nome: Francisco Carlos 
Idade: 54 ano(s) 
Sexo: Masculino 
25 
 
Pessoa 
String nome, ano 
char sexo 
setaDados 
calculaIdade 
exibePessoa 
 Diagrama de classe 
 
3.2.3.8 Dado o seguinte programa principal, implemente a classe 
Pessoa e seus métodos. 
 
// ----------------------------------------------------- TestaPessoaVetor2.cs 
 
using System; 
 
namespace TestaPessoa2 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 Pessoa [] pessoa = new Pessoa[3]; 
 
 pessoa[0] = new Pessoa(); 
 pessoa[0].setaDados("Paulo Roberto", 1962, 'm'); 
 pessoa[0].calculaIdade(); 
 pessoa[0].exibePessoa(); 
 
 pessoa[1] = new Pessoa(); 
 pessoa[1].setaDados("Renato Luis", 1960, 'm'); 
 pessoa[1].calculaIdade(); 
 pessoa[1].exibePessoa(); 
 
 pessoa[2] = new Pessoa(); 
 pessoa[2].setaDados("Francisco Carlos", 1959, 'm'); 
 pessoa[2].calculaIdade(); 
 pessoa[2].exibePessoa(); 
 } 
 } 
} 
 
Resultado do Programa: 
 
Nome: Paulo Roberto 
Idade: 51 ano(s) 
Sexo: Masculino 
Nome: Renato Luis 
Idade: 53 ano(s) 
Sexo: Masculino 
Nome: Francisco Carlos 
Idade: 54 ano(s) 
Sexo: Masculino 
 
Pessoa 
String nome, ano 
char sexo 
setaDados 
calculaIdade 
exibePessoa 
 Diagrama de classe 
 
3.2.3.9 Dado o seguinte programa principal, implemente a classe 
Pessoa e seus métodos. 
 
// -------------------------------------------------- Sort.cs 
 
using System; 
 
namespace Sort 
{ 
 class MainClass 
 { 
26 
 public static void Main (string[] args) 
 { 
 Pessoa pessoa = new Pessoa(7); 
 
 pessoa.insereDados("Beatriz", 11); 
 pessoa.insereDados("Debora", 13); 
 pessoa.insereDados("Fátima", 15); 
 pessoa.insereDados("Geni", 16); 
 pessoa.insereDados("Carla", 12); 
 pessoa.insereDados("Eva", 14); 
 pessoa.insereDados("Ana", 10); 
 pessoa.exibeDados(); 
 pessoa.sort(); 
 pessoa.exibeDados(); 
 } 
 } 
} 
 
Resultado do Programa: 
 
Lista de Pessoas 
Nome: Beatriz Idade: 11 
Nome: Debora Idade: 13 
Nome: Fátima Idade: 15 
Nome: Geni Idade: 16 
Nome: Carla Idade: 12 
Nome: Eva Idade: 14 
Nome: Ana Idade: 10 
Lista de Pessoas 
Nome: Ana Idade: 10 
Nome: Beatriz Idade: 11 
Nome: Carla Idade: 12 
Nome: Debora Idade: 13 
Nome: Eva Idade: 14 
Nome: Fátima Idade: 15 
Nome: Geni Idade: 16 
 
Pessoa 
String [] nome 
int [] idade 
int n 
insereDados 
exibeDados 
sort 
 Diagrama de classe 
 
3.2.3.10 Dado o seguinte programa principal, implemente a classe 
Agenda e seus métodos. 
 
// ------------------------------------------------------- TestAgenda.cs 
 
using System; 
 
namespace TestAgenda 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 Agenda agenda = new Agenda(5); 
 
 agenda.insereTelefone("Ana", "99811234"); 
 agenda.insereTelefone("Beatriz", "99812345"); 
 agenda.insereTelefone("Carla", "99813456"); 
 agenda.insereTelefone("Debora", "99814567"); 
 agenda.insereTelefone("Eva", "99815678"); 
 agenda.insereTelefone("Fátima", "99816789"); 
 String fone = "99815678"; 
 String nome = agenda.consultaNome(fone); 
 if (nome.CompareTo("") != 0) { 
 Console.WriteLine("Nome: " + nome + " - Telefone: " + fone); 
 } else { 
 Console.WriteLine("ERRO: Usuário não Encontrado"); 
 } 
27 
 fone = "99810123"; 
 nome = agenda.consultaNome(fone); 
 if (nome.CompareTo("") != 0) { 
 Console.WriteLine("Nome: " + nome + " - Telefone: " + fone); 
 } else { 
 Console.WriteLine("ERRO: Usuário não Encontrado"); 
 } 
 } 
 } 
} 
 
Resultado do Programa: 
 
ERRO: Excedeu limite do Vetor 
Nome: Eva - Telefone: 99815678 
ERRO: Usuário não Encontrado 
 
Agenda 
String [] nome 
String [] fone 
int n 
int max 
insereTelefone 
consultaNome 
 Diagrama de classe 
 
Exemplo da definição de uma classe “Data”: 
 
// ----------------------------------------------- Fonte: Data.cs 
 
using System; 
 
namespace TestaData 
{ 
 public class Data 
 { 
 private int dia, mes, ano; // atributos da classe 
 
 public Data () 
 { 
 } 
 
 public Data(int dia, int mes, int ano) { // construtor da classe 
 this.dia = dia; 
 this.mes = mes; 
 this.ano = ano; 
 } 
 
 // ------------------------------- sobrecarga do método toString 
 
 public String toString() { 
 return(dia + "/" + mes + "/" + ano); 
 } 
 
 } 
} 
 
Programa exemplo que utiliza a classe “Data”: 
 
// --------------------------------------------- Fonte: TestaData.cs 
using System; 
 
namespace TestaData 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 Data data = new Data(19, 11, 2013); 
 
 Console.WriteLine(data.toString()); 
 } 
 } 
} 
28 
 
Exemplo da definição de uma classe “Calculadora”: 
 
// -------------------------------------------------------- Fonte: Calculadora.cs 
 
using System; 
 
namespace Calc 
{ 
 public class Calculadora 
 { 
 // ............................................. lista de atributos da classe 
 private double x, y, resp; 
 private char op; 
 private int erro; 
 
 // ............................................. métodos públicos da classe 
 public Calculadora () // construtor 
 { 
 erro = 0; 
 } 
 
 // ---------------------------- entradaDados 
 public void entradaDados () 
 { 
 Console.Write ("Digite um Valor: "); 
 String s = Console.ReadLine (); 
 x = Convert.ToDouble (s); 
 do { 
 Console.Write ("Operador [+ - * / Rr Pp Ss Cc Tt]: "); 
 s = Console.ReadLine (); 
 op = s [0]; 
 } while (!strChr ("+-*/RrPpSsCcTt", op)); 
 if (!strChr ("RrSsCcTt", op)) { 
 Console.Write ("Digite outro Valor: "); 
 s = Console.ReadLine (); 
 y = Convert.ToDouble (s); 
 } 
 } 
 
 // ---------------------------- operaCalculadora 
 public void operaCalculadora () 
 { 
 switch (op) { 
 case '+': 
 resp = soma (x, y); 
 break; 
 case '-': 
 resp = subtracao (x, y); 
 break; 
 case '*': 
 resp = multiplicacao (x, y); 
 break;case '/': 
 if (y == 0) 
 erro = 1; // divisao por zero 
 else 
 resp = divisao (x, y); 
 break; 
 case 'R': 
 case 'r': 
 if (x < 0) 
 erro = 2; // raiz negativa 
 else 
 resp = raizQuadrada (x); // Raiz Quadrada 
 break; 
 case 'P': 
 case 'p': 
 resp = power (x, y); // potencia 
 break; 
 case 'S': 
 case 's': 
 resp = seno (x); // seno 
 break; 
 case 'C': 
29 
 case 'c': 
 resp = cosseno (x); // cosseno 
 break; 
 case 'T': 
 case 't': 
 if (x == 90 || x == 180) { 
 erro = 3; 
 } else { 
 resp = tangente (x); // tangente 
 } 
 break; 
 } 
 } 
 
 // ---------------------------- exibeCalculadora 
 public void exibeCalculadora () 
 { 
 if (erro == 1) { 
 Console.WriteLine ("Erro: Divisao por Zero"); 
 } else { 
 if (erro == 2) { 
 Console.WriteLine ("Erro: Raiz Complexa"); 
 } else { 
 if (erro == 3) { 
 Console.WriteLine ("Erro: Tangente Infinita"); 
 } else { 
 Console.WriteLine ("Resposta: " + resp); 
 } 
 } 
 } 
 } 
 
 // ................................................ métodos privados da classe 
 // ---------------------------- strChr 
 private bool strChr (String s, char ch) 
 { 
 for (int i = 0; i < s.Length; i++) { 
 if (s [i] == ch) { 
 return(true); 
 } 
 } 
 return(false); 
 } 
 
 // ---------------------------- soma 
 private double soma (double x, double y) 
 { 
 return(x + y); 
 } 
 
 // ---------------------------- subtracao 
 private double subtracao (double x, double y) 
 { 
 return(x - y); 
 } 
 
 // ---------------------------- multiplicacao 
 private double multiplicacao (double x, double y) 
 { 
 return(x * y); 
 } 
 
 // ---------------------------- divisao 
 private double divisao (double x, double y) 
 { 
 if (y == 0) { 
 erro = 1; 
 return(-1); 
 } 
 return(x / y); 
 } 
 
 // ---------------------------- raizQuadrada 
 private double raizQuadrada (double x) 
 { 
 return(Math.Sqrt (x)); 
30 
 } 
 
 // ---------------------------- power 
 private double power (double x, double y) 
 { 
 return(Math.Pow (x, y)); 
 } 
 
 // ---------------------------- seno 
 private double seno (double x) 
 { 
 const double pi = 3.14158; 
 double rads; 
 
 rads = x * pi / 180.0; 
 return(Math.Sin (rads)); 
 } 
 
 // ---------------------------- cosseno 
 private double cosseno (double x) 
 { 
 const double pi = 3.14158; 
 double rads; 
 
 rads = x * pi / 180.0; 
 return(Math.Cos (rads)); 
 } 
 
 // ---------------------------- tangente 
 private double tangente (double x) 
 { 
 const double pi = 3.14158; 
 double rads; 
 
 rads = x * pi / 180.0; 
 return(Math.Tan (rads)); 
 } 
 } 
} 
 
Programa exemplo que utiliza a classe “Calculadora”: 
 
// ---------------------------------------------- Fonte: Calc.cs 
 
using System; 
 
namespace Calc 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 Calculadora calc = new Calculadora(); 
 
 calc.entradaDados(); 
 calc.operaCalculadora(); 
 calc.exibeCalculadora(); 
 } 
 } 
} 
 
Modificadores de Acesso: 
 
• public: Os atributos e métodos tornam-se públicos, ou seja, 
qualquer outro método pode chamar ou utilizar estes atributos 
e/ou métodos. 
 
• private: Somente os métodos da classe (membros) da classe podem 
chamar ou utilizar atributos ou métodos privados. 
 
• protected: Utilizado em herança simples de classe (construção de 
subclasses), ou seja, uma subclasse herda todos os atributos e 
31 
métodos da classe base (superclasse). Deixa acessível os 
atributos e/ou métodos para todas as outras classes (classe 
base) e subclasses (classe derivada). 
 
3.3 Sobrecarga de métodos em C# 
 
CSharp permite que métodos estáticos sejam sobrecarregados, 
desta forma, o retorno, número de argumentos ou mesmo o tipo de dados 
dos argumentos possam ser diferentes. 
 
// ------------------------------------------ Fonte: SobreCarga.cs 
 
using System; 
 
namespace SobreCarga 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 imprime ("Pelotas-RS"); 
 imprime (123.45); 
 imprime (123.45f); 
 imprime (123); 
 imprime ('A'); 
 } 
 
 static void imprime (String s) 
 { 
 Console.WriteLine ("String: " + s); 
 } 
 
 static void imprime (double d) 
 { 
 Console.WriteLine ("Double: " + d); 
 } 
 
 static void imprime (float f) 
 { 
 Console.WriteLine ("Float: " + f); 
 } 
 
 static void imprime (int i) 
 { 
 Console.WriteLine ("Inteiro: " + i); 
 } 
 
 static void imprime (char ch) 
 { 
 Console.WriteLine ("Caracter: " + ch); 
 } 
 } 
} 
 
Resultado do programa: 
 
String: Pelotas-RS 
Double: 123,45 
Float: 123,45 
Inteiro: 123 
Caracter: A 
 
3.4 Ponteiros, referências e endereços em C# 
 
A seguir são mostrados alguns conceitos e diferenças entre 
Ponteiros, Referências e Endereços. 
 
Endereço é um local na memória aonde um dado está armazenado, ou seja, 
corresponde a uma posição de memória capaz de armazenar os dados de um 
programa com um determinado quantidade de bytes. 
32 
 
Ponteiro é um tipo de dado (variável) que permite acessar um endereço 
qualquer. 
 
Referência é um grau de abstração de um endereço mas de forma que o 
programador não pode alterar, somente usá-lo. É uma referência a um 
item de dados ou a um objeto. O programador/compilador não pode 
manipular uma referência diretamente. 
 
 
 
// ------------------------------------------ Fonte: Ponteiro.cs 
 
using System; 
 
namespace Ponteiro 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 unsafe { // é necessário configurar para executar 
 char x = 'A'; 
 char *p; 
 
 p = &x; // p recebe o endereço de x (&x) 
 Console.WriteLine("Valor de x...: {0}", x); // *p valor é 65 
 Console.WriteLine("Caracter ....: {0}", *p); // caracter 'A' 
 } 
 } 
 } 
} 
 
Resultado do programa: 
 
Valor de x...: A 
Caracter ....: A 
 
Observação: Para utilizar este código é necessário configurar o compilador ou ambiente 
de programação (Permitir código inseguro). 
 
 
Resumo: x -> 65 
 &x -> 100 
33 
 p -> &x -> 100 
 *p -> 65 
 &p -> 200 
 
 
Definição: 
 
 tipo_dado_base *nome_do_ponteiro; 
 
tipo_dado_base: qualquer tipo básico válido em C#. 
nome_da_ponteiro: nome da variável que representa o ponteiro. 
 
 O tipo de dados do ponteiro define para que tipos de variáveis o 
ponteiro pode apontare qual o tamanho ocupado na memória por estas 
variáveis. 
 
Operadores de ponteiros 
 
& - endereço de memória do operando. 
* - conteúdo do endereço apontado pelo ponteiro. 
 
Exemplo: ponteiro = &variável; 
 
Logo: variável = *ponteiro; 
 
4. Métodos de entrada e saída de dados 
 
 
 A seguir são mostrados alguns métodos que permitem fazer entrada 
de dados via teclado e saída de dados via monitor (tela). 
 
4.1 Entrada e saída de dados usando TextReader e TextWriter 
 
 A seguir é visto um exemplo de entrada de dados usando as 
classes TextReader e TextWriter. 
 
Programa exemplo: Entrada de Dados via teclado em terminal de texto 
usando a classe TextReader e saída via monitor utilizando a classe 
TextWriter. 
 
// ---------------------------------------------- Fonte: Input.cs 
 
using System.IO; 
 
namespace Input 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 TextReader leitor = System.Console.In; 
 TextWriter escritor = System.Console.Out; 
 escritor.Write("Digite seu nome: "); 
 string nome = leitor.ReadLine(); 
 escritor.WriteLine("Número de Caracteres: {0}", nome.Length); 
 } 
 } 
} 
 
Resultado do Programa: 
 
Digite seu nome: Paulo Roberto Gomes Luzzardi 
Número de Caracteres: 28 
 
34 
 
 
 
 
4.2 Entrada e saída de dados utilizando Console 
 
 A seguir é visto outra forma de entrada e saída utilizando a 
classe Console. 
 
Programa exemplo: Entrada de dados via teclado em caixa de diálogo 
gráfica sobreposta a interface usando a classe Console. 
 
// --------------------------------------------- Fonte: EntradaSaida.cs 
 
using System; 
 
namespace EntradaSaida 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 Console.Write("Digite seu Nome: "); 
 string nome = Console.ReadLine(); 
 Console.WriteLine("Número de Caracteres: {0}", nome.Length); 
 } 
 } 
} 
 
Resultado do Programa: 
 
Digite seu nome: Paulo Roberto Gomes Luzzardi 
Número de Caracteres: 28 
 
4.3 Leitura de uma tecla em C# (pausa por teclado) 
 
 Em C# é possível ler via teclado uma tecla. 
 
// --------------------------------------------- Fonte: Caracter.cs 
 
using System; 
 
namespace Caracter 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 for (int ch = 0; ch < 255; ch++) { 
 Console.Write ("Código: " + ch + " - Caracter: " + (char)ch); 
 Console.ReadKey (); 
 } 
 } 
 } 
} 
 
Resultado do Programa: 
 
Código: 35 - Caracter: # 
Código: 36 - Caracter: $ 
Código: 37 - Caracter: % 
Código: 38 - Caracter: & 
Código: 39 - Caracter: ' 
Código: 40 - Caracter: ( 
Código: 41 - Caracter: ) 
Código: 42 - Caracter: * 
Código: 43 - Caracter: + 
Código: 44 - Caracter: , 
Código: 45 - Caracter: - 
Código: 46 - Caracter: . 
Código: 47 - Caracter: / 
35 
Código: 48 - Caracter: 0 
Código: 49 - Caracter: 1 
Código: 50 - Caracter: 2 
Código: 51 - Caracter: 3 
Código: 52 - Caracter: 4 
5. Operadores em C# 
 
 São símbolos especiais que obrigam o compilador a executar 
determinadas operações. Estas operações podem ser aritméticas, 
comparativas ou lógicas. 
 
5.1 Operadores aritméticos em C# 
 
 São operadores que realizam uma operação matemática. 
Tabela 3: Operadores aritméticos 
Operador aritmético Ação 
- Subtração 
+ Adição 
* Multiplicação 
/ Divisão 
% Resto inteiro da divisão 
-- ++ Decremento/incremento 
 
Precedência dos operadores aritméticos (Hierarquia nas Operações) 
 
Tabela 4: Precedência dos operadores aritméticos 
Hierarquia Operação 
1 Parênteses 
2 Métodos 
3 ++ -- 
4 - (menos unário) 
5 * / % 
6 + - 
 
Observação: Quando houver duas ou mais operações de mesma hierarquia, 
o compilador executa-as da esquerda para a direita. 
 
5.2 Operadores relacionais em C# 
 
 São operadores que permitem comparar valores, ou seja, são 
utilizados principalmemte em comandos que possuem condições. 
 
Tabela 5: Operadores relacionais 
Operador Ação 
> Maior que 
>= Maior ou igual a 
< Menor que 
<= Menor ou igual 
== Igual a 
!= Diferente de 
 
5.3 Operadores lógicos em C# 
 
 São operadores utilizados em comandos que tem mais de uma 
condição. 
 
Exemplo: if (condição1 && condição2 || condição3) 
 
Tabela 6: Operadores lógicos 
36 
Operador lógica Ação 
&& ou & AND (e) 
|| ou | OR (ou) 
! NOT (não) 
 
Observação: $$ e || são chamados Short Circuit Operator, ou seja, 
quando o resultado das condições não puder mais ser alterado, há um 
truncamento nas próximas condições. 
 
Precedência (Hierarquia dos operadores) 
 
Tabela 7: Precedência dos operadores relacionais e lógicos 
Hierarquia Operação 
1 ! 
2 > >= < <= 
3 == != 
4 && 
5 || 
 
Observação: As expressões que utilizam operadores relacionais e 
lógicos retornam 0 (zero) para falso e !0 (não zero) para verdadeiro, 
ou seja: 
 
true é diferente de 0 (!= 0) e false é igual 0 (== 0) 
 
5.4 Incremento e decremento em C# 
 
 São operadores aritméticos que permitem realizar operações de 
soma e subtração de forma simplificada. 
 
ü ++ adiciona (1) ao operando 
ü subtrai (1) ao operando 
 
 As seguintes operações são equivalentes: 
 x++; x = x + 1; 
 x--; x = x - 1; 
 
Observação: 
 
 Os operadores (++ ou --) podem ser colocados antes ou depois do 
operando. Quando precede seu operando, C# efetua a operação de 
incremento ou decremento antes de utilizar o valor do operando. Quando 
o operador vier depois do operando, C# utiliza o valor do operando 
antes de incrementá-lo ou decrementá-lo. 
 
Exemplo: 
 Equivalência 
 
 x = 10; // y será 11 x = 10; 
 y = ++x; // x será 11 x = x + 1; 
 y = x; 
 
 x = 10; // y será 10 x = 10; 
 y = x++; // x será 11 y = x; 
 x = x + 1; 
5.5 Operador de atribuição em C# 
 
 O operador de atribuição é o sinal de igual =. A sintaxe do 
operador de atribuição pode ser escrito em uma das seguintes formas: 
 
37 
 variável = constante; x = 3; 
 variável = variável; x = y; 
 variável = expressão; x = a + b; 
 variável = método(x); x = Math.sqrt(y); 
 
Programa exemplo: O programa calcula a idade de uma pessoa. 
 
// ------------------------------------------ Fonte: Operadores.cs 
 
using System; 
 
namespace Operadores 
{ 
 class MainClass 
 { 
 public static void Main (string[] args) 
 { 
 // leitura do ano atual 
 Console.Write("Ano ATUAL: "); 
 String s = Console.ReadLine(); 
 int ano_atual = Convert.ToInt32 (s); 
 
 Console.Write("Ano de NASCIMENTO: "); 
 s = Console.ReadLine(); 
 
 // leitura do ano de nascimento 
 int ano_nasceu = Convert.ToInt32(s); 
 
 // atribuição – cálculo da idade 
 int idade = ano_atual - ano_nasceu; 
 Console.WriteLine("Sua IDADE é " + idade + " anos"); 
 } 
 } 
} 
 
Resultado do Programa: 
 
Ano ATUAL: 2013 
Ano de NASCIMENTO: 1962 
Sua IDADE é 51 anos 
 
 A linguagem de programação CSharp permite utilizar o operador de 
atribuição em expressões, junto com operadores matemáticos, lógicos, 
relacionais, chamada de métodos, e outros (como foi mencionado acima). 
 
if ((produto = x * y) < 0) 
 
Funcionamento: Primeiramente C# atribui o valor x * y a variável 
produto, para depois avaliar a expressão, ou seja, comparar se o 
produto é menor (<) que zero. 
 
5.6 Casts em C# 
 
 É possível forçar que o resultado de uma expressão seja de um 
determinado tipo. Para tanto deve ser utilizado uma construção chamada 
de cast, ou seja, pode ser utilizado para "tipar" uma variável com um 
tipo diferente do resultado da expressão. 
 
variável = (tipo) expressão; 
 
Programa exemplo: O programa imprime na tela o resultado de uma 
divisão. 
 
// -------------------------------------------- Fonte: Cast.cs 
 
using System; 
 
namespace Cast 
38 
{ 
 class MainClass