Está en la página 1de 139

Linguagem de Programação C#

1

SUMÁRIO
CAPÍTULO 1 – Revisão .................................................................................................................................... 3
1.1 Lógica .......................................................................................................................................................... 3
1.1.1 Sequência Lógica...................................................................................................................................... 3
1.2 Algoritmo ..................................................................................................................................................... 3
1.2.1 Formas de Representação de Algoritmos .................................................................................................. 3
1.2.2 Regras para construção do Algoritmo ........................................................................................................ 6
1.2.3 Fases Fundamentais ................................................................................................................................. 6
1.2.4 Estrutura de um Algoritmo ......................................................................................................................... 6
1.3 Comando ESCREVA ................................................................................................................................... 7
1.4 Comando LEIA ............................................................................................................................................ 8
1.5 Variáveis ...................................................................................................................................................... 8
1.6 Comandos de Atribuição .............................................................................................................................. 9
1.7 Operadores .................................................................................................................................................. 9
1.7.1 Operadores Aritméticos ............................................................................................................................. 9
1.7.2 Operadores Relacionais .......................................................................................................................... 10
1.7.3 Operadores Lógicos ................................................................................................................................ 10
1.8 Funções Intrínsecas ................................................................................................................................... 11
1.8.1 Funções Aritméticas ................................................................................................................................ 11
1.9 Comandos para controle de Fluxo .............................................................................................................. 13
1.9.1 Estrutura de Sequência ........................................................................................................................... 13
1.9.2 Estrutura de Seleção ............................................................................................................................... 13
1.9.3 Estruturas de Repetição .......................................................................................................................... 18
CAPÍTULO 2 – Visual C# 2008 Express................................................................................................ ........ 24
2.1 Instalando o Visual C# 2008 Express ......................................................................................................... 24
2.2 Introdução ao Visual C# Express ............................................................................................................... 28
CAPÍTULO 3 – Introdução ao IDE do Visual C# 2008 Express ............................................................ ........ 30
3.4 – Primeiro Programa ......................................................................................................................... ........ 39
3.4.1 Main........................................................................................................................................................ 39
3.5 – Estrutura de um programa .............................................................................................................. ........ 40
CAPÍTULO 4 – Variáveis na Linguagem C# ......................................................................................... ........ 41
4.1 Tipos de dados .......................................................................................................................................... 41
4.1.1 Tipos Valor e Tipos Referência ............................................................................................................... 41
4.1.2 Conversão de Tipos ................................................................................................................................ 41
4.1.3 O Objeto Convert .................................................................................................................................... 42
4.2 Arrays ........................................................................................................................................................ 42
CAPÍTULO 5 – Operadores ................................................................................................................... ........ 44
5.1 Operadores Aritméticos.............................................................................................................................. 44
5.2 Operadores de Incremento e Decremento .................................................................................................. 46
5.3 Operadores Lógico, Relacional e Condicional ............................................................................................ 46
5.4 Operação de Atribuição.............................................................................................................................. 46
CAPÍTULO 6 – Comandos .................................................................................................................... ........ 47
6.1 Seleção ..................................................................................................................................................... 47
6.1.1 Comando if ............................................................................................................................................. 47
6.1.2 Comando switch ..................................................................................................................................... 49
6.2 Loop .......................................................................................................................................................... 50
6.2.1 Comando for ........................................................................................................................................... 50
6.2.2 Comando foreach.................................................................................................................................... 52
6.2.3 Comandos do - while .............................................................................................................................. 53
CAPÍTULO 7 – Desenvolvimento de aplicações com C# .................................................................... ........ 54
CAPÍTULO 8 – Conversão de Tipos com C# ........................................................................................ ........ 75
8.1 Problema na Conversão de Tipos .............................................................................................................. 75
CAPÍTULO 9 – Programação baseada em Objetos ............................................................................. ........ 92
9.1 Convenções e Padrões de Nomenclatura................................................................................................... 92
9.1.1 Nomeação de variáveis ........................................................................................................................... 93
9.1.2 Nomeação de classes, métodos, propriedades, entre outros. .................................................................. 93
9.2 Classes ...................................................................................................................................................... 93
9.3 Propriedades ............................................................................................................................................. 94
9.4 Modificadores de visibilidade ...................................................................................................................... 94
9.5 Herança ..................................................................................................................................................... 95
Linguagem de Programação C#

2

9.5.1 This e Base ............................................................................................................................................. 95
9.6 Declaração e Chamada de Métodos e Objetos ........................................................................................... 96
9.7 Métodos e Atributos Static ......................................................................................................................... 96
9.8 Const e ReadOnly ...................................................................................................................................... 96
9.9 Classes e Métodos Abstratos ..................................................................................................................... 97
9.10 Interfaces ................................................................................................................................................. 97
9.11 Métodos Virtuais ...................................................................................................................................... 98
9.12 Classes e Métodos sealed - Finais ........................................................................................................... 98
9.13 Quando devo utilizar o que? ..................................................................................................................... 99
CAPÍTULO 10 – Tratamento de Erros e Exceções............................................................................... ...... 100
10.1 Comando throw...................................................................................................................................... 100
10.2 Bloco try - catch ..................................................................................................................................... 101
10.3 Bloco try - finally ..................................................................................................................................... 101
10.4 Bloco try - catch - finally ......................................................................................................................... 102
10.5 A classe Exception ................................................................................................................................. 103
CAPÍTULO 11 - Funções Matemáticas ................................................................................................. ...... 104
11.1 Funções para manipular Strings no C# ................................................................................................... 104
Capítulo 12 - Funções para Manipulação de Arquivos ....................................................................... ...... 108
12.1 Classes DirectoryInfo e FileInfo .............................................................................................................. 108
12.1.1 Criando diretórios e subdiretórios ........................................................................................................ 109
12.1.2 Acessando as propriedades ................................................................................................................ 109
12.2 Criando arquivos usando a classe FileInfo ............................................................................................. 110
12.2.1 Entendendo o método Open() ............................................................................................................. 110
12.2.2 Entendendo a classe FileStream ......................................................................................................... 110
12.2.3 Métodos CreateText() e OpenText() .................................................................................................... 111
CAPÍTULO 13 – Aprofundando Windows Forms ................................................................................. ...... 112
13.1 Aplicações MDI ...................................................................................................................................... 112
13.1.1 Adicionando uma nova janela filha ...................................................................................................... 112
3.1.2 Fechando uma janela filha .................................................................................................................... 113
13.2 Aplicações SDI....................................................................................................................................... 113
13.2.1 Exemplo múltiplos formulários ............................................................................................................. 113
13.3 Passando valores entre Forms ............................................................................................................... 114
13.4 Posicionando os formulários na tela ....................................................................................................... 114
13.5 Controlando os eventos dos formulários ................................................................................................. 114
CAPÍTULO 14 – Conexão com Banco de Dados ................................................................................. ...... 115
14.1 O que é o ADO.NET ?............................................................................................................................ 115
14.2 Os namespaces relacionados ao ADO.NET ........................................................................................... 115
14.3 O modelo de execução do ADO.NET ..................................................................................................... 115
14.4 O modelo de execução em um ambiente conectado ............................................................................... 116
14.5 O modelo de execução em um ambiente desconectado ......................................................................... 117
14.6 Estabelecendo uma conexão com um banco de dados .......................................................................... 117
14.7 Criando comandos ................................................................................................................................. 118
14.8 Executando comandos ........................................................................................................................... 118
14.8.1 O método ExecuteNonQuery ............................................................................................................... 118
14.8.2 O método ExecuteScalar..................................................................................................................... 118
14.8.3 O método ExecuteReader ................................................................................................................... 119
14.9 Passando parâmetros ............................................................................................................................ 119
14.10 O que é um DataSet?........................................................................................................................... 120
14.11 O que é um DataAdapter? .................................................................................................................... 120
14.12 Criando um DataSet e um DataAdapter................................................................................................ 120
14.13 Criando e preenchendo um DataSet..................................................................................................... 121
CAPÍTULO 15 – Operações CRUD com Entity Framework ................................................................. ...... 122
CAPÍTULO 16 - Conexão C# com o MYSQL......................................................................................... ...... 128
16.1 Inserção de dados em MySQL ............................................................................................................... 131
CAPÍTULO 17 - Gerando um Executável a partir de um Windows Forms .......................................... ...... 136



Linguagem de Programação C#

3

CAPÍTULO 1 – Revisão

1.1 Lógica
A lógica de programação é necessária para pessoas que desejam trabalhar com desenvolvimento
de sistemas e programas, ela permite definir a sequência lógica para o desenvolvimento.
"Lógica de programação é a técnica de encadear pensamentos para atingir determinado objetivo."

1.1.1 Sequência Lógica
Estes pensamentos podem ser descritos como uma sequência de instruções, que devem ser
seguidas para se cumprir uma determinada tarefa.
"Sequência Lógica são passos executados até atingir um objetivo ou solução de um problema."

1.2 Algoritmo
Algoritmo é uma sequencia de ações finitas encadeadas e lógicas que descrevem como um
determinado problema deve ser resolvido.
Um algoritmo é formalmente uma sequencia finita de passos que levam a execução de uma tarefa.
Podemos pensar em algoritmo como uma receita, uma sequencia de instruções que executam uma meta
específica. Estas tarefas não podem ser redundantes nem subjetivas na sua def inição, devem ser claras e
precisas.
Como exemplos de algoritmos podemos citar os algoritmos das operações básicas (adição,
multiplicação, divisão e subtração) de números reais decimais. Outros exemplos seriam os manuais de
aparelhos eletrônicos, como um aparelho de som, que explicam passo-a-passo como, por exemplo, gravar
um evento.
Até mesmo as coisas mais simples do nosso dia a dia, podem ser descritas por sequencias lógicas.
Apesar do nome pouco usual, algoritmos são comuns em nosso cotidiano, como por exemplo, uma receita
de bolo. Nela está descrita uma série de ingredientes necessários e uma sequencia de diversos passos
(ações) que devem ser fielmente cumpridos para que se consiga fazer o alimento desejado, conforme se
esperava, antes do início das atividades (objetivo bem definido).
Observa-se, porém que uma ordem isolada não permite realizar o processo completo, para isso é
necessário um conjunto de instruções colocadas em ordem sequencial lógica. No exemplo do parágrafo
anterior para fazermos um bolo não podemos começar por colocar os ingredientes no forno. É necessário
todo um processo passo a passo para se chegar a este fim.

1.2.1 Formas de Representação de Algoritmos
Existem diversas formas de representação de algoritmos, mas não há um consenso com relação à
melhor forma delas.
O critério usado para classificar hierarquicamente estas formas está diretamente ligado ao nível de
detalhe, inversamente ao grau de abstração oferecido.
Algumas formas de representação de algoritmos tratam os problemas apenas em nível lógico,
abstraindo-se de detalhes de implementação muitas vezes relacionados com alguma linguagem de
programação específica. Por outro lado, existem formas de representação de algoritmos que possuem
uma maior riqueza de detalhes e muitas vezes acabam por obscurecer a ideia principal, o algoritmo,
dificultando seu entendimento.
Linguagem de Programação C#

4

Dentre as formas de representação de algoritmo mais conhecidas, destacam-se:
- A descrição narrativa;
- O fluxograma convencional;
- O pseudocódigo, também conhecido como linguagem estruturada ou Portugol.
A) Descrição Narrativa
Nesta forma de representação, os algoritmos são expressos em linguagem natural.
Exemplo:
“Receita de um bolo”
1. Separar os ingredientes
2. Bater os ovos em neve na batedeira
3. Acrescentar açúcar e farinha de trigo
4. Colocar extrato de baunilha
5. Acrescentar uma colher de manteiga
6. Acrescentar uma colher de Fermento em pó
7. Verificar se esta doce o suficiente
8. Colocar na forma
9. Colocar no forno e assar
10. Retirar do forno
11. Tirar da forma e servir
12. Fim do processo

Quando elaboramos um algoritmo devemos especificar ações claras e precisas, que a partir de um
estado inicial, após um período de tempo finito, produzem um estado final previsível e bem definido. Isto
significa que o algoritmo fixa um padrão de comportamento a ser seguido, uma norma de execução a ser
trilhada, com vistas a alcançar, como resultado final, a solução de um problema, garantindo que sempre
que executado, sob as mesmas condições, produza o mesmo resultado.
A importância de se construir um algoritmo: conseguimos visualizar e testar ainda no papel, a
solução criada com lógica de programação sem nos preocupar com detalhes computacionais e uma vez
concebida uma solução algorítmica para um problema, esta pode ser traduzida facilmente para qualquer
linguagem de programação e ser agregada das funcionalidades disponíveis nos diversos ambientes, ou
seja, a codificação.

B) Diagrama de Bloco ou Fluxograma
O diagrama de blocos é uma forma padronizada e eficaz para representar os passos lógicos de um
determinado processamento. Com o diagrama podemos definir uma sequência de símbolos, com
significado bem definido, portanto, sua principal função é a de facilitar a visualização dos passos de um
processamento.
Existem diversos símbolos em um diagrama de bloco. Veja no quadro abaixo alguns dos símbolos
que iremos utilizar:


Linguagem de Programação C#

5

Símbolo Nome – Significado

Terminal – Símbolo usado como ponto para indicar o início e
fim do fluxo de um programa.

Seta de fluxo de dados – Permite indicar o sentido do fluxo de
dados. Serve exclusivamente para conectar os símbolos ou
blocos existentes.

Processamento – Símbolo ou bloco que se utiliza para indicar
cálculos (algoritmos) e efetuar, atribuições de valores qualquer
manipulação de dados que tenha um bloco específico para sua
descrição.

Entrada de dados ou Leitura dos dados – Utilizado para ler os
dados necessários ao programa.

Saída de dados em vídeo – utiliza-se este símbolo quando se
quer mostrar dados na tela do vídeo.

Saída de dados em impressora – É utilizado quando se deseja
que os dados sejam impressos.

Decisão – Indica a decisão que deve ser tomada, indicando a
possibilidade de desvios para outros pontos do fluxo,
dependendo do resultado de comparação e de acordo com
situações variáveis.

Conector – Utilizado quando é preciso particionar o diagrama.
Quando ocorrer mais de uma partição, é colocada uma letra ou
número dentro do símbolo de conexão para identificar os pares
de ligação.

Conector – Específico para indicar conexão do fluxo em outra
página.

Repetição – Indica repetição do tipo para. Caracteriza-se por
efetuar um laço por um determinado número de vezes
previamente definido

C) Pseudocódigo
Como foi visto até agora, o fluxograma convencional é a primeira forma de notação gráfica, mas
existe outra, que é uma técnica narrativa denominada pseudocódigo, também conhecida como português
estruturado ou chamada por alguns de portugol.
Esta técnica de algoritmização é baseada em uma PDL – Program Design Language (Linguagem
de Projeto de Programação). Aqui vamos apresentá-la em português. A forma original de escrita é
conhecida como inglês estruturado, muito parecida com a notação da linguagem PASCAL.
A PDL (neste caso, o pseudocódigo) é usada como referência genérica para uma linguagem de
projeto de programação, tendo como finalidade mostrar uma notação para elaboração de algoritmos, os
quais serão utilizados na definição, criação e desenvolvimento de uma linguagem computacional (Clipper,
C, Fortran, Pascal, Delphi, Visual-Objects) e sua documentação. Abaixo é apresentado um exemplo deste
tipo de algoritmo.
Os algoritmos são independentes das linguagens de programação. Ao contrário de uma
linguagem de programação não existe um formalismo rígido de como deve ser escrito o algoritmo.
O algoritmo deve ser fácil de interpretar e fácil de codificar. Ou seja, ele deve ser o intermediário
entre a linguagem falada e a linguagem de programação.
Linguagem de Programação C#

6

D) Portugol
A maioria esmagadora das linguagens de programação de computadores é em língua inglesa. Para
facilitar o aprendizado de lógica de programação foram criadas algumas pseudolinguagens.
O Portugol é uma pseudolinguagem de programação, uma simbiose de Português, Algol e Pascal,
criada originalmente em inglês, com a proposta de ser independente da linguagem nativa (ou seja, exi ste
em japonês, javanês, russo...).
Basicamente, é uma notação para algoritmos, a ser utilizada na definição, criação,
desenvolvimento e documentação dos programas.
Algumas Palavras Chave: Inicio, Fim, Algoritmo, Enquanto, Se, então, Para, Até, Até que, Leia,
Escreva, Faça, Repita, FimSe, FimEnquanto, FimSelecione, entre outras que veremos adiante.

1.2.2 Regras para construção do Algoritmo
Para escrever um algoritmo precisamos descrever a sequencia de instruções, de maneira simples e
objetiva. Para isso utilizaremos algumas técnicas:
1. Usar somente um verbo por frase
2. Imaginar que você está desenvolvendo um algoritmo para pessoas que não trabalham com
informática
3. Usar frases curtas e simples
4. Ser objetivo
5. Evite usar palavras que tenham sentido dúbio
6. Procure dividir o problema em etapas menores.

1.2.3 Fases Fundamentais
Vimos que ALGORITMO é uma sequencia lógica de instruções que podem ser executadas.
É importante ressaltar que qualquer tarefa que siga comportamento padrão pode ser descrita por
um algoritmo.
Entretanto ao montar um algoritmo, precisamos primeiro dividir o problema apresentado em três
fases fundamentais.

ENTRADA: São os dados de entrada do algoritmo
PROCESSAMENTO: Procedimentos utilizados para chegar ao resultado final
SAÍDA: São os dados já processados

1.2.4 Estrutura de um Algoritmo
Nome do algoritmo
Declaração das variáveis
Inicio
Corpo do algoritmo, composto por comando de entrada e saída, operadores, estruturas
de decisão, de repetição, chamadas de funções e etc.
Fim do Algoritmo
Linguagem de Programação C#

7

A) Exemplo de Algoritmo
Imagine o seguinte problema: Calcular a média final dos alunos. Pelas provas os alunos receberão
2 notas: N1, N2. Onde:
N1 + N2
Média Final = --------------------
2
Para montar o algoritmo proposto, faremos três perguntas:

a) Quais são os dados de entrada?
R: Os dados de entrada são N1, N2
b) Qual será o processamento a ser utilizado?
R: O procedimento será somar todos os dados de entrada e dividi-los por 2 (dois)
c) Quais serão os dados de saída?
R: O dado de saída será a média final
INICIO do algoritmo
| Receba a nota da prova1
| Receba a nota de prova2
| Some todas as notas e divida o resultado por 2
| Mostre o resultado da divisão
FIM do algoritmo

B) Teste de Mesa
Após desenvolver um algoritmo ele deverá sempre ser testado. Este teste é chamado de TESTE
DE MESA, que significa, seguir as instruções do algoritmo de maneira precisa para verificar se o
procedimento utilizado está correto ou não.
Veja o exemplo: Nota da Prova 1 Nota da Prova 2 Nota da Prova 3 Nota da Prova 4
Utilize a tabela abaixo:
P1 P2 P3 P4 Média



EXERCÍCIOS
1) Crie uma sequência lógica para tomar banho.
2) Faça um algoritmo para somar dois números e multiplicar o resultado pelo primeiro número.
3) Descreva com detalhes a sequência lógica para trocar um pneu de um carro.
4) Faça um algoritmo para trocar uma lâmpada. Descreva com detalhes.

1.3 Comando ESCREVA
O comando 'escreva' faz com que algo seja exibido na tela. pode ser qualquer coisa: Variáveis,
números, caracteres, espaços em branco e tudo mais que seu teclado puder digitar. É seguido de
parênteses com o que será exibido na tela. Exemplo:
escreva ("Isso será exibido na tela");

Linguagem de Programação C#

8

Você também pode fazer:
Algoritmo exemplo
var
x : inteiro;
inicio
x <- 5
escreva (x);
fim-algoritmo

1.4 Comando LEIA
O comando leia serve para entrada de dados, que evidentemente serão armazenados em uma
variável. Ele vem seguido do nome da variável em que você quer que o valor digitado seja atribuído.

Exemplo
escreva ("Digite seu nome: ");
leia (nome);
escreva ("Bom dia ",nome);
//Agora o valor da variável 'nome' é o valor que o usuário digitou

Depois de ter armazenado a informação do usuário em uma variável, você pode usá-la como
quiser.
1.5 Variáveis
Variável é a representação simbólica dos elementos de um certo conjunto. Cada variável
corresponde a uma posição de memória, cujo conteúdo pode se alterado ao longo do tempo durante a
execução de um programa. Embora uma variável possa assumir diferentes valores, ela só pode armazenar
um valor a cada instante.

1.5.1 Tipos de Variáveis
As variáveis e as constantes podem ser basicamente de quatro tipos: Numéricas, caracteres,
Alfanuméricas ou lógicas.
- Numéricas Específicas para armazenamento de números, que posteriormente poderão ser
utilizados para cálculos. Podem ser ainda classificadas como Inteiras ou Reais. As variáveis do tipo inteiro
são para armazenamento de números inteiros e as Reais são para o armazenamento de números que
possuam casas decimais.
- Caracteres Específicos para armazenamento de conjunto de caracteres que não contenham
números (literais). Ex: nomes.
- Alfanuméricas Específicas para dados que contenham letras e/ou números. Pode em
determinados momentos conter somente dados numéricos ou somente literais. Se usado somente para
armazenamento de números, não poderá ser utilizada para operações matemáticas.
- Lógicas Armazenam somente dados lógicos que podem ser Verdadeiro ou Falso.

1.5.2 Declaração de Variáveis
As variáveis só podem armazenar valores de um mesmo tipo, de maneira que também são
classificadas como sendo numéricas, lógicas e literais.


Linguagem de Programação C#

9

