Escolar Documentos
Profissional Documentos
Cultura Documentos
PROGRAMANDO COM C# E VISUAL STUDIO - NET 2005 (I6-Full) PDF
PROGRAMANDO COM C# E VISUAL STUDIO - NET 2005 (I6-Full) PDF
NET 2005
por Júlio Battisti. No Mercado Livre, somente o usuário GROZA é que tem
Ao adquirir este ebook você tem o direito de lê-lo na tela do seu computador e de
cópia ou qualquer outro meio de reprodução, para outras pessoas. Se você recebeu
este ebook através do e-mail ou via ftp de algum site da Internet, ou através de
um CD de Revista, saiba que você está com uma cópia pirata, ilegal, não
Lei 5988. Se for este o caso entre em contato com o autor, através do e-mail
cópia você irá remunerar, mediante uma pequena quantia, o trabalho do autor e
sobre novos cursos que gostaria de ver disponibilizados, entre em contato pelo e-
mail: webmaster@juliobattisti.com.br.
novidades:
• Cursos de informática.
NÃO AUTORIZADA
PREVISTA DE CADEIA
Para que você possa acompanhar as lições deste curso é necessário que você já
Explorer.
Palavras do autor:
linguagem C# e a ferramenta Visual Studio .NET 2005. Para tanto, não exite em
curso, envie-me também suas sugestões para que possamos sempre melhorar o
moroni@weblitenet.com.br.
Ao final deste curso você vai dominar a linguagem de programação C# e vai saber
como tirar proveito dos principais recursos do Visual Studio .NET 2005,
Índice do Curso
Índice do Curso............................................................................................ 7
Introdução ................................................................................................ 10
Módulo 1.............................................................................................................................................13
.NET.................................................................................................................................................34
Módulo 2.............................................................................................................................................56
Variáveis.............................................................................................................................................56
Módulo 3.............................................................................................................................................81
Módulo 4...........................................................................................................................................107
Módulo 5...........................................................................................................................................129
Módulo 6...........................................................................................................................................144
Módulo 7...........................................................................................................................................183
Lição 32 – Coleções.................................................................................................................197
Módulo 8...........................................................................................................................................205
Módulo 9...........................................................................................................................................221
Módulo 10 ........................................................................................................................................238
Lição 40– Usando o Visual Studio 2005 para manipular dados de um banco de
dados. ...........................................................................................................................................245
Módulo 11 ........................................................................................................................................260
Imprimindo......................................................................................................................................260
Módulo 12 ........................................................................................................................................274
Introdução
O C#, junto com o Visual Studio .NET 2005 compõe uma ferramenta extremamente
robusta e fácil de utilizar, com perfeito suporte a todas as novas ondas que rondam
para a plataforma .NET. Com uma interface amigável e integrada com os ambientes
sofisticadas com todos os recursos existentes, sem ter que ficar criando parte de
Studio .NET 2005, vai aprender a criar aplicações Windows e a utilizar o CSC para
compilar seu programa pelo prompt de comando. Vai aprender também como gerar
programas.
Capítulo 2: Neste capítulo você vai aprender sobre variáveis, tipos de dados,
Common Type System, além disso vai receber dicas sobre como nomear suas
variáveis.
Capitulo 3: Neste capitulo você vai entender o que são métodos e escopo. Vai
Capítulo 4: Neste capítulo você vai aprender sobre estruturas de DECISÃO, vai
Capítulo 5: Neste capítulo você vai aprender sobre estruturas de REPETIÇÃO, vai
Capítulo 6: Neste capítulo você vai aprender como encontrar erros utilizando o
Visual Studio .NET, vai também aprender a usar o Try..Catch..Finally para tratar
Capítulo 7: Neste capítulo você vai aprender a criar e manipular dados de Arrays e
Coleções.
Capítulo 8: Neste capítulo você vai aprender a usar múltiplos formulários no seu
programa, passar valor entre eles, posicioná-los na tela e controlar seus eventos.
Capítulo 9: Neste capítulo você vai aprender a usar os controles disponíveis para
Capítulo 10: Neste capítulo você vai aprender os conceitos principais de banco de
Capítulo 11: Neste capítulo você vai aprender a imprimir informações de seus
e visualizar impressão.
Capítulo 12: Neste capítulo você vai aprender como distribuir suas aplicações
criando um instalador.
Para enviar suas dúvidas referentes aos assuntos e exemplos abordados neste
para criticar e para elogiar (porque não?), é só entrar em contato pelo e-mail:
moroni@weblitenet.com.br.
Módulo 1
desenvolvimento do Visual Studio .NET 2005. Para isso vai criar uma sua primeira
aplicação.
2005
A imagem anterior mostra o Visual Studio .NET assim que o iniciamos, é exibida a
pagina Start Page onde podemos abrir rapidamente os ultimos projetos criados
A caixa de dialogo New Project aparece. Ela permite que criemos um novo
Perceba que você pode ainda alterar o caminho onde sua aplicação será
6 – Clique em OK.
A barra de menus (menu bar) possibilita o acesso aos comandos que você usa
Windows.
disponibiliza botões que executam os comandos usados com mais freqüência. Não
A janela Solution Explorer mostra os nomes dos arquivos associados com o seu
projeto. Você pode dar um clique duplo sobre o nome do arquivo para exibi-lo no
painel de código (Code pane). Vamos examinar os arquivos que o Visual Studio
extensão .csproj.
esse arquivo para adicionar atributos ao seu programa, como por exemplo,
nome do autor, data que o programa foi escrito e outros. Vamos examina-lo
Aos poucos nós vamos explorando mais o Visual Studio, vamos ao nosso primeiro
exemplo.
método chamado Main. Todos os métodos precisam ser definidos dentro de uma
classe. O método Main é especial porque ele é o primeiro a ser executado quando
o programa é iniciado, por isso ele precisa ser designado como static (estático),
diferente de main.
Nosso primeiro exemplo é bem simples, e um clássico para quem esta aprendendo
entradas do teclado. Tudo que o usuário digita no teclado pode ser lido através da
seguinte imagem:
Quando o IntelliSense aparece você também pode pressionar W para ir direto para
10 – Abra parênteses (
teclado.
12 – Digite entre os parênteses a string “Hello World”, string deve ficar entre
de entrar com seus respectivos conteúdos. Assim você evitará alguns erros por
esquecer de fechar.
Solution. Se tudo estiver certinho vai aparecer a seguinte linha na janela Output:
Para exibir a janela Output na barra de menus clique em View, Output ou pressione
Ctrl+W+O.
foram salvas. Você pode salvar manualmente antes de compilar a aplicação, mas
Nós escolhemos Start Without Debugging para forçar uma pausa no final da
de comando logo após a execução, seria tão rápido que não conseguiríamos ver o
correspondem a pastas com seus respectivos nomes. Essas pastas são criadas
bin.
Como vimos até agora, o Visual Studio compilou automaticamente nosso programa
using System;
namespace txtHello
class Class1
Console.WriteLine("Hello World");
Para isso será necessário escolher Todos os arquivos na opção Salvar como tipo no
4 – Feche o notepad.
Ele vai listar os arquivos da pasta, no caso vai mostrar o arquivo teste.cs.
Agora você não vê apenas o arquivo teste.cs, foi adicionado um arquivo chamado
nome do arquivo fonte. Será criado então o arquivo teste.exe, execute este
Studio .NET.
namespace txtHello
class Class1
Console.WriteLine("Hello World");
prompt para se familiarizar melhor com ele, já que não falaremos muito mais
teste.cs(7,4): error CS0246: The type or namespace name 'Console' could not be
System.Console.WriteLine("Hello World");
Como parte do Microsoft .NET Framework o C# pode fazer uso de uma série de
classes de utilidades que executam uma gama de operações úteis. Essas classes
contém as classes que a maior parte das aplicações utiliza para interagir com o
sistema operacional.
no prompt de comando.
manutenção.
Programas pequenos e crianças pequenas têm uma coisa obvia em comum, eles
sua manutenção.
bloco de código. Você pode fazer referencia a vários namespaces no seu arquivo
Até agora por motivo didático usamos somente o prompt de comando para criar os
nossos exemplos. Como sabemos esse tipo de aplicação não é muito útil nos dias
de hoje. O Visual Studio .NET conta com diversos recursos importantes para o
chamado WinHello.
Design.
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 ele na barra de
canto superior esquerdo. A segunda opção coloca o controle no local onde você
clicar.
Para voltar ao modo design, também na janela Solution Explorer clique em View
Design.
Form1.cs tem todo o código gerado automaticamente pelo Visual Studio .NET.
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
namespace WinHello
...
iniciado.
...
public Form1()
...
código, use a janela Properties no modo Design. Vamos aprender mais sobre
this.SuspendLayout();
//
// label1
//
this.label1.AutoSize = true;
this.label1.Name = "label1";
this.label1.TabIndex = 0;
this.label1.Text = "label1";
//
// button1
//
this.button1.Name = "button1";
this.button1.TabIndex = 1;
this.button1.Text = "button1";
this.button1.UseVisualStyleBackColor = true;
//
// textBox1
//
this.textBox1.Name = "textBox1";
this.textBox1.TabIndex = 2;
//
// Form1
//
13F);
this.AutoScaleMode =
System.Windows.Forms.AutoScaleMode.Font;
this.Controls.Add(this.textBox1);
this.Controls.Add(this.button1);
this.Controls.Add(this.label1);
this.Name = "Form1";
this.Text = "Form1";
this.ResumeLayout(false);
this.PerformLayout();
}...
Para voltar ao modo design, também na janela Solution Explorer clique em View
Design.
Properties Window.
Assim você pode saber se elas estão com seu valor padrão ou não.
redimensionar o formulário.
Isso serve para os outros controles também, clique sobre os outros controles e note
os marcadores.
Note que ele vai diretamente para o painel de código e é criado automaticamente o
seguinte código.
Tudo que for digitado dentro deste código será executado assim que o Button1 for
Tenha atenção com esse código, ele deve ser digitado exatamente como se segue,
final da linha.
16 – Execute o programa.
Para executar o programa você pode clicar e F5, ou no menu Debug clicar em
Start Debugging.
cometários
Documentacao.
BemVindos, não pode haver espaços entre as palavras quando se nomeia uma
classe.
/// <summary>
/// <remarks>
/// </remarks>
/// </summary>
4 – Dentro do método Main digite o código que escreve “Hello World” no prompt
BemVindos.cs
Se você for verificar o nome do arquivo pelo Explorer do Windows verá que o nome
Mudao o nome da classe não muda o nome do arquivo, é uma boa pratica sempre
Você vai visualizar o código XML com os comentários que inserimos no código no
Internet Explorer.
Existe uma variedade enorme de tags XML que podem ser usadas na documentação
O comentário XML é sempre adicionado após barras triplas, ou seja, uma barra a
/// <remarks>
/// </remarks>
Abaixo segue uma lista das tags XML mais usadas. Lembre-se que com XML você
TAG PROPÓSITO
tag <remarks>
membro da biblioteca.
código da aplicação.
da descrição.
método.
retornado de um método.
Existe uma maneira mais fácil de gerar sua documentação XML, usando o Visual
Seu arquivo de documentação é gerado. Você pode alterar o nome do arquivo que
será gerado na caixa de texto que segue a opção XML documentation file, pode
alterar também o caminho do local onde o arquivo será gerado. Por padrão ele tem
Você pode agora ir clicar em Show All Files na janela Solution Explorer e
navegar até o local onde o arquivo XML foi criado para visualizá-lo.
Módulo 2
Variáveis
plataforma .NET.
Isso não acontece com o .NET, esse acessa seus recursos do .NET Framework. O
Você vai entender melhor os benefícios do .NET Framework durante o curso. Como
• Tratamento de erros
• Segurança
• Depuração
• Controle de versão
Estes benefícios estão disponíveis em qualquer linguagem criada para a CLR. Isto
quer dizer que a CLR pode servir a uma variedade de linguagens e pode oferecer
Quando você declara uma variável no C# você precisa determinar qual tipo de dado
será armazenado nela. O tipo de dado vai dizer quais valores são possíveis de se
gerenciamento dos tipos é o CTS ou common type system que faz parte do CLR.
plataforma e ter total integração entre elas, além disso, ele é responsável por
dados.
A referencia aos dados de uma variável pode ser feita de duas maneiras:
A principal diferença entre os dois tipos é que quando você faz referencia a uma
Value-Type
structures.
Reference-Type
objeto.
Vamos aprender agora como declarar variáveis, seus principais tipos e como
• Não crie variáveis que apenas se diferenciem apenas pela sua forma.
• Quando o nome tiver mais que uma palavra, a primeira letra de cada
camelCase);
Convenção PascalCasing
void InitializeData();
leitura e namespaces.
Convenção camelCasing
Para usar esse tipo de convenção, capitalize a primeira letra de cada palavra menos
int loopCountMax;
campos e parâmetros.
A linguagem C# reserva setenta e cinco palavras para seu próprio uso. Estas
palavras são chamadas de palavras reservadas e cada uma tem um uso particular.
computador. Sempre que declaramos uma variável precisamos dizer que tipo de
dado pode ser armazenado nela. O tipo de dado indica qual o tamanho do espaço
exemplo:
int contador;
Esse exemplo declara uma variável chamada contador do tipo integer. Ou seja, ela
seguinte maneira:
Estamos declarando nesse exemplo duas variáveis do tipo integer, uma chamada
Depois de declarar sua variável você precisa atribuir um valor a ela. No C# você
não pode usar uma variável antes de colocar um valor nela, isso gera um erro de
compilação.
int numeroFuncionario;
numeroFuncionario = 23;
Primeiro nós declaramos nossa variável do tipo integer. Depois atribuímos o valor
recebe 23.
Isso faz à mesma coisa que o exemplo anterior, só que tudo em uma linha.
Mais um exemplo:
bool System.Boolean
byte System.Byte
sbyte System.SByte
char System.Char
decimal System.Decimal
double System.Double
float System.Single
int System.Int32
uint System.UInt32
long System.Int64
ulong System.UInt64
object System.Object
short System.Int16
ushort System.UInt16
string System.String
Cada tipo no C# é um atalho para o tipo do Framework. Isso quer dizer que se
string nome;
ou dessa forma
System.String nome;
desenvolver a aplicação.
long –9,223,372,036,854,775,808 a
Todos os tipos na tabela com exceção dos tipos object e string são conhecidos
Console.WriteLine(minhaVariavel.GetType());
int contador;
contador = 2;
mesma.
Perceba que para somar o valor a variável precisamos repetir o nome da variável.
contador += 40;
contador -= 23;
Na verdade você pode fazer isso com todos os operadores aritméticos, como
capitulo.
Para saber mais você pode consultar a documentação do Visual Studio e procurar
por “assignment”.
Embora não tenhamos feito nenhum exercício até aqui neste capitulo você
aprendeu como declarar uma variável, de que forma nomear as variáveis, quais as
palavras que não podem ser usadas na nomeação de variáveis e quais os tipos de
dados e valores que eles suportam. Os exercícios sobre esse conteúdo serão feitos
sempre, já que sempre faremos uso de variáveis em nossos programas, assim fique
Lição 12 – Operadores
Operadores Aritméticos:
aritméticas básicas como adição (+) e subtração (-), ele utiliza o asterisco (*) para
multiplicação e barra pra frente (/) para divisão. Esses símbolos são chamados
long salario;
salario.
Entretanto você não pode usar os operadores para qualquer tipo de dado. Os
operadores matemáticos, por exemplo, só podem ser usados para os tipos char,
int, long, float, double e decimal. Eles não podem ser usados para string e bool.
Exemplo:
Isso vai gerar um erro porque você não pode subtrair uma string de outra.
Console.WriteLine(“43” – “11”);
Isso também vai gerar um erro, porque valores entre aspas são sempre strings,
Console.WriteLine(43 – 11);
Operadores.
• 3 Label
• 3 TextBox
• 1 Button
• 1 GroupBox
• 5 RadioButton
5 – Execute a aplicação.
Clique na TextBox1, pressione a tecla Tab do teclado, verifique que conforme você
Clique sobre os operadores, veja que você só pode selecionar um, essa é uma
característica do controle RadioButton que não tinha sido usado até aqui. A
7 - Vamos agora digitar o código que efetuará os cálculos, esse código vai ser
primeiroValor = int.Parse(textBox1.Text);
segundoValor = int.Parse(textBox2.Text);
if (radioButton1.Checked)
textBox3.Text = resultado.ToString();
else if (radioButton2.Checked)
textBox3.Text = resultado.ToString();
else if (radioButton3.Checked)
textBox3.Text = resultado.ToString();
else if(radioButton4.Checked)
textBox3.Text = resultado.ToString();
else if(radioButton5.Checked)
textBox3.Text = resultado.ToString();
O tipo Long é usado aqui porque armazena uma grande variedade de números.
segundoValor.
primeiroValor = int.Parse(textBox1.Text);
segundoValor = int.Parse(textBox2.Text);
Como o valor que esta na caixa de texto é do tipo string convertemos para int
usando int.Parse. Você pode usar o método Parse sempre que precisar converter
um tipo de dados em outro. Para usa-lo digite o tipo do dado ponto Parte como o
long.Parse(textBox2.Text);
Autor: Herbert Moroni Cavallari da Costa Gois
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET” Página 75
Curso Programando com C# e o Visual Studio .NET 2005
verificar qual operação executar, para isto usamos a propriedade checked de cada
RadioButton.
if (radioButton1.Checked)
ou
else if (radioButton2.Checked)
Se o valor da propriedade Checked do RadioButton for True quer dizer que ele esta
textBox3.Text = resultado.ToString();
Fizemos isto utilizando o método ToString. Você pode usar o método ToString
8 – Execute o programa.
Subtração:
Multiplicação:
Divisão, perceba que ele retorna um resultado em inteiro, o numero inteiro mais
próximo do resultado:
Resto da Divisão, perceba que ele retorna o resto da divisão, 9 dividido por dois
10 – Pare a aplicação.
Precedência de Operadores:
Operações dentro dos parênteses são sempre executadas primeiro, como nas
operações matemáticas.
-).
2+3*4
2+3*4
2 + 12
14
(2 + 3) * 4
(2 + 3) * 4
5*4
20
Perceba que a ordem de precedência altera o valor do resultado, por isso devemos
Módulo 3
Métodos e Escopo
corpo. O corpo contem as instruções que vão ser executadas quando o método for
CalcularImpostoVenda.
// corpo do método
• tipoDeRetorno – é o tipo de dado que vai ser retornado pelo método após sua
execução. Pode ser o nome de qualquer tipo como int ou string. Se o seu
método não for retornar valor algum, você precisa usar a palavra reservada
• nomeDoMetodo – é o nome que vai ser usado para chamar o método. Este
nome deve seguir as mesmas recomendações usadas nos nomes das variáveis.
método faz.
• Corpo do método – linhas de código que vão ser executadas quando o método é
chamado.
e C++.
//...
//...
int.
// ...
Lembre-se de usar a palavra reservada void quando o método não for retornar
nada.
Se você quer que seu método retorne uma informação (em outras palavras que
retorne um tipo e não um void), você precisa escrever um código de retorno dentro
do método.
Para isso você usa a palavra reservada return, seguida da expressão que calcula o
Por exemplo:
//...
O retorno do método deve estar no final do método porque ele causa a finalização
do método. Qualquer código depois da linha que faz o retorno não vai ser
executado.
Se você não quer que seu método retorne informação alguma (do tipo void), você
Por exemplo:
...
if (...)
return;
...
Se o seu método não precisar retornar nada você pode simplesmente omitir o
return, porque o método vai ser finalizado automaticamente quando a ultima linha
Chamando métodos:
Métodos existem para serem chamados. Você chama um método pelo seu nome
para ele executar uma tarefa. Se esse método precisa de informações para realizar
sua tarefa (parâmetros), você precisa enviar essas informações pra ele. Se o
método retornar uma informação, você precisa ter uma forma de receber essa
maiúsculas de minúsculas.
passar um valor para cada parâmetro e este valor precisa ser compatível o tipo
//...
Este método tem dois parâmetros entre os parênteses, para chamá-lo, faça assim:
adicionarValores(39,3)
Autor: Herbert Moroni Cavallari da Costa Gois
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET” Página 85
Curso Programando com C# e o Visual Studio .NET 2005
Esta é a maneira correta de chamar o método, se você tentar das seguintes formas
O método adicionarValores retorna um numero inteiro. Este valor inteiro pode ser
usado em qualquer lugar que uma variavel int puder ser usada.
Por exemplo:
resultado = adicionarValores(39,3);
mostrarResultado(adicionarValores(39,3));
No segundo atribuímos o resultado a outro método, que vai utilizar este resultado
Você viu que pode criar uma variável dentro de um método. A variável é criada na
código que a define, e outros código no mesmo método que vêm depois podem
usar a variável. Em outras palavras, uma variável pode ser usada só em certos
lugares depois de que ter sido criada. Uma vez que o método terminou, a variável
desaparece completamente.
Autor: Herbert Moroni Cavallari da Costa Gois
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET” Página 86
Curso Programando com C# e o Visual Studio .NET 2005
variáveis locais porque são locais ao método onde são declaradas. Elas não
podem ser usadas no escopo nenhum outro método, por isso você não pode usar
Por exemplo:
class Exemplo
void método()
int variavel;
...
void outroMetodo()
determinam seu escopo. Assim sendo, qualquer variável que você criar dentro do
corpo da classe (mas que não estejam dentro do método), fazem parte do seu
variáveis locais você pode usar os campos para armazenar informações entre os
métodos.
Por exemplo:
class Exemplo
int campo;
void método()
campo = 42;
...
void outroMetodo()
campo = 44;
Em um método você precisa declarar uma variável antes de usá-la. Campos são
diferentes, um método pode usar um campo antes de ser definido algum valor para
ele.
chamada Metodo.
2 – No painel de código crie digite o seguinte código que cria o método lerDouble
Console.Write(inicie);
return double.Parse(linha);
Esse método escreve no console o texto que é enviado para ele como parâmetro.
Digite o seguinte código, você pode digitá-lo em qualquer local desde que esteja
Console.Write(inicio);
return int.Parse(linha);
Esse método faz a mesma coisa que o método lerDouble, só que retorna uma
integer (inteiro).
using System;
using System.Collections.Generic;
using System.Text;
namespace Metodo
class Program
Console.Write(inicie);
return double.Parse(linha);
Console.Write(inicio);
return int.Parse(linha);
minúsculas.
Esse método retorna a multiplicação dos dois parâmetros que são enviados para
ele.
using System;
using System.Collections.Generic;
using System.Text;
namespace Metodo
class Program
Console.Write(inicie);
return double.Parse(linha);
Console.Write(inicio);
return int.Parse(linha);
Chamando Métodos
9 – Crie um novo método que não retorna nada, ou seja, do tipo void. De o nome
dele de Executar
escrever(calcular(taxadiaria,dias));
Na primeira linha de código criamos uma variável do tipo double e atribuímos a ela
o método lerDouble.
Na segunda linha criamos uma variável do tipo int e atribuímos a ela o método
lerInteiro.
seguinte código:
(new Class1()).executar();
Isso vai executar o método executar assim que o programa for iniciado
(new Program()).executar();
A taxa é: 5197,5
Vou digitar o código fonte todo utilizado para você poder verificar caso haja algum
problema e vamos depurar nosso programa para entender melhor como ele
funciona.
using System;
using System.Collections.Generic;
using System.Text;
namespace Metodo
class Program
Console.Write(inicie);
return double.Parse(linha);
Console.Write(inicio);
return int.Parse(linha);
escrever(calcular(taxadiaria, dias));
(new Program()).executar();
verificação e correção de erros. Ele vem embutido no Visual Studio e vamos utilizá-
linha:
17 – Clique com o botão direito do mouse sobre ela, no menu que se abre clique
em Run To Cursor.
execução é pausada e uma seta amarela indica que chegou à linha selecionada.
Como vimos no método executar nossa primeira linha de código cria uma variável
O controle retorna ao Visual Studio e a seta amarela fica sobre a linha que chama o
Perceba que agora a seta se move para a primeira linha de código do método
escrever(calcular(taxadiaria,dias));
Aqui o método escrever recebe como parâmetro o método calcular, antes de ser
Parabéns, você escreveu métodos e os chamou com sucesso, alem disso usou o
Módulo 4
Estruturas de Decisão
FALSO.
Exemplo:
Se preço for menor que 100 então o resultado da expressão acima é VERDADEIRO.
Agora que você já sabe o que é uma expressão condicional vamos estudar o que é
Uma ESTRUTURA DE DECISÃO nada mais é que do que um bloco de código que
utiliza as expressões condicionais para tomar decisões que orientam qual código
Lição 17 – Usando o if
A primeira estrutura de decisão que iremos estudar é o IF, veja a sintaxe a seguir:
if ( expressãocondicional )
Autor: Herbert Moroni Cavallari da Costa Gois
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET” Página 108
Curso Programando com C# e o Visual Studio .NET 2005
bloco-de-codigo1
else
bloco-de-codigo2
executado.
Salario *= 1.1;
Existe uma variável chamada Salario que está definida e contém o valor 1200.
valor é maior que 1000, e caso seja verdadeiro será somado 10% ao Salario. Se
Salario += 50;
else
Salario += 100;
50 ou 100, pois há o Else. Então se a variável for menor que 500 adicionamos nela
Salario += 50;
Salario += 100;
else
Salario += 250;
verdadeira.
É possível avaliar diversos else ifs com uma determinada expressão. Como no
exemplo abaixo:
Salario += 50;
Salario += 100;
Salario += 110;
Salario += 120;
else
Salario += 250;
Exemplo:
Nesta linha testamos se o Salario é maior ou igual a 500 e o Salario é menor que
600.
FALSA.
O && é conhecido como um OPERADOR LÓGICO, temos quatro deles como mostra
a tabela a seguir:
verdadeiro.
falso.
lógicos.
Veiculo = “Bicicleta” && Preço < 300 Verdadeiro (Se as duas condições forem
verdadeiras)
Veiculo = “Carro” || Preço < 500 Verdadeiro (Se uma das condições
forem verdadeiras)
2 - Label
Autor: Herbert Moroni Cavallari da Costa Gois
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET” Página 113
Curso Programando com C# e o Visual Studio .NET 2005
2 – TextBox
1 – Button
Textbox1 Text
Textbox2 Text
else
MessageBox.Show("Usuario Invalido");
Close();
Você pode substituir o valor do nome para o seu nome e sua senha.
sempre temos que fazer isso quando tivermos mais que uma linha de
mesmo.
6 – Execute o programa.
8 – Clique em validar.
9 – Clique em Ok.
MessageBox.Show("Usuario Invalido");
Close();
Em resumo:
Depois testamos se o valor do nome era Moroni e a Senha 123, você pode
substituir o valor para o seu nome e sua senha. Se o resultado da expressão for
uma expressão.
A sintaxe é a seguinte:
switch (testexpression)
case constant-expression:
statements
break:
default:
statements
}
Autor: Herbert Moroni Cavallari da Costa Gois
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET” Página 118
Curso Programando com C# e o Visual Studio .NET 2005
para cada Case existe uma condição a ser validada. Caso o Case seja verdadeiro,
então a linha ou o bloco de código é executado. Se nenhum dos Cases for válido,
então default é executado. O default é opcional e você pode ter quantos Cases for
Veja o exemplo:
int diaDaSemana = 3;
switch (diaDaSemana)
case 1:
MessageBox.Show("Domingo");
break;
case 2:
MessageBox.Show("Segunda-Feira");
break;
case 3:
MessageBox.Show("Terça-Feira");
break;
case 4:
MessageBox.Show("Quarta-Feira");
break;
case 5:
MessageBox.Show("Quinta-Feira");
break;
case 6:
MessageBox.Show("Sexta-Feira");
break;
case 7:
MessageBox.Show("Sabado");
break;
variável.
não verificando os outros Cases. Caso contrario ele vai pro próximo case e segue
valor da expressão de teste nenhum código será executado, para isso que serve o
int diaDaSemana = 3;
switch (diaDaSemana)
case 1:
MessageBox.Show("Domingo");
break;
case 2:
MessageBox.Show("Segunda-Feira");
break;
case 3:
MessageBox.Show("Terça-Feira");
break;
case 4:
MessageBox.Show("Quarta-Feira");
break;
case 5:
MessageBox.Show("Quinta-Feira");
break;
case 6:
MessageBox.Show("Sexta-Feira");
break;
case 7:
MessageBox.Show("Sabado");
break;
default:
MessageBox.Show("Dia Inválido");
break;
invalido, o que não é o caso para o nosso exemplo, já que o valor da expressão se
Para entender ainda melhor vamos fazer um exemplo no Visual Studio. Esse
exemplo lista todos os meses do ano e quando selecionado um mês ele exibe uma
Application.
switch (Convert.ToString(listBox1.SelectedItem))
case "Fevereiro" :
break;
case "Abril":
case "Junho":
case "Setembro":
case "Novembro":
break;
default:
break;
5 – Clique sobre um mês, por exemplo, Fevereiro, note a janela que exibe o
Nosso exemplo é simples, criamos uma estrutura switch e demos a ela como
Se sim então mostra a caixa de dialogo com a mensagem dizendo que o mês possui
28 dias, senão vai para o próximo Case que verifica se o item selecionado é Abril, e
ele vai para o default que executa o código com a mensagem de que o mês possui
31 dias.
6 – Vamos fazer uma mudança no nosso switch agora, siga o exemplo abaixo:
switch (listBox1.SelectedIndex + 1)
case 2 :
break;
case 4:
case 6:
case 9:
case 11:
break;
default:
break;
O índice é um numero que é atribuído a cada valor na lista começando por zero,
Como sabemos que Janeiro é o primeiro mês do ano e fevereiro o segundo e assim
por diante adicionamos 1 ao valor do índice. Isso apenas para não confundirmos.
if seguidos;
• Você só pode usar o switch com tipos de dados primitivos, como: (int,
long, float, double, decimal, string, char, bool). Para usar outros tipos
• Você precisa repetir a sintaxe do case para cada valor individual que você
quer avaliar, mesmo que ele execute o mesmo bloco de código, veja o
ultimo exemplo.
• Você deve usar o break após cada bloco de código senão ele vai continuar
Módulo 5
Estruturas de Repetição
permitem que você executa uma linha ou bloco de código repetidamente até que
O uso de loopings nos programas é uma prática comum, pois em muitos casos é
while ( booleanExpression )
statement
while.
• 1 Button
• 1 ListBox
int contador = 0;
contador++;
listBox1.Items.Add(contador);
int contador = 0;
contador++;
listBox1.Items.Add(contador);
A segunda linha começa o While com a condição. Essa linhar quer dizer enquanto
contador for menor que 20, ou seja ele vai executar o loop ou o código que esta
entre os colchetes até que o conteudo da variável contador seja igual ou maior
que 20.
mesmo significado:
contador = contador + 1
Entretanto da forma que fizemos no nosso exemplo é mais elegante porque não
contador = 1
infinito ou seja nunca ia parar de rodar porque nunca entraria na condição que o
faz parar. Cuidado com esse tipo de loop, seus loops nunca devem ser infinitos.
verdadeiro o falso.
• Se você for usar mais de uma linha de código dentro do while precisa
Lição 20 – Usando o do
no Do a condição é colocada no final, fazendo com que mesmo que o resultado seja
falso da expressão booleana o código seja executado pelo menos uma vez. Caso
precise abandonar o looping, use o break, que é opcional. Veja a sintaxe (não
do
statement
while (booleanExpression);
int contador = 0;
contador++;
listBox1.Items.Add(contador);
int contador = 0;
contador++;
if (contador == 10)
break;
listBox1.Items.Add(contador);
se o conteudo da variavel contador é 10, se for ele executa o break que finaliza
imediatamente o loop.
4 - Execute a aplicação:
5 - Clique em Loop.
Perceba que ele nem chega a escrever o número 10 por que a linha de código que é
começa como false, já que o valor não é menor que 20, e sim é igual a 20.
do
contador++;
listBox1.Items.Add(contador);
if (contador == 10)
break;
Se a expressão estivesse encima nada apareceria, mas agora aparece o 21, isso
porque ele executou uma vez o loop antes de avaliar a expressão, algumas vezes
O For é usado quando sabemos o número de vezes que iremos executar o Loop. O
statement
1 - Crie uma nova aplicação do tipo Windows Application com nome For.
do botão:
MessageBox.Show(i.ToString());
5 - Execute a aplicação.
MessageBox.Show(i.ToString());
Quando inicializamos o for, primeiro iniciamos uam variável do tipo integer e damos
o valor 1 para ela, demos o nome de i para essa variavel. Depois colocamos uma
expressão booleana que será responsável por avaliar o numero de vezes que o for
será executado, nossa expressão diz que o for deve ser executado enquanto o
MessageBox.Show(i.ToString());
Perceba que o i+= 5 fez com que o número adicionado a variavel a cada passada
do loop é 5 ao invés de 1.
O Foreach é usado em casos onde você precisa percorrer uma coleção de dados.
No Foreach você não precisa verificar o limite do looping, pois isto já está implícito
Caso tenha dúvida no uso, pense da seguinte forma: Para cada elemento contido
na coleção, faça algo. Vamos estudá-lo em detalhe quanto falarmos sobre Arrays e
Coleções.
Módulo 6
Três tipos de erros podem ser encontrados em seus programas, são eles: erros de
Acontece quando você digita de forma errada uma palavra reservada ou comando
do C#. Você não consegue executar seu programa quando tem esse tipo de erro no
seu código.
Erros de Runtime:
seu código, por exemplo, quando seu código precisa ler um disquete que não esta
no drive, ao não encontrar o disquete ele gera uma exceção e para bruscamente a
Erros lógicos:
Esse é o tipo de erro mais dificil de ser tratado. É um erro humano. O código
funciona perfeitamente, mas o resultado é errado. Exemplo, uma função que deve
retornar um valor, só que o valor retornado esta errado, o erro neste caso se
certo é 4 mas ele retorna 3. Quando é uma conta simples é fácil de identificar mas
Studio.NET 2005
abaixo:
• 1 Button
• 2 TexBox
Até agora sempre usamos a janela Properties para setar as propriedades dos
De um clique duplo sobre o Form1 em qualquer lugar, desde que não seja encima
Tudo que estiver dentro deste procedimento, chamado Form1_Load será executado
button1.Text = "Testar";
4 - Execute a aplicação.
Note que a propriedade text do button1 foi modificada como se a tivéssemos feito
na janela properties.
Para usar o Debug não é necessário setar as propriedades assim, pode ser pela
clique de botão.
int idade;
idade = int.Parse(textBox1.Text);
else
Nosso programa vai ler o conteudo no TextBox1, se o valor for um numero entre
A caixa de dálogo esta dizendo que sua aplicação tem erros, se você clicar em sim
ele tenta executar a aplicação mesmo com os erros, clicando em não ele para a
7 – Clique em No.
Agora no painel de código perceba que depois da linha de inicio do If o código que
8 - De um clique duplo sobre a mensagem “The name ‘textox2’ does not exist in
the context”
Ele escreve a mensagem “Você não é adolescente”, porque ele entra no else do IF,
adolescente”.
13 - Feche a aplicação.
idade = int.Parse(textBox1.Text);
16 - Clique sobre esta linha com o botão direito do mouse e selecione a opção
código.
detalhada.
sobre o texto idade em qualquer lugar do código para ver o conteúdo da variável.
A seta amarela representa a próxima linha de código que será executada. Neste
Note que depois que ele avalia o IF como não entra na condição ele já pula para o
Else.
22 - Pare a execução.
O debug é muito útil para encontrar erros lógicos, supondo que os adolecentes são
pessoas de faixa etária que vai de 13 a 19 anos procure localizar o erro lógico no
na linha:
idade = int.Parse(textBox1.Text);
2 - Execute o programa.
Break Mode.
5 - Clique com o botão direito sobre o nome da variável idade, e selecione Add
É adicionado uma linha com o nome da variável e seu valor na janela Watch.
Agora a cada passo do programa você vai poder acompanhar o valor de cada um
destes itens.
9 - Clique em Step Into mais algumas vezes até a completa execução do código.
Para remover um item da janela Watch, clique sobre o mesmo, exemplo, idade <
você precisa usar a janela Watch, porque a janela Locals não mantem os valores
Para esse item suponho que você tenha finalizado o anterior e o que o exemplo
1 - Execute o programa.
6 - Clique duas vezes sobre o botão Step Into na barra de ferrametas Debug.
8 - Clique no botão Step Into da barra de ferramentas Debug mais duas vezes.
Em companhia com as janelas Locals e Watch a janela Command pode ser muito
Lição 27 – try..catch
Até agora você aprendeu como utilizar o Visual Studio .NET para resolver erros de
sintaxe e lógicos. À partir deste item você aprenderá a tratar erros de runtime
erro de runtime esta ocorrendo no seu programa e através disso emitir uma
Um exemplo bem comum, mas que permite que ilustremos bem como os erros de
Para esse exemplo será necessário um disquete com um arquivo nele. Vamos
1 - Pegue um disquete - o ideal é que não tenha nenhum arquivo nele ou pelo
pasta amostra de imagens dentro de Meus Documentos > Minhas Imagens >
Windows Application.
• 1 Button
• 1 PictureBox
pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg");
Quando for passar um caminho como string utilize o @ antes como fizemos no
código acima.
9 - Clique no botão Testar Drive, a imagem deve abrir no Form como a seguir:
try
Autor: Herbert Moroni Cavallari da Costa Gois
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET” Página 170
Curso Programando com C# e o Visual Studio .NET 2005
pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg");
catch
Você não precisa digitar denovo a linha que executa a leitura da imagem do
mensagem de erro.
15 - Execute a aplicação.
Perceba que agora ele mostra a caixa de dialógo com a mensagem que
19 - Feche a aplicação.
try
catch
Finally
O código fica sempre após a palavra reservada try, se algum erro aconteçer no
processamento deste código o programa vai imediatamente para o bloco catch que
imagem dentro do try, e no catch o código que abre a caixa de dialógo pedindo
Se nenhum erro ocorrer é executado apenas o código dentro do try, senão ele vai
try
pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg");
catch
try
pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg");
catch
finally
Você não precisa mudar o código anterior, apenas acrescentar o finally, como
exemplo de uso do finally apenas vamos exibir mais uma caixa de diálogo.
21 - Execute a aplicação.
22 - Teste com e sem disque do drive. Vai ver que a mensagem do Finally apareçe
A tabela a seguir mostra o que ocasiona a maior parte dos erros de runtime:
try
pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg");
catch
try
Autor: Herbert Moroni Cavallari da Costa Gois
Site: www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET” Página 176
Curso Programando com C# e o Visual Studio .NET 2005
pictureBox1.Image = pictureBox1.Image =
System.Drawing.Image.FromFile(@"a:\inverno.jpg");
catch
button1.Enabled = false;
A primeira mensagem de erro pede para o usuario inserir o disque e clicar em OK,
se ele o fizer o programa tenta ler o arquivo, se não for possivel emite a mensagem
Vamos fazer esse exemplo para você ver a diferença do que tinhamos feito até
aqui.
try
pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg");
catch
try
pictureBox1.Image = pictureBox1.Image =
System.Drawing.Image.FromFile(@"a:\inverno.jpg");
catch
button1.Enabled = false;
6 - Clique em OK.
button1.Enabled = false;
if (System.IO.File.Exists(@"a:\inverno.jpg"))
pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg");
else
O código acima usa a o método File.Exists para verificar se o arquivo existe antes
de tentar abri-lo.
A resposta depende de com que freqüência você acha que o problema vai ocorrer
no programa que você esta criando. Se o erro de runtime for ocorrer menos de
25% das vezes que o código for executado o tratamento de erros é a forma mais
eficiente de tratar o erro. Os try...catch é essencial se você tem mais do que uma
condição para testar também, e se você quer privar os usuários de várias questões
Mas o ideal é o uso das duas, tanto da programação defensiva como dos blocos
Try...Catch.
Para finalizar suponha que o usuário esta sem o disco e tente abrir o arquivo, não
bloco try...catch trata o erro, mas novamente o usuario clica no botão e o erro
Para evitar esse problema podemos criar uma variavel que armazena o numero de
vezes que o Catch foi executado, chegando a um número estipulado podemos por
int retorno = 0;
try
pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg");
catch
retorno += 1;
if (retorno <= 2)
else
button1.Enabled = false;
Módulo 7
Arrays e Coleções
Imagine que você tem que armazenar as faltas cometidas por cada jogador de um
faltas que cada jogador cometeu. Como faria para armazenar isso em variáveis?
Provavelmente você teria que declarar duas variáveis para cada jogador, uma para
variáveis, você precisa declarar seus arrays antes de usá-los. Os arrays também
questão.
Vamos fazer um exemplo, nele vamos criar o programa que armazenará os dados
chamado Arrays.
• 3 Button
• 1 ListBox
• 2 Labels
• 2 TextBoxes
10 - Na janela Solution Explorer clique no botão View Code para ir para o Painel
de código.
Nesta linha declaramos um Array de tamanho fixo. O array que criamos é como
uma tabela com 11 linhas, o suficiente para armazenar o nome do time inteiro, 11
jogadores.
lado da aba Start Page, à essa altura do curso você ja deve estar familiarizado
jogadores[0] = textBox1.Text;
código:
listBox1.Items.Add(jogadores[0]);
Não se assuste com o código para inserir no ListBox1, se fosse em uma TextBox
textBox1.Text = jogadores[0];
Só que para inserir um item no ListBox precisamos usar seu método Add.
15 – Execute a aplicação.
Agora que você já compreende como inserir e ler dados do array vamos avançar
no exemplo.
18 – Pare a execução.
int contador = 0;
Isto cria uma variável que estará disponível para todos os procedimentos dentro da
classe, ou seja, seu escopo é a classe. Também já atribuímos o valor 0 nela. Essa
variável será usada para controlar o índice ou local do array onde vamos inserir
cada jogador.
jogadores[contador] = textBox1.Text;
contador += 1;
textBox1.Text = null;
else
button1.Enabled = false;
variável contador.
posição.
No else apenas desabilitamos o Button1 caso o array esteja vazio ou não tenha
listBox1.Items.Add(jogadores[i]);
Aqui usamos o loop tor para passar por cada item do Array e adiciona-lo no
ListBox1.
A cada passada pelo For o i assume o valor de uma linha do array até chegar ao
final.
23 - Execute a aplicação.
Faça isso sucessivamente até que o botão seja desabilitado, ou seja, que o array
Como você pode ver, trabalhamos facilmente com os nomes dos 11 jogadores em
nosso array, podemos modificar os dados do nosso array facilmente, bastando para
isso indicar qual linha deve ser alterada e o novo dado, como no exemplo:
jogadores[10] = “Robinho”;
Um array pode conter mais de um coluna. Vamos entender como isso funciona
Como um Array só pode conter um tipo de dado e nosso Array já é do tipo String,
no nosso exemplo vamos adicionar o número de faltas como string mesmo, mas, a
maneira correta seria criar um outro Array do tipo integer para armazenar as faltas.
Vamos optar pela primeira opção para você aprender a trabalhar com duas colunas.
jogadores[contador] = textBox1.Text;
jogadores[contador,0] = textBox1.Text;
Isso apenas indica que vamos adicionar o nome na linha que o loop indicar, na
coluna 1, de índice 0.
int contadorFaltas = 0;
jogadores[contadorFaltas, 1] = textBox2.Text;
contadorFaltas += 1;
textBox2.Text = null;
else
button2.Enabled = false;
o textBox2 e o button2.
Note também que agora atribuimos os valores à segunda coluna, como mostra o
código:
jogadores[contadorFaltas, 1] = textBox2.Text;
Agora precisamos mudar o código do button3, que exibe os dados, para listar as
faltas também.
jogadores[i,1]);
Faça isso sucessivamente até que o botão seja desabilitado, ou seja, que o array
34 – Digite uma quantidade de faltas para cada jogador como fez com o nome dos
Lição 32 – Coleções
Uma coleção é um grupo de objetos relacionados. Todo controle que você arrasta
Collection.
chamado Coleções.
Sempre que adicionamos controles como o Button por exemplo ao nosso Form,
controles.Text = "OK";
5 - Clique no Button1.
Criamos um loop que passou por cada controle modificando sua propriedade Text.
6 - Você pode filtrar os controles que quer modificar também, vamos fazer isso
if (controles.Name != "button1")
7 - Execute a aplicação.
8 - Clique no Button1.
utiliza o indice para localizar um objeto da coleção. Como nos arrays o indice
indice 1 e assim sucessivamente. Se você adicionar um controle novo , ele fica com
Controls[0].Left += 35;
Control Collection.
Controls[0].Left += 35;
10 - Execute a aplicação.
11 - Clique no Button2.
então nosso código moveu apenas o Button3 - que foi o último controle adicionado
- para a esquerda.
Módulo 8
um formulário (Form). Sempre temos vários deles nos nossos programas, vamos
estudar neste capitulo como trabalhar com varios formulários. Alem disso, vamos
Sempre que você cria uma Windows Application um formulário já é criado por
seguinte.
Vamos fazer um exemplo que ilustra como podemos trabalhar com múltiplos
formulário.
respectivamente.
Vermelho.Show();
Verde.ShowDialog();
10 – Execute a aplicação.
O formulário Vermelho é aberto, perceba que você pode clicar novamente no Form1
Perceba agora que você não consegue voltar para o Form1 sem antes fechar o
aplicações.
Para esta lição continuaremos usando o exemplo que criamos na lição anterior.
label1.Text = mensagem;
6 - Execute a aplicação.
O conteúdo da variável foi exibida no label1. O mais importante desta lição é que
Posicionando.
3 - Execute a aplicação.
Essa propriedade faz com que o formulário em questão seja exibido no centro da
tela.
Agora você deve especificar manualmente como os valores que serão usados para
7 - Execute a aplicação.
tela.
Application.
O clique do botão é um exemplo de evento que pode ocorrer nos seus programas.
Existem dezenas de eventos que podem ocorrer em seus programas, e sempre que
um evento ocorre um bloco de código pode ser processado, esse bloco de código é
conhecido como Manipulador de Evento. O evento que você mais usou até aqui
• 1 Label
• 1 TextBox
• 1 Button
4 – Clique sobre cada um dos controles acima e visualize sua lista de eventos.
Módulo 9
calendário. Muito util para evitar erros de digitação de data ou hora incorretos.
O objeto DateTimePicket por padrão exibe a data atual, mas você pode ajustar
Você pode escolher a data no calendário. Isso é muito prático e evita erros.
dateTimePicker1.Value.DayOfYear.ToString());
A primeira linha usa a propriedade Text para exibir a data que esta selecionada no
controle.
A segunda usa o método DayOfYear para recuperar apenas o dia do ano da data
A terceira linha exibe a data e hora atual usando o método Now da estrutura
DateTime.
9 - Execute a aplicação.
Para encontrar mais facil a data você pode digitar o ano no controle antes de abrir
12 - Clique em OK.
ListBox e ComboBox para receber informações dos usuários. Para isso vamos
criar uma simples aplicação que usa os quatro tipos de controles para você
• 2 GroupBox
• 3 RadioButton
• 3 CheckBox
• 1 ListBox
• 1 ComboBox
• 8 Label
Clique no botão com as reticências nesta propriedade, deve abrir a seguite caixa:
17 - Clique em OK.
20 - Execute a aplicação.
são usados sempre que o usuário precisa fazer uma escolha única, já que não
permite que mais de um item seja marcado. Podemos também colocar uma escolha
que já aparece marcada como padrão, para isso você deve mudar a propriedade
para os RadioButtons.
label3.Text = "PC";
label3.Text = "MAC";
label3.Text = "Notebook";
que há uma mudança na propriedade Checked. Quando você clica nele o Checked
fica como True, então o evento é disparado e muda a propriedade Text do Label3.
usados sempre para perguntas que requerem nenhum ou várias respostas como no
nosso exemplo. O usuário pode não querer nenhum item para o escritório, pode
if (checkBox1.Checked == true)
label6.Text = "Fax";
else
label6.Text = "";
if (checkBox2.Checked == true)
label7.Text = "Calculadora";
else
label7.Text = "";
if (checkBox3.Checked == true)
label8.Text = "Copiadora";
else
label8.Text = "";
32 - Execute sua aplicação. Marque as opções FAX e Copiadora, por exemplo, como
label4.Text = listBox1.SelectedItem.ToString();
label5.Text = comboBox1.SelectedItem.ToString();
Módulo 10
Tudo o que aprendemos até aqui é relacionado à interface com o usuário ou Front
End, esse acessa os dados nos bancos de dados. Um banco de dados é uma
outros de terceiros como Paradox, Oracle, etc, ou seja, você não usa o Visual
Basic.NET para criar bancos de dados, mas para exibir, analisar, e manipular as
suas informações.
representa um campo, sendo cada campo uma informação do cliente, como nome
e telefone. Podemos ter mais informações como endereço, cep, etc. Um banco de
dados pode e geralmente contem varias tabelas. Outras tabelas no nosso banco de
Para criar o banco de dados que vamos utilizar nos exemplos deste capitulo vamos
usar o Access. O Access é instalado junto com o Microsoft Office, se sua versão for
a 2003, ele deve estar em Iniciar > Programas > Microsoft Office > Microsoft
Office Access 2003. Você pode usar qualquer versão do Access para os exemplos
deste capítulo.
1 - Entre no Access.
3 - Crie uma pasta chamada ADONET no local que você esta criando seus
exemplos, navegue até essa pasta e crie o banco com o nome dados.mdb.
modo Design.
Note que o campo id contêm uma chave, para adiciona-lá com o campo id
mensagem:
7 - Clique em Sim.
figura:
campo que identifica individualmente cada registro no banco de dados. Por isso
marcamos ele com a chave primaria, podem ter dois clientes com o mesmo nome,
10 - Feche o Access.
Next.
Escolhemos que nossa origem de dados será um banco de dados, agora criaremos
5 – Na janela Choose Data Source, selecione Microsoft Access Database File, já que
Se você clicar em sim o Visual Studio criará automaticamente uma copia do banco
mesmo.
11 –Clique em Sim.
configuração XML, certifique-se que Yes, save the connection as estaja marcado e
clique em Next.
Nesta janela configuramos como os controles de tela devem ser criados baseados
16 – Arraste Clientes para o formulário, ele deve ficar como a seguinte figura:
mesmos.
17 – Execute a aplicação.
Detais.
22 – Execute a aplicação.
Você também pode configurar individualmente como será exibido cada campo da
tabela através da janela Data Sources. Basta clicar na seta para baixo do campo
Módulo 11
Imprimindo
• 3 Button
• 1 TextBox
• 1 PrintDocument
• 1 PrintDialog
• 1 PageSetupDialog
• 1 PrintPreviewDialog
Multiline = True
ScrollBars = Vertical
using System.Drawing.Printing;
Isso permite que usemos a classe PrintDocument, ela fica localizada dentro do
string stringParaImprimir;
Como pode perceber no código acima criamos 3 variáveis que vão armazenar
classe Form1.
stringParaImprimir = textBox1.Text;
printDialog1.Document = printDocument1;
printDocument1.Print();
PrintDocument1.
int numeroLinhas;
int numeroCaracteres = 0;
string stringParaPagina;
RectangleF(e.MarginBounds.Left, e.MarginBounds.Top,
e.MarginBounds.Width, e.MarginBounds.Height);
e.MarginBounds.Height - fontParaImprimir.GetHeight(e.Graphics));
formataString.Trimming = StringTrimming.Word;
e.Graphics.MeasureString(stringParaImprimir,
numeroLinhas);
stringParaPagina = stringParaImprimir.Substring(0,
numeroCaracteres);
e.Graphics.DrawString(stringParaPagina, fontParaImprimir,
stringParaImprimir =
stringParaImprimir.Substring(numeroCaracteres);
e.HasMorePages = true;
else
e.HasMorePages = false;
stringParaImprimir = textBox1.Text;
Esse procedimento de eventos define a área da página que vai ser impressa, se for
classe RectangleF.
formataString.Trimming = StringTrimming.Word;
e.Graphics.MeasureString(stringParaImprimir, fontParaImprimir,
e.Graphics.DrawString(stringParaPagina, fontParaImprimir,
stringParaImprimir = stringParaImprimir.Substring(numeroCaracteres);
e.HasMorePages = true;
else
e.HasMorePages = false;
stringParaImprimir = textBox1.Text;
pouco complicado comparado com os demais vistos neste curso, não se preocupe,
com pouco tempo de experiência você será capaz de compreende-lo com facilidade.
Vamos implementar agora o código que permite que o usuário escolha a impressora
stringParaImprimir = textBox1.Text;
printDialog1.Document = printDocument1;
resultado = printDialog1.ShowDialog();
if (resultado == DialogResult.OK)
printDocument1.Print();
18 - Execute a aplicação.
Agora antes da impressão é exibida a janela Imprimir que permite que o usúario
pageSetupDialog1.PageSettings = configuracaoDepagina;
pageSetupDialog1.ShowDialog();
Button1.
printDocument1.DefaultPageSettings = configuracaoDepagina;
printDocument1.DefaultPageSettings = configuracaoDepagina;
stringParaImprimir = textBox1.Text;
printDialog1.Document = printDocument1;
resultado = printDialog1.ShowDialog();
if (resultado == DialogResult.OK)
printDocument1.Print();
24 - Execute a aplicação.
26 - Clique em OK.
código:
pageSetupDialog1.PageSettings = configuracaoDepagina;
stringParaImprimir = textBox1.Text;
printPreviewDialog1.Document = printDocument1;
printPreviewDialog1.ShowDialog();
exibe a visualização.
29 - Execute a aplicação.
32 - Para a aplicação.
Módulo 12
Depois de pronta sua aplicação precisa ser distribuida para todos que querem ou
precisam usá-la. Para usar a sua aplicação, o único requisito para o computador do
cliente é que tenha instalado o .NET Framework. Este pode ser instalado
futuramente deve vir junto com todos os sistemas operacionais da Microsoft. Então,
No entanto essa prática não é muito recomendada, é mais elegante criar um pacote
O .NET Framework não funciona no Windows 95, então não será possivel rodar sua
Programas que usam o Access como banco de dados também precisam que o
arquivo do Access seja copiado junto com a instalação. Não é necessário ter
Durante este capitulo você vai aprender a criar o pacote de instalação para os seus
programas.
formularios.
Projects.
disponibilidar a aplicação.
Merge Module Project - cria um arquivo de instalação do tipo msm que pode ser
Cab Project - usado quando você precisa de arquivos de instalação com tamanho
especifico. Se por exemplo sua aplicação tem 30MB e você quer disponibiliza-la na
Smart Device CAB Project – usado para criação de projeto instalação para
dispositivos móveis.
Setup Wizard - é um assistente, através dele você pode criar os tipos citados
Isso adiciona o projeto a solução que esta aberta no Visual Studio, se estiver
projeto.
6 - Em Name você pode dar uma nome para seu projeto de instalação, neste
7 - Clique em OK.
O Assistente é iniciado.
8 - Clique em Next.
Isto informa que nossa aplicação é do tipo Windows Application e para tal
Na próxima caixa de diálogo você escolhe os arquivos adicionais que podem ser
incluidos na instalação.
banco de dados do Access ou algum TXT com informações sobre o projeto clique
11 - Clique em Next.
12 - Clique em Finish.
O Visual Studio adiciona um novo projeto na solução chamado Setup1, como você
Você usa o File System Editor para adicionar arquivos no seu projeto de
Quando a aplicação for instalada, um atalho para a mesma será criado no menu
Iniciar > Programas. Você pode adicionar também o atalho no Desktop para
da companhia que desenvolve o software, seus valores também são usados para
construir o caminho padrão onde será instalado o programa. Uma vez instalado o
propriedades Product Code contém informações geradas pelo Visual Studio que
aplicação Formularios.
permite que você altere algumas das opções escolhidas no assistênte (Setup
ele contém a extensão .msi por ser usado pelo Windows Installer.
de instalação.
19 - Clique em OK.
20 - Um passo importante, simples e que não deve ser esquecido é mudar para
Quando estamos criando nossa aplicação é importante que esta caixa de seleção
esteja marcada com Debug para que possamos usar as ferramentas de depuração
informações extras para permitir a depuração dos erros, essas informações não são
necessário para sua aplicação funcionar. Por padrão sempre que é inicializado a
ou não. Se não estiver ele usa essa propriedade, a InstallUrl para fazer o
Você pode disponibilizar o .NET Framework junto com sua instalação, para que não
seja necessário baixar o arquivo da internet. Para isso você muda a propriedade
23 -Na janela Solution Explorer, clique com o botão direito sobre Setup1, depois
clique em Build.
Eis os arquivos necessários para a instalação do seu projeto, você pode copiados
anteriormente você pode copiar para esta pasta também o arquivo Dotnetfx.exe
instalação.
2 - Clique em Next.
programa apenas para o seu usuário na máquina, marque a opção Just me, se
3 - Clique em Everyone.
4 - Clique em Next.
É iniciada a instalação:
Formularios.
Se você tivesse apenas copiado seu programa para a máquina de destino ele não
11 - Clique em Fechar.
12 - Clique em Remover.
13 - Clique em Sim.
O programa é desinstalado.