EXERCÍCIOS
1. Marque as variáveis como I – Inteiro, R – Real, B – Lógico, L – Literal, N – Não é possível definir.
( ) “F.” ( ) “n1” ( ) .F ( ) “.F.”
( ) 75,0 ( ) 1 ( ) “Cinco” ( ) “V”
( ) 2 ( ) 0, ( ) “+32.7” ( ) M
( ) .V. ( ) -0,01 ( ) V
2. Marque as variáveis como V – Variáveis Válidas, I – Variáveis Inválidas.
( ) Nome Usuario ( ) Endereco ( ) Fone$Com
( ) Nome_Usuario ( ) 2B ( ) 21Brasil
( ) Ab ( ) eEnd* ( ) “+32.7”
( ) A B ( ) Cidade3 ( ) #CAEB
( ) NomeUsuario ( ) N1 ( ) N!
1.6 Comandos de Atribuição
O comando de atribuição simplesmente define o valor de uma variável onde o tipo do dado
atribuído para a variável necessita ser compatível com o tipo declarado para a mesma. O símbolo de
atribuição é a seta para a esquerda, veja no exemplo abaixo:
Algoritmo:
Variável ÷ valor, variável ou expressão;
Em pascal
Variável := valor, variável ou expressão;
Em outras linguagens derivadas da linguagem C
Variável = valor, variável ou expressão;
Obs: Na linguagem Pascal/Delphi, o comando de atribuição é o := (dois pontos igual) e nas
linguagens como o C ou suas derivadas (C++, JAVA, C#, PHP, javascript, etc.) usa-se somente o = (igual)
para atribuir valor em uma variável.

1.7 Operadores
Os operadores são meios pelo qual incrementamos, decrementamos, comparamos e avaliamos
dados dentro do computador. Temos três tipos de operadores:
- Operadores Aritméticos
- Operadores Relacionais
- Operadores Lógicos

1.7.1 Operadores Aritméticos
Os operadores aritméticos são os utilizados para obter resultados numéricos. Além da adição,
subtração, multiplicação e divisão, podem utilizar também o operador para exponenciação. Os símbolos
para os operadores aritméticos podem ser vistos ao lado:






Operação Símbolo
Adição +
Subtração -
Multiplicação *
Divisão /
Exponenciação ** ou ^
Linguagem de Programação C#

10

Hierarquia das Operações Aritméticas
1º ( ) O que estiver entre Parênteses
2º Exponenciação
3º Multiplicação, divisão (o que aparecer primeiro)
4º + ou – (o que aparecer primeiro)

Exemplos:
- TOTAL = PREÇO * QUANTIDADE
- 1 + 7 * 2 ** 2 – 1 = 28
- 3 * (1 - 2) + 4 * 2 = 5

1.7.2 Operadores Relacionais
Os operadores relacionais são utilizados para comparar String de caracteres e números. Os valores
a serem comparados podem ser caracteres ou variáveis.
Igual a =
Diferente de <> ou =
Maior que >
Menor que <
Maior ou igual a >=
Menor ou igual a <=
Estes operadores sempre retornam valores lógicos (Verdadeiro ou Falso/ True ou False)
Para estabelecer prioridades no que diz respeito a qual operação executar primeiro, utilize os
parênteses. Os operadores relacionais são:
Exemplos: Tendo duas variáveis A = 5 e B = 3 , os resultados das expressões seriam:
d Resultado
A = B Falso
A <> B Verdadeiro
A > B Verdadeiro
A < B Falso
A >= B Verdadeiro
A <= B Falso

1.7.3 Operadores Lógicos
Os operadores lógicos servem para combinar resultados de expressões, retornando se o resultado
final é verdadeiro ou falso. Os operadores lógicos são:
E (And) A expressão é verdadeira se todas as condições forem verdadeiras
OU (Or) A expressão é verdadeira se pelo menos uma condição for verdadeira
NÃO (Not) Inverte o valor da expressão ou condição, se verdadeira inverte para falsa e vice-
versa.

Linguagem de Programação C#

11

Conjunção (E)
O resultado será verdadeiro se e somente se os operandos forem verdadeiros
A B A (E) B
V V V
F V F
F F F
V F F
Disjunção (OU)
O resultado será falso se, e somente se ambos os operandos forem falsos
A B A (OU) B
V V V
V F V
F V V
F F F
A tabela mostra todos os valores possíveis criados pelos três operadores lógicos.
Exemplos: Suponha que temos três variáveis A = 5, B = 8 e C =1. Os resultados das expressões
seriam:








1.8 Funções Intrínsecas
São funções que resumem uma série se operações básicas. Podem ser Aritméticas, quando no
tratamento de números e Literais quando no tratamento de alfanuméricos.

1.8.1 Funções Aritméticas
Sintaxe Descrição
Caracter Caracter(Num) Fornece o caracter correspondente a Num (entre 1 e 255) de acordo
com a tabela ASCII
Int Int(Num) Arredonda um número real Num para baixo, retornando a parte
inteira mais próxima.
Raiz Raiz(Num) Retorna uma raiz quadrada de Num.
Abs Abs(Núm) Retorna o valor absoluto de Num, que é um número sem o respectivo
sinal.
Div Div(Num;Divisor) Retorna o quociente da divisão de Num por divisor.
Mod Mod(Num;Divisor) Retorna o resto depois da divisão de Num por divisor.
Expressões Resultado
A = B AND B > C Falso
A <> B OR B < C Verdadeiro
A > B NOT Verdadeiro
A < B AND B > C Verdadeiro
A >= B OR B = C Falso
A <= B NOT Falso.
Linguagem de Programação C#

12


1.8.2 Funções Literais Usuais
Sintaxe Descrição
Ltrim Ltrim(Texto) Elimina de Texto espaços em branco à esquerda.
Rtrim Rtrim(Texto) Elimina de Texto espaços em branco à direita.
Comp Comp(Texto) Fornece o total de caracteres de Texto incluindo espaços em
branco.
Direita Direita(Texto;NCaract) Retorna os últimos NCaract caracteres em Texto.
Esquerda Esquerda(Texto;Núm_Caract) Retorna os primeiros Núm_Caract caracteres em Texto.
Sub Sub(Texto; N; M) Resulta uma parte de Texto que começa no caracter de numero
N e tem tamanho M
Pos Pos(Texto; Parte) Indica a posição da primeira ocorrência de Parte em Texto
ASCII ASCII(Texto) Fornece o valor inteiro correspondente ao primeiro caractere de
Texto, segundo a tabela ASCII

EXERCÍCIOS
1) Identifique os dados de entrada, processamento e saída no algoritmo abaixo
- Receba código da peça
- Receba valor da peça
- Receba Quantidade de peças
- Calcule o valor total da peça (Quantidade * Valor da peça)
- Mostre o código da peça e seu valor total
2) Faça um algoritmo para “Calcular o estoque médio de uma peça”, sendo que
ESTOQUEMÉDIO = (QUANTIDADE MÍNIMA + QUANTIDADE MÁXIMA) /2
3) Teste o algoritmo anterior com dados definidos por você.
4) Defina as regras, faça o algoritmo e o fluxograma para ler as coordenadas de dois pontos no
plano cartesiano e imprimir a distância entre estes dois pontos. OBS: fórmula da distância entre dois
pontos (x
1
,y
1
) e (x
2
, y
2
):

5) Defina as regras, faça o algoritmo e o fluxograma que dado o preço de um produto em reais,
converter e imprimir este valor para o equivalente em dólares. O programa deverá ler o preço do produto
em reais e o preço do dólar.
6) Defina as regras, faça o algoritmo e o fluxograma para calcular e imprimir o salário bruto a ser
recebido por um funcionário em um mês. O programa deverá ler os seguintes dados: número de horas que
o funcionário trabalhou no mês, valor recebido por hora de trabalho.
7) O custo ao consumidor, de um carro novo, é a soma do custo de fábrica com a percentagem do
distribuidor e dos impostos (aplicados ao custo de fábrica). Supondo que a percentagem do distribuidor
seja de 28% e os impostos de 45%, definir as regras, escrever o algoritmo e o fluxograma para ler o custo
de fábrica de um carro, calcular e escrever o custo ao consumidor.
8) Definir as regras, escrever o algoritmo e o fluxograma que calcule o tempo que um objeto
arremessado verticalmente para cima levará para atingir uma determinada altura. Considerar que a altura
a ser atingida, bem como a velocidade inicial do objeto, serão lidos pelo programa.


9) Defina as regras, faça o algoritmo e o fluxograma que dado um número inteiro, obter seu último
algarismo.
10) Defina as regras, faça o algoritmo e o fluxograma que dado um número inteiro de 3 algarismos,
inverter a ordem de seus algarismos. Os 3 algarismos do número dado são diferentes de zero.
) ( ) (
1 2 1 2
2 2
y y x x ÷ ÷
+
0
2
2
= + ÷ h vt
gt
Linguagem de Programação C#

13

1.9 Comandos para controle de Fluxo
Para representar a solução de um problema devemos escrever o conjunto de passos a serem
seguidos, sendo que, a maioria dos problemas exigem uma dinâmica na sua solução, impondo assim que
os algoritmos executem conjunto de instruções de acordo com as possíveis situações encontradas no
problema original. E de acordo com a Programação Estruturada os mecanismos utilizados para esse
controle são : Sequência, Seleção e Repetição.

1.9.1 Estrutura de Sequência
Usada para executar comandos passo a passo, sabendo que todos eles serão executados na
ordem de escrita, sem nenhum desvio. Uma sequência pode possuir um ou vários comandos, os quais
devem ser delimitados pelos identificadores Início e Fim.
Inicio
Comando_1
Comando_2
Comando_3
...
Comando_n
Fim

1.9.2 Estrutura de Seleção
Em “Operações Lógicas”, verificamos que na maioria das vezes necessitamos tomar decisões no
andamento do algoritmo. Essas decisões interferem diretamente no andamento do programa.
Trabalharemos com dois tipos de estrutura. A estrutura de decisão SE e a estrutura de decisão múltipla
(CASO).

A) Comando SE
Os comandos de decisão ou desvio fazem parte das técnicas de programação que conduzem a
estruturas de programas que não são totalmente sequenciais. Com as instruções de SALTO ou DESVIO
pode-se fazer com que o programa proceda de uma ou outra maneira, de acordo com as decisões lógicas
tomadas em função dos dados ou resultados anteriores. As principais estruturas de decisão são: “Se
Então”, “Se então Senão” e “Caso Selecione”.

SE ENTÃO / IF ... THEN
A estrutura de decisão “SE/IF” normalmente vem acompanhada de um comando, ou seja, se
determinada condição for satisfeita pelo comando SE/IF então execute determinado comando. Imagine um
algoritmo que determinado aluno somente estará aprovado se sua média for maior ou igual a 5.0, veja no
exemplo de algoritmo como ficaria.
SE MEDIA >= 5.0
ENTÃO
ALUNO APROVADO

Linguagem de Programação C#

14

SE ENTÃO SENÃO / IF ... THEN ... ELSE
A estrutura de decisão “SE/ENTÃO/SENÃO”, funciona exatamente como a estrutura “SE”, com
apenas uma diferença, em “SE” somente podemos executar comandos caso a condição seja verdadeira,
diferente de “SE/SENÃO” pois sempre um comando será executado independente da condição, ou seja,
caso a condição seja “verdadeira” o comando da condição será executado, caso contrário o comando da
condição “falsa” será executado.
Em algoritmo ficaria assim:
SE MÉDIA >= 5.0
ENTÃO
ALUNO APROVADO
SENÃO
ALUNO REPROVADO
Em fluxogramas as estruturas de decisão do tipo Se são representadas assim:

Os símbolos que estiverem na direção de “True” serão executados caso o teste seja verdadeiro. Já
os símbolos que estiverem na direção de “false” serão executados caso o teste tenha um resultado falso.
Imagine a seguinte situação: em uma empresa, será solicitado o salário de um determinado
funcionário, para se calcular seu novo salário, sendo que, se este tiver um salário superior a R$ 300.00, o
reajuste será de 5%, caso contrário o reajuste será de 8%.
Observe que teremos que testar o valor do salário, para saber o índice a ser aplicado. Vamos criar
então um pseudocódigo com este objetivo:
Algoritmo testa_salario
Variáveis
Real Salario
Real Salario_final
Inicio
Escreva('Informe o seu salario: ')
Leia (Salario)
Se (Salario <= 300) ENTÂO
Salario_final = (Salario * 1,08)
SENÃO
Salario_final = (Salario * 1,05)
Fim_se
Escreva ('Salario_final')
Fim.

Linguagem de Programação C#

15

Observe o trecho do pseudocódigo acima, representado no fluxograma:

B) CASO SELECIONE / SELECT ... CASE
A estrutura de decisão CASO/SELECIONE é utilizada para testar, na condição, uma única
expressão, que produz um resultado, ou, então, o valor de uma variável, em que está armazenado um
determinado conteúdo. Compara-se, então, o resultado obtido no teste com os valores fornecidos em cada
cláusula “Caso”.
No exemplo do diagrama de blocos abaixo, é recebido uma variável “Op” e testado seu conteúdo,
caso uma das condições seja satisfeita, é atribuído para a variável Titulo a String “Opção X”, caso contrário
é atribuído a string “Opção Errada”.
Em fluxogramas são representadas assim:

Vamos imaginar um exemplo parecido, de reajuste de salário, porém teremos as seguintes
situações para reajuste:
Linguagem de Programação C#

16

- Salários inferiores a R$ 400,00 = reajuste de 9%
- Salários iguais a R$ 400,00 e inferiores a R$ 800,00 = reajuste de 7%
- Salários iguais a R$ 800,00 e inferiores a R$ 1000,00 = reajuste de 5%
- Fora das faixas supra citadas = reajuste de 3%
Veja o pseudocódigo do exemplo citado:
Algoritmo testa_salario2
Variaveis
Real Salario , Salario_final
Inicio
Leia (Salario)
Faca caso
Caso salario < 400
Salario_final = (salario * 1.09)
Caso salario >= 400 .e. salario < 800
Salario_final = (salario * 1.07)
Caso salario>=800 .e. salario < 1000
Salario_final = (salario * 1.05)
Outro caso
Salario_final = (salario * 1.03)
Escreva (Salario_final)
Fim.

Observe que, temos aqui uma novidade, ou seja, em uma única condição, estamos na verdade
realizando dois testes, isto porque usamos o operador lógico “AND” “.e.”, ou seja, se salário menor ou igual
a 400 e salário menor que 800 faça isso... assim sucessivamente.
Quando usamos o operador lógico “.e.”, os testes, neste caso dois, que formam o caso, devem ser
verdadeiros. O outro operador lógico “.ou.”, retorna verdadeiro caso um dos testes que formam o conjunto
satisfaça a uma determinada condição.

EXERCÍCIOS
1) Faça um algoritmo e o fluxograma que leia um número e imprima caso seja maior do que 20.

2) João Papo-de-Pescador, homem de bem, comprou um microcomputador para controlar o
rendimento diário de seu trabalho. Toda vez que ele traz um peso de peixes maior que o
estabelecido pelo regulamento de pesca do estado de São Paulo (50 quilos) deve pagar um multa
de R$ 4,00 por quilo excedente. João precisa que você faça um diagrama de blocos que leia a
variável P (peso de peixes) e verifique se há excesso. Se houver, gravar na variável E (Excesso) e
na variável M o valor da multa que João deverá pagar. Caso contrário mostrar tais variáveis com o
conteúdo ZERO.

3) Elabore um algoritmo e o fluxograma que leia as variáveis C e N, respectivamente código e número
de horas trabalhadas de um operário. E calcule o salário sabendo-se que ele ganha R$ 10,00 por
hora. Quando o número de horas exceder a 50 calcule o excesso de pagamento armazenando-o na
variável E, caso contrário zerar tal variável. A hora excedente de trabalho vale R$ 20,00. No final do
processamento imprimir o salário total e o salário excedente.

4) Desenvolva um algoritmo e o fluxograma que:
- Leia 4 (quatro) números;
- Calcule o quadrado de cada um;
- Se o valor resultante do quadrado do terceiro for >= 1000, imprima-o e finalize;
- Caso contrário, imprima os valores lidos e seus respectivos quadrados.
Linguagem de Programação C#

17

5) Faça um algoritmo e o fluxograma que leia um número inteiro e mostre uma mensagem indicando
se este número é par ou ímpar, e se é positivo ou negativo.

6) A Secretaria de Meio Ambiente que controla o índice de poluição mantém 3 grupos de indústrias
que são altamente poluentes do meio ambiente. O índice de poluição aceitável varia de 0,05 até
0,25. Se o índice sobe para 0,3 as indústrias do 1º grupo são intimadas a suspenderem suas
atividades, se o índice crescer para 0,4 as indústrias do 1º e 2º grupo são intimadas a suspenderem
suas atividades, se o índice atingir 0,5 todos os grupos devem ser notificados a paralisarem suas
atividades. Faça um algoritmo e o fluxograma que leia o índice de poluição medido e emita a
notificação adequada aos diferentes grupos de empresas.

7) Elabore um algoritmo e o fluxograma que dada a idade de um nadador classifique-o em uma das
seguintes categorias:
- Infantil A = 5 a 7 anos
- Infantil B = 8 a 11 anos
- Juvenil A = 12 a 13 anos
- Juvenil B = 14 a 17 anos
- Adultos = Maiores de 18 anos

8) Faça um algoritmo e o fluxograma que leia dois valores numéricos e efetue a adição, caso o
resultado seja maior que 10 apresentá-lo.
9) Faça um algoritmo e o fluxograma que leia um número e informe se ele é ou não divisível por 5.
10) Faça um algoritmo e o fluxograma que leia um número e informe se ele é divisível por 3 e por 5.
11) Faça um algoritmo e o fluxograma que leia um número e informar se ele é divisível por 10, ou é
divisível por 5, ou é divisível por 2 ou se não é divisível por nenhum destes.
12) Faça um algoritmo e o fluxograma que leia um número e indique se o número digitado está
compreendido entre 20 e 90 ou não.
13) Faça um algoritmo e o fluxograma que leia um número e imprimir uma das mensagens: maior do
que 20, é igual a 20 ou é menor do que 20.
14) Faça um algoritmo e o fluxograma que leia um número e informe se sua raiz quadrada é inteira.
15) Faça um algoritmo e o fluxograma que leia o nome, a nota da PR1 e a nota da PR2 de 1 aluno.
Imprimir: nome, nota da PR1, nota da PR2, média aritmética e uma das mensagens: AP, RP ou PF
(a média é 7 para aprovação (AP), menor que 3 para reprovação (RP) e as demais em prova final
(PF)).
16) Faça um algoritmo e o fluxograma que leia o nome da capital do Brasil. Se a resposta estiver
correta, imprimir PARABÉNS, caso contrário, ERROU. (Considerar: BRASÍLIA ou Brasília).
17) Faça um algoritmo e o fluxograma que leia dois números e exiba se o primeiro é divisível pelo
segundo.
18) Faça um algoritmo e o fluxograma que leia dois números sendo o 1º o divisor e o 2º o dividendo e
informe se o quociente é inteiro.
19) Faça um algoritmo e o fluxograma que leia dois números e imprima uma mensagem dizendo se
são iguais ou diferentes.
20) Faça um algoritmo e o fluxograma que leia dois números e imprima o maior número (suponha
números diferentes).
21) Faça um algoritmo e o fluxograma que leia dois números e imprima o menor número (suponha
números diferentes).
22) Faça um algoritmo e o fluxograma que leia dois números e imprima-os em ordem crescente
(suponha números diferentes).
Linguagem de Programação C#

18

23) Faça um algoritmo e o fluxograma que leia dois números e imprima-os em ordem decrescente
(suponha números diferentes).
24) Faça um algoritmo e o fluxograma que leia três números e imprima o maior número(suponha
números diferentes).
25) Faça um algoritmo e o fluxograma que leia três números e armazene o maior número na variável
de nome maior (suponha números diferentes).
26) Faça um algoritmo e o fluxograma que leia três números e imprima-os em ordem crescente
(suponha números diferentes).
27) Faça um algoritmo e o fluxograma que leia três números e imprima-os em ordem decrescente
(suponha números diferentes).
28) Faça um algoritmo e o fluxograma que leia três números e armazene-os em três variáveis com os
seguintes nomes: maior, intermediário e menor (suponha números diferentes).
29) Faça um algoritmo e o fluxograma que leia cinco números inteiros e identificar o maior e o menor
valor.
30) Faça um algoritmo e o fluxograma que leia o salário de uma pessoa e imprima o desconto do INSS
segundo a tabela abaixo:
Faixa Desconto
Menor ou igual a R$ 600,00 isento
Maior que R$ 600,00 e menor ou igual a R$ 1200,00 20%
Maior que R$ 1200,00 e menor ou igual a R$ 2000,00 25%
Maior que R$ 2000,00 30%

31) Um comerciante comprou um produto e quer vendê-lo com um lucro de 45% se o valor da compra
for menor que R$ 20,00 caso contrário, o lucro será de 30%. Faça um algoritmo e o fluxograma que
leia o valor do produto e imprima o valor da venda.
32) Faça um algoritmo e o fluxograma que leia o ano de nascimento de uma pessoa e o ano atual.
Imprima a idade da pessoa. Não se esqueça de verificar se o ano de nascimento é um ano válido,
isto é, é menor que o ano atual.
33) Faça um algoritmo e o fluxograma que leia o nome, sexo e idade de uma pessoa. Se a pessoa for
do sexo feminino e tiver menos que 25 anos então imprimir nome e a mensagem: ACEITA, caso
contrário, imprimir nome e a mensagem: NÃO ACEITA.(considerar f e F)
34) Faça um algoritmo e o fluxograma que leia a idade de uma pessoa e informe a sua classe eleitoral:
- não eleitor (abaixo de 16 anos)
- eleitor obrigatório ( entre 18 e 65 anos)
- eleitor facultativo ( entre 16 e 18 anos e maior de 65 anos)

1.9.3 Estruturas de Repetição
Em linguagem de programação, as estruturas de repetição são conhecidas como laços (loops).
Trabalhamos basicamente com dois tipos de estruturas de repetição:
- Loops contados: quando se tem, de forma prévia, o número de vezes que uma determinada
sequência de comandos será executada.
- Loops condicionais: aqueles que não possuem um número pré-determinado de vezes que a
estrutura de comandos será executada, porém este número estará vinculado a uma
determinada condição.
Os laços de repetição são muito úteis e muito utilizados, pois possibilitam a facilidade de repetir um
certo trecho de programa por um determinado número de vezes. O número de vezes que um laço pode
repetir um trecho de programa pode ser previamente conhecido ou não, vai depender da característica de
execução do laço.
Linguagem de Programação C#

19

Um laço de repetição em que se conhece o número de vezes que ele será executado é
predeterminado, pois sabe-se quando começa e quando termina. Porém, há ainda a possibilidade de
desenvolver um laço de repetição indeterminado, ou seja, sabe-se quando ele começa, mas não se sabe
quando ele termina, pois apenas o usuário do programa é que determina o final.
Para os laços predeterminados, de forma geral podem ser usados os tipos de laços de repetição:
ENQUANTO, REPITA e PARA. Para os laços indeterminados, podem ser usados apenas os laços de
repetição dos tipos ENQUANTO e REPITA.
Os laços de repetição dos tipos ENQUANTO e REPITA são controlados pelo uso de condição, logo
são laços de repetição condicionais. Já o laço de repetição do tipo PARA é incondicional, pois não faz uso
do conceito de condições.
De forma geral, quando há necessidade de trabalhar com um laço de repetição predeterminado,
utiliza-se o conceito PARA, deixando os conceitos de laços de repetição ENQUANTO e REPITA para
situações de laços indeterminados. Apesar desta característica operacional, nesta obra serão utilizados
todos os tipos de laço para demonstrar suas aplicações nas mais variadas situações.

A) LAÇO ENQUANTO
O laço de repetição do tipo enquanto caracteriza-se por efetuar um teste condicional no início do
laço. Desta forma, é possível verificar se é permitido executar o trecho de instruções subordinado à
condição. Para este tipo de estrutura será utilizado o código em português estruturado enquanto...faça e
fim_enquanto.
Português estruturado
Enquanto (<condição>) faça
Instruções executadas enquanto condição for verdadeira
Fim_enquanto
Em fluxogramas são representadas assim:

B) LAÇO REPITA
O laço de repetição do tipo repita caracteriza-se por efetuar um teste condicional no final do laço.
Desta forma, as instruções subordinadas ao laço serão executadas no mínimo uma vez. Para este tipo de
estrutura será utilizado o código em português estruturado repita e até_que.

Português Estruturado
Repita
Instruções executadas até que condição torne-se verdadeira
Até_que (<condição>)

Linguagem de Programação C#

20

Em fluxogramas são representadas assim:

C) LAÇO PARA
O laço de repetição do tipo para caracteriza-se por efetuar um laço por um determinado número de
vezes previamente definido. Para este tipo de estrutura será utilizado o código em português estruturado
para...de...até...passo...faça e fim_para.
Português Estruturado
Para variável de início até final passo incremento faça
Instruções executadas até contador atingir seu final
Fim_para
Em fluxogramas são representadas assim:

EXERCÍCIOS

1. Construa um algoritmo e o fluxograma que exiba em um monitor uma contagem decrescente do
valor 30 até o valor 1.

2. Elabore um programa em fluxograma e pseudocódigo que apresente os números pares de 1 a 100.

3. Faça um algoritmo e o fluxograma que leia 50 números inteiros, conte quantos são divisíveis por 3
e exiba o resultado.

4. Faça um algoritmo e o fluxograma que leia 40 números reais, somar e calcular a média dos
números positivos e contar os números negativos e exiba os resultados.

Linguagem de Programação C#

21

5. Faça um algoritmo e o fluxograma que leia o nome e a idade de 20 pessoas, calcule e exiba a
média das idades.
6. Faça um algoritmo e o fluxograma que leia o sexo (Masculino / Feminino) e o salário de 15
pessoas, calcule e exiba a média dos salários dos homens e das mulheres.
7. Uma fábrica tem 10 representantes. Cada um recebe uma comissão calculada a partir do número
de itens de um pedido, segundo os seguintes critérios:
- para menos de 20 itens vendidos, a comissão é de 10% do valor total do pedido;
- para pedidos de 20 e 49 itens, a comissão é de 15% do valor total do pedido;
- para pedidos de 50 a 74 itens, a comissão é de 20% do valor total do pedido; e
- para pedidos iguais ou superiores, a 75 itens a comissão é de 25%.

8. Faça um programa que processe 10 pedidos. Para cada pedido o programa deve ler o código do
representante (1 a 10), o total de itens e o valor total do pedido. O programa deve informar:
- o valor da comissão de cada pedido;
- o total de vendas dos pedidos processados;
- o total de comissões para cada representante; e
- o total de comissões que a companhia pagou aos seus representantes.

9. Em uma pesquisa perguntou-se a cada aluno quantas refeições fez no mês anterior. Faça um
algoritmo e o fluxograma que leia o número de refeições diárias de 350 alunos e calcule e exiba:
- o número de alunos que fez menos de 10 refeições no mês;
- o número de alunos que fez entre 10 e 20 refeições; e
- o número de alunos que fez mais de 20 refeições.

10. Um total de 500 alunos de uma universidade foram entrevistados. De cada um deles foram
colhidas as seguintes informações: o código do curso que frequenta (1-engenharia; 2-computação;
3-administração) e a idade. Faça um algoritmo e o fluxograma que processe estes dados e que
forneça as seguintes informações:
- número de alunos por curso;
- número de alunos com idade entre 20 e 25 anos, por curso; e
- qual o curso com menor média de idade.

11. Uma confecção fabrica os produtos da tabela abaixo, identificados pelo seu código e com o preço
correspondente:

Faça um algoritmo e o fluxograma que processe diversos pedidos feitos a esta confecção. Em cada
pedido serão especificados os produtos pedidos, identificados através de seu código, e a quantidade
pedida de cada produto. O programa deverá calcular o total a pagar de cada pedido. No final dos 100
pedidos, o programa deverá fornecer um relatório de vendas, com as seguintes informações:
- total vendido de cada produto;
- total vendido de todos os produtos;
- total vendido em reais;
- valor médio de pedido (em reais).
Linguagem de Programação C#

22

12. Uma pesquisa sobre algumas características físicas da população de uma determinada região
coletou os seguintes dados, referentes a cada habitante, para análise:
- sexo ( M - masculino, F - feminino);
- cor dos olhos (A - azuis, V - verdes, C - castanhos);
- cor dos cabelos (L - loiros, C - castanhos, P - pretos);
- idade em anos.
Para cada um dos 2000 habitantes foi preenchido um cartão com estes dados. Fazer um programa
que calcule e exiba:
- a maior idade dos habitantes;
- a média da idade dos habitantes;
- a quantidade de habitantes do sexo feminino cuja idade está entre 18 e 35 anos, inclusive, e
que tenham olhos verdes e cabelos loiros;
- a quantidade de habitantes do sexo masculino cuja idade está entre 20 e 25 anos, inclusive,
e que tenham olhos pretos e cabelos castanhos.

13. Faça um algoritmo e o fluxograma em Pascal que leia um numero N, some todos os números
inteiros entre 1 e N, e mostre o resultado obtido.

14. Faça um algoritmo e o fluxograma em Pascal que leia um número e divida-o por dois
(sucessivamente) até que o resultado seja menor que 1. Mostre o resultado da última divisão
efetuada.

15. Escreva um algoritmo e o fluxograma em Pascal que leia 50 valores e encontre o maior e o menor
deles. Mostre o
resultado.

16. Escrever um algoritmo e o fluxograma em Pascal que leia um número n que indica quantos valores
devem ser lidos a seguir. Para cada número lido, mostre uma tabela contendo o valor lido e o
fatorial deste valor.

17. Escrever um algoritmo e o fluxograma em Pascal que lê um conjunto não determinado de valores,
um de cada vez, e escreve uma tabela com cabeçalho, que deve ser repetido a cada 20 linhas. A
tabela conterá o valor lido, seu quadrado, seu cubo e sua raiz quadrada.

18. Escrever um algoritmo e o fluxograma em Pascal que lê um número não determinado de valores
para m, todos inteiros e positivos, um de cada vez. Se m for par, verificar quantos divisores possui
e escrever esta informação. Se m for impar e menor do que 10 calcular e escrever o fatorial de m.
Se m for impar e maior ou igual a 10 calcular e escrever a soma dos inteiros de 1 até m.

19. Foi feita uma pesquisa entre os habitantes de uma região. Foram coletados os dados de idade,
sexo (M/F) e salário. Faça um algoritmo e o fluxograma que informe:
a) a média de salário do grupo;
b) maior e menor idade do grupo;
c) quantidade de mulheres com salário até R$100,00.
Encerre a entrada de dados quando for digitada uma idade negativa.

20. Escreva um algoritmo e o fluxograma em Pascal que gere os números de 1000 a 1999 e escreva
aqueles que dividido por 11 dão resto igual a 5.

21. Escreva um programa em Pascal que leia 500 valores inteiros e positivos e:
a) encontre o maior valor;
b) encontre o menor valor;
c) calcule a média dos números lidos.


Linguagem de Programação C#

23

22. Faça um algoritmo e o fluxograma em Pascal que leia dois números X e N. A seguir , mostre o
resultado das divisões de X onde , após cada divisão por N , X passa a ter como conteúdo o
resultado da divisão anterior e N é decrementado de 1 , em 1 , ate chegar a 2.

23. Faça um algoritmo e o fluxograma em Pascal que leia um número e, a seguir, leia uma lista de
números até achar um número igual ao primeiro lido . Mostre todos os números lidos.
24. Faça um algoritmo e o fluxograma em Pascal que leia e mostre um texto, caracter a caracter, até
encontrar a sequencia de caracteres "/*". A sequencia de caracteres que determina o final do texto
também deve ser mostrada.

25. Faça um algoritmo e o fluxograma em Pascal que leia um número X e , a seguir, leia e mostre uma
lista de números com o término da lista ocorrendo quando a soma de dois números consecutivos
da lista for igual a X.

26. Faça um algoritmo e o fluxograma em Pascal que leia um número inteiro N , calcule e mostre o
maior quadrado menor ou igual a N.
Por exemplo, se N for igual a 38, o Menor quadrado é 36 (quadrado de 6).

27. Faça um algoritmo e o fluxograma em Pascal que leia uma lista de letras terminada pela letra "Z" .
Ao final o algoritmo deve mostrar a quantidade lida de cada vogal.

28. Faça um algoritmo e o fluxograma em Pascal que leia o número de andares de um prédio e, a
seguir, para cada andar do prédio, leia o número de pessoas que entraram e saíram do elevador.
Considere que o elevador está vazio e está subindo , os dados se referem a apenas uma “subida”
do elevador e que o número de pessoas dentro do elevador sempre será maiores ou iguais a 0.
Se o número de pessoas , após a entrada e saída for maior que 15, deve ser mostrada a
mensagem “EXCESSO DE PASSAGEIROS . DEVEM SAIR" em seguida, o número de pessoas
que devem sair do elevador, de modo que seja obedecido o limite de 15 passageiros.
Após a entrada de pessoas no último andar o algoritmo deve mostrar quantas pessoas irão descer.

29. Num frigorífico existem 90 bois. Cada boi traz em seu pescoço um cartão contendo um número
de identificação e seu peso. Escrever um algoritmo e o fluxograma em Pascal que leia o cartão e o
peso dos 90 bois e ao final imprima o número e o peso do boi mais gordo e dos bois mais magro.

30. Escreva um algoritmo e o fluxograma em Pascal que.
a) leia uma letra do alfabeto;
b) a seguir leia outra letra que suceda a primeira, mas não necessariamente vizinha da mesma;
c) imprima todas as letras do alfabeto situadas entre as duas primeiras, incluindo-as.

31. Escreva um algoritmo e o fluxograma em Pascal que leia um caracter, mas só aceite se o mesmo
for alfabético maiúsculo. O programa em Pascal deve ficar em loop até que a condição imposta
seja atingida.

32. Uma determinada companhia deseja obter o resultado de uma pesquisa, relacionada com um novo
tipo de produto lançado. As respostas dos entrevistados devem entrar pelo teclado da seguinte
maneira:
- se o cliente gostou será digitada a letra S, maiúscula;
- se o cliente não gostou será digitada a letra N, maiúscula;
- se não for digitada S ou N, o algoritmo deve emitir uma mensagem de erro;

Quando o usuário quiser ver o resultado da pesquisa deve apertar a tecla ESC e o algoritmo deve
apresentar No vídeo o resultado da pesquisa, obedecendo ao seguinte critério:

BOM : se a maioria responder S.
RUIM : se a maioria responder N.
EMPATE : caso ocorra empate.
Linguagem de Programação C#

24

CAPÍTULO 2 – Visual C# 2008 Express
2.1 Instalando o Visual C# 2008 Express
Primeiro você deverá efetuar o download do produto, que pode ser encontrado no seguinte link:
http://www.microsoft.com/visualstudio/en-us/products/2008-editions/express
Após abrir a página, algumas opções estarão disponíveis. Vamos baixar o Visual Studio Express
2008, que é a versão gratuita do Visual Studio. Lembrando que nada impede que você baixe e instale
outra que não seja a versão Express.
Na tela que será exibida, escolha a opção desejada. Neste exemplo, escolhi a opção completa, e
foi apresentado um link para baixar a imagem do CD de instalação(.ISO).

Clicando no botão FREE DOWNLOAD, o download será iniciado.
Agora temos duas opções, ou gravamos o arquivo em um dvd, utilizando por exemplo o Nero
através da funcionalidade de gravação de dvd a partir de um arquivo de imagem, ou emulamos o DVD
através do Alcohol ou do Daemon Tools (Freeware).
Assim que o DVD tenha sido introduzido, o instalador será carregado automaticamente. Na tela
inicial basta clicar no link "Install Visual Studio 2008" para começar instalação.
Clique no Visual C # 2008 Express Edition link.
Linguagem de Programação C#

25


Em seguida, a instalação irá copiar os recursos necessários para a pasta temporária.

Em seguida, a instalação irá carregar os componentes de instalação.

Se não houver o Visual Studio 2008 SP1 instalado (no caso da máquina já tenha instalado o Visual
Studio 2008), a seguinte mensagem de erro será exibida.

Clique em avançar para a página de boas vindas.
Linguagem de Programação C#

26


Aceite os termos do contrato de licença e clique em Avançar

Nesta instalação que incluem a instalação da versão MS SQL Express. Em seguida, selecione a
caixa de seleção e clique em Avançar

Linguagem de Programação C#

27

Neste caso, não podemos alterar o caminho de instalação, pois a versão completa do Visual Studio
2008 já está instalado nesta máquina. Esta página também apresenta um resumo dos produtos e
componentes a serem instalados. Clique em Instalar.

A instalação deve começar imediatamente.

Linguagem de Programação C#

28


Se não ocorrer nenhum erro, será apresentada ao final a mensagem para reiniciar o computador
para finalizar a instalação.


2.2 Introdução ao Visual C# Express
Este material inicia o aprendizado na linguagem C# desenvolvida especialmente para a plataforma
.NET. Ao acompanhar esta apostila você aprenderá a criar pequenos aplicativos para desktop. Veremos
aqui os conceitos básicos da linguagem C# e a IDE Visual Studio, para um melhor aproveitamento do .NET
Framework. Para um melhor entendimento dos capítulos seguintes, é importante ter conhecimento em
lógica de programação. Qualquer dúvida em relação a lógica de programação pode ser encontrada no
capítulo 1.
Então você instalou o Visual C# Express Edition no seu computador e agora quer saber o que fazer
com ele. Visual C# é uma linguagem de programação eficiente projetada para criar uma ampla gama de
aplicativos que vão desde utilitários até aplicativos corporativos completos. O Visual C# Express Edition
fornece um ambiente sofisticado para criar e testar aplicativos baseados no Windows.
Você já usou aplicativos do Windows Forms. Programas da Microsoft como o Word, o Excel, o
PowerPoint, o Internet Explorer e as janelas exibidas dentro desses aplicativos (para abrir, salvar e
imprimir arquivos) são todos aplicativos do Windows Forms. Esses aplicativos não podem ser escritos no
Visual C#, embora demonstrem a funcionalidade que é possível colocar nos aplicativos do Visual C#
Express. É possível fazer praticamente tudo usando a linguagem de programação C# – escrever jogos de
computador, gerenciar sistemas corporativos e bancos de dados, desenvolver aplicativos Web e criar
aplicativos do Windows Forms para ajudar nas tarefas pessoais e profissionais do dia-a-dia.
Linguagem de Programação C#

29

A parte realmente importante
Em programação, como em todas as outras profissões, as pessoas que têm mais sucesso são
aquelas que amam o que fazem. Se você gosta de programação, achará difícil se privar de aprender
coisas novas. Sua necessidade de conhecimento o levará adiante e estudar mais será apenas algo que
acontecerá ao longo do caminho.

A linguagem
A linguagem de programação C# (lê-se C Sharp) surge como uma evolução da linguagem "C" e
destina-se a aplicações utilizando o .NET Framework, utilizando os novos conceitos de Orientação a
Objetos (OO).
O C# é uma solução poderosa, produtiva e fácil de usar. Veja o porquê de escolher esta linguagem
- C# oferece o mesmo poder que o C++
- Facilidade de programação assim como no Visual Basic
- Linguagem nativa da Plataforma .NET
- C# oferece poder , facilidade e flexibilidade
- Resolve o abismo entre as linguagens de “baixo nível” e “alto nível”
- Uma mesma aplicação possa ser executada em diversos dispositivos de hardware(PCs,
Handhelds e qualquer outro dispositivo móvel.
Além dessas características, o C# por ser uma linguagem da Microsoft e a mesma possuir
“parcerias” com muitas empresas, faz com que a empresa sinta-se mais segura em trabalhar com a
linguagem. Sendo assim, com toda a certeza você pode investir no aprendizado da linguagem, pois, não
faltará oportunidades no mercado de trabalho.

O .NET Framework
O Framework é essencial para rodar vários programas que foram desenvolvidos com o uso dessa
tecnologia da Microsoft. Ou seja, é o modelo da plataforma .NET para construir, instalar e rodar qualquer
aplicação, no desktop ou na Internet. Para executar um programa .NET, é preciso ter o Framework
instalado.
Versões do FRAMEWORK: 1.0, 1.1, 2.0, 3.0, 3.5
Como saber qual versão do Framework está instalada no seu PC?
A forma manual de verificar qual versão do Microsoft .NET Framework está instalada no seu
computador é através do Adicionar ou Remover Programas do Painel de Controle. Porém, você pode
utilizar o ASoft .NET Version Detector, uma ferramenta gratuita e portátil. Ela dá informações sobre as
diferentes versões do Microsoft .NET que estão instalados no seu computador.
Basicamente definido como um componente integral do Windows responsável por fornecer os
serviços necessários, para construção e carregamento de aplicações para Windows e Web.
O . NET Framework utiliza o CLR (Common Language Run Time) sendo uma base para o .NET
Framework, disponibilizando:
- Interoperabilidade de linguagem;
- Suporte de versões aprimorado;
- Segurança aprimorada;
- Garbage Colection.
Também utiliza o Framework Class Library (Biblioteca de Classes) e tem como agente um serviço
de Run Time que gerencia o código durante a execução do aplicativo.
Linguagem de Programação C#

30

CAPÍTULO 3 – Introdução ao IDE do Visual C# 2008 Express
A melhor maneira se aprender é rodando o Visual C#. Você poderá rodar o C# da mesma maneira
que roda qualquer aplicação Windows, como segue abaixo:
- Dando um duplo-clique no ícone do Visual C#, na área de trabalho (desktop) ou no menu INICIAR
>> Todos os Programas >> Visual C# 2008 Express.

A figura abaixo mostra como o Visual Studio 2008 irá aparecer quando for rodado pela primeira vez:


Linguagem de Programação C#

31

Para criarmos uma aplicação no Visual C# podemos clicar na opção File >> New Project contida na
Tela Inicial. A seguir deveremos escolher o programa C#, o Windows Forms Application, o nome e o local
do projeto a ser criado, conforme é apresentado na figura abaixo:


Ao clicar no botão OK, o C# criará um diretório com o nome do seu projeto, contendo toda a
estrutura de diretórios e arquivos deste projeto.
Linguagem de Programação C#

32

DICA: O local padrão para criação deste diretório é em MEUS DOCUMENTOS / Visual Studio 2008 /
Projects. Se você quiser copiar um projeto de um computador para o outro, copie todo o diretório para um
pendrive ou compacte o diretório do seu projeto para enviá-lo por email, por exemplo.

3.1 IDE - Ambiente de Desenvolvimento Integrado

O ambiente do Visual C# é repleto de detalhes. O primeiro passo PE criar um projeto, o qual pode
conter várias classes, códigos que podem ser executados separadamente ou juntos, dependendo da
aplicação que construiu.

Linguagem de Programação C#

33

1 – Menu de opções: muitas funções podem ser acessadas por ele, tais como salvar o
projeto, adicionar classe, formulários, compilar o projeto, configurar o ambiente de acordo
com suas necessidades, como por exemplo, ajustar a fonte e seu tamanho, cor de letra e
cor de fundos, entre outros.

2 – Barra de Ferramentas: atalho para acesso a determinadas funções do menu, como
salvar e criar projeto e fechar o atual.

3 – Janela de código/Formulário: Onde serão adicionados códigos para que a aplicação
possa funcionar corretamente.



Linguagem de Programação C#

34

4 – Solution Explorer ou Explorando a Solução: possibilita todo o controle necessário da
aplicação, permitindo criar pastas e adicionar referências de outras aplicações prontas à
atual.

5 – Janela de propriedades: é possível configurar algumas propriedades em tempo de construção de
projeto. Ela será bastante utilizada quando criarmos aplicações visuais.


Linguagem de Programação C#

35

6 – Toolbox: dá acesso aos componentes que podem ser adicionados ao objeto principal (formulário),
sejam eles label, textbox, combobox, Button, entre outros.

3.2 Atalhos de teclado
Nome Teclas de Atalho Descrição
Ativar menu de
aplicativo
ALT + a BARRA DE
ESPAÇOS
Abre o menu programa, permitindo que o usuário para Gerenciar o
estado do janela do aplicativo, por exemplo, mover ou
redimensionar.
Ativar menu janela
do documento
ALT + HÍFEN Abre o menu documento, permitindo que o usuário para Gerenciar
o estado da janela de documento ativo, por exemplo, mover ou
redimensionar.Disponível somente enquanto no modo MDI de
dentro de uma janela de documentos.
Ativar menu janela
Ferramenta
ALT + HÍFEN Abre o menu Janela ferramenta, permitindo que o usuário mover a
janela Ferramenta dentro de IDE.Disponível somente enquanto
dentro de uma janela Ferramenta.
Fechar aplicativo ALT + F4 Fecha o IDE.
Fechar documento CTRL+F6 Fecha o documento como aplicativo ativo.
Recolher Tudo nós
de árvore
Num + - Recolhe Tudo nós no modo de Exibir de árvore atual.
Linguagem de Programação C#

36

Expandir Tudo nós
de árvore
Num + * Expande Tudo nós no modo de Exibir de árvore atual.
Mover para barra de
menus
ALT Ativa a barra de menus principal IDE.
Mover para Avançar
barra de ferramentas
CTRL + TAB Move para o Avançar barra de ferramentas visível.Disponível
somente enquanto o barra de menus principal Está Ativo.
Mover para barra de
ferramentas anterior
CTRL + SHIFT + TAB Move para a barra de ferramentas visível anterior.Disponível
somente enquanto o barra de menus principal Está Ativo.
Mover para barra de
ferramentas da
janela Ferramenta
SHIFT + ALT Ativa a barra de ferramentas Janela ferramenta.Disponível
somente enquanto em uma janela Ferramenta contendo uma barra
de ferramentas.
Mover o foco de
árvore para baixo
CTRL + DOWN. Move o foco em modo de Exibir de árvore para baixo sem alterar a
seleção.Esse atalho pode ser usado para selecionar Múltiplo itens
de árvore.
Mover o foco de
árvore para cima
CTRL + UP Move o foco em modo de Exibir de árvore backup sem alterar a
seleção.Esse atalho pode ser usado para selecionar Múltiplo itens
de árvore.
Menu de atalho SHIFT + F10 Exibe o menu de atalho.
Alternar drop-Para
Baixo Lista
visibilidade
F4 Oculta e mostra uma lista Soltar-Para Baixo.Disponível somente
enquanto dentro de uma lista Soltar-Para Baixo.
Alternar Árvore foco
seleção
CTRL + SPACEBAR Alterna uma seleção para o foco atual em modo de Exibir de
árvore.
3.3 Criando a primeira aplicação Windows e como criar corretamente uma
interface de usuário (formulário)
1 - Entre no visual Studio .NET.
2 – Crie um novo projeto, do tipo Windows Application. O projeto será chamado de WinHello.
3 – O Visual Studio .NET cria e mostra um formulário formado em Windows no modo Design.
4 – Agora, vamos criar a nossa interface com o usuário.
5 – Na barra de ferramentas do Visual Studio .NET, clique em Toolbox (à esquerda do formulário) ou no
menu View  Toolbox.
6 – Arraste da barra de ferramenta o controle LAbel e posicione-o no canto superior esquerdo do
formulário.
Linguagem de Programação C#

37

7 – Para colocar um controle no formulário, você pode, também, dar um clique duplo sobre ele na barra de
ferramentas ou clicar uma vez sobre a barra de ferramentas e, depois, clicar no formulário. O clique duplo
posiciona o controle no canto superior esquerdo, enquanto a segunda opção coloca o controle no local em
que você clicar.
8 – Também coloque no formulário um controle TextBox e um controle Button.
9 – Na janela Solution Explorer, clique no botão View Code.
10 – O código do arquivo Form1.cs aparecerá.
11 – Para voltar ao modo design, também na janela Solution Explorer, clique em View Design.
12 – Form1.cs tem todo o código gerado automaticamente pelo Visual Studio .NET. Note os seguintes
elementos no código:
As diretivas usadas no início do código referenciando os namespaces:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
O Visual Studio .NET usa o mesmo nome do projeto para criar o namespace principal:
namespace WinHello
{
...
}
Uma classe chamada Form1 dentro do namespace WinHello:
Namespace WinHello
{
Public class Form1 ...
{
...
}
}
O constructor (construtor) é um método especial que tem o mesmo nome da classe. É o primeiro
método a ser executado quando o programa é iniciado:
Public class Form1 ...
{
...
Public Form1 ( )
{
...
}
}
Linguagem de Programação C#

38

O código dentro do método chamado InitializeComponent configura as proprieddes dos controles
que adicionamos no modo Design. Atenção: não modifique o conteúdo do InitializeComponent diretamente
no código, use a janela Properties no modo Design.
13 – Agora, vamos definir as propriedades dos controles inseridos. Para isso, volte ao modo Design.
14 – Para voltar ao modo Design, também na janela Solution Explorer, clique em View Design.
15 – Dê um clique sobre button1, para selecioná-lo.
16 – Na janela Properties, altere a propriedade Text de button1 para OK.
17 – Se não localizar a janela Properties, clique em F4, ou, no menu View, clique em Properties Window.
18 – Altere também a propriedade Text do label1 para Digite o seu nome.
19 – Altere agora a propriedade Text do controle textBox1 para aqui.
Nota: as propriedades modificadas na janela Properties ficam em negrito. Assim, você pode saber se elas
estão com seu valor padrão ou não.
20 – Selecione o formulário clicando sobre ele.
Importante: aparecem alguns marcadores em volta do formulário, que ajudam a redimensioná-lo.
21 – Clique sobre o marcador central na parte de baixo do Form1 e, mantendo o botão pressionado,
arraste para cima.
22 – O procedimento também serve para outros controles. Clique sobre os outros controles e note os
marcadores.
Feito isso, vamos escrever o código para o nosso programa:
1 – No painel de código, dê um clique duplo sobre o button1.
2 – Ele vai diretamente para painel, sendo criado automaticamente o seguinte código:
Private void button1_Click (object sender, System.EventArgse)
{
}
3 – Tudo o que for digitado dentro deste código será executado assim que o button1 for clicado, quando o
programa estiver executando.
4 – Digite o seguinte código:
MessageBox.Show (“Hello” + textBox1.Text);
Atenção: este código deve ser digitado exatamente como segue. Lembre-se de que o C# é case-
sensitive. É necessário, também, o ponto-e-vírgula no final da linha.
5 – Veja como vai ficar:
private void button1_Click (object sender, System.EventArgse)
{
MessageBox.Show (“Hello” + textBox1.Text);
}
6 – Execute o programa. Para executar o programa, você pode clicar em F5, ou, no menu Debug, clicar em
Start Debugging.
7 – Automaticamente, o Visual Studio .NET salva o programa, compila e o executa.
8 - Digite seu nome e clique em OK.
9 – Uma janela aparecerá, exibindo a mensagem Hello + seu nome.
10 – Clique em OK para fechar a janela com a mensagem.
11 – Na janela executando o Form1, clique em Fechar.

Linguagem de Programação C#

39

3.4 – Primeiro Programa
Escrevendo o tradicional programa Hello World, em C#:
Código 1: Hello World em C#
using System ;
class Hello
{
public static void Main()
{
Console.WriteLine("Hello World!!!");
}
}

A cláusula using referencia a as classes a serem utilizadas, System atua como namespace das
classes. O namespace System contém muitas classes, uma delas é a Console. O método WriteLine,
simplesmente emite a string no console.

3.4.1 Main
O método Main é o ponto de entrada de execução do seu programa. A classe que será executada
inicialmente possui embutida a função estática Main. Uma ou mais classes podem conter a função Main,
entretanto, apenas uma será o ponto de entrada, indicada na compilação pelo parâmetro /main:<tipo>, ou
simplificando /m:<tipo>.
O método Main, pode ser declarado de 4 formas:
1. Retornando um vazio(void): public static void Main();
2. Retornando um inteiro(int): public static int Main();
3. Recebendo argumentos, através de um array de string e retornando um vazio: public static void
Main(string[ ] args);
4. Recebendo argumentos, através de um array de string e retornando um inteiro: public static int
Main(string[ ] args).


Linguagem de Programação C#

40

3.5 – Estrutura de um programa
O esqueleto de um programa em C#, apresentando alguns dos seus elementos mais comuns:
Código 2: Estrutura de um programa em C#
using System ;
namespace MathNamespace
{
public class MathClass
{
/* Main : exibe no prompt */
public static void Main ( string [ ] args )
{
Math m = new Math();
Console.WriteLine(m.Sum(1 ,1));
}
// <summary > Classe Math </ summary >
public class Math : Object
{
public int Sum(int a, int b)
{
return (a+b);
}
}
}
}
A estrutura de um programa em C#, pode ser dividida em um ou mais arquivos, e conter:
• Namespaces: são a forma lógica de organizar o código-fonte;
• Tipos: classes, estruturas, interfaces, delegações, enums;
• Membros: constantes, campos, métodos, propriedades, indexadores, eventos, operadores,
construtores;
• Outros: comentários e instruções.
Linguagem de Programação C#

41

CAPÍTULO 4 – Variáveis na Linguagem C#
Na linguagem C# as variáveis estão agrupadas em algumas categorias como:
• Static: existe apenas uma única copia desta variável para todas as instâncias de uma classe. Uma
variável static começa a existir quando um programa começa a executar, e deixa de existir quando o
programa terminar.
• Instance: existe uma copia para cada instância de uma classe. Uma variável Instance começa a
existir quando uma instância daquele tipo e criado, e deixa de existir quando não houver nenhuma
referencia aquela instância ou quando e método Finalize e executado.
• Array: é uma matriz que e criada em tempo de execução.

4.1 Tipos de dados
Como toda linguagem de programação o C# também apresenta seu grupo de tipos de dados
básico. Esses tipos são conhecidos como tipos primitivos ou fundamentais por serem suportados
diretamente pelo compilador, e serão utilizados durante a codificação na definição de variáveis,parâmetros,
declarações e até mesmo em comparações.

4.1.1 Tipos Valor e Tipos Referência
Os tipos de dados no C# são divididos em 3 categorias:
• Tipos valor(value types);
• Tipos referência(reference types);
• Tipos ponteiro(pointer types).
Tipos valor armazenam dados em memória enquanto tipos referência armazenam uma referência,
ou o endereço, para o valor atual.
Quando utilizamos uma variável do tipo referência não estaremos acessando seu valor
diretamente,mas sim um endereço referente ao seu valor, ao contrário do tipo valor que permite o acesso
diretamente a seu conteúdo.
Os tipos ponteiro, apenas apontam para um endereço de memória.

4.1.2 Conversão de Tipos
Converter um tipo de dado em número ou em literal é comum em situações de programação.
Devemos considerar alguns aspectos para a conversão de números:
• Como existem diversos tipos de números, inteiros, ponto flutuante ou decimal, os valores são
convertidos sempre para o tipo de maior faixa de valores. Por exemplo, o tipo long é convertido para o
ponto flutuante, mais é importante ressaltar que o contrario causa um erro.
• Os tipos de menor faixa são convertidos para os de maior faixa. Por exemplo, o tipo int pode ser
convertido para: long, float, double ou decimal.
• A conversão dos tipos de ponto flutuante(float, double) para decimal causa erro.
• A conversão entre os tipos com sinal e sem sinal de valores inteiros com o mesmo tamanho causa
erro. Por exemplo, entre o tipo int e unit.

Linguagem de Programação C#

42

Código 3: Exemplo de conversão automática de tipos
int VarInteiro = 32450;
long VarLong = VarInteiro ;
float VarFloat = VarLong ;
double VarDouble = VarFloat ;
decimal VarDecimal = VarLong ;
byte VarByte = ( byte ) VarInteiro ;
int VarInteiro = (int) 31.245 F;
Tipos de conversão automática
Tipo Converte em
sbyte short, int, long, float, double, decimal
byte short, ushort, int, uint, long, ulong, float, double, decimal
short int, long, float, double, decimal
ushort int, uint, long, ulong, float, double, decimal
int long, float, double, decimal
uint long, ulong, float, double, decimal
long float, double, decimal
ulong long, double, decimal
char ushort, int, uint, long, ulong, float, double, decimal
float Double

4.1.3 O Objeto Convert
Em C# temos o objeto Convert que é usado para converter um tipo de dado em outro. Os tipos de
dados suportados são: Boolean, Char, SByte, Byte, Int16, Int32, Int64, UInt16, UInt32, UInt64, Single,
Double, Decimal, DateTime e String.
Por exemplo:
Código 4: Exemplo de utilização do objeto Convert
double dNumber = 23.15;
int iNumber = System . Convert . ToInt32 ( dNumber );
bool bNumber = System . Convert . ToBoolean ( dNumber );
String strNumber = System . Convert . ToString ( dNumber );
char chrNumber = System . Convert . ToChar ( strNumber [0]) ;
4.2 Arrays
Um tipo array é uma matriz de valores do mesmo tipo, que é criada em tempo de execução,
podendo ser acessada por meio de um índice.
A declaração do array sempre faz o uso de um colchete( [ ] ) depois do tipo da variável. O uso da
instrução new sempre deve ser utilizado, pois é obrigatório.
O tipo array pode ter diversas dimensões, o tamanho desta é definido pelo desenvolvedor, mas
devemos saber que o primeiro índice é sempre zero.
No tipo array devemos sempre inicializar seus elementos, pois é obrigatório também. Veja abaixo a
forma de sintaxe para a declaração de arrays.

Linguagem de Programação C#

43

Código 5: Sintaxe para a declaração de Arrays
<TIPO >[ ] NomeDoArray = new <TIPO > [ tamanho do array ];
float [ ] ValorIndice = new float [10];
string [ ] ElementoVetor = new string [10];
Código 6: Sintaxe para a declaração de Arrays com duas ou mais dimensões
<TIPO> [,] NomeDoArray = new <TIPO> [tamanho do array, tamanho do array];
float [,] ValorIndice = new float[10 ,10];
string [,,] ElementoVetor = new string[10 ,10 ,10];
Código 7: Sintaxe para a declaração de uma matriz de Arrays com duas ou mais dimensões
<TIPO>[][] NomeDoArray = new <TIPO> [tamanho do array][tamanho do array];
float [ ][ ] ValorIndice = new float [10][10];
string [ ][ ][ ] ElementoVetor = new string [10][10][10];
Código 8: Sintaxe para a inicialização de Arrays com duas ou mais dimensões
<TIPO> [ ] NomeDoArray = new <TIPO> [tamanho do array]
{
valores separados por ,
};
float [ ] ValorIndice = new float [5]{1.25 ,2 ,3.23 ,1.32 ,5};
string [,] ElementoVetor = new string [3 ,3]
{
{ " a b " , " a c " , " b c " } ,{"ab" , "ac" , "bc" }
};
int [ ][ ] MatrizDeInteiro = new int [2][ ];
MatrizDeInteiro [ 0 ] = new int [ 5 ] {1 ,3 ,5 ,7 ,9};
MatrizDeInteiro [ 1 ] = new int [ 4 ] {2 ,4 ,6 ,8};
Para passar um argumento array para um método, especifique o nome do array sem usar colchetes
e para que um método receba um array, a lista de parâmetros deve especificar que um array será
recebido. Veja o seguinte exemplo:
Código 9: Passando Arrays à métodos
int [ ] vetor = {10 , 20, 30, 40, 50};
Array . IndexOf (vetor , 22) ;
public void ExibeVetor ( int [] vetor );
Algumas Propriedades e Métodos dos Arrays:
• Array.Length − Tamanho do vetor;
• Array.IndexOf(Array vetor, object value) − Procura a primeira ocorrência de valor em vetor;
• Array.LastIndexOf(Array vetor, object value) − Procura a última ocorrência de valor em vetor;
• Array.Sort(Array vetor) − Ordena um vetor crescentemente;
• Array.Reverse(Array vetor) − Ordena um vetor decrescentemente.
Linguagem de Programação C#

44

CAPÍTULO 5 – Operadores

C# é uma linguagem muito rica em operadores. Estes representados por símbolos são utilizados na
construção de expressões. A sintaxe de expressão do C# é baseada na sintaxe do C++. Os operadores
são categorizados em diversas funcionalidades. A tabela 3 apresenta essas divisões.
Quando uma expressão possui múltiplas operações, a precedência dos operadores é levada em
consideração na avaliação da mesma. Normalmente, as expressões são avaliadas da esquerda para
direita, exceto para operações de atribuição e condicional, porém a precedência pode ser alterada através
do uso do parênteses.
Tabela 3: Operadores do C#
Categoria Operadores
Aritmética & + - * / %
Lógica (boolena e bitwise) & | ˆ ! && || true false
Concatenação de string +
Incremento e decremento ++ –
Shift << >>
Relacional == != <> <= >=
Atribuição = += -= *= /= %= &= —= ˆ= <<= >>=
Acesso a membro .
Indexação [ ]
Indexação ()
Condicional ?:
Delegate (concatenação e remoção) + -
Delegate (concatenação e remoção) New
Informação de tipo is sizeof typeof
Controle de exceção de overflow checked unchecked
Indireção e endereço * -¿ [ ] &

5.1 Operadores Aritméticos
Os operadores aritméticos são utilizados na maioria das expressões para execução de cálculos.
Numa expressão, eles podem produzir resultados fora da faixa de valores. Neste caso, uma
excessão como OverflowException é gerada.
Os operadores unários (atribuídos a 1 atributo) + e - são utilizados para representar se o número é
positivo ou negativo, respectivamente.
Código 22: Operadores Unários
x = +1000 // x = 1000
x = -1000 // x = -1000
Os operadores binários +, -, *, / e % são utilizados nas expressões para execução de cálculos tais
como soma, subtração, multiplicação, divisão e sobra. O operador binário + quando utilizado entre strings
representam concatenação. No entanto, quando existem strings e números na expressão e nenhuma
operação de cast for executada a operação é tratado como concatenação. O operador binário % é
computado através da fórmula dividendo - ( dividendo / divisor ) * divisor. Os exemplos abaixo ilustram
essas condições:
Código 23: Operadores Binários
string x = "Hello" + "World" // x = " HelloWorld "
string x = "Valor = " + 100 // x = " Valor = 100"
int x = 1000 % 11 // x = 10
Linguagem de Programação C#

45

O Código abaixo utiliza os operadores aritméticos. Note a utilização e recebimento de argumentos
através da linha de comando. O entry-point Main permite ser passado um vetor de strings como parâmetro.
O método Length conta o número de parâmetros passado, ignorando o executável. Como todo vetor o
primeiro parâmetro é representado pelo índice zero, por exemplo args[0]. A variável args não é uma
palavra-chave, portanto, esta pode ser alterada:
Código 24: Exemplo Operadores Binários
using System ;
class Arithmetics
{
public static void Main ( string [ ] args )
{
// Verifica o número de argumentos entrados
if(args.Length == 3)
{
int x=0,y=0;
// Convertem os valores dos argumentos 2 e 3 para inteiro 32-
bit
// Se ocorrer algum erro o modo de utilização
try
{
x = args [1]. ToInt32 ();
y = args [2]. ToInt32 ();
}
catch
{
usage ();
return ;
}
// Efetua a operação selecionada no primeiro argumento
switch ( args [0])
{
case " + " :
Console.Write("Valor da soma={0}", x+y);
break ;
case " - " :
Console.Write("Valor da subtração={0}", x-y);
break ;
case " / " :
Console.Write("Valor da divisão={0}", x/y);
break ;
case " * " :
Console.Write("Valor da multiplicação={0}" ,x*y);
break ;
case " % " :
Console.Write("Valor da sobra={0}", x%y);
break ;
default :
usage ();
}
}
else
{
usage ();
}
}
public static void usage()
{
// Modo de utilização
Console.WriteLine("Modo de usar : Arithmetics operador valor1 valor2");
Console.WriteLine("Ex.: Arithmetics + 100 200 " );
} }

Linguagem de Programação C#

46

5.2 Operadores de Incremento e Decremento
Os operadores ++ e – aumentam ou diminuem por um o valor correspondente. O ponto chave é
que se o operador for utilizado à esquerda da variável, ou seja prefixado, o valor é adicionado ou subtraído
de um antes de sua utilização.
Código 25: Operadores de Incremento e Decremento
int x = 1000; // x = 1000
x++; // x = 1001
int y = x++; // x = 1002 , y = 1001
x --; // x = 1001
y = --x; // x = 1000 , y = 1000
++x; // x = 1001
--x; // x = 1000
y = ++x; // x = 1001 , y = 1001

5.3 Operadores Lógico, Relacional e Condicional
Esses operadores são utilizados em expressões onde o resultado retornado ou a característica é
booleana.
O operador de negação ! retorna o complemento de um valor booleano.
Código 26: Exemplo do operador de negação
bool x = true ;
bool y = !x // y = false ;
if (!y) System.Console.Write("y é verdadeiro");
Os operadores relacionais ==, !=, ¡, ¿, ¡=, ¿=, resultam em um valor booleano e representam igual,
não igual ou diferente, menor, maior, menor ou igual e maior ou igual, respectivamente.
Por exemplo, a == b quer dizer se a for igual a b, isto é totalmente válido na expressão com tipos
primitivos(value types), tais como int, long, char, entre outros. Porém o comportamento dos operadores ==
e != são diferenciados quando utilizado entre structs (value types) e classes (reference types). Para structs
a comparação deve levar em consideração todos os campos da estrutura. Para classes a comparação é
efetuada pelo endereço, ou referência, da classe. O único reference type que compara o valor e não a
referência é a string ou a classe System.String, pois os operadores == e != são sobrecarregados. A
sobrecarga pode alterar o comportamento padrão dos operadores.

5.4 Operação de Atribuição
Estes operadores, divididos entre simples e compostos, são utilizados na designação de um valor
para uma variável. O operador = representa a atribuição simples, ou seja uma variável do lado esquerdo
recebe o conteúdo de um valor, de uma variável ou do resultado de uma expressão do lado direito.
Código 27: Exemplo do operador de atribuição
int x = 10;
int y = x;
int z = x + y;
Os operadores +=, -=, *=, /=, %=, &=, —=, ˆ =, ¡¡= e ¿¿= representam a atribuição composta, que
normalmente atuam como um atalho na construção de uma expressão.
Código 28: Exemplo do operador de atribuição composta
x = x + 10; // Pode ser escrito como :
x+= 10; // x <op >= <valor >
Linguagem de Programação C#

47

CAPÍTULO 6 – Comandos
6.1 Seleção
Os comandos de seleção são utilizados na escolha de uma possibilidade entre uma ou mais
possíveis. Os comandos if e switch fazem parte deste grupo.

6.1.1 Comando if
O comando if utiliza uma expressão, ou expressões, booleana para executar um comando ou um
bloco de comandos. A cláusula else é opcional na utilização do if , no entanto, seu uso é comum em
decisões com duas ou mais opções.
Código 10: Exemplo do comando if em C#
/*if com uma única possibilidade.
Exibe a string " Verdadeiro " no Console caso a expressão (a== true ) seja
verdadeira*/

if(a== true )
{
System.Console.Write("Verdadeiro");
}

/* if com uma única possibilidade. Exibe a string " Verdadeiro " no
Console caso a expressão (a== true ) seja verdadeira , senão exibe a string "
Falso"*/
if(a== true)
{
System.Console.Write("Verdadeiro");
}
else
{
System.Console.Write("Falso");
}
Toda expressão do comando if deve ser embutida em parênteses (()) e possui o conceito de curto-
circuito (short-circuit). Isto quer dizer que se uma expressão composta por And (&&), fornecer na sua
primeira análise um valor booleano false (falso), as restantes não serão analisadas. Este conceito é válido
para todas expressões booleanas. Por exemplo:
Código 11: Ifs com And e Or
// && (And ). Somente a primeira função é executada
if( MyFunc () && MyFunc2 ());

// || (Or). Ambas funções são executadas
if( MyFunc() || MyFunc2());

public static bool MyFunc()
{
return false ;
}

public static bool MyFunc2(){ return true ; }

Linguagem de Programação C#

48

Assim como outros comandos. O if também pode ser encontrado na forma aninhada.
Código 12: Ifs aninhados
if(x == 1)
{
if(y == 100)
{
if(z == 1000)
{
System.Console.Write("OK");
}
}
}
Porém, devido a característica de curto-circuito nas expressões, as linhas de cima podem e devem
ser reescritas para:
Código 13: Curto-circuito
if(x == 1 && y == 100 && z == 1000) System.Console.Write("OK");
O comando if também pode ser encontrado num formato escada if-else-if , quando existem mais do
que duas possibilidades. Porém, na maioria destes casos, se as expressões não forem compostas ou
utilizarem de funções, a cláusula switch substitui este tipo de construção.
Código 14: Exemplo if-else-if
using System ;
class Ifs
{
public static void Main ()
{
char chOpt ;
Console.WriteLine(" 1 - Inserir " );
Console.WriteLine(" 2 - Atualizar");
Console.WriteLine(" 3 - Apagar");
Console.WriteLine(" 4 - Procurar");
Console.Write("Escolha entre[1] a [4] :");
do
{
chOpt = ( char ) Console.Read ();
} while (chOpt < '1' || chOpt > '4');

if( chOpt == '1' )
{
Console.WriteLine ( "Inserir...");
}
else if( chOpt == '2' )
{
Console.WriteLine ( " Atualizar...");
}
else if( chOpt == '3' )
{
Console.WriteLine ( " Apagar...");
}
else
{
Console.WriteLine("Procurar...");
}
}
}
Linguagem de Programação C#

49

O comando if com a cláusula else única pode ser encontrado em sua forma reduzida com operador
ternário representado por interrogação (?:). É chamado de operador ternário por possuir 3 expressões: a
primeira refere-se a condição boolena, a segunda se a condição é verdadeira e a terceira se a condição é
falsa.
Código 15: Operador Ternário
int x;
if(f== true )
x = 100;
else
x = 1000;

// As linhas acima podem ser substituídas por :
int x = f == true ?100:1000;

6.1.2 Comando switch
O comando switch utiliza o valor de uma determina expressão contra uma lista de valores
constantes para execução de um ou mais comandos. Os valor constante é tratado através da cláusula
case e este pode ser numérico, caracter ou string. A cláusula default é utilizada para qualquer caso não
interceptado pelo case. O exemplo abaixo implementa a versão com o comando switch do exemplo,
previamente mostrado com o comando if :
Código 16: Comando switch
using System ;
class Switchs {
public static void Main (){
char chOpt ;
Console.WriteLine ( " 1 - Inserir" );
Console.WriteLine ( " 2 - Atualizar" );
Console.WriteLine ( " 3 - Apagar" );
Console.WriteLine ( " 4 - Procurar" );
Console.Write ("Escolha entre[1] a [4]:" );
// Verifica se os valores entrados esta entre 1 e 4
// caso contrário pede reentrada
do
{
chOpt = ( char ) Console . Read ();
} while (chOpt < ’ 1 ’ || chOpt > ’ 4 ’ );
switch ( chOpt )
{
case ’ 1 ’ :
Console . WriteLine ( "Inserir...");
// InsertFunction ();
break ;
case ’ 2 ’ :
Console . WriteLine("Atualizar...");
// UpdateFunction ();
break ;
case ’ 3 ’ :
Console . WriteLine("Apagar...");
// DeleteFunction ();
break ;
default :
Console . WriteLine("Procurar...");
// FindFunction ();
} }
Uma ou mais cláusulas case podem ser encontradas seguidamente quando mais do que uma
opção é permitida para um comando ou bloco de comandos. O exemplo abaixo apresenta essa condição:
Linguagem de Programação C#

50

Código 17: Comando switch
switch ( sProduct )
{
case "Windows2000":
case "WindowsNT":
System.Console.Write("Sistema Operacional");
break;
case " MSDE":
System.Console.Write("Mecanismo Simplificado");
goto case "SQL Server";
case "SQL Server":
System.Console.Write("Banco de Dados");
}
A cláusula break , é utilizada para separar os blocos do switch e garante que o bloco seja
executado somente até determinado ponto.

6.2 Loop
Conhecidos como laço ou loop, os comandos de iteração executam repetidamente um comando ou
bloco de comandos, a partir de uma determinada condição. Esta condição pode ser pré-definida ou com
final em aberto. Em C#, fazem parte dos comandos de iteração: while ,do , for e foreach .

6.2.1 Comando for
O comando for possui 3 declarações opcionais, separadas por ponto e vírgula (;), dentro dos
parênteses: inicialização, condição e a iteração. Em cada parâmetro, mais de uma expressão pode ser
encontrada separada por vírgula.
Código 18: Iteração for
for(int x=0; x < 100; ++x)
{
System.Console.WriteLine(x);
}
for (;;)
{ // Laço infinito
System.Console.WriteLine("Hello,World!");
}
for(int y=100 , int x = 0;x < y; ++x, --y)
{ // Laço com mais de 1 variável
System.Console.WriteLine(y);
}
Quando a cláusula for é processada pela primeira vez, se presente, a expressão ou expressões da
declaração inicializadora são executadas na ordem que elas estão escritas, este passo ocorre apenas uma
vez.
Linguagem de Programação C#

51

Se a declaração condicional estiver presente, será avaliada, caso contrário o for assume o valor
verdadeiro (true). Na avaliação, se o valor obtido for verdadeiro (true) o comando ou bloco de comandos
associados serão executados, ao seu final a terceira declaração ou declaração de iteração é processada e,
então, novamente a declaração condicional é processada.
Este fluxo ocorre continuamente até que a declaração condicional seja avaliada como falsa (false)
ou o comando break seja encontrado, como visto anteriormente. O comando continue força uma nova
iteração.
Código 19: Iteração for (exemplo)
using System ;
class Fibonacci
{
public static void Main ()
{
int iVezes ;
Console.Write("Entre de 1 a 100 para o n de elementos a exibir
na sequência de Fibonacci" );
// Verifica se os valores entrados esta entre 1 e 100
// caso contrário pede reentrada
do
{
iVezes = Console.ReadLine().ToInt32();
} while (iVezes <1 || iVezes >100) ;

// Cria o vetor dinamicamente
int [ ] iSeq = new int[ iVezes ];
iSeq [0] = 1;
// Preenche o vetor
if( iVezes > 1)
{
iSeq [1] = 1;
for(int a=2; a < iVezes ; ++a)
iSeq [a] = iSeq [a -1] + iSeq [a -2];
}

// Exibe o vetor
for (int a=0; a < iVezes ; ++a)
{
Console.Write(iSeq [a]);
Console.Write(" ");
}
}
}

Linguagem de Programação C#

52

6.2.2 Comando foreach
O comando foreach enumera os elementos de uma coleção. O código abaixo implementa a
funcionalidade do exemplo anterior:
Código 20: Iteração foreach (exemplo)
using System ;
class Fibonacci
{
public static void Main ()
{
int iVezes ;
Console.Write("Entre de 1 a 100 para o nº de elementos a exibir na sequência de
Fibonacci: " );
// Verifica se os valores entrados esta entre 1 e 100
// caso contrário pede reentrada
do{
iVezes = Console . ReadLine (). ToInt32 ();
} while (iVezes <1 || iVezes >100) ;

// Cria o vetor dinamicamente
int [ ] iSeq = new int[ iVezes ];
iSeq [0] = 1;
// Preenche o vetor
if( iVezes > 1)
{
iSeq [1] = 1;
for(int a=2; a < iVezes ; ++a)
iSeq [a] = iSeq [a -1] + iSeq [a -2];
}
// Exibe o vetor
foreach (int a in iSeq )
{
Console.Write (a);
Console.Write ( " " );
}
}
}

Linguagem de Programação C#

53

6.2.3 Comandos do - while
Os comandos do - while têm características semelhantes. Ambos executam condicionalmente um
comando ou bloco de comandos. No entanto, o comando do pode ser executado uma ou mais vezes e o
comando while pode ser executado nenhuma ou mais vezes, isto ocorre porque a expressão condicional
do comando do é encontrada no final do bloco.
Código 21: Iteração do while (exemplo)
// Comando while :
int a = 0;
bool f = true ;
while (f)
{
if (++ a ==100) f = true ;
System.Console.WriteLine (a);
}
// Comando do ... while :
int a = 0;
bool f = true ;
do
{
if (++ a ==100) f = true ;
System.Console.WriteLine (a);
} while (f);

Linguagem de Programação C#

54

CAPÍTULO 7 – Desenvolvimento de aplicações com C#

Abaixo a tela inicial do Visual Studio:


Para construir um programa vamos seguir 3 passos:

1º Passo: Criar um Projeto Fique atento neste passo, pois o Visual Studio permite que você
escolha entre 4 linguagens (Visual Basic, Visual C#, C++, J#). Escolha sempre o VISUAL C#



Linguagem de Programação C#

55

Esta é a Tela de Escolha de Projetos, fique atento pois o Visual Studio permite que você programe
em 4 linguagens diferentes (Visual Basic, Visual C#, C++ e J#). Você deve escolher VISUAL C#.


Fique atento a esta aba, verifique se tem o texto Form1.cs, caso não tenha feche o programa e
refaça o 1º Passo



Antes de prosseguirmos para o 2º Passo, devemos conhecer com mais detalhes as janelas do
Visual Studio.

Linguagem de Programação C#

56

TOOLBOX: Esta caixa de diálogo é muito importante pois é nela que iremos escolher e pegar os
objetos que usaremos no nosso programa. Ela dividida por grupos de objetos que são separados por tipo.
Neste primeiro momento usaremos somente os objetos do COMMOM CONTROLS.



SOLUTION EXPLORER: Esta caixa de diálogo é usada para gerenciar os arquivos que foram
criados no nosso projeto.


CLASS VIEW: Esta caixa de diálogo é usada para gerenciar as classes criadas no nosso projeto.


Linguagem de Programação C#

57

PROPERTIES: Esta caixa de diálogo é outra muito importante pois é nela que configuraremos os
objetos adicionados no nosso programa.



Ela é dividida em 2 partes: Properties e Events, para selecioná-los basta clicar em:

Para exibir as propriedades do objeto selecionado

Para exibir os eventos do objeto selecionado

Este campo informa o objeto selecionado





Linguagem de Programação C#

58

Esta é a tela do nosso programa, conhecida como FORM ou FORMULÁRIO






Linguagem de Programação C#

59

2º Passo: Construir a tela do programa. Este passo requer somente criatividade.



Todos objetos adicionados ao FORM deverão ter alteradas as propriedades NAME e TEXT. A
propriedade NAME serve para identificar o objeto em nível do programador (VARIÁVEL).
A propriedade TEXT serve para identificar o objeto em nível do usuário (RÓTULO).



Nesta propriedade podemos usar acentos, caracteres especiais e espaço em branco. Altere a
propriedade para o texto: Clique Aqui!!!



Nesta propriedade NÃO podemos usar acentos, caracteres especiais e espaço em branco. Altere a
propriedade para o texto: btnClique



Linguagem de Programação C#

60

Existe uma Regra de Nomenclatura: Remover as vogais e adicionar a funcionalidade do objeto.

Exemplos:

Button1 => btnSair Label1 => lblNome

TextBox1 => txtEndereco
TextBox1 => txtEndereco

3º Passo: Codificar o programa. Este passo é o mais importante, pois é nele que iremos fazer
nosso programa funcionar, isto é, sem ele teremos o projeto correto com uma tela bonita mas SEM
FUNCIONAMENTO.
Exemplo1: Faça um programa que escreva a frase hello world na tela quando um botão for clicado.

1º Passo: Criar um projeto



2º Passo: Construir a tela do programa


Linguagem de Programação C#

61

Para que o FORM fique assim deve-se alterar algumas propriedades dos três objetos: FORM,
BUTTON e LABEL.
Tome cuidado para não alterar a propriedade do objeto errado. CLIQUE 1 VEZ NO OBJETO, PARA
SELECIONÁ-LO, E DEPOIS ALTERE AS PROPRIEDADES.



As propriedades NAME e TEXT sempre serão alteradas. Existem outras propriedades que também
são interessantes, teste as seguintes propriedades:
BACKCOLOR – usada para alterar a cor de fundo
FONT – usada para alterar a fonte (estilo, tamanho, entre outros)
FORECOLOR – usada para alterar a cor da fonte

3º Passo: Codificar o programa



Linguagem de Programação C#

62



Analisando as ABAS acima verificamos que agora temos o código fonte separado da tela, para
acessar a tela (FORM) clique na ABA Form1.cs [Design] e para acessar o código fonte clique na ABA
Form1.cs



Para diferenciar as duas telas verifique se existe o cadeado azul na frente das ABAS, caso exista
feche a tela do programa que está executando antes de alterar qualquer coisa.


Linguagem de Programação C#

63



Conclusão: Neste exemplo aprendemos a usar dois objetos (LABEL e BUTTON) e um evento
(CLICK).
LABEL – usado para escrever mensagens na tela
BUTTON – usado para executar a funcionalidade do programa. Para isto acionamos o evento
CLICK, que executa o código através do click do mouse no objeto.
EXEMPLO 2: Faça um programa que escreva a frase bom dia, seu nome na tela quando um botão
for clicado
1º Passo: Criar um projeto



Linguagem de Programação C#

64

2º Passo: Construir a tela do programa

Para que o FORM fique assim deve-se alterar algumas propriedades dos três objetos: FORM,
BUTTON, LABEL e TEXTBOX.

Tome cuidado para não alterar a propriedade do objeto errado. CLIQUE 1 VEZ NO OBJETO, PARA
SELECIONÁ-LO, E DEPOIS ALTERE AS PROPRIEDADES.
As propriedades NAME e TEXT sempre serão alteradas.
Existem outras propriedades que também são interessantes, teste as seguintes propriedades:
BACKCOLOR – usada para alterar a cor de fundo
FONT – usada para alterar a fonte (estilo, tamanho, entre outros)
FORECOLOR – usada para alterar a cor da fonte

Linguagem de Programação C#

65

3º Passo: Codificar o programa




Agora teste este código:

Qual a diferença entre os códigos?
Linguagem de Programação C#

66

A diferença é que no primeiro não usamos variável e no segundo usamos a variável nome do tipo
STRING (texto) para armazenar as informações digitadas pelo usuário.
Funciona sem variável?
Sim, pois a propriedade TEXT armazena automaticamente as informações digitadas. Lembre-se
que ela armazena somente Texto (STRING)

Conclusão: Neste exemplo aprendemos a usar um objeto novo (TEXTBOX) e variável.
TEXTBOX – usado para capturar as informações digitadas pelo usuário. Estas informações serão .
SEMPRE no formato de texto (STRING). Quando precisarmos de valores numéricos (INT ou DOUBLE)
teremos que converter.
VARIÁVEL – Variável é o nome dado a uma posição de memória onde podemos armazenar um tipo de
dado definido. Os tipos são:
int – dados do tipo inteiro
double – dados do tipo real
String ou string – dados do tipo texto

Exercícios
1) Faça um programa em C# para calcular a área de um retângulo. O usuário deverá fornecer os
valores da Base e da Altura e o programa deverá responder o valor da área calculado, conforme a tela:


Linguagem de Programação C#

67

2) Faça um programa em C# que calcule quantas horas uma pessoa já viveu. O usuário deverá
informar sua idade em anos e o programa deverá responder a idade da pessoa em horas, conforme a tela
abaixo:

Sabe-se: dia = 24h Ano = 365 dias
A resposta deve seguir o exemplo: Pedro já viveu 1.245.000 horas
3) Faça um programa em C# que calcule o salário de um funcionário horista, isto é, que recebe por
horas trabalhadas. O usuário deverá fornecer o seu nome, o número de horas trabalhadas e o valor que
ele recebe por cada hora trabalhada e o programa deverá responder o seu salário final, conforme a tela
abaixo:

4) Faça um programa em C# que calcule o salário de um vendedor. O usuário deverá fornecer o
seu nome, o seu salário mensal e o total de vendas do mês e o programa deverá responder o salário
mensal deste vendedor, conforme a tela abaixo:

• Sabe-se que: o percentual ganho sobre o total de vendas é de 15%
• sal_final = salário + (15% do total de vendas)
• A resposta deve seguir o exemplo abaixo: O salário da Paola é 3500,00
Linguagem de Programação C#

68

5) Faça um programa em C# que converte um valor em reais para seu equivalente em dólares. O
usuário deverá fornecer o preço do produto em dólar e o programa deverá responder o preço do produto
em reais, conforme a tela abaixo:

Use como preço do dólar o valor de R$1,89.
6) Faça um programa em C# que converta uma temperatura em Farenheit para Celsius. O usuário
deverá fornecer uma temperatura em graus Farenheit e o programa deverá responder o seu equivalente
em graus Celsius, conforme a tela abaixo:

+ Use a formula:

6) Faça um programa em C# que calcule a equação do 2º grau (ax2+bx+c), através da fórmula de
Baskara. O usuário deverá fornecer os valores de A, B, C e o programa deverá responder as duas
respostas X1 e X2, conforme a tela abaixo:


) 32 (
9
5
÷ = F C
Linguagem de Programação C#

69

EXEMPLO 1: Faça um programa que leia um número qualquer e verifique se este número está entre 10 e
20.
1º Passo: Criar um projeto

2º Passo: Construir a tela do programa

Para que o FORM fique assim deve-se alterar algumas propriedades dos três objetos: FORM,
BUTTON, LABEL e TEXTBOX.
Linguagem de Programação C#

70



3º Passo: Codificar o programa


Linguagem de Programação C#

71

Agora teste este código. Nele usamos o comando MessageBox.Show(“”); para exibir a resposta ao
invés do lblResposta.Text.


Exercícios
1) Faça um programa que escreva por extenso o nome do mês escolhido pelo usuário, conforme o
modelo abaixo:
Botão Conversor: Deverá transformar o número do mês digitado no textbox1 para seu nome por
extenso, mostrando no label3.
Botão Sair: Deverá sair do programa.

2) Faça um programa que coloque na ordem crescente dois números reais digitados pelo usuário,
conforme o modelo abaixo:
Botão Processar: Deverá colocar na ordem crescente dois números digitados pelo usuário e
mostrá-los nos Label3 e Label4.

Linguagem de Programação C#

72

3) Faça um programa que verifique se um determinado número, digitado pelo usuário, é par ou
ímpar, conforme o modelo abaixo:
Botão Par ou Ímpar: Deverá verificar se o número é par ou ímpar, exibindo a resposta em uma
caixa de mensagem => MessageBox.Show(“”);

Para descobrir o resto da divisão use o operador %. Exemplo: N1 % 2
4) Faça um programa que permita ao usuário escrever seu nome e escolher uma cor entre Azul e
Rosa, conforme o modelo abaixo:
Os quadrados decorativos foram feitos com o GROUPBOX. Para ficar fechado é só apagar a
propriedade TEXT e para ficar com o texto ESCOLHA UMA COR, escrever a mensagem na propriedade
TEXT.
As opções Azul e Rosa foram feitas com o RADIOBUTTON, propriedade TEXT para os textos. O
radiobutton possui uma propriedade chamada CHECKED que armazena TRUE (selecionado) ou FALSE
(não selecionado). Use o evento CLICK do radiobutton.
O programa deverá funcionar da seguinte maneira: o usuário irá escrever o seu nome e escolher
uma cor, o programa deverá responder alterando a cor do form, para a cor escolhida, e exibindo no Label2
a mensagem: “Nome_do_usuário, você gosta da cor cor_escolhida”
.
5) Faça um programa que calcule o peso ideal de uma pessoa, conforme a tela abaixo.
Lembre-se: RADIOBUTTON – Evento CLICK – ação de clicar no RadioButton
O programa deverá calcular o peso ideal de uma pessoa usando a altura digitada pelo usuário e a
opção do sexo escolhida, exibindo o peso ideal no Label3. Use as fórmulas abaixo:
- para homens: (72.7*h)-58 - para mulheres: (62.1*h)-44.7

Linguagem de Programação C#

73

6) Desenvolva um programa em C# que determine o gasto em reais do consumo mensal de energia
elétrica de uma residência. O programa deverá ler o nome do proprietário, a quantidade de Kwh
consumidos no mês para cada residência e o valor unitário do Kwh em reais (R$) e deverá determinar e
exibir o gasto em reais (R$) de uma residência, conforme tabela abaixo:
Tipo de Consumidor Consumo Acréscimo no Valor Unitário
Consumidor Normal Até 150 Kwh Valor normal
Consumidor Extra – faixa 1 151 Kwh até 250 Kwh 3% de acréscimo
Consumidor Extra – faixa 2 Acima de 250 Kwh 5% de acréscimo

Verificar se o TextBox do Consumo e do Valor Unit estão “vazio”
Cálculo do Gasto em Reais verificando o Tipo de Consumidor e exibir resposta.
Exemplo da resposta: A residência do Sr. Paulo gastou R$ 270,00. Ele é Consumidor Extra – faixa1

7) Desenvolva um programa em C# que determine o gasto semanal de uma pessoa em uma Lan
House. O programa deverá ler o nome da pessoa, o número de horas usadas (de computador) na última
semana e o valor cobrado por hora, em reais. O programa deverá determinar e exibir o gasto em reais da
pessoa conforme tabela abaixo:
Horas Usadas Valor cobrado por Hora
até 20 h por semana Valor normal
Para as horas que ultrapassarem 20 h Valor normal com 50% de desconto

Verificar se o TextBox das Horas Usadas e do Valor R$ estão “vazio”. Cálculo do Gasto Semanal
e exibir resposta.
Exemplo da resposta: O Sr. João usou 12 horas e deve pagar R$ 12,00

Linguagem de Programação C#

74

8) Faça um programa em C# que lê o nome, o salário fixo de um vendedor, o total de vendas por
ele efetuadas no mês e calcule o valor do salário final, isto é, salário fixo mais a porcentagem sobre as
vendas e mais o prêmio, conforme a seguinte tabela:
Total de vendas no mês Porcentagem sobre Vendas Prêmio
Até R$ 5000 2% 100
De R$ 5001 até R$ 7500 3% 200
Acima de R$ 7500 4% 300

Verificar se o TextBox do Salário Fixo e do Total de Vendas estão “vazio”
Cálculo do Salário Final (salário fixo + porcentagem sobre as vendas + premio) e exibir resposta.
Exemplo da resposta: O Sr. Paulo vendeu R$ 5700,00. Salário Final R$ 571,00

9) Um banco concederá um crédito especial aos seus clientes, variável de acordo com o saldo
médio no último ano. Faça um programa em C# que leia o nome do cliente, o saldo médio deste cliente e
calcule o valor do crédito de acordo com a tabela abaixo.
Saldo médio Percentual
Até R$ 200 nenhum crédito
de R$ 201 a R$ 400 20% do valor do saldo médio
de R$ 401 a R$ 600 30% do valor do saldo médio
acima de R$ 601 40% do valor do saldo médio

Verificar se o TextBox do Saldo Médio está vazio. Cálculo do Crédito e exibir resposta.
Exemplo da resposta: O Sr. João tem 20% de crédito e receberá R$ 80,00

Linguagem de Programação C#

75

CAPÍTULO 8 – Conversão de Tipos com C#
8.1 Problema na Conversão de Tipos
• A conversão de tipos numéricos possui dois problemas que acontecem em tempo de execução,
são eles:
• Conversão de valores NULOS para valores numéricos (quando o usuário deixa um TextBox vazio)
• Conversão de valores alfanuméricos (letras) para valores numéricos (quando o usuário preenche o
TextBox com letras)

EXEMPLO 1: Faça um programa que leia somente letras no textbox do nome e somente números
no textbox do salário e calcule o novo salário (40% de reajuste)
1º Passo: Criar um projeto



Linguagem de Programação C#

76

Para travarmos as letras ou os números de um TextBox precisamos usar o evento KEYPRESS.
Este evento é responsável pela captura de cada tecla pressionada no TextBox.

Selecione o TextBox do Nome (txtNome), acione o evento KeyPress e digite o código:

Este código é responsável pela verificação letra a letra (digitada) no TextBox. Caso esta letra esteja
entre as letras minúsculas/maiúsculas ele libera a exibição da mesma (e.Handled=false), caso contrário ele
apaga a letra digitada (e.Handled=true).
Observe que o código digitado anteriormente libera somente as letras (minúsculas/maiúsculas),
conclusão não conseguimos usar o Backspace para apagar um texto digitado errado. Para corrigir o erro
usaremos a tabela ASCII, neste caso o código do Backspace é o número 8.
Linguagem de Programação C#

77


Agora usaremos os mesmos passos para o TextBox do Salário (txtSalario).

Selecione o TextBox do Salário (txtSalario), acione o evento KeyPress e digite o código:
Linguagem de Programação C#

78


Agora vamos efetuar o cálculo do novo salário, lembrando que talvez o usuário pode deixar de
preencher o textbox e clicar em Calcular.


Linguagem de Programação C#

79

Acione o evento CLICK do btnCalcular e escreva o código:

Conclusão: Para corrigirmos o erro conversão quando um textbox está vazio devemos fazer um if
antes da conversão numérica, isto é, a conversão só pode acontecer caso o textbox tenha sido
preenchido.
EXEMPLO 2: Faça um programa que leia somente letras no textbox do nome e somente números
no textbox do salário e calcule o novo salário (40% de reajuste)
1º Passo: Criar um projeto


Linguagem de Programação C#

80




Linguagem de Programação C#

81




Linguagem de Programação C#

82





Linguagem de Programação C#

83



Selecione o frmTelaSalario (No Solution Explorer)
Para travarmos as letras ou os números de um TextBox precisamos usar o evento KEYPRESS.
Este evento é responsável pela captura de cada tecla pressionada no TextBox.
Linguagem de Programação C#

84


Selecione o TextBox do Nome (txtNome), acione o evento KeyPress e digite o código:

Este código é responsável pela verificação letra a letra (digitada) no TextBox. Caso esta letra esteja
entre as letras minúsculas/maiúsculas ele libera a exibição da mesma (e.Handled=false), caso contrário ele
apaga a letra digitada (e.Handled=true).
Observe que o código digitado anteriormente libera somente as letras (minúsculas/maiúsculas),
conclusão não conseguimos usar o Backspace para apagar um texto digitado errado. Para corrigir o erro
usaremos a tabela ASCII, neste caso o código do Backspace é o número 8.
Linguagem de Programação C#

85


Agora usaremos os mesmos passos para o TextBox do Salário (txtSalario).

Selecione o TextBox do Salário (txtSalario), acione o evento KeyPress e digite o código:
Linguagem de Programação C#

86


Agora vamos efetuar o cálculo do novo salário, lembrando que talvez o usuário pode deixar de
preencher o textbox e clicar em Calcular.



Linguagem de Programação C#

87

Acione o evento CLICK do btnCalcular e escreva o código:


Conclusão: Para corrigirmos o erro conversão quando um textbox está vazio devemos fazer um if
antes da conversão numérica, isto é, a conversão só pode acontecer caso o textbox tenha sido
preenchido.
Observação: Acima aprendemos a corrigir o problema de TEXTBOX vazio, mas não podemos
esquecer que nosso usuário poderá digitar um valor alfanumérico (LETRAS) no TEXTBOX e isto irá
acarretar um erro de conversão, pois letras não podem virar números, para este problemas usamos o
evento KeyPress e limitamos os caracteres em cada TEXTBOX.
Será que não existe uma outra maneira de corrigirmos os dois erros ao mesmo tempo, sem usar o
evento KeyPress dos TEXTBOX? Sim, existe é estas solução será explicada agora.


Linguagem de Programação C#

88



Conclusão: Qual seria a diferença efetiva entre os dois códigos? Já que os dois resolvem nossos
problemas. Na realidade os dois códigos podem ser usados sem trazer perdas para seu programa.
A diferença está mesmo entre os comandos IF e o comando TRY, analisando o comando TRY
verificamos que ele funciona como se fosse um if, mas ele trata erros de execução, isto é, caso ocorra
algum problema quando o programa está sendo em uso.

Exercícios
1) Faça um programa em C# que possua as Telas abaixo:
a) Tela Principal:


MainMenu, funcionando, isto é, abrindo a Tela de
Clientes (somente 1 vez) e fechando o programa quando
selecionar Sair.
Linguagem de Programação C#

89

b) Tela Clientes:

- Trocar o nome de todos os objetos da Tela.
- O Botão Sair deve fechar esta tela e voltar para a
tela anterior.
- A tela deve começar com os TextBoxs dos
dependentes bloqueados.
- Quando for selecionado o checkBox 1 deve ser
habilitado o textBox do Dependente 1.
- Quando for selecionado o checkBox 2 deve ser
habilitado o textBox do Dependente 1 e do
Dependente 2.
- Quando for selecionado o checkBox Nenhum deve-se manter todos os textBox’s desabilitados.
- Quando for selecionado um chechBox os outros deverão ser bloqueados
- O botão cadastrar deve somar e exibir a quantidade clientes cadastrados, limpar as seleções,
desbloquear os checkBox’s e bloquear os TextBoxs dos dependentes.

c) Tela Filmes:
- Trocar o nome de todos os objetos da
Tela.
- O Botão Sair deve fechar esta tela e
voltar para a tela anterior.
- A tela deve começar com os TextBoxs
dos nomes dos filmes bloqueados.
- Quando for selecionado o checkBox
DVD deve ser habilitado o textBox do
Nome do Filme em DVD e somar a
quantidade de filme em DVD.
- Quando for selecionado o checkBox
VHS deve ser habilitado o textBox do
Nome do Filme em VHS e somar a
quantidade de filme em VHS.
- Quando for selecionado um chechBox
o outro deverá ser bloqueado.
- O botão cadastrar deve exibir a quantidade filmes cadastrados por tipo DVD e VHS, limpar as seleções,
desbloquear os checkBox’s e bloquear os TextBoxs dos nomes dos filmes.

2) Faça um programa em C# que possua as Telas abaixo:
a) Tela Principal:

MainMenu, funcionando, isto é, abrindo a Tela de
Fornecedores (somente 1 vez) e fechando o programa
quando selecionar Sair.

Linguagem de Programação C#

90

b) Tela Clientes:

- Trocar o nome de todos os objetos da Tela.
- O Botão Sair deve fechar esta tela e voltar para a tela
anterior.
- A tela deve começar com os 3 CheckBox’s bloqueados.
- Quando for selecionado o radioButton SP deve ser
habilitado o checkBox Alimentícia.
- Quando for selecionado o radioButton RG deve ser
habilitado os checkBox’s Higiene Pessoal e Vestuário.
- Quando o checkBox Alimentícia for selecionado deve-se
somar fornecedores para SP.
- Quando o checkBox Higiene Pessoal e/ou Vestuário for
selecionado deve-se somar fornecedores para RG.
- O botão cadastrar deve exibir a quantidade de
fornecedores por estado SP e RG, limpar as seleções e
bloquear dos 3 CheckBox’s.




b) Tela Vendas:

- Trocar o nome de todos os
objetos da Tela.
- O Botão Sair deve fechar esta
tela e voltar para a tela anterior.
- A tela deve começar com os 3
CheckBox’s bloqueados.
- Quando for selecionado o
radioButton Á vista deve ser
habilitado os checkBox’s Banana e
Uva.
- Quando for selecionado o
radioButton Cartão deve ser
habilitado o checkBox Maça.
- Quando o checkBox de cada produto for selecionado deve-se somar a quantidade de cada produto
vendido.
- O botão cadastrar deve exibir a quantidade de produtos vendidos, limpar as seleções e bloquear dos 3
CheckBox’s.


Linguagem de Programação C#

91

3) Desenvolva um programa em C# que cadastre candidatos na empresa de RH – ABCD
Carreiras. O programa deverá ter a tela abaixo:













a. Preencher o ComboBox da Função com os valores PROFESSOR, COORDENADOR, AUXILIAR.
b. Preencher o ComboBox do Estado Civil com os valores CASADO, SOLTEIRO, VIÚVO.
c. O Botão Limpar deve limpar todos os textbox’s, combobox’s e variáveis indicando um novo cadastro.
d. Quando selecionar uma função preencher automaticamente o salário conforme a tabela abaixo:
Função Salário
Professor 1500,00
Coordenador 3000,00
Auxiliar 850,00
e. Trocar a propriedade NAME de todos os objetos.
f. O botão Cadastrar Candidatos deve cadastrar os candidatos no textbox seguindo o padrão:
ABCD Carreiras
José Feliciano – 22 anos
Sexo: Masculino – Casado
Cargo Pretendido: Professor – R$ 1500,00
Gabriela Silva – 18 anos
Sexo: Feminino – Solteira
Cargo Pretendido: Auxiliar – R$ 850,00
Total de Candidatos: 2


Linguagem de Programação C#

92

CAPÍTULO 9 – Programação baseada em Objetos

9.1 Convenções e Padrões de Nomenclatura
As convenções e padrões de nomenclatura auxiliam o desenvolvedor na organização, localização e
manutenção de seus Códigos. Imagine como seria encontrar a seguinte codificação:
Código 29: Exemplo de codificação sem qualquer padrão de nomenclatura
using System ;
class classeparacadastrodeclientes
{
private int j;
private int n;
private string str;
public adicionarcliente ( string s)
{
}
}
Observe a diferença, se utilizarmos algumas regras de nomenclatura:
Código 30: Exemplo de codificação com padrão de nomenclatura
using System ;
class ClasseCadastrodeClientes
{
private int numFilhos ;
private int numBens ;
private string nomeCompleto ;
public adicionarCliente ( string cliente )
{

}
}

Após aplicadas as regras de nomenclaturas, além de saber o que significa cada variável e método,
conseguimos ler sem dificuldade as palavras sem os espaços que as separam.
Para a nomenclatura de classes, como visto no exemplo, deve-se utilizar o seguinte padrão:
Primeiro caractere de cada palavra em caixa alta. Chamada de notação PascalCasing.
Para a nomenclatura de métodos, utiliza-se: Primeira letra de cada palavra em caixa alta, menos da
primeira. Chamada de notação camelCasing.

Linguagem de Programação C#

93

9.1.1 Nomeação de variáveis
Recomendação da Microsoft para nomeação de variáveis:
• Evite usar underline ” ”;
• Não crie variáveis com o mesmo nome mudando somente entre maiúsculas e minúsculas;
• Utilize nomes de variáveis com minúsculas;
• Evite utilizar todas as letras maiúsculas (normalmente utilizado para definir constantes);
• Notação camelCasing.
9.1.2 Nomeação de classes, métodos, propriedades, entre outros.
Recomendações para nomeação de classes, métodos, propriedades, enumeradores, interfaces,
constantes, campos somente leitura e namespace: Notação PascalCasting.

9.2 Classes
Uma classe é um poderoso tipo de dado em C#. Como estrutura, uma classe define os dados e o
comportamento dos tipos de dados.
Uma classe em C# tem a seguinte estrutura:
Código 31: Exemplo de Classe em C#
class NomeDaClasse
{
// Definição dos atributos
private int atrib1 ;
private string atrib2 ;

// Método construtor
public NomeDaClasse (int param1 , string param2 )
{
atrib1 = param1;
atrib2 = param2;
}

// Definição dos métodos
public tipoRetorno MetodoUm ([ lista de parâmetros ])
{
return [ valor ];
}
}

Os atributos definem através de tipos de dados as características que um objeto venha a
apresentar. Em uma classe Carro, por exemplo, poderíamos afirmar que cor, peso e modelo seriam seus
atributos.
O método construtor sempre é chamado quando se cria um novo objeto, ele pode ou não conter
uma assinatura.
Os outros métodos definem através de rotinas as ações que um objeto venha a apresentar, No
exemplo citado acima, uma classe Carro poderia conter os métodos: acelerar, frear e ligar.

Linguagem de Programação C#

94

9.3 Propriedades
As propriedades são recursos fornecidos pelas classes para que seja possível alterar seus valores.
Os recursos get e set comuns às propriedades.
Veja como é possível se definir esses recursos:
Código 32: Exemplo de Propriedades em C#
public tipodedado NomeDaPropriedade
{
get
{
return nomeAtributo ;
}
set
{
nomeAtributo = value ;
}
}

// Utiliza -se da seguinte maneira
this . NomeDaPropriedade = valor ;
valor = this . NomeDaPropriedade ;

9.4 Modificadores de visibilidade
C# apresenta os seguintes modificadores de visibilidades:
1. private: Significa que, exceto a classe incluída, nada pode acessar o objeto, método ou variável;
2. public: Significa que todos têm acesso livre a este membro;
3. protected: Significa que são apenas visíveis para as classes derivadas por meio de herança;
4. internal: todos têm acesso livre a este membro dentro de um assembly (DLL ou EXE;
correspondente ao JAR do Java). Fora do assembly a classe é inacessível.
Atributos internal, são utilizados geralmente para a criação de bibliotecas, já que uma biblioteca
pode ter vários namespaces.
O exemplo a seguir mostra como devemos dispor os modificadores de visibilidade:
Código 33: Exemplo de utilização dos modificadores de visibilidade C#
class NomeDaClasse
{
private int atrib1 ;
public int atrib2 ;
protected int atrib3 ;
internal int atrib4 ;
...
}

Linguagem de Programação C#

95

9.5 Herança
A herança é um recurso utilizado para derivar classes que têm métodos ou atributos em comum.
Sua principal vantagem é o reaproveitamento de Código.
Para ilustrar a utilização do recurso de herança, imagine a seguinte situação:
Em um determinado programa, deve-se implementar as seguintes classes: Fornecedor(id, cpf, rua,
numero, bairro, telefone, email, gerente) e Cliente(id, cpf, rua, numero, bairro, telefone, email,
limiteDeCompras). O programa deve cadastrar essas informações, bem como consulta-las e imprimi-las.
Se o programador optar por utilizar herança, os atributos e métodos em comum:
• Atributos:
– rua;
– número;
– bairro;
– telefone;
– email.
• Métodos:
– cadastrar();
– consultar();
– imprimir().
Poderiam ser escritos em uma ”Pai” chamada Pessoa que derivaria as duas classes filhas
Fornecedor e Cliente.
Em C# todas as classes derivam da classe Object. Sua declaração deve acontecer da seguinte
maneira:
Código 34: Exemplo de declaração de herança em C#
class NomeDaClasse : ClasseBase
{
...
}

9.5.1 This e Base
As cláusulas this e base são referências que indicam a própria classe e a classe base,
respectivamente.
Entende-se como classe base, a classe cuja a classe atual herda as propriedades e atributos. Sua
notação pode ser observada no seguinte exemplo:
Código 35: Exemplo de this e base em C#
this.nomeAtributo = valor ;
valor = this.nomeAtributo ;
this.NomeMetodo ();
base.nomeAtributoClasseBase = valor ;
valor = base.nomeAtributoClasseBase ;
base.NomeMetodoClasseBase ();
Linguagem de Programação C#

96

9.6 Declaração e Chamada de Métodos e Objetos
Para se instanciar um objeto deve-se utilizar a operação new. Essa operação atribui um <objeto>
montado dentro de uma variável do tipo <objeto>.
Utiliza-se a seguinte notação:
Código 36: Exemplo instanciação de objeto em C#
MinhaClasse obj = new MinhaClasse ();
Para acessar seus atributos e métodos utilizamos a instrução ”.”, como pode ser observado no
exemplo a seguir:
Código 37: Exemplo acesso a atributos e métodos em C#
obj. nomeMetodo ();
obj. nomeAtributo = 23;
obj. NomePropriedade = " Apenas um teste" ;
Entretanto como já foi explanado, atributos com modificador de acesso do tipo private não
possibilitam o acesso direto, para isso devemos utilizar as propriedades explanadas na sessão 8.3.

9.7 Métodos e Atributos Static
A operação static define um método ou atributo como pertencentes à classe em questão e não aos
objetos, assim sendo esses atributos ou métodos terão apenas 1 cópia para n objetos que gerarem.
Sua declaração é feita com a palavra static depois do modificador de acesso (public, private) e
antes do tipo de dado (int, string).
O seu acesso é feito pelo nome da classe e não mais pela referência da classe ou pelo nome
do objeto.
Veja no exemplo:
Código 38: Exemplo acesso a atributos e métodos estáticos em C#
NomeDaClasse . atributoEstatico = valor ;
valor = NomeDaClasse . atributoEstatico ;
NomeDaClasse . MetodoEstatico ();

9.8 Const e ReadOnly
São operadores utilizados para a criação de constantes, cujos os valores não poderão ser alterados
durante a execução do programa.
Algumas diferenças entre os operadores:
• const:
– Não pode ser estático (static);
– O valor é setado em tempo de compilação;
– é inicializado somente na compilação.
• readonly:
– Pode ser estático (static);
– O valor é setado em tempo de execução;
– Pode ser inicializado na declaração ou na codificação do construtor.
Linguagem de Programação C#

97

9.9 Classes e Métodos Abstratos
A classe abstrata é um tipo de classe que somente pode ser herdada e não instanciada, de certa
forma pode se dizer que este tipo de classe é uma classe conceitual que pode definir funcionalidades para
que as suas subclasses (classes que herdam desta classe) possam implementa-las de forma não
obrigatória, ou seja ao se definir um conjunto de métodos na classe abstrata não é de total obrigatoriedade
a implementação de todos os métodos em suas subclasses, em uma classe abstrata os métodos
declarados podem ser abstratos ou não, e suas implementações devem ser obrigatórias na subclasse ou
não, quando criamos um método abstrato em uma classe abstrata sua implementação é obrigatória, caso
você não implemente o mesmo o compilador criará um erro em tempo de compilação.
O mesmo se têm com métodos abstratos, não se pode herda-los.
Exemplo de implementação de uma classe abstrata em C#
abstract class formaClasse
{
abstract public int Area ();
}
class quadrado : formaClasse
{
int x, y;
// Se não for implementado o método Area ()
// será gerado um compile - time error .
// Utiliza -se o operador override para indicar a sobrescrita .
public override int Area ()
{
return x * y;
}
}

9.10 Interfaces
As interfaces são fundamentais em um sistema orientado a objetos, quando dizemos que um objeto
é a instancia de uma classe, na verdade queremos dizer, que este objeto implementa a interface definida
pela classe, ou seja uma interface define as operações que um objeto será obrigado a implementar. Para
cada operação declarada por um objeto deve ser especificado o nome da operação, os objetos que esta
operação aceita como parâmetro e o tipo de valor retornado pela operação; este conjunto de informações
sobre uma determinada operação tem o nome de assinatura da operação, e um conjunto de assinaturas
de operações dá-se o nome de interface.
É importante lembrar que uma interface nunca contém implementação, ou seja numa interface não
se pode definir campos, pois o mesmo é uma implementação de um atributo objeto, a interface também
não permite construtores pois num construtor temos as instruções usadas para inicializar campos. Para
podermos usar uma interface devemos criar uma classe ou estrutura e herdar da interface, com isso é
obrigatório implementar todos os métodos da interface.

Linguagem de Programação C#

98

Exemplo de implementação de uma interface em C#
interface IExemploInterface
{
void ExemploMetodo ();
}
class ImplementacaoClasse : IExemploInterface
{
// Implementação explicita da interface
void IExemploInterface . ExemploMetodo ()
{
// Implementação do método
}
static void Main ()
{
// Declarando uma instancia de uma interface
IExemploInterface obj = new ImplementacaoClasse ();
// chama o método.
obj. ExemploMetodo ();
}
}

Note que, para se sobrescrever um método da interface utilizamos <Interface>.<Método>.
A declaração de uma instância de uma interface é feita de forma diferente da declaração de um
objeto normal, aqui temos: Interface <var> = new <ClasseQueImplementaAInterface>();

9.11 Métodos Virtuais
Quando queremos possibilitar a algum método que ele seja sobrescrito, utilizamos o operador
virtual. Os métodos virtuais podem possuir corpo.
Caso um método não seja declarado como virtual ou abstract não será possível a sua sobrescrita.

9.12 Classes e Métodos sealed - Finais
Uma classe selada é utilizada para restringir características da Herança do objeto, quando uma
classe é definida como sealed , está classe não poderá ser herdada, caso você tente o compilador criara
um erro em tempo de compilação, após criar uma classe selada pode se observar que o intelisense
(famoso ctrl + espaço) não mostra o nome da classe definida como sealed quando você tenta criar uma
Herança para novas classes.
Os métodos declarados como sealed também não poderão ser sobrescritos.

Linguagem de Programação C#

99

Exemplo de implementação de uma classe sealed em C#
sealed class ClasseSelada
{
public int x;
public int y;
}
class MainClass
{
static void Main ()
{
ClasseSelada sc = new ClasseSelada ();
sc.x = 110;
sc.y = 150;
Console.WriteLine(" x = {0} , y = {1} " , sc.x, sc.y);
}
}

9.13 Quando devo utilizar o que?
Classes Abstratas podem adicionar mais funcionalidades, sem destruir as funcionalidades das
classes filhos que poderiam estar usando uma versão mais antiga. Elas fornecem uma maneira simples e
fácil para versionar nossos componentes. Através da atualização da classe base, todas as classes que
herdam são atualizadas automaticamente com a mudança.
Em uma interface, a criação de funções adicionais terá um efeito sobre suas classes filhos, devido
à necessidade de implementação dos Métodos criados na interface.
Classes abstratas deveriam ser usadas principalmente para objetos que estão estritamente
relacionados, enquanto o uso de interfaces é mais adequado para fornecer funcionalidade comum a
classes independentes. Digamos que existem duas classes, de pássaros e de aviões, e nas duas existam
os métodos chamados voar(). Seria estranho para uma classe aviões herdar a partir de umas classe
pássaros apenas porque necessita do método voar(). Em vez disso, o método voar() deve ser definido em
uma interface e em ambas as classes pássaros e aviões devem implementar a interface. Se queremos
proporcionar uma funcionalidade em comum para os componentes, devemos utilizar uma classe abstrata.
Classes abstratas nos permite implementar parcialmente uma classe, enquanto a interface não contem a
implementação de qualquer membro. Por isso, a seleção de interface ou classes abstratas depende das
necessidades e design do nosso projeto. Podemos fazer uma classe abstrata, interface, ou até uma
combinação de ambas dependendo de nossas necessidades. Se desejarmos criar uma classe ou método
interno para um componente ou library o ideal é utilizar o tipo sealed porque qualquer tentativa de anular
algumas das suas funcionalidades não será permitida.
Nós podemos marcar uma classe ou método como selados por motivos comerciais, a fim de
impedir um terceiro de modificar nossa classe. Por exemplo, no .NET a string é uma classe selada. Não
devemos usar a palavra-chave sealed com um método a menos que o método seja uma mudança de outro
método, ou se estamos definindo um novo método e não queremos que ninguém mais o sobreponha, não
se deve declará-lo como virtual em primeiro lugar. A palavra-chave selado fornece uma maneira de
garantir que ao sobrepor um método seja fornecido um ”final”significa que ninguém mais poderá sobrepor-
lo novamente.

Linguagem de Programação C#

100

CAPÍTULO 10 – Tratamento de Erros e Exceções
No mundo dos frameworks e linguagens de programação, as exceções, ações que causam
anomalias nas aplicações são tratadas de diversas formas. O .NET Framework elege, pelo poder e pela
flexibilidade, o tratamento de exceções estruturadas. Desta forma o C# também utiliza-se deste modelo
estruturado, uniforme e type-safe.
Quando uma exceção ocorre, um objeto herdado de System.Exception, é criado para representá-la.
O modelo orientado `a objetos permite que seja criada uma exceção definida pelo usuário que é herdada
de System.Exception ou de uma outra classe de exceção pré-definida. As exceções pré-definas mais
comuns são apresentadas na Tabela 9.
As exceções podem ser disparadas de duas formas: através do comando throw, fornecendo a
instância de uma classe herdada de System.Exception, ou em certas circunstâncias durante o
processamento dos comandos e expressões que não podem ser completadas normalmente. Os comando
em C# para utilização do tratamento de exceções estruturados são: try – bloco de proteção do Código,
catch - filtra e trata a exceção, finally - sempre executado após o disparo da exceção ou não, e throw -
dispara uma exceção.

10.1 Comando throw
O comando throw é utilizado para disparar ou sinalizar a ocorrência de uma situação inesperada
durante a execução do programa, ou seja uma exceção. O parâmetro seguido deve ser da classe
System.Exception ou derivada.
Classes de exceções mais comuns em C#
Exceção Descrição (disparado quando)
System.OutOfMemoryException alocação de memória, através de new, falha.
System.StackOverflowException
quando a pilha(stack) está cheia e
sobrecarregada.
System.NullReferenceException
uma referência nula(null) é utilizada
indevidamente.
System.TypeInitializationException um construtor estático dispara uma exceção.
System.InvalidCastException
uma conversão explícita falha em tempo de
execução.
System.ArrayTypeMismatchException o armazenamento dentro de um array falha.
System.IndexOutOfRangeException
o índice do array é menor que zero ou fora do
limite.
System.MulticastNotSupportedException a combinação de dois delegates não nulo falham.
System.ArithmeticException
DivideByZeroException e OverflowException.
Base aritmética.
System.DivideByZeroException ocorre uma divisão por zero.
System.OverflowException
ocorre um overflow numa operação aritmética.
Checked.


Linguagem de Programação C#

101

Código 42: Exemplo de utilização do comando throw
using System ;
class Throws
{
public static void Main ( string [ ] args )
{
// Verifica se somente uma string foi entrada
if(args.Length ==1)
System.Console.WriteLine(args[0]) ;
else
{
ArgumentOutOfRangeException ex;
ex = new ArgumentOutOfRangeException("Utilize uma string
somente" );
throw (ex); // Dispara a exceção
}
}
}

10.2 Bloco try - catch
Uma ou mais instruções catch são colocadas logo abaixo do bloco try para interceptar uma
exceção. Dentro do bloco catch é encontrado o Código de tratamento da exceção. O tratamento da
exceção trabalha de forma hierárquica, ou seja quando uma exceção é disparada, cada catch é verificado
de acordo com a exceção e se a exceção ou derivada dela é encontrada o bloco será executado e os
outros desprezados, por isso, na implementação é muito importante a sequência dos blocos catch. O catch
também pode ser encontrado na sua forma isolada, tratando qualquer exceção não detalhada.
Exemplo de utilização do bloco try - catch
using System ;
class Catchs
{
public static void Main ()
{
int iMax =0;
Console.Write("Entre um inteiro para valor máximo, entre 0 e o máximo
será sorteado:");
try
{
iMax = Console . ReadLine (). ToInt32 ();
Random r = new Random (); // Instância a classe Random
int iRand = r. Next (1, iMax ); // Sorteia randomicamente entre
0 e máximo
Console.Write("O valor sorteado entre 1e {1} é {0}", iRand
,iMax);
}
catch ( ArgumentException )
{
Console.WriteLine("0 não é um valor válido");
}
catch ( Exception e)
{
Console . WriteLine (e);
}
}}

10.3 Bloco try - finally
A instrução finally garante a execução de seu bloco, independente da exceção ocorrer no bloco.
Tradicionalmente o bloco finally é utilizado para liberação de recursos consumidos, por exemplo fechar um
arquivo ou uma conexão.
Linguagem de Programação C#

102

Exemplo de utilização do bloco try - finally
using System ;
class TryFinally
{
public static void Main ()
{
try
{
throw new Exception("A exceção...");
// Dispara a exceção
}
finally
{
Console.WriteLine("O bloco finally é sempre executado" );
}
Console.WriteLine("Esta linha não será executada...");
}
}
Se não tratada, o comportamento de qualquer exceção é de terminação, como podemos concluir no
exemplo acima. Lembrando que, o tratamento de uma exceção, ou sua interceptação, é feita no bloco
catch.

10.4 Bloco try - catch - finally
Os comandos try, catch e finally podem ser utilizados em conjunto, como no exemplo:
Código 45: Exemplo de utilização do bloco try - catch - finally
using System ;
using System . Xml;
class TryCatchFinally
{
public static void Main ()
{
XmlDocument doc = null ;
try
{
doc = new XmlDocument ();
doc . LoadXml("<Exception> The Exception </Exception> " );
// Carrega o conteúdo
throw new Exception(doc.InnerText ); // Dispara a exceção
}
catch ( OutOfMemoryException )
{
// Tratamento aqui
}
catch ( NullReferenceException )
{
// Tratamento aqui
}
catch ( Exception e)
{
// Tratamento aqui
Console.WriteLine("Excessão ocorrida no programa" , e);
}
finally
{
Console. WriteLine (@"Gravando o Documento no C:\" );
// Uso do verbatim (@)
doc. Save (@"c:\exception.xml");
// Grava o conteúdo
}
Console.WriteLine("Esta linha não será executada...");
}
}
Linguagem de Programação C#

103

10.5 A classe Exception
A forma mais comum e generalizada de disparo de uma exceção é através da classe base
Exception. Ela fornece as informações necessárias para tratamento das exceções, possuindo alguns
membros, métodos e propriedades, que trazem as informações necessárias decorrentes do erro.
Normalmente uma instância de classe, ou derivada, é utilizada através de um bloco catch, como vimos nos
exemplos anteriores.
Vamos descrever alguns membros da classe Exception:
• Message: retorna uma string com o texto da mensagem de erro.
• Source: possui ou define a uma string com o texto da origem (aplicação ou objeto) do erro.
• HelpLink: possui uma string com o link(URN ou URL) para arquivo de ajuda.
• StackTrace: possui uma string com a sequência de chamadas na stack.
• InnerException: retorna uma referência para uma exceção interna.
• TargetSite: retorna o método que disparou esta exceção.
• GetBaseException: retorna uma referência para uma exceção interna.
• SetHelpLink: define o link(URN ou URL) para arquivo de ajuda.
Membros da classe Exception
catch ( System . Exception e)
{
System.Console.WriteLine(e.Message );
}

catch (System.Exception e)
{
System.Console.WriteLine(e.Source );
}

catch (System.Exception e)
{
System.Console.WriteLine(e.HelpLink );
}

catch ( System.Exception e)
{
System.Console.WriteLine(e.StackTrace );
}

throw e.InnerException ;

System.Reflection.MethodBase mb = e. TargetSite ;
if(mb.IsStatic )
Console.Write("Membro que disparou a exceção é static" );

throw e. GetBaseException ();

e. SetHelpLink ("http://www.microsoft.com/brasil/msdn");

Linguagem de Programação C#

104

CAPÍTULO 11 - Funções Matemáticas
Disponível no pacote System.Math
Abs – valor absoluto de um número
Acos – ângulo a partir de um determinado cosseno
Asin - ângulo a partir de um determinado seno
Atan - ângulo a partir de uma determinada tangente
Atan2 - ângulo a partir do quociente de 2 números espeficicados
Ceiling – menor número inteiro maior ou igual a um dado número
Cos – cosseno de um ângulo especificado
Cosh – cosseno hiperbólico de um ângulo especificado
Exp – número determinado elevado ao expoente especificado
Floor – maior inteiro menor ou igual ao número especificado
Log – logaritmo de um número especificado
Log10 – logaritmo de base 10 de um número especificado
Max – maior de 2 números especificados
Min – menor de 2 números especificados
Pow – número especificado elevado pelo expoente especificado
Round – número mais próximo do valor especificado
Sign – valor indicando o sinal de um número
Sin - seno de um ângulo específico
Sinh – seno hiperbólico de um ângulo específico
Sqrt – raiz quadrada de um número especificado
Tan – tangente de um ângulo especificado
Tanh – tangente hiperbólica de um ângulo especificado

11.1 Funções para manipular Strings no C#
O tipo string apesar de se comportar como um value type é na verdade um reference type. Apesar
disso, devemos considerar que estamos trabalhando com um value type quando estamos manipulando
strings, tendo em vista que este tipo de dado foi programado para funcionar como tal.
A classe string possui uma série de métodos estáticos e não estáticos, que são utilizamos para
formatação, concatenação, desmembramento, substring, etc. Vamos analisar alguns destes métodos da
classe string.

O método Substring
O método substring é um método não estático que permite pegarmos uma porção de uma string.
Para utilizarmos o método substring, basta chamar o método a partir de uma variável string ou mesmo de
uma string literal, conforme o exemplo.
string nome = "Testando da Silva";
string sobreNome = nome.Substring(12,5);
Linguagem de Programação C#

105

O método substring aceita como parâmetro a posição inicial que queremos obter e quantos
caracteres devem ser extraídos. Caso não seja informado o número de caracteres a ser extraído, a função
retornará o restante da string a partir da posição inicial informada.

O método IndexOf
O método IndexOf é utilizado para localizar uma determinada palavra dentro da string. Este método
retornará a posição da string desejada. Caso a string não seja encontrada, será retornado o valor -1.
string nome = "Testando da Silva";
int pos = nome.IndexOf("Silva");
//A partir do índice 5
int pos2 = nome.IndexOf("Silva", 5);

Conforme vimos no exemplo, é possível informar a posição inicial para busca como um parâmetro
adicional.

Funções ToUpper e ToLower
As funções ToUpper e ToLower permitem colocar uma string em letra minúsculas ou maiúsculas,
conforme o exemplo a seguir.
string nome = "Maurício";
nome = nome.ToUpper();
nome = nome.ToLower();

Funções StartsWith e EndsWith
As funções startswith e endswith verificam se a string começo ou termina com uma determinada
palavra ou caracter. Estas funções retornam um valor booleano (true ou false).
string arquivo = "comctl32.dll";
if(nome.StartsWith("com"))
Console.WriteLine("Começa com COM!");
if(nome.EndsWith(".dll"))
Console.WriteLine("É uma dll!");

Funções TrimStart, TrimEnd e Trim
As funções de Trim servem para remover espaços em branco das strings. A função TrimStart
remove os espaços em branco do início da string, já a função TrimEnd remove os espaços em branco do
final da string. A função Trim remove os espaços em branco do inicio e do fim da string.
string nome = " MAURICIO ";
nome = nome.TrimEnd();
nome = nome.TrimStart();
nome = nome.Trim();

Funções PadLeft e PadRight
As funções PadLeft e PadRight servem para preencher uma string a esquerda ou a direita com um
caracter especificado. Os exemplos a seguir mostra o uso das funções PadLeft e PadRight.
Linguagem de Programação C#

106


string nome = "Mauricio";
nome = nome.PadRight(10, ' ');
// "Mauricio "
string codigo = "123";
codigo = codigo.PadLeft(6, '0');
// "000123"

Funções String.Join e String.Split
A função Split serve para quebrar uma string em um array de strings de acordo com um separador.
Ao contrário da função split, a função Join concatena um array de string inserindo um separador.
string linha = "Teste, 10, 20, 10/06/2007";
string[] campos = linha.Split(',');
string linhaNova = String.Join(';', campos);

A Função String.Format
A função String.Format é uma das funções mais versáteis da classe string. Esta função permite a
criação de uma string baseada em um padrão. Podemos colocar dentro do padrão da string de formatação
alguns tokens que poderam ser substituídos por variáveis passadas por parâmetro no comando format.
string teste = String.Format("Vou colocar o {0} aqui.", "parâmetro");

No exemplo acima, o padrão da string (primeiro parâmetro) contém um token {0}. Este token indica
que este valor deve ser substituido pelo segundo parâmetro passado para a função (neste caso a palavra
“parâmetro”).
sTeste = String.Format("Formatação de string com {0} parâmetro. ",
"Agora são {1}. Valor numérico: {2}", 1, Now(), 15.5);

No exemplo acima, temos o padrão da string com mais de um token, com números de 0 à 2. A
função também recebe 3 parâmetros adicionais que correspondem aos valores que serão substi tuídos na
string. Além de informarmos os tokens, podemos informar regras de formatação que serão utilizadas de
acordo com o tipo de dado passado por parâmetro, conforme o exemplo,
sTeste = String.Format("Custom Format: {0:d/M/yyy HH:mm:ss}", dtHoje);
sTeste = String.Format("Formatação do número inteiro: {0:D}.", iNumero);
sTeste = String.Format("Formatação do número inteiro: {0:D4}.", iNumero);

A classe StringBuilder
Apesar da versatilidade da classe string, operações com string podem consumir muitos recursos e
causar perda de desempenho. Isto ocorre porque a cada operação o framework cria um novo buffer para a
string resultante da operação, ao invés de aproveitar o buffer que está sendo utilizado. Isto é mais
aparente em operações de concatenação.
Para não criar este tipo de problema, podemos utilizar a classe StringBuilder, do namespace
System.Text. Esta classe permite a criação de strings aproveitando o buffer utilizado, o que torna o código
mais eficiente.
Linguagem de Programação C#

107

No exemplo a seguir temos um trecho de código com uma operação feita de forma ineficiente e
outra mais eficiente usando o stringBuilder, veja a diferença.
// Codigo ineficiente
string sql;
sql = "SELECT * FROM Products";
sql += " WHERE CategoryId=1 AND";
sql += " AND UnitPrice>10";

// Codigo Eficiente
StringBuilder sb = new StringBuilder();

sb.Append("SELECT * FROM Products");
sb.Append(" WHERE CategoryId=1 AND");
sb.Append(" AND UnitPrice>10");
sql = sb.ToString();

LastIndexOf
Informa a posição de índice da última ocorrência de um caractere Unicode especificado ou String
dentro dessa instância.
Remove
Exclui um número especificado de caracteres de uma String
Replace
Substitui todas as ocorrências de um caractere ou de uma String, por outro caractere ou por outra
String.
ToString
Converte um valor numero em uma String.
Copy
Cria uma cópia de uma String com o mesmo valor String.
Equals
Determina se dois valores do tipo String são iguais.


Linguagem de Programação C#

108

Capítulo 12 - Funções para Manipulação de Arquivos
Com a manipulação de arquivos, podemos criar, editar e excluir arquivos ou diretórios. Para que
possamos trabalhar com as classes referente a manipulação de arquivos devemos utilizar o pacote:
System.IO (IO Input/Output significa Entrada/Saída).
As principais classes que estão nesse pacote:

12.1 Classes DirectoryInfo e FileInfo
É possível recuperar algumas informações de arquivos e diretórios, como data de criação,
extensão, entre outros. Para isso utiliza-se em C# as classes DirectoryInfo e FileInfo.
Utiliza-se DirectoryInfo quando se deseja informações sobre um diretório, e FileInfo para
informações de um arquivo.
Principais classes do System.IO
Classe Uso
Directory, File, DirectoryInfo, e FileInfo
Cria, exclui e move arquivos e diretórios. Ainda
retorna informações específicas sobre arquivos ou
diretórios
FileStream
Usado para escrever/ler informações em arquivo
com ajuda das classes StreamReader e Stream-
Writer
StreamWriter e StreamReader Lê e escreve um informação textual
StringReader e StringWriter
Lê e escreve um informação textual a partir de um
buffer de string
A seguir estão listadas algumas propriedades e métodos que essas classes oferecem:
Propriedades e métodos de DirectoryInfo e FileInfo
Propriedade/Método Uso
Attributes Retorna os atributos associados aos arquivos
CreationTime Retorna a hora de criação do arquivo
Exists Checa se o arquivo/diretório existe
Extension Retorna a extensão do arquivo
LastAccessTime Retorna a hora do último acesso
FullName Retorna o nome completo do arquivo/diretório
LastWriteTime
Retorna a hora da ultima escrita no
arquivo/diretório
Name Retorna o nome do arquivo/diretório
Delete() Exclui o arquivo/diretório

Linguagem de Programação C#

109

12.1.1 Criando diretórios e subdiretórios
Para criar um diretório utiliza-se a seguinte notação:
Criação de diretório
DirectoryInfo dir1 = new DirectoryInfo (@"F:\WINNT");
Para criar um subdiretório:
Código 48: Criação de subdiretórios
DirectoryInfo dir = new DirectoryInfo(@"F:\WINNT");
try
{
dir.CreateSubdirectory("Sub");
dir.CreateSubdirectory(@"Sub\MySub");
}
catch ( IOException e)
{
Console.WriteLine(e.Message);
}

12.1.2 Acessando as propriedades
Para acessar as propriedades de um diretório utiliza-se a seguinte notação:
Código 49: Propriedades de um diretório
Console.WriteLine("Full Name is:{0}",dir1.FullName);
Console.WriteLine("Attributes are:{0}",dir1.Attributes.ToString());
Abaixo um exemplo de acesso `as propriedades de arquivos:
Código 50: Propriedades de arquivos
DirectoryInfo dir = new DirectoryInfo(@"F:\WINNT");
FileInfo [ ] bmpfiles = dir.GetFiles("*.bmp");
Console.WriteLine("Total number of bmp files" , bmpfiles.Length);
Foreach(FileInfo f in bmpfiles )
{
Console.WriteLine("Name is : {0}" , f.Name);
Console.WriteLine("Length of the file is : {0}" , f.Length);
Console.WriteLine("Creation time is : {0} " , f.CreationTime);
Console.WriteLine("Attributes of the file are : {0} " ,
f.Attributes.ToString());
}


Linguagem de Programação C#

110

12.2 Criando arquivos usando a classe FileInfo
Com a classe FileInfo, é possível criar novos arquivos, acessar suas informações, excluí-los e
move-los. Essa classe também oferece métodos para abrir, ler e escrever um arquivo. O seguinte exemplo
mostra como é possível criar um arquivo texto e acessar suas informações.
Código 51: Criando arquivos com a classe FileInfo
FileInfo fi = new FileInfo(@"C:\Myprogram.txt" );
FileStream fstr = fi.Create();
Console.WriteLine("Creation Time: {0} " ,fi.CreationTime );
Console.WriteLine("Full Name: {0}" ,fi.FullName );
Console.WriteLine("File Attributes : {0} " ,fi.Attributes.ToString());
//Way to delete Myprogram .txt file .
Console.WriteLine("Press any key to delete the file" );
Console.Read();
fstr.Close();
fi.Delete();

12.2.1 Entendendo o método Open()
Com o método Open(), disponível na classe FileInfo, é possível abrir um arquivo. Deve-se passar
no construtor, o modo de abertura e acesso ao arquivo.
O seguinte exemplo ilustra essa situação:
Código 52: Abrindo arquivos com a classe FileInfo
FileInfo f = new FileInfo("c:\myfile.txt");
FileStream s = f.Open(FileMode.OpenorWrite, FileAccess.Read);

12.2.2 Entendendo a classe FileStream
Ao abrir ou criar nossos arquivos, o atribuímos para a classe FileStream. Ela pode escrever ou ler
arquivos, com a ajuda das classes StreamWriter e StreamReader. O exemplo a seguir ilustra como isso é
possível:
Código 53: Escrevendo/Lendo com FileStream
FileStream fs = new FileStream (@"c:\mcb.txt", FileMode.OpenOrCreate,
FileAccess.Write);
StreamWriter sw = new StreamWriter (fs);
sw.write("teste");
sw.writeLine("teste");
sw.Close();
FileStream fs = new FileStream(@"c:\mcb.txt",FileMode.OpenOrCreate,
FileAccess.Write );
StreamReader sr = new StreamReader (fs);
string texto ;
texto = sr.ReadToEnd();
sr.Close();
Linguagem de Programação C#

111

12.2.3 Métodos CreateText() e OpenText()
O método CreateText() retorna um StreamWriter que vai escrever um arquivo. O método
OpenText() retorna um StreamReader que vai ler um arquivo. Esses métodos são utilizados quando
trabalha-se com arquivos de texto puro. Exemplos de utilização dos métodos:
Código 54: CreateText e OpenText
FileInfo fi = new FileInfo("c:\myfile.txt");
StreamReader txtR ;
txtR = fi.OpenText();
string read = null ;
while(( read = txtR.ReadLine()) != null )
{
Console.WriteLine(read);
}
s.Close();
// Método ReadToEnd ();
Console.WriteLine(txtR.ReadToEnd());
FileInfo fi = new FileInfo("c:\myfile.txt");
StreamWriter txtW ;
txtW = fi.CreateText();
txtW.Write("teste");
txtW.Close ();


Linguagem de Programação C#

112

CAPÍTULO 13 – Aprofundando Windows Forms
Um programa dificilmente é desenvolvido com apenas um formulário (Form). Sempre temos vários
deles nos nossos programas, vamos estudar neste capitulo como trabalhar com vários formulários. Além
disso, vamos estudar as propriedades mais importantes dos formulários.
Basicamente podemos ter os seguintes tipos de interface Windows:
• MDI (Multiple Document Interface): Aplicação que suporta múltiplos documentos abertos
simultaneamente, como o Word por exemplo.
• SDI (Single Document Interface): Aplicação que permite a abertura de apenas um documento
de cada vez. Exemplo: O Paint do Windows, a calculadora, o Internet Explorer.
• Janelas modais. Exemplo: As janelas informativas conhecidas como diálogos.

13.1 Aplicações MDI
As aplicações MDI têm como objetivo criar várias instâncias (filhos) dentro de uma aplicação
principal (pai). Por esse motivo temos que seguir alguns passos para configurar esse ambiente. Para
definir uma janela como principal (janela pai) altera-se a propriedade isMdiContainer = true ainda em
tempo de compilação.

13.1.1 Adicionando uma nova janela filha
Para adicionar uma nova janela filha, devemos inserir um novo formulário ao projeto: menu File/Add
> New Item, selecione Windows Forms.
Ao instanciarmos uma nova janela filha utilizamos a seguinte codificação:
Código 55: Janela filha (MDI)
wndFilha myWnd = new wndFilha( );
myWnd.MdiParent = this;
myWnd.Text = " Janela Filha";
myWnd.Show ();
O que se fez aqui?
• Criamos uma nova instância do formulário que constitui a nossa janela filha;
• Em seguida, definimos o pai da janela filha ajustando a propriedade MdiParent do formul ário como
sendo o formulário principal. Por essa razão, atribuímos a essa propriedade o valor this, indicando que a
janela pai é o objeto correspondente ao formulário principal.
• Finalmente mostramos a janela filha chamando o método Show().

Linguagem de Programação C#

113

3.1.2 Fechando uma janela filha
Para fechar uma janela filha MDI ativa utiliza-se a seguinte notação:
Código 56: Fechar janela filha (MDI)
if ( this . MdiChildren . Length != 0)
this . ActiveMdiChild . Close ( );

13.2 Aplicações SDI
Sempre que você cria uma Windows Application um formulário já é criado por padrão, ele é
conhecido como formulário Base.
Para adicionar um novo formulário no seu programa você:
1. Na janela Solution Explorer, clique com o botão direito no nome do projeto, selecione Add e
clique em Windows Form;
2. Digite um nome para o novo formulário e clique em Add.

13.2.1 Exemplo múltiplos formulários
Vamos fazer um exemplo que ilustra como podemos trabalhar com múltiplos formulário:
1. Crie uma Windows Application chamada Formulários;
2. Arraste 2 buttons para o Form1;
3. Mude as propriedades Text dos Buttons 1 e 2 para Vermelho e Verde respectivamente;
4. Adicione mais dois formulários no projeto;
5. Mude o nome do Form2 para frmVermelho e do Form3 para frmVerde. Para isso clique sobre o
nome do Form no Solution Explorer e clique em Rename;
• Se a uma mensagem de confirmação aparecer, clique em Sim. Isso vai atualizar todas as
referencias ao form do projeto para o novo nome.
6. Mude a propriedade BackColor do frmVermelho para a cor Vermelha;
7. Mude a propriedade BackColor do frmVerde para Verde;
8. No Form1 de um clique duplo sobre o botão Vermelho e digite o seguinte Código dentro do
procedimento do evento click:
Código 57: Código para exibir formulário
frmVermelho Vermelho = new frmVermelho();
Vermelho.Show();
9. Faça o mesmo para o botão Verde mas digite o seguinte Código:
Código 58: Código para exibir formulário com show dialog
frmVerde Verde = new frmVerde();
Verde.ShowDialog ();
10. Execute a aplicação.
Note que para a chamada de um formulário é necessário que o mesmo seja instanciado.
Com o formulário Vermelho aberto, perceba que você pode clicar novamente no Form1 e depois
voltar para o Vermelho e assim por diante, o que não acontece com o formulário Verde.
Isso porque usamos o método ShowDialog ao invés do método Show.
Linguagem de Programação C#

114

13.3 Passando valores entre Forms
Continuando com o exemplo anterior, vamos alterar um componente de um formulário, em outro:
1. Adicione 1 button e 1 label no formulário frmVermelho;
2. Vá para o painel de Código do frmVermelho e dentro da classe frmVermelho digite o seguinte Código:
Código 59: Variável pública do tipo string
public string mensagem ;
Isso cria uma variável publica do tipo string chamada Mensagem.
3. Vá para o Form1 e de um clique duplo sobre o botão Vermelho.
4. Adicione o seguinte Código:
Código 60: Modificando o valor da string
Vermelho.mensagem = "Formulario Form1" ;
5. Volte para o frmVermelho, de um clique duplo sobre o button1 e digite o seguinte Código no
procedimento:
Código 61: Modificando o valor da label para um string local
label1.Text = mensagem;
Isso adiciona o conteúdo da variável mensagem no Label1.
6. Execute a aplicação.
O conteúdo da variável foi exibida no label1. O mais importante desta lição é que você agora é
capaz de passar valores entre formulários.

13.4 Posicionando os formulários na tela
Por questões de estética, temos a possibilidade de alterar algumas propriedades dos componentes
para que eles se tornem mais apresentáveis. O posicionamento de formulário na tela ilustra uma dessas
possibilidades. Vamos estudar algumas modificações na propriedade StartPosition.
• CenterScreen: Essa propriedade faz com que o formulário em questão seja exibido no centro da
tela;
• Manual: Deve-se especificar manualmente como os valores que serão usados para posicionar o
formulário na tela.
– A propriedade location faz o posicionamento x, y do formulário na tela. Se alterarmos a
propriedade para (100, 50), o formulário será exibido a 100 pixels da lateral esquerda e 50 pixels do topo
da tela.
A propriedade WindowsState altera o estado inicial do meu formulário principal:
• Normal: Abre o formulário em seu estado inicial;
• Minimized: Abre o formulário minimizado na barra de tarefas;
• Maximized: Abre o formulário maximizado.

13.5 Controlando os eventos dos formulários
Os eventos são ações atribuídas ao comportamento do formulário. Sempre que um evento ocorre
um bloco de Código pode ser processado, esse bloco de Código é conhecido como Manipulador de
Evento.
O .NET Framework usa uma nomeação padrão para os Manipuladores de Eventos. Essa
nomeação combina o nome do objeto com o evento correspondente ligando-os por um underline, exemplo:
button1 Click; form1 Load.
Linguagem de Programação C#

115

CAPÍTULO 14 – Conexão com Banco de Dados

14.1 O que é o ADO.NET ?
O ADO.NET é uma nova tecnologia baseada no ADO (Active Data Objects), com muito mais
recursos. O ADO.NET possui um modelo para manipulação de dados completamente diferente da versão
anterior do ADO, simplificando o processo de conexão e manipulação de dados.
A arquitetura do ADO.NET foi criada para trabalhar com um ambiente desconectado, ou seja,
buscamos as informações do banco de dados e trazemos para a memória da aplicação. A manipulação
dos dados é feita toda em memória e posteriormente enviada ao banco de dados.
Por trabalhar de uma forma voltada ao modelo desconectado, o ADO.NET possui uma camada de
persistência em XML. é possível gravar e ler todo o conteúdo de todo um conjunto de armazenado nas
estruturas do ADO.NET em XML.
O ADO.NET faz parte do .NET Framework, e é composto por um conjunto de classes, interfaces,
tipos e enumerações.

14.2 Os namespaces relacionados ao ADO.NET
Para trabalharmos com o ADO.NET em uma aplicação .NET, é necessário utilizarmos algumas das
namespaces disponíveis nas bibliotecas do .NET Framework. Alguns dos principais namespace são:
• System.Data: Contém a infra-estrutura básica para trabalharmos com qualquer base de dados
relacional. Neste namespace encontramos as classes responsáveis por armazenar as estruturas dos
bancos relacionais em memória;
• System.Data.Common: Contém as interfaces comuns a todos os bancos de dados. Este
namespace é utilizado internamente pelo framework e por fabricantes de bancos de dados, para a
construção de bibliotecas de acesso;
• System.Data.SqlClient: Biblioteca de acesso ao SQL Server. Permite a conexão, a extração e a
execução de comandos em servidores SQL Server de versão 7 ou superior;
• System.Data.OleDb: Biblioteca de acesso para bancos de dados que suportam OleDb. Permite
conexão, a extração e a execução de comandos nestes bancos de dados. é necessário informar o
provedor OleDb a ser utilizado. Permite acesso a bancos mais simples, como o Access;
• System.Data.SqlTypes: Contém a definição dos tipos nativos do SQL Server;
• System.XML: Contém as classes para manipulação de documentos XML. Como o ADO.NET
possui uma camada de persistência em XML, este namespace é amplamente utilizado.

14.3 O modelo de execução do ADO.NET
O ADO.NET provê uma estrutura de acesso a dados que permite o acesso a múltiplas bases de
dados simultaneamente. é possível armazenar duas tabelas de diferentes bancos de dados (SQL Server e
Access por exemplo) em uma mesma estrutura de dados (DataSet).
A estrutura responsável pelo armazenamento dos dados é o DataSet, que contém um conjunto de
objetos (DataTables) que representam resultados tabulares extraídos da base de dados.
Linguagem de Programação C#

116


Esquema acesso ao banco de dados
Para fazer a extração dos dados, o ADO.NET utiliza os chamados ”.NET Data Providers”.
Os Data Providers são bibliotecas de classes especializadas para o acesso a um tipo de banco de
dados relacional. Por serem uma implementação específica para o banco de dados, estas possuem um
acesso bem mais eficiente do que outras bibliotecas como a OleDb.
Segue uma lista de data providers disponíveis para os bancos citados:
• Firebird .NET Data Provider;
• MySQL .NET Data Provider;
• Npgsql .NET Data Provider;
Apesar de serem uma implementação específica para um tipo de banco de dados, as classes dos
Data Providers possuem uma estrutura comum.

14.4 O modelo de execução em um ambiente conectado
O ADO.NET é capaz de trabalhar com dois modelos, o modelo conectado e o modelo
desconectado.
No modelo conectado é necessário manter a conexão aberta enquanto são realizadas as
operações de leitura e gravação.
Para trabalharmos em um modelo conectado, devemos observar alguns objetos disponíveis nas
classes dos .NET Data Providers, que devem ser utilizados na seguinte ordem:
• XxxConnection: é o objeto utilizado para estabelecer a conexão com o banco. é necessário
informar os parâmetros de conexão e abrir a conexão com o banco. Exemplos dessa classe são
SqlConnection e OleDbConnection;
• XxxCommand: é um objeto utilizado para enviar comandos a base de dados. é necessário montar
a cláusula Sql desejada e informar ao objeto de comando. Ao executar o comando, este pode devolver um
objeto do tipo XxxDataReader;
• XxxDataReader: é um objeto utilizado para ler dados de um comando executado. O método Read
lê os dados de registro em registro. Após a leitura completa dos dados é necessário fechar o DataReader e
a conexão;


Linguagem de Programação C#

117

14.5 O modelo de execução em um ambiente desconectado
O modelo de execução em um ambiente desconectado utiliza outros objetos. Neste modelo
utilizamos o objeto DataSet para armazenar e manipular os dados em memória e o objeto XxxDataAdapter
para extrair e enviar as alterações ao banco de dados. O objeto de conexão também é utilizado neste
modelo.
Os passos para extração e manipulação dos dados em um ambiente desconectado são:
1. é aberta uma conexão utilizando um objeto XxxConnection (OleDbConnection ou Sql-
Connection por exemplo);
2. é criado um objeto do tipo XxxDataAdapter que é responsável por fazer a extração de dados do
banco de dados para a memória e o posterior envio dos dados da memória para o banco de dados;
3. Utilizando o método Fill, extraímos os dados da base de dados e armazenamos em um DataSet.
Neste momento fechamos a conexão com o banco pois os dados já estão na memória da aplicação para
serem manipulados;
4. Como os dados estão em memória, é possível inserir, remover ou alterar registros do DataSet;
5. Ao finalizar as alterações, restabelecemos a conexão com o banco de dados para enviar as
alterações;
6. Utilizando o método Update do DataAdapter, enviamos as alterações para o banco de dados. O
DataAdapter verifica os tipos de alterações que foram realizadas e executa o comando correspondente no
banco de dados (inserção, exclusão, atualização);
7. Ao finalizar o processo, fechamos a conexão com o banco de dados.

14.6 Estabelecendo uma conexão com um banco de dados
O primeiro passo para criarmos uma aplicação com conexão a um banco de dados é estabelecer a
conexão com o banco. Para estabelecermos a conexão, devemos criar um objeto de conexão.
Ao criarmos uma instância da classe que irá se conectar, devemos informar uma string de conexão,
que contém todos os parâmetros para a conexão com o banco de dados, como usuário e senha.
A string de conexão possui uma série de parâmetros, que pode variar de acordo com o banco de
dados utilizado. Os parâmetros da string de conexão são separados por ponto e vírgula, e devem ser
informados com a seguinte Notação:
Código 62: Padrão para Connection Strings
"Nome do Parâmetro = Valor do Parâmetro"
Abaixo está uma classe com string de conexão para os bancos MySQL, Firebird e Post-GreSQL:
Código 63: Padrão para Connection Strings
class Global
{
public static string cnmysql = "database=dados; datasource=lo
calhost; userid = root; password = <password>";
public static string cnfirebird = "User=SYSDBA;
Password=masterke;Database=C:\\dados.fdb;DataSource=localhost;Dialect=3;Charset
=WIN1252;Role=;Connectionlifetime=15;Pooling=true;MinPoolSize=0;MaxPoolSize=50;
PacketSize=4096;ServerType=0";
public static string cnpostgree =
"UserID=postgres;Password=password;Host=localhost;Port=5432;Database=dados;Pool
ing=true;MinPoolSize=0;MaxPoolSize=100;ConnectionLifetime=0";
}
Linguagem de Programação C#

118

14.7 Criando comandos
É possível executar comando no banco de dados através da classe SqlCommand. Ao criar um
objeto dessa classe, devemos informar o comando Sql a ser executado, bem como a conexão a ser
utilizada. Estes parâmetros podem ser informados tanto no construtor da classe SqlCommand como
também através das propriedades CommandText e Connection.
Os comandos SQL informados em um objeto de comando podem ser de qualquer tipo: que
retornam um conjunto de linha, que retornam um valor específico, ou que não retornam nenhuma quer.
Cada um destes tipos de comando SQL possui um método para execução.
Através da classe SqlCommand também é possível executar Stored Procedures do banco de
dados, sendo necessário apenas informar o nome da stored procedure no parâmetro Command- Text, e
setar a propriedade CommandType da classe para CommandTypes.StoredProcedure. Um exemplo de
criação de um objeto de comando pode ser observado a seguir.
Código 64: Exemplo de utilização do comando SqlCommand
SqlCommand oCmd = New SqlCommand ("UPDATE Products SETU nit Price = Unit
Price*1.1");
oCmd.Connection = oConn ;
oCmd.CommandText = "UPDATE Products SET Unit Price=Unit Price * 1.05";

14.8 Executando comandos
Para executarmos os comandos especificados na classe SqlCommand, precisamos executar um
dos métodos de execução disponíveis. Os métodos de execução variam de acordo com a natureza do
comando executado. Os três métodos mais comuns são:
• ExecuteNonQuery: Para comandos que não executam consultas (querys);
• ExecuteScalar : Para comandos que executam resultados escalares;
• ExecuteReader: Para comandos que retornam conjuntos de dados.

14.8.1 O método ExecuteNonQuery
O método ExecuteNonQuery é utilizado quando queremos executar um comando que não retorna
como resultado um conjunto de dados. Este método é utilizado para comandos de atualização e inserção e
também para comando DCL (Data Control Language) suportados pelo banco de dados.
Opcionalmente podemos informar um parâmetro para este método para obter o número de linhas
afetadas pelo comando executado.
Um exemplo de utilização do comando ExecuteNonQuery pode ser observado a seguir.
Código 65: Exemplo de utilização do comando ExecuteNonQuery
SqlCommand oCmd = new SqlCommand("UPDATE Products SET Unit Price = Unit
Price * 1.1");
oCmd.Connection = oConn ;
oCmd.CommandText = "UPDATE Products SET Unit Price = Unit Price * 1.05";
oCmd.ExecuteNonQuery();

14.8.2 O método ExecuteScalar
O método ExecuteScalar é utilizado para comandos que retornam valores escalares, ou seja,
valores únicos. Em geral é utilizado para comandos que retornam uma contagem de registros ou que
executam ao comando de agregação no banco de dados.
Linguagem de Programação C#

119

Este comando pode retornar qualquer tipo de dado. Um exemplo de utilização do comando
ExecuteScalar pode ser observado a seguir.
Código 66: Exemplo de utilização do comando ExecuteScalar
SqlCommand oCmd = new SqlCommand("UPDATE Products SETU nit Price = Unit
Price * 1.1");
oCmd.Connection = oConn ;
oCmd.CommandText = "SELECT COUNT(*) FROM Products";
int iNumProdutos ;
iNumProdutos = oCmd.ExecuteScalar();

14.8.3 O método ExecuteReader
O método ExecuteReader é utilizado para executar querys que retornam um conjunto de dados.
Este método tem como resultado um objeto do tipo SqlDataReader.
A classe SqlDataReader representa um cursor aberto no banco de dados com os dados retornados
pela query informada no objeto de comando.
Para lermos os dados de um DataReader, é necessário executamos o método Read. Este método
retorna verdadeiro caso um registro tenha sido lido do cursor do banco de dados, e falso quando não
houver mais registros a serem lidos. é necessário chamar o método Read pelo menos uma vez, pois o
cursor aberto não fica posicionado no primeiro registro.
Como o DataReader mantém um cursor aberto com o banco de dados, não é possível realizar
nenhuma operação no banco de dados (utilizando a conexão utilizada pelo DataReader) enquanto o
DataReader estiver aberto. Por tanto, é necessário fechar o DataReader imediatamente após a sua
utilização.
Um exemplo de utilização do método ExecuteReader e da classe DataReader pode ser observado
a seguir.
Código 67: Exemplo de utilização do comando ExecuteReader
SqlCommand oCmd=new SqlCommand ("SELECT ProductName,ProductId FROM Products"
,oConn);
SqlDataReader oDr;
oDr = oCmd.ExecuteReader ();
while (oDr.Read ())
{
Debug.WriteLine ( oDr("Product Name").ToString());
}

14.9 Passando parâmetros
É possível passar parâmetros para os objetos da classe SqlCommand. Para indicarmos parâmetros
nas querys informadas neste objeto, utilizamos o símbolo @ como prefixo para indicar um parâmetro. Esta
sintaxe pode variar de acordo com o banco de dados utilizado (o Oracle utiliza ”:”por exemplo).
Depois de indicar os parâmetros na query, é preciso adicionar objetos do tipo SqlParameter na
coleção de parâmetros do SqlCommand. A coleção de parâmetros pode ser acessada através da
propriedade Parameters do objeto de comando.

Linguagem de Programação C#

120

Um exemplo de criação de parâmetros pode ser observado a seguir.
Código 68: Exemplo de utilização de parâmetros
SqlConnection oConn = new SqlConnection ( sConnString );
SqlCommand oCmd = new SqlCommand ();
oCmd.Connection = oConn ;
oCmd.CommandText = "UPDATE Products" + "SETUnitPrice = @UnitPrice" +
"WHERE ProductId = @ProductId";
SqlParameter oParam = new SqlParameter("@UnitPrice", 1.5);
oCmd.Parameters.Add(oParam);
oParam = new SqlParameter ();
oParam.ParameterName = "@ProductId";
oParam.DbType = DbType.Int32 ;
oParam.Value = 1;
oCmd.Parameters.Add(oParam );
oCmd.ExecuteNonQuery();

14.10 O que é um DataSet?
O DataSet é uma classe capaz de armazenar múltiplos resultados tabulares em uma mesma
estrutura. O DataSet é composto por estruturas chamadas DataTables que representam estes resultados
tabulares.
Para extrairmos dados da base de dados e preenchermos o DataSet utilizamos a classe
DataAdapter. Esta classe é capaz de executar os quatro comandos básicos de um banco de dados (Insert,
Update, Delete, Select) sendo capaz de executar estas operações sobre os dados do DataSet.

14.11 O que é um DataAdapter?
O DataAdapter é a classe responsável por fazer a interação entre a base de dados e o DataSet.
Ela possui quatro propriedades que representam os quatro comandos principais que utilizamos
para interagir com o banco de dados.
Para realizar a extração de dados do banco de dados para o DataSet, o DataAdapter usa o
comando de select, contido na propriedade SelectCommand.
Após extrairmos os dados para o DataSet, podemos modificar estes dados (que estão
armazenados em memória). `A medida que modificamos os dados do DataSet, este faz uma marcação nas
alterações que fazemos, marcando as linhas inseridas como inseridas, modificadas como modificados e
excluídos como excluídos. Quando concluímos as alterações, é possível chamar o DataAdapter
novamente para que ele execute para cada linha modificada o comando correspondente a modificação
realizada.

14.12 Criando um DataSet e um DataAdapter
Quando criamos um DataAdapter é possível informar uma query e uma conexão para a extração
dos dados. O SqlCommand referente `a propriedade SelectCommand é criado automaticamente.
Os outros comandos devem ser criados manualmente.
Um exemplo de criação de um objeto DataAdapter pode ser observado a seguir.
Linguagem de Programação C#

121

Código 69: Criando um DataSet e um DataAdapter
SqlDataAdapter daProduct = new SqlDataAdapter("SELECT * FROM Products" ,
oConn );
SqlDataAdapter daOrders = new SqlDataAdapter ();
SqlCommand oCmd = new SqlCommand("SELECT * FROM Orders " , oConn);
daOrders.SelectCommand = new SqlCommand(oCmd );

14.13 Criando e preenchendo um DataSet
Para criar um novo DataSet basta utilizar o comando New e criar um novo objeto. Para preencher
um dataset utilizando um DataAdapter, devemos utilizar o método Fill do DataAdapter, informando o
DataSet e nome da tabela a ser criada no DataSet.
Um exemplo de criação de um DataSet e utilização de um DataAdapter podem ser observados a
seguir.
Código 70: Criando e preenchendo um DataSet
SqlDataAdapter daProduct = new SqlDataAdapter("SELECT * FROM Products",
oConn);
DataSet ds = new DataSet();
daProduct.Fill(ds ,"Products");

Linguagem de Programação C#

122

CAPÍTULO 15 – Operações CRUD com Entity Framework
Operações CRUD (Create, Read, Update e Delete) são as operações de inserir, alterar, excluir e
consultar dados em um banco de dados.
Para tanto, utilizarei um exemplo bem simples para proporcionar facilidade no entendimento do
framework, utilizando banco de dados SQL Server.
Crie um projeto em Visual Stúdio 2008, salve-o no local dejado e com o nome que preferir.
Clique no menu Arquivo > Novo Projeto. Escolha o nome e o local que pretende salvar seu projeto.

Crie um banco de dados e nele uma tabela, conforme código abaixo:
CREATE DATABASE CRUDC;
USE CRUDC;
CREATE TABLE PRODUTO
(
COD INT NOT NULL IDENTITY (1, 1) PRIMARY KEY,
NOME VARCHAR (50) NOT NULL,
VALOR MONEY NOT NULL CHECK (VALOR > 0)
);

Agora vamos criar o Modelo de Dados de Entidade para gerar o modelo de entidades mapeando os
campos da tabela para entidades que serão tratadas pelo Entity Framework.
Clique com o botão direito no nome de sua aplicação, escolha a opção Adicionar > Novo Item.
Em “Categorias”, escolha a opção “Dados” e na área de “Modelos” a opção “Modelo de Dados de
Entidade ADO .NET”.
Linguagem de Programação C#

123


Seguindo o assistente selecione a opção “Gerar a partir do banco de dados” na próxima janela e
clique “Avançar”.
Selecione a seguir a conexão com o banco de dados CRUDC que foi criado no SQL Server e clique
em “Próximo”.

Linguagem de Programação C#

124

Na próxima janela selecione a tabela “Produto” e clique em “Concluir”;

Ao final teremos o modelo de entidades sendo representado pela entidade Produtos mapeada para
a tabela Produtos do nosso o banco de dados;

Linguagem de Programação C#

125

Após esse procedimento já é possível criar as operações de manipulação dos dados no banco de
dados. Agora, vamos definir os seguintes controles no formulário “form1.cs”:
Label
lblCodigo
lblProduto
lblValor
TextBox
txtCodigo
txtProduto
txtValor
DataGridView
dtgProdutos
Button
cmdInserir
cmdAlterar
cmdExcluir

Conforme mostrado abaixo:

Vamos agora definir as operações CRUD.
Leitura de Dados
Vamos criar aqui um método para fazer a leitura dos dados e preenchê-los no objeto DataGridView.
private void lerProdutos()
{
CRUDCEntities contexto = new CRUDCEntities();
IEnumerable<PRODUTO> lista = from p in contexto.PRODUTO select p;
dtgProdutos.DataSource = lista.ToList();
}
O código cria uma instância do ObjectContext que foi criado no Entity Data Model e com ele temos
acesso as entidades e aos recursos do Entity Framework.
Linguagem de Programação C#

126

A seguir efetuamos uma consulta usando uma expressão LINQ para selecionar no contexto todos
os produtos mapeados para a entidade Produto. O retorno é do tipo IEnumerable <Produto>, a seguir
exibimos o resultado no controle DataGridView.
A interface IEnumerable expõe o enumerador que oferece suporte a iteração sobre a coleção do
tipo especificado que no caso é a entidade Produto.
Executando o projeto iremos obter o formulário exibindo os dados da tabela produtos no controle
DataGridView: dtgProdutos.

Inserindo Dados
Agora vamos inserir os dados digitados na tela pelo usuário no banco de dados. Este código
deverá ficar no botão “cmdInserir”.
private void cmdInserir_Click(object sender, EventArgs e)
{
CRUDCEntities contexto = new CRUDCEntities();
PRODUTO produto = new PRODUTO();
produto.NOME = txtProduto.Text.ToUpper();
produto.VALOR=Decimal.Parse(txtValor.Text.Substring(2,txtValor.Text.Length));
contexto.AddToPRODUTO(produto);
contexto.SaveChanges();
lerProdutos();
}
Para criar um novo produto, após criar a instância do Contexto, definimos uma nova entidade
Produto atribuindo os valores informados no formulário para o nome do produto e para o código da
categoria:
Depois usamos o método AddToProduto para incluir o novo objeto Produto na coleção de objetos:
contexto.AddToProdutos (produto);
Na linha de código contexto.AddToProduto (produto) o método AddTo<EntityName>, que é usado
pelo Entity Framework baseado nas entidades geradas a partir do banco de dados realizará a inclusão do
novo objeto no contexto.
O código do produto é auto-incremental e controlado pelo gerenciado do banco de dados visto que
definimos o campo como identity.
Para persistir as informações usamos o método SaveChanges().

Alterando Dados
Agora vamos alterar os dados digitados na tela pelo usuário no banco de dados. Este código
deverá ficar no botão “cmdAlterar”
private void cmdAlterar_Click(object sender, EventArgs e)
{
CRUDCEntities contexto = new CRUDCEntities();
int cod = Int32.Parse(txtCodigo.Text);
PRODUTO produto = contexto.PRODUTO.First(p => p.COD == cod);
produto.NOME = txtProduto.Text.ToUpper();
produto.VALOR = decimal.Parse(txtValor.Text);
contexto.SaveChanges();
lerProdutos();
limpaCampos();
}
Após criar o contexto obtemos o código do produto informado na caixa de texto do formulário.
A seguir usamos uma expressão lambda para retornar o produto desejado e realizarmos as
alterações com base nas informações do formulário. Nesta consulta LINQ estamos usando o operador
First que retorna o primeiro elemento da sequencia que satisfaz o critério definido na expressão lambda.
Linguagem de Programação C#

127

Apagando Dados
Agora vamos excluir os dados digitados na tela pelo usuário no banco de dados. Este código
deverá ficar no botão “cmdExcluir”.
private void cmdExcluir_Click(object sender, EventArgs e)
{
CRUDCEntities contexto = new CRUDCEntities();
int cod = Int32.Parse(txtCodigo.Text);
PRODUTO produto = contexto.PRODUTO.First(p => p.COD == cod);
contexto.DeleteObject(produto);
contexto.SaveChanges();
lerProdutos();
limpaCampos();
}

Após criar o contexto obtemos o código do produto informado na caixa de texto do formulário.
A seguir usamos uma expressão lambda para retornar o produto a excluir.
Depois chamamos o método DeleteObject() do contexto do objeto e passamos o objeto produto e
chamamos o método SaveChanges para persistir as mudanças.
Agora vamos definir uma funcionalidade muito prática no projeto: Permitir que quando o usuário
clicar no DataGridView o conteúdo da linha selecionada seja exibida nos controles TextBox do formulário;
Para fazer isso vamos usar o evento CellContentClick do controle DataGridView e nele inserir o
código abaixo:

private void dtgProdutos_CellContentClick(object sender,
DataGridViewCellEventArgs e)
{
txtCodigo.Text = dtgProdutos.CurrentRow.Cells[0].Value.ToString();
txtProduto.Text = dtgProdutos.CurrentRow.Cells[1].Value.ToString();
txtValor.Text = dtgProdutos.CurrentRow.Cells[2].Value.ToString();
}

Linguagem de Programação C#

128

CAPÍTULO 16 - Conexão C# com o MYSQL
Quem está habituado a programar C# normalmente utiliza SQL Server como banco de dados, uma
vez que ela está integrada no Visual Studio e, por isso mesmo, existe grande facilidade em trabalhar com
as duas ferramentas.
Por vezes existem projetos em que se torna conveniente (por várias razões) utilizar outro tipo de
base de dados. Seja que banco de dados for, a sua integração é sempre diferente do SQL Server.
Neste caso, mostraremos como fazer a integração entre o C# e o MySQL.
Supondo que já existe uma instalação do MySQL na máquina, precisamos instalar um componente
intermediário entre o C# e a base de dados. Neste caso necessitamos instalar o MySQL Connector NET.
Download no link http://dev.mysql.com/downloads/connector/net/6.0.html
A partir da versão 5.0 já existe suporte ao Visual Studio 2008, mas vamos utilizar a última versão
(6.0).
Instale o Connector Net 6.0.
Devemos já ter uma base de dados com uma tabela (users por exemplo), em que os campos da
tabela são: id, nome, email.
Como exemplo criamos um projecto Windows Forms Application.
Antes de mais nada, devemos fazer uma referência à classe que vai ligar o C# ao MySQL. Para
isso vamos ao painel Solution Explorer, na raiz do projeto, clicamos com o lado direito do mouse e
selecionamos Add Reference.

Na primeira divisória (.NET) selecionamos a referência MySQL.Data e damos OK.
Não esquecer: incluir no início do código as classes:
using System.Data;
using MySql.Data.MySqlClient;

Linguagem de Programação C#

129

Sem adicionar a referência à MySQL.Data, a classe MySql.Data.MySqlClient não será reconhecida.
Para exemplificar fazemos um formulário de inserção de dados (nome e e-mail) na base de dados.
No form colocamos duas caixas de texto, uma para o nome (txtNome) e outra para o e-mail (txtMail)
e um botão que terá a ação de inserir os dados na base de dados.

Vamos então definir, em primeiro lugar, o dataset e a string de conexão à base de dados.
private MySqlConnection bdConn; //MySQL
private MySqlDataAdapter bdAdapter;
private DataSet bdDataSet; //MySQL
Na ação do botão:
//Definição do dataset
bdDataSet = new DataSet();
//Define string de conexão
bdConn = new
MySqlConnection("PersistSecurityInfo=False;server=localhost;database=Aula;uid=root;pwd=
''");

Neste caso a base de dados não tem password.
//Abre conecção
try
{
bdConn.Open();
//Se estiver aberta insere os dados na BD
MySqlCommand commS = new MySqlCommand("INSERT INTO Agenda (Nome, Email, Fone)
VALUES('"+txtNome.Text + "','" + txtMail.Text + "','"+txtFone.Text+"')", bdConn);
commS.BeginExecuteNonQuery();
}
catch
{
MessageBox.Show("Impossível estabelecer conexão");
}
Linguagem de Programação C#

130

Exemplo de Consulta:
Como exemplo criamos um projecto Windows Forms Application.
Antes de mais nada, devemos fazer uma referência à classe que vai ligar o C# ao MySQL. Para
isso vamos ao painel Solution Explorer, na raiz do projeto, clicamos com o lado direito do mouse e
selecionamos Add Reference.

Na primeira divisória (.NET) selecionamos a referência MySQL.Data e damos OK.
Não esquecer: incluir no início do código as classes:
using System.Data;
using MySql.Data.MySqlClient;

Sem adicionar a referência à MySQL.Data, a classe MySql.Data.MySqlClient não será reconhecida.
Vamos então definir, em primeiro lugar, o dataset e a string de conexão à base de dados.
private MySqlConnection mConn; //MySQL
private MySqlDataAdapter mAdapter;
private DataSet mDataSet; //MySQL


Linguagem de Programação C#

131

Adicionar o DataGridView no formulário. Na ação do botão:
mDataSet = new DataSet();
mConn = new
MySqlConnection("PersistSecurityInfo=False;server=localhost;database=Aula;uid=root;pwd=
''");
try
{
mConn.Open();
mAdapter = new MySqlDataAdapter("Select * from Agenda",mConn);
mAdapter.Fill(mDataSet,"Agenda");
dataGridView1.DataSource = mDataSet;
dataGridView1.DataMember = "Agenda";
}
catch
{
MessageBox.Show("Impossível estabelecer conexão");
}

Figura 1 - Exemplo de Conexão
16.1 Inserção de dados em MySQL
Demonstraremos como efetuar ligações entre o C# e bases de dados para inserir dados numa base
de dados MySQL. Apesar de a ligação C# – MySQL não ser a mais utilizada, visto que o C# é uma
linguagem mais orientada para o ambiente Windows, e o MySQL orientado para a Web, veremos que não
existe nenhum “segredo”, e é até bastante simples a inserção de dados.
Antes de começar a ler este tutorial, é muito importante que tenha compreendido o capítulo anterior
relacionado com este tema (C# – Conexão a Base de Dados MySQL), visto que os primeiros passos são
iguais.
Primeiro criamos uma base de dados no phpMyAdmin. Neste caso criei a base de dados com o
nome pplware_bd.
Esta base de dados, terá uma tabela com o nome tabela_dados, com três campos:
- id (INT (5), AUTO_INCREMENT, Chave Primária)
- titulo (VARCHAR(25))
- descricao (VARCHAR(100))
Linguagem de Programação C#

132

Para que seja possível inserir dados numa base de dados MySQL em C#, é necessário adicionar a
referência MySql.Data. Para isso é necessário efetuar o download do mysql-connector-net-6.X.X. Depois é
só executar o setup. (No fim é necessário reiniciar o Visual Studio).
Para adicionar uma referência:
- Clicar com o botão direito em Referência e fazer “Add Reference”.

- Selecionar na lista MySQL.Data no separador .NET

- Como a referência já está adicionada, temos de a inserir no código.
using MySql.Data.MySqlClient;
Agora vamos ao código
1º – Temos de adicionar um MySqlConnection, MySqlDataAdapter e um DataSet.
private MySqlConnection mConn;
private MySqlDataAdapter mAdapter;
private DataSet mDataSet;
O MySqlConnection, MySqlDataAdapter e o DataSet, são necessários para a conexão e leitura
da base de dados.

Linguagem de Programação C#

133

2º – Criar o “layout” da mini aplicação.

3º – Código do botão “Gravar”
private void bt_Gravar_Click(object sender, EventArgs e)
{
// Início da Conexão com indicação de qual o servidor, nome de base de dados e
utilizar

/* É aconselhável criar um utilizador com password. Para acrescentar a password
é somente
necessário acrescentar o seguinte código a seguir ao uid=root;password=xxxxx*/

mConn = new MySqlConnection("Persist Security Info=False;
server=localhost;database=pplware_bd;uid=root");

// Abre a conexão
mConn.Open();

//Query SQL
MySqlCommand command = new MySqlCommand("INSERT INTO tabela_dados
(titulo,descricao)"+
"VALUES('" + tb_titulo.Text + "','" + tb_descricao.Text + "')", mConn);
//Executa a Query SQL
command.ExecuteNonQuery();
// Fecha a conexão
mConn.Close();
//Mensagem de Sucesso
MessageBox.Show("Gravado com
Sucesso!","Informação",MessageBoxButtons.OK,MessageBoxIcon.Information);
// Método criado para que quando o registo é gravado, automaticamente a
dataGridView efectue um "Refresh"
mostraResultados();
}
Linguagem de Programação C#

134

4º – Código do método de visualização de dados
private void mostraResultados()
{
mDataSet = new DataSet();
mConn = new MySqlConnection("Persist Security Info=False;
server=localhost;database=pplware_bd;uid=root");
mConn.Open();
//cria um adapter utilizando a instrução SQL para aceder à tabela
mAdapter = new MySqlDataAdapter("SELECT * FROM tabela_dados ORDER BY id", mConn);
//preenche o dataset através do adapter
mAdapter.Fill(mDataSet, "tabela_dados");
//atribui o resultado à propriedade DataSource da dataGridView
dataGridView1.DataSource = mDataSet;
dataGridView1.DataMember = "tabela_dados";
}
Este método será “chamado” no botão Visualizar, como exemplificado na imagem abaixo.
private void bt_visualizar_Click(object sender, EventArgs e)
{
mostraResultados();
}
E o resultado será:

Linguagem de Programação C#

135



Linguagem de Programação C#

136

CAPÍTULO 17 - Gerando um Executável a partir de um Windows
Forms
Neste capítulo mostraremos como é simples e rápido gerar um executável de sua aplicação
Windows Forms, para depois gravar num CD ou copiar para um Pendrive, e executá-lo no cliente, na
casa de um amigo, disponibilizar na internet,e etc.
Neste exemplo usaremos um projeto feito em laboratório, o Cálculo de Média.
Então, com o projeto aberto abra a Solution Explorer (CTRL + W + S), clique com o botão direito
em cima do seu projeto e clique em Publish para que seja aberto o Wizard do Visual Studio.

Na tela que abre, clique em Browse e selecione uma pasta em que será gerado o instalador ou crie
uma se for necessário. Após isso, clique em Next.

Linguagem de Programação C#

137

Agora o Wizard irá perguntar como os usuários instalarão sua aplicação, deixe selecionada a
terceira opção: From a CD-ROM ou DVD-ROM e clique em Next.

Na próxima tela o Wizard irá perguntar se a aplicação irá procurar por atualizações. Deixe
selecionada a segunda opção: The application will not check for updates e clique em Next.

Linguagem de Programação C#

138

Será exibida uma tela avisando que quando o executável for instalado na máquina do cliente, será
gerado um atalho no menu Iniciar e a opção de Desinstalar o Aplicativo no Adicionar/Remover
Programas, do Painel de Controle.
Clique em Finish e aguarde o Wizard gerar seu instalador.

Quando terminar, será mostrada abaixo no canto esquerdo a mensagem Publish Suceeded.

Se seu browser abrir tentando carregar o executável e der erro, ignore.
Agora vá na pasta em que foi gerado o executável e dê dois cliques no arquivo Setup.exe. Na tela
que aparece, clique em Install:


Linguagem de Programação C#

139

Seu programa deverá ser executado:

Simples, não é? Note que se você for ao menu Iniciar e em Todos os programas verá que foi
criado um atalho para seu programa:

Da mesma forma se você for ao Painel de Controle, clicar em Adicionar ou remover programas,
verá que tem uma opção para desinstalar o aplicativo:

Pronto, só gravar em um CD ou mesmo passar pro Pendrive o Setup.exe e distribuir pros amigos
ou mesmo instalar no cliente!
Referências
SANTOS, Luis Carlos. Microsoft Visual C# Express Edition 2008. Editora Érica. 1ª edição. 2009.
MORONI, Herbert. Treinamento Profissional em C#.net. Digerati Books. 2006.