Desenvolvimento .Net C# VB.Net

Desenvolvimento em .
Net
C# e Visual Basic .Net
Apostila voltada para estudantes da rea de desenvolvimento, abordando a tecnologia .Net e seus vrios recursos para desenvolvimento Desktop.
Microsoft Innovation Center
Microsoft Innovation Center 2 Desenvolvimento em .Net
Sumrio
Introduo ..........................................................................................................................4 .Net Framework......................................................................................................................... 4 Microsoft Visual Studio ............................................................................................................. 6 Principais linguagens da plataforma .Net ................................................................................. 6 Conhecendo a rea de trabalho do Microsoft Visual Studio..................................................... 6 Criando novas solues e aplicaes ........................................................................................ 8 Viso geral das janelas de auxlio .............................................................................................. 9 Viso geral sobre os captulos ................................................................................................. 12 Captulo I Variveis, Operadores e Estruturas de Deciso ................................................. 13 Variveis .................................................................................................................................. 13 Laboratrio 1 - Variveis ......................................................................................................... 15 Operadores.............................................................................................................................. 18 Laboratrio 2 Operadores .................................................................................................... 20 Estruturas de Deciso.............................................................................................................. 23 Laboratrio 3 Estrutura de Deciso...................................................................................... 26 Laboratrios extras ................................................................................................................. 31 Captulo II Estruturas de repetio................................................................................... 32 Estrutura Repita ...................................................................................................................... 32 Laboratrio 1 Repita............................................................................................................. 34 Estrutura Para ......................................................................................................................... 37 Laboratrio 2 Para................................................................................................................ 38 Estrutura Enquanto ................................................................................................................. 41 Laboratrio 3 Enquanto ....................................................................................................... 42 Laboratrios extras ................................................................................................................. 45 Captulo III Vetores ......................................................................................................... 46 Caractersticas dos vetores ..................................................................................................... 46 Vetores unidimensionais ......................................................................................................... 47 Vetores multidimensionais ..................................................................................................... 49 Aplicaes especficas para vetores ........................................................................................ 51 Laboratrio 1 Vetores unidimensionais e barras de progresso ........................................... 53 Laboratrio 2 Vetores multidimensionais ............................................................................ 58 Laboratrios extras ................................................................................................................. 67
Microsoft Innovation Center 3 Desenvolvimento em .Net Captulo IV Tratamento de Excees e Mtodos............................................................... 68 Tratamento de Excees ......................................................................................................... 68 Try...Catch ............................................................................................................................... 69 Finally ...................................................................................................................................... 70 Exemplo: Gerando um erro em tempo de execuo .............................................................. 71 Mtodos .................................................................................................................................. 73 Laboratrio 1 Mtodos ........................................................................................................ 76 Foreach.................................................................................................................................... 78 Laboratrio 2 Foreach .......................................................................................................... 79 Laboratrios Extras ................................................................................................................. 81 Captulo V Formulrios .................................................................................................... 82 Formulrios ............................................................................................................................. 83 Formulrios MDI...................................................................................................................... 84 Instanciao de formulrios .................................................................................................... 85 Menus...................................................................................................................................... 85 Laboratrio 1 Formulrios e menus ..................................................................................... 88 Controles ................................................................................................................................. 99 Laboratrio 2 Formulrios e controles ............................................................................... 102 Laboratrios extras ............................................................................................................... 107 Captulo VI Acesso ao banco de dados ........................................................................... 108 Viso geral do ADO .Net ........................................................................................................ 108 Viso geral dos .Net Framework Data Providers................................................................... 108 Arquitetura do ADO .Net ....................................................................................................... 109 Laboratrio 1 Primeira aplicao de acesso ao banco de dados ....................................... 111 Laboratrio 2 Trabalhando com uma base de dados por meio de cdigo ........................ 125 Laboratrios extras ............................................................................................................... 139 Captulo VII Relatrios .................................................................................................. 140 Criao de relatrios ............................................................................................................. 140 Microsoft Report Viewer ....................................................................................................... 141 Crystal Reports ...................................................................................................................... 141 Laboratrio 1 Relatrio simples com Microsoft Report Viewer ......................................... 142 Laboratrio 2 Relatrio com parmetros e Crystal Reports .............................................. 152 Laboratrio 3 Relatrio com juno e Crystal Reports ...................................................... 161 Laboratrios extras ............................................................................................................... 166
Introduo
Tpicos abordados:
Viso geral sobre funcionamento do .Net Framework; Conhecendo o Visual Studio e suas principais linguagens; A rea de trabalho do Visual Studio; Principais janelas de trabalho; Viso geral sobre os prximos captulos.
Essa apostila desenvolvida pelos membros e colaboradores do Centro de Inovao Microsoft tem como objetivo ajudar no desenvolvimento de novos profissionais da rea de desenvolvimento. Focando as duas principais linguagens do .Net Framework,e fazendo o uso de uma explicao detalhada e de fcil entendimento, voltada principalmente para iniciantes no campo da informtica. Voc ir encontrar laboratrios para o tema abordado em cada captulo, como tambm atividades extras para que tenha chance de desenvolver sua lgica na programao. Mesmo sendo um contedo voltado principalmente para iniciantes, as tcnicas abordadas em cada tpico so direcionadas para construo de aplicaes que mesmo simples, viso o uso de ferramentas necessrias para desenvolver solues competitivas no mercado.
.Net Framework
O .Net Framework a plataforma de desenvolvimento fornecida pela Microsoft para que desenvolvedores criem desde solues acadmicas at profissionais, com qualidade e rapidez em sua construo. Esse modelo para programao auxilia na criao de aplicativos para clientes, servidores, dispositivos mveis ou incorporados ao Windows. Veja abaixo alguns fatores que o .Net Framework possui e que so de grande relevncia para os desenvolvedores. I. II. III. IV. V. Conjunto rico de bibliotecas, para diversos fins, facilitando e agilizando a criao de solues; Facilidade na instalao e na distribuio de aplicaes; Alta escalabilidade para ambientes de misso crtica; Interoperabilidade entre plataformas e componentes desenvolvidos em outras linguagens .Net; Suporte para orientao a objetos.
Microsoft Innovation Center 5 Desenvolvimento em .Net Uma das grandes vantagens que temos no .Net Framework est relacionada diretamente ao seu funcionamento. Veja a seguir seu funcionamento e como isso permite e favorece o trabalho em equipe por diferentes programa programadores. A plataforma .Net executada sobre uma CLR (Common Language Runtime Common Ambiente de Execuo Independente de Linguagem) interagindo com uma c coleo de bibliotecas. Esta CLR capaz de executar, atualmente, mais de vinte diferentes linguagens de programao (inclusive linguagens no Microsoft, como Cobol, Pascal - Delphi, etc.), interagindo entre si como se fossem uma nica linguagem. O modelo mostrado na Figura 1 representa de maneira simples o funcionamento do .Net Framework.
Figura 1 Modelo de funcionamento do Framework .Net.
Perceba que na parte superior do modelo temos as linguagens de programao que utilizamos para nossas solues. Podemos dizer que a plataforma compila o cdigo do desenvolvedor em uma ou mais linguagens para um cdigo intermedirio, o qual o responsvel por juntar linguagens diferentes em uma mesma soluo. A prxima etapa onde encontramos a CLR trabalhando. Ao receber o cdigo intermedirio, ela executa sobre ele uma nova compilao. Esse resultado se torna a soluo esperada para o usurio.
Microsoft Visual Studio

O Microsoft Visual Studio um ambiente de desenvolvimento integrado (IDE Integrated Development Environment) para a construo de aplicaes utilizando as linguagens de programao Visual Basic .Net, Visual C#, Visual C++, Visual J#. No ambiente do Visual Studio possvel criar suas aplicaes atravs de um simples arrastar de componentes de forma visual, bem como desenvolver todo o procedimento atravs de linhas de cdigo. Alm de proporcionar experincias ao usurio com a mais alta qualidade e riqueza, aplicativos mais seguros, gerenciveis e confiveis. Atualmente o Visual Studio encontra-se na verso 2008, disponibilizando no mercado trs opes diferentes para cada tipo especifico de usurio. Elas so: Visual Studio Professional, Visual Studio Team System e Visual Studio Express Editions.
Principais linguagens da plataforma .Net

A linguagem C# trata-se de uma das principais linguagens que caracterizam a plataforma de desenvolvimento .Net. A linguagem orientada a objetos e possui fortes caractersticas da linguagem C++. O responsvel pela coordenao do desenvolvimento da linguagem foi Anders Hejlsberg. Outra grande linguagem a Visual Basic .Net, que foi introduzida inicialmente atravs do ambiente de desenvolvimento Visual Studio 2002, e pode ser considerada uma evoluo da linguagem Visual Basic 6 para tornar-se compatvel com o Microsoft .Net Framework. Durante o processo de reestruturao da linguagem vrias mudanas foram incorporadas para suportar todas as funcionalidades do Microsoft .Net Framework e, desde ento a linguagem passou a basear-se no paradigma da orientao a objetos. As duas linguagens possuem suas prprias caractersticas de sintaxe, contudo, possvel perceber semelhanas em seus cdigos, isso devido ao uso da mesma plataforma. Esse material visa ao leitor possibilidade de estudar as duas ou mesmo uma a sua preferncia. Todos os laboratrios e exemplos so comentados e exibidos nas duas linguagens, o que at permite ao leitor fazer comparaes entre ambas.
Conhecendo a rea de trabalho do Microsoft Visual Studio

Vamos conhecer agora a rea de trabalho que a ferramenta de desenvolvimento oferece. Certifique-se de possuir instalada em seu computador uma das verses do Visual Studio. Todo o contedo abordado durante os captulos no far uso de nada alm do que a verso Express Editions pode oferecer. Caso deseje, visite o link abaixo para fazer a aquisio desta verso que distribuda gratuitamente. http://www.microsoft.com/Express/
Microsoft Innovation Center 7 Desenvolvimento em .Net Primeiramente vamos visualizar nossa janela principal que apresentada assim que o Visual Studio aberto, como mostra a Figura 2.
3 2 4 2
Figura 2 Apresentao inicial do Visual Studio.
Vamos agora analisar cada parte dessa apresentao inicial: 1. Aqui encontramos o menu superior. A partir dele podemos chegar a varias opes, como criar novos projetos e arquivos, configurar opes da ferramenta, modificar a exibio das janelas que auxiliam, entre muitas outras coisas. 2. Todas as partes marcadas com esse nmero representam as nossas janelas de auxilio. Logo mais veremos o que cada uma oferece para ajudar os desenvolvedores. Outro detalhe que elas podem ter suas posies alteradas, o que deixa possvel a opo de cada programar personalizar seu ambiente de trabalho. 3. Inicialmente, essa rea notifica as novidades e lanamentos que a Microsoft lana ao processo de desenvolvimento e suas aplicaes. Para quem possui uma conexo sempre acessvel com a internet, essa janela pode fornecer muitas informaes. Caso queria, pode ser desativada tambm para que no aparea mais quando o Visual Studio for inicializado. 4. Nessa rea voc pode encontrar os seus projetos mais recentes. Acessando-os de uma forma bem rpida.
Criando novas solues e aplicaes

O Visual Studio editor padro para desenvolvimento utilizando a plataforma criada pela Microsoft. Com ele podemos criar a soluo ideal para cada problema. Vamos conhecer agora os principais tipos de projetos que podemos criar e tambm como realizar isso. Depois de abrir seu Visual Studio, navegue para o menu superior. Entre as varias opes que temos escolha File. Nesse item temos as principais opes para controle de projetos, como criar novos, abrir, salvar, etc. Escolha a opo New, aqui temos as opes de criar um projeto novo, criar apenas um arquivo separado de algum projeto ou mesmo um web site. Acesse o item Project, como mostra a Figura 3.
Figura 3 Acessando o menu superior para criar um novo projeto.
Feito isso, uma nova janela ir aparecer para que sejam informados alguns dados para criao do projeto. Veja a Figura 4. 3
Figura 4 Janela de criao de novos projetos.
Microsoft Innovation Center 9 Desenvolvimento em .Net 1. No campo Name indicamos qual ser o nome do nosso projeto. Por padro o Visual Studio cria a soluo com o mesmo nome tambm. 2. Location local a soluo e todos os seus componentes sero salvos. Voc pode optar por salvar em um local especifico em vez da pasta que o Visual Studio reserva. 3. Nessa seleo de itens escolhemos qual verso do .Net Framework utilizaremos. recomendado deixar sempre na verso mais recente (atualmente 3.5), j que cada atualizao corrige e aprimora a plataforma de desenvolvimento. 4. Nessa parte, chamada Project type, fazemos a escolha do tipo de projeto que ser criado, se vai ser um projeto para desktop, uma aplicao web, um sistema para dispositivo mvel, etc. Se seu Visual Studio for a verso Professional ou Team System, voc ver que nessa rea temos mais de uma linguagem diferente para escolher. Os principais tipos de projetos, como citados anteriormente, fazem parte de todas as linguagens da Microsoft, porm alguns projetos mais especficos, como desenvolvimentos para jogos em XNA, suportado apenas para linguagem C#. 5. Depois que o tipo de projeto foi escolhido precisamos definir qual ser seu template, ou seja, mesmo que o tipo de projeto seja aplicao para desktop (Windows Forms Application), ainda precisamos escolher quais elementos especficos vamos trabalhar dentro dessa rea. Pode ser um projeto completo, um projeto que suporte apenas classes (Class Library), entre outros.
Viso geral das janelas de auxlio

Depois que criamos uma nova soluo ou abrimos alguma pronta, as janelas de auxlio so preenchidas conforme o arquivo que estamos trabalhando. Vamos analisar cada uma das principais janelas. Solution Explorer:
Figura 5 Janela Solution Explorer.
A Figura 5 representa a rea que fornecida para controle da nossa soluo. Quando nos referimos a uma soluo, estamos nos referindo resoluo da tarefa proposta, ou seja, conjunto de elementos que interligados formam a soluo para o problema, por isso uma soluo pode ter mais de um projeto e, dependendo da situao, necessrio trabalhar com vrios projetos em uma mesma soluo. Por exemplo, combinando um projeto Class Library com um projeto Windows Forms Application.
Microsoft Innovation Center 10 Desenvolvimento em .Net Quando criamos um novo projeto, que no seja em branco, ele construdo com vrios arquivos padro. Por exemplo, o arquivo Form1.cs, que um formulrio em branco, ou o arquivo Program.cs, que contm as principais informaes sobre sua aplicao.
Alterando formulrios:
Figura 6 rea para alterao de formulrios.
Formulrios so as janelas que nossos programas e aplicaes vo possuir, como mostra a Figura 6. Dentro delas podemos inserir varias coisas, como caixas de textos ou mesmo imagens (conhecidos como controles). Podemos editar os formulrios por meio de cdigo, cada formulrio tem seu respectivo arquivo em cdigo, o qual permite a implementao de regras de negcios, ou mesmo aes que devem ser executados caso algum boto seja pressionado.
Toolbox:
Figura 7 Controles na janela Toolbox.
Como citado anteriormente, os formulrios so preenchidos por componentes para que seja possvel a construo de uma interface grfica com os usurios. Esses componentes so chamados em geral por controles. Quando estamos editando visualmente nosso formulrio, podemos adicionar novos controles a ele de duas formas bem simples: com um clique duplo sobre o controle desejado, ou mesmo no simples arrastar e soltar.
Microsoft Innovation Center 11 Desenvolvimento em .Net Properties:
Figura 8 Janela para alterar as propriedades de um controle.
Cada controle possui suas propriedades, todos, desde um boto at um formulrio. Essas propriedades so as configuraes que cada controle tem, por exemplo, tamanho, cor e tamanho da fonte, entre outros. Existem propriedades que so comuns aos controles e outras que so especificas para cada um. Temos duas maneiras para fazer essas alteraes, via cdigo, ou mesmo pelo modo visual, selecionando um controle e navegando at a janela Properties, assim como mostra a Figura 8.
Server Explorer:
Figura 9 Janela Server Explorer.
Essa janela de auxlio responsvel pelo gerenciamento das conexes que temos com o Visual Studio e bases de dados. Assim como mostra a Figura 9, podemos configurar e acessar tanto servidores como bancos de dados diretamente. Alm da opo de manuteno e gerenciamento, podemos criar novas bases de dados diretamente dessa janela.
Viso geral sobre os captulos

Captulo I - Variveis, operadores e estruturas de deciso: Esse primeiro captulo aborda a introduo ao desenvolvimento de aplicaes, focando nos conceitos bsicos e necessrios para construo de qualquer aplicao. Captulo II - Estruturas de repetio: Aqui so desenvolvidas estruturas que auxiliaram no desenvolvimento de regras de negocio mais aprimoradas, as quais so essenciais para a lgica de seu programa. Captulo III - Vetores: Todo desenvolvedor sempre chega ao ponto de trabalhar com uma grande quantidade de dados, uma das maneiras mais utilizadas para criao e manuteno desse tipo de problema com a utilizao de vetores. Onde voc aprender a trabalhar e aplicar os conceitos de vetores unidimensionais e multidimensionais. Captulo IV - Tratamento de excees e mtodos: Como nenhuma aplicao pode garantir que nunca ocorrer um erro devemos aprender a utilizar os tratamentos dos mesmos, para que um erro no seja fatal e atrapalhe a execuo do programa. abordado tambm a utilizao de mtodos (funes), que ajudam a garantir no programa uma reutilizao maior como tambm um aprimoramento na organizao do projeto e facilidade para desenvolver aplicaes com estruturas mais complexas. Captulo V - Formulrios: A integrao de programa com usurio essencial para sucesso da soluo. Para isso devemos saber como utilizar nossos formulrios e seus controles das melhores maneiras possveis. Captulo VI - Acesso ao banco de dados: Aplicaes que envolvem armazenamento de dados, precisam acessar bases de dados, tanto para receber como inserir informaes. Neste captulo abordado as maneiras que a plataforma .Net disponibiliza para que isso seja feito, tanto visualmente ou por cdigo. Captulo VII - Relatrios: Uma das funes mais essenciais que as aplicaes devem possuir atualmente gerar relatrios. Seja qual for o tipo e tamanho de empresa, tomas de decises, para que ocorram com sucesso devem possuir boas analises, utilizando relatrios possvel fornecer algumas dessas analisem. Veja como construir relatrios de maneira bem simples e eficiente para seus programas.
Captulo I Variveis, Operadores e Estruturas de Deciso

Tpicos abordados:
Variveis; Laboratrio 1; Operadores; Laboratrio 2; Estruturas de Deciso; Laboratrio 3;
Neste captulo vamos estudar os conceitos sobre variveis, aplicaes de operadores e a utilizao de Estruturas de Deciso para auxiliar o desenvolvimento de um aplicativo.
Variveis
Uma varivel um local de armazenamento temporrio para dados em seu programa. Voc pode utilizar uma ou muitas variveis no cdigo, e elas podem conter palavras, nmeros, datas, propriedades ou outros valores. Utilizando variveis, voc pode atribuir um nome curto e fcil de lembrar a cada parte dos dados com o qual deseja trabalhar. As variveis podem armazenar informaes inseridas pelo usurio em tempo de execuo, o resultado de um clculo especfico ou uma parte dos dados que voc quer exibir em um formulrio. Em resumo, as variveis so contineres teis que voc pode utilizar para armazenar e monitorar quase todo tipo de informao. As variveis tm mbitos diferentes, ou seja, lugares onde esto disponveis. Normalmente elas so divididas entre variveis locais e globais. As variveis globais so as que esto declaradas no mbito mais amplo possvel. Essas variveis so acessveis de qualquer lugar do aplicativo. J as variveis locais, so usadas em lugares mais dimensionados, como por exemplo, um mtodo. Quando se declara variveis locais, somente podemos acess-las dentro do lugar aonde tenha sido declarada, ou seja, se havamos declarado em um mtodo somente podemos acess-la quando estivermos nesse mtodo. A declarao de variveis no C# e no Visual Basic .Net diferem bastante uma da outra. Em C# escrevemos o tipo da varivel e seu nome, j no Visual Basic .Net utilizamos a palavra-chave Dim, ento o nome da varivel e o seu tipo. Vejamos no exemplo a sintaxe nas duas linguagens, onde vamos declarar uma varivel chamada i do tipo String:
- Sintaxe C#: String i; - Sintaxe Visual Basic .Net: Dim i As String
Tipos de variveis:
byte sbyte int/Integer uint long ulong short ushort decimal double
Inteiro de 8 bits sem sinal Inteiro Inteiro com sinal de 8 bits Inteiro Inteiro de 32 bits com sinal Inteiro Inteiro de 32 bits sem sinal Inteiro Inteiro com sinal de 64 bits Inteiro Inteiro sem sinal de 64 bits Inteiro Inteiro com sinal de 16 bits Inteiro Inteiro sem sinal de 16 bits Inteiro Ponto flutuante decimal. Este tipo tem uma preciso de 28 casas decimais. Ponto Ponto flutuante binrio. Este tipo tem uma preciso de 15 casas decimais. Ponto
Ponto float/single Ponto flutuante binrio. Este tipo tem uma preciso de 7 casas decimais. Tipo bool/Boolean Tipo de dados booleano. Pode ser apenas true ou false.
char string
Um nico caractere unicode de 16 bits. Um Unicode com at 1 gigabyte de caracteres. Unicode
Esses so os tipos mais comuns de variveis no Visual Basic .Net e no C#, algumas s se diferem na sintaxe, mas suas especificaes so as mesmas.
Laboratrio 1 - Variveis
Neste laboratrio iremos aprender a declarar variveis e conhecer o comando Console.WriteLine() para mostrar uma mensagem na tela. - Exerccio: 1. Primeiramente abra o Visual Studio 2008, ento crie um novo projeto em File\New Project... 2. Aparecer uma tela, nela voc poder escolher a linguagem e a verso do .Net Framework. Crie um projeto Console Application chamado Variaveis como mostra a Figura 1.
Figura 1 Criando um novo projeto.
3. Agora dever aparecer a tela principal do projeto, com o arquivo Program.cs aberto, como mostra a Figura 2 em C# ou Module1.vb como mostra a Figura 3 em Visual Basic .Net.
Figura 2 Tela principal do projeto em C#.
Figura 3 Tela principal do projeto em Visual Basic .Net.
4. Agora dentro do static void Main(string[] args)em C# ou no Sub Main() em Visual Basic .Net, que so os mtodo principais do projeto, iremos declarar a varivel do tipo String chamada nome e atribuir a ela a String Jos, como na Figura 4 e 5.
using using using using
System; System.Collections.Generic; System.Linq; System.Text;
namespace Variaveis { class Program { static void Main(string[] args) { string nome; nome = "Jos"; } } } Figura 4 Declarao e atribuio a varivel em C#.
Module Module1 Sub Main() Dim nome As String nome = "Jos"
End Sub End Module

Figura 5 Declarao e atribuio a varivel em Visual Basic .Net
Microsoft Innovation Center 17 Desenvolvimento em .Net 5. Ento agora, utilizando o comando Console.WriteLine(), que um mtodo que faz parte do Framework .Net, que utilizado para mostrar valores em uma tela de prompt. Iremos mandar como parmetro para o mtodo Console.WriteLine() a nossa varivel nome para que seu valor seja mostrado na tela, como ilustra a Figura 6 em C# e a 7 em Visual Basic .Net.
namespace Variaveis { class Program { static void Main(string[] args) { string nome; nome = "Jos"; Console.WriteLine(nome); } } } Figura 6 Parmetro enviado ao mtodo Console.WriteLine() em C#.
Module Module1 Sub Main() Dim nome As String nome = "Jos" Console.WriteLine(nome)
End Sub End Module Figura 7 Parmetro enviado ao mtodo Console WriteLine() em Visual Basic .Net.
6. Salve seu projeto, execute-o apertando o atalho Ctrl + F5 e veja o resultado.
Operadores
Operadores aritmticos: So os operadores matemticos clssicos, que permitem somar, subtrair, multiplicar e dividir nmeros ou variveis que contenham nmeros.
+/& / * = % ^
Operadores lgicos:
Soma de dois nmeros, ou concatenao
Subtrao de dois nmeros
Diviso de dois nmeros
Multiplicao de dois nmeros
Nesse caso, atribuio de valor
Resto da diviso inteira de um nmero por outro Exponenciao
So aqueles que manipulam os valores lgicos True (verdadeiro) e False (falso). Sua sintaxe muda de linguagem para linguagem, mas suas funes continuam as mesmas.
E lgico: retorna verdadeiro se todos os valores da expresso forem verdadeiros e falso em qualquer outro caso
&& / AndAlso
|| / OrElse
Ou lgico: retorna falso somente se todos os valores da expresso forem falsos e verdadeiro em qualquer outro caso
! / Not
No lgico: "nega", ou melhor, inverte o valor lgico da expresso
Microsoft Innovation Center 19 Desenvolvimento em .Net Operadores relacionais: Servem para comparao de dados. Dependendo da linguagem a sintaxe diferente, mas as funes se mantm.
< <= > >= == / = != / <>
Menor que Menor ou igual a Maior que Maior ou igual a Nesse caso, igual a Diferente de
Laboratrio 2 Operadores
Neste laboratrio veremos como utilizar alguns operadores e vamos conhecer o comando Console.ReadLine().
- Exerccio: 1. Primeiramente abra o Visual Studio 2008, ento crie um novo projeto em File\New Project... 2. Aparecer uma tela, nela voc poder escolher a linguagem e a verso do .Net Framework. Crie um projeto Console Application chamado Operadores como mostra a Figura 7.
3. Agora dever aparecer a tela principal do projeto, com o arquivo Program.cs aberto em C# e o Module1.vb em Visual Basic .Net, como mostra a Figura 8 e 9.
4. Agora no mtodo Main, vamos declarar duas variveis do tipo decimal, chamadas num1 e num2. E utilizando o comando Console.WriteLine() mostraremos a mensagem Digite dois nmeros: na tela, como na Figura 10 em C# e a 11 em Visual Basic .Net.
using using using using System; System.Collections.Generic; System.Linq; System.Text;
namespace Operadores { class Program { static void Main(string[] args) { decimal num1; decimal num2; Console.WriteLine("Digite dois numeros: "); Figura 11 Declarao das variveis em C#.
Module Module1 Sub Main() Dim num1 As Decimal Dim num2 As Decimal Console.WriteLine("Digite dois nmeros: ") Figura 12 Declarao das variveis em Visual Basic .Net.
Microsoft Innovation Center 22 Desenvolvimento em .Net 5. Vamos utilizar o comando Console.ReadLine() para capturar os dois nmeros que pedimos para o usurio digitar. Em C#, este comando, por padro, s captura valores String, para armazenar o valor digitado nas nossas variveis teremos que converter o que foi digitado para o tipo decimal, usando o comando Convert.ToDecimal(). A sintaxe dever ficar semelhante Figura 12 e 13.
num1 = Convert.ToDecimal(Console.ReadLine()); num2 = Convert.ToDecimal(Console.ReadLine()); Figura 13 Captura e converso dos nmeros digitados em C#. num1 = Console.ReadLine() num2 = Console.ReadLine() Figura 14 Captura dos nmeros digitados em Visual Basic .Net.
6. Agora utilizando o comando Console.WriteLine() iremos mostrar na tela todas as operaes aritmticas possveis com os nmeros que foram digitados. Alm de utilizar os operadores aritmticos, tambm veremos o uso do + em C# e & em Visual Basic .Net, para realizar concatenaes. O cdigo dever ficar semelhante Figura 14 e 15.
Console.WriteLine("Soma: "+ num1 +" + "+ num2 +" = "+ (num1 + num2)); Console.WriteLine("Subtrao: " + num1 + " - " + num2 + " = " + (num1 - num2)); Console.WriteLine("Diviso: " + num1 + " / " + num2 + " = " + (num1 / num2)); Console.WriteLine("Multiplicao: " + num1 + " * " + num2 + " = " + (num1 * num2)); Figura 15 Apresentao dos resultados em C#. Console.WriteLine("Soma: " & num1 & " num2)) Console.WriteLine("Subtrao: " & (num1 - num2)) Console.WriteLine("Diviso: " & (num1 / num2)) Console.WriteLine("Multiplicao: " & (num1 * num2)) + " & num2 & " = " & (num1 + " & num1 & " - " & num2 & " = & num1 & " / " & num2 & " = " num1 & " * " & num2 & " = " &
Figura 16 Apresentao dos resultados em Visual Basic .Net.
Entre as aspas, colocamos palavras e caracteres que desejamos mostrar como texto e para fazer as variveis que digitamos aparecem em meio ao texto utilizamos o + e o nome da varivel. E por fim colocamos a operao que ser executada entre as duas variveis, desse modo o resultado j ser mostrado, sem a necessidade de que esse resultado seja armazenado em uma varivel.
Estruturas de Deciso
As Estruturas de Deciso utilizam expresses condicionais para controlar quais instrues devem ser executadas e em qual ordem. Existem duas estruturas que cuidam para realizar essa funo, a estrutura Se ou a Escolha. Primeiramente vamos entender o que uma expresso condicional. Esta uma expresso que sempre retorna um valor booleano, ou seja, verdadeiro ou falso, utilizando os operadores relacionais.
Estrutura Se:
No caso da estrutura Se temos a seguinte sintaxe nas linguagens .Net: - Sintaxe em C#: If ( expresso condicional ) { bloco de cdigo 1 } else if ( expresso condicional ) { bloco de cdigo 2 } else { bloco de cdigo 3 }
- Sintaxe em Visual Basic .Net:

If expresso condicional bloco de cdigo 1 ElseIf expresso condicional bloco de cdigo 2 Else bloco de cdigo 3 End If
Assim, se a primeira expresso condicional for verdadeira, o bloco de cdigo 1 ser executado e os demais no sero utilizados. Caso a primeira expresso seja falsa, a segunda expresso ser testada, se for verdadeira o bloco de cdigo 2 ser executado. Ento se a primeira e a segunda expresso forem falsas, automaticamente, o bloco de cdigo 3 ser executado, porque ele no possui a palavra-chave if, apenas else. Ele como um plano de emergncia, caso todos falhem, ele entra em ao. Lembrado que a estrutura Se no precisa obrigatoriamente conter um else no fim e, o else if pode ser utilizado quantas vezes forem necessrias.
Estrutura Escolha: Voc tambm pode controlar a execuo de instrues em programas utilizando a estrutura de deciso Escolha. Ela semelhante estrutura Se, mas, mais eficiente quando o desvio depende de uma varivel-chave ou, caso de teste. Voc tambm pode utilizla para deixar o cdigo mais legvel. - Sintaxe em C#: switch ( varivel-chave ) { case valor1: bloco de cdigo 1 break; case valor2: bloco de cdigo 2 break; default: bloco de cdigo 3 break; }
A estrutura Escolha v o contedo da varivel-chave, ento dependendo do seu valor executa um bloco de cdigo. Caso nenhum dos valores seja o mesmo, o default acionado e o bloco de cdigo 3 executado.
Microsoft Innovation Center 25 Desenvolvimento em .Net - Sintaxe em Visual Basic .Net: Select Case varivel Case valor1 bloco de cdigo 1 Case valor2 bloco de cdigo 2 Case Else bloco de cdigo 3 End Select
Assim como a estrutura Escolha em C#, ela v o contedo da varivel-chave, ento dependendo do seu valor executa um bloco de cdigo. Caso nenhum dos valores seja o mesmo, o Case Else acionado e o bloco de cdigo 3 executado.
Laboratrio 3 Estrutura de Deciso
Neste laboratrio ser realizado a criao de um menu bsico e a utilizao das estruturas Se e Escolha para gerenciar logins de usurios diferentes.
- Exerccio:
1. Primeiramente abra o Visual Studio 2008, ento crie um novo projeto em File\New Project... 2. Aparecer uma tela, nela voc poder escolher a linguagem e a verso do .Net Framework. Crie um projeto Console Application chamado EstruturasDecisao como mostra a Figura 15.
3. Agora dever aparecer a tela principal do projeto, com o arquivo Program.cs em C# ou Module1.vb em Visual Basic .Net aberto, como mostra a Figura 16 e 17.
4. Primeiramente vamos declarar as variveis que sero utilizadas. Usaremos uma varivel do tipo Int em C# e Integer em Visual Basic . Net, que ser nossa varivelchave. Ela ir se chamar resp. E vamos declarar duas Strings chamadas login e senha, que armazenaro respectivamente o login e a senha que o usurio digitar. Vamos declarar tambm quatro variveis String, chamadas admin e senhaAdmin, usurio e senhaUsuario, que sero inicializadas contento o login e senha corretos do Administrador e do Usurio.
static void Main(string[] args) { int resp; string login; string senha; string admin = "Professor"; string senhaAdmin = "admin"; string usuario = "Aluno"; string senhaUsuario = "123"; Figura 20 Variveis que sero utilizadas em C#.
Module Module1 Sub Main() Dim resp As Integer Dim login As String Dim senha As String Dim admin As String = "Professor" Dim senhaAdmin As String = "admin" Dim usuario As String = "Aluno" Dim senhaUsuario As String = "123" Figura 21 Variaveis que sero utilizadas em Visual Basic .Net.
Microsoft Innovation Center 28 Desenvolvimento em .Net 5. Vamos criar um menu simples onde o usurio poder escolher logar como Administrador ou Usurio, ou se desejar, sair do aplicativo.Ento vamos capturar o que o usurio digitar e armazenar na varivel-chave.Lembrando que o comanado Console.ReadLine() em C#, s captura valores String, temos que converter o valor capturado pra Int para que seja armazenado na nossa varivel, como mostra Figura 20.
Console.WriteLine("- Console.WriteLine("|1Console.WriteLine("|2Console.WriteLine("|3Console.WriteLine("- - - Logon Logon Sair - - - - - - -"); Admin |"); Usuario |"); |"); - - - - -");
resp = Convert.ToInt32(Console.ReadLine()); Figura 22 Estrutura do menu em C#. Console.WriteLine("- Console.WriteLine("|1Console.WriteLine("|2Console.WriteLine("|3Console.WriteLine("- - - Logon Logon Sair - - - - - - -") Admin |") Usuario |") |") - - - - -")
resp = Console.ReadLine() Figura 23 Estrutura do menu em Visual Basic .Net.
6. Como cada uma das opes dadas ao usurio deve realizar tarefas diferentes, iremos utilizar a estrutura de Deciso Escolha para implementar cada opo. Como a varivel resp guarda o valor da opo que o usurio escolheu, ela ser nossa varivel-chave no Escolha. Ento caso o usurio escolha a opo 1, ser pedido que ele digite o login do Administrador e a senha. Utilizando uma estrutura Se, vamos verificar se o login e a senha digitados so iguais as variveis admin e senhaAdmin. Caso sejam iguais, mostraremos a mensagem de confirmao do login, caso no sejam iguais mostramos uma mensagem de login ou senha invlida.
switch (resp) { case 1: Console.WriteLine("Digita o login de Administrador:"); login = Console.ReadLine(); Console.WriteLine("Digite a senha:"); senha = Console.ReadLine(); if ((login == admin) && (senha == senhaAdmin)) { Console.WriteLine("Login Efetuado com Sucesso!"); } else { Console.WriteLine("Login ou Senha Incorretos"); } break; Figura 24 Estrutura do caso 1 em C#.

Select Case resp Case 1 Console.WriteLine("Digite o login de Administrador:") login = Console.ReadLine() Console.WriteLine("Digite a Senha:") senha = Console.ReadLine() If login = admin AndAlso senha = senhaAdmin Then Console.WriteLine("Login Efetuado com Sucesso!") Else Console.WriteLine("Login ou Senha Incorretos!") End If
Figura 25 Estrutura do caso 1 em Visual Basic .Net.
7. Caso o usurio escolha a opo 2, crie uma estrutura semelhante a que criamos anteriormente, apenas substitua a varivel admin por usurio e senhaAdmin por senhaUsuario. O cdigo dever ficar semelhante Figura 24 em C# e 25 em Visual Basic .Net.
case 2: Console.WriteLine("Digite o login de Usurio:"); login = Console.ReadLine(); Console.WriteLine("Digite a senha:"); senha = Console.ReadLine(); if ((login == usuario) && (senha == senhaUsuario)) { Console.WriteLine("Login Efetuado com Sucesso!"); } else { Console.WriteLine("Login ou Senha Incorretos"); Console.Clear(); } break;
Figura 26 Estrutura do caso 2 em C#.
Case 2 Console.WriteLine("Digite o login de Usuario:") login = Console.ReadLine() Console.WriteLine("Digite a Senha:") senha = Console.ReadLine() If login = usuario AndAlso senha = senhaUsuario Then Console.WriteLine("Login Efetuado com Sucesso!") Else Console.WriteLine("Login ou Senha Incorretos!") End If
Figura 27 Estrutura do caso 2 em Visual Basic .Net.
Microsoft Innovation Center 30 Desenvolvimento em .Net 8. No caso da opo 3, como apenas para finalizar o programa, mostraremos uma mensagem dizendo que o programa ser finalizado. E tambm criaremos a opo Default, para caso o usurio no digite nenhuma das trs opes mostradas na tela, aparea mensagem de opo invalida.
case 3: Console.WriteLine("Fechando o Aplicativo!"); break; default: Console.WriteLine("Opo Invalida!"); break;

Figura 28 Caso 3 e o fechamento das estruturas em C#.
Case 3 Console.WriteLine("Fechando o Aplicativo!") Case Else Console.WriteLine("Opo Invalida!") End Select

Figura 29 = Caso 3 e o fechamento das estruturas em Visual Basic .Net.
9. Agora salve o seu projeto, execute-o e veja o resultado.
Laboratrios extras
1) Trabalhando com operadores. Crie uma aplicao do tipo Console Applicattion que receba do usurio o seu peso e a sua altura, e realize o calculo do IMC (ndice de Massa Corporal) do usurio. Lembrando que a formula para calcular o IMC IMC = Peso/Altura.
2) Utilizando Estruturas de Deciso. Crie uma aplicao semelhante anterior, mas agora introduza a tabela abaixo ao aplicativo: IMC < 19,99 20 24,99 25 29,99 30 35 > 35 CLASSIFICAO Magreza Normal Excesso de Peso Obesidade Grande Obesidade
Aps o clculo do IMC, utilize uma estrutura de deciso para que, dependendo do valor calculado, verifique em que classificao o usurio se encontra, e mostre a classificao na tela.
Captulo II Estruturas de repetio

Tpicos abordados:
Importncia da utilizao de estruturas de repetio; Estrutura Repita; Laboratrio 1 - Repita Estrutura Para; Laboratrio 2 - Para; Estrutura Enquanto; Laboratrio 3 Enquanto;
As estruturas de repetio ou iterao so de crucial importncia para a programao. Elas possibilitam executar um mesmo trecho de cdigo vrias vezes seguidas, enquanto um dado critrio no satisfeito. Qualquer estrutura de repetio funciona com uma varivel que chamamos de sentinela (conhecida tambm como contador). Essa varivel ir ditar quando o programa dever sair da repetio e geralmente tem trs caractersticas: I. II. III. Qual valor essa varivel ir iniciar. Como esta varivel ter seu valor alterado para que chegue ao valor final. Qual valor essa varivel deve atingir para que a repetio pare.
A varivel de controle ou sentinela sempre dever ter essas caractersticas ou poder ocorrer um erro que chamamos de loop infinito. Isso ocorre por causa do erro de lgica, no qual a varivel sentinela nunca chega ao seu resultado final.
Estrutura Repita
Esta estrutura executa um grupo de instrues at que certa condio seja verdadeira. Este tipo de loop valioso porque voc pode no saber de antemo quantas vezes dever ser repetido. Por exemplo, talvez voc queira que o usurio repita um processo de cadastramento de funcionrios at que ele responda No para a pergunta Deseja cadastrar outro funcionrio?. Nesse caso, voc pode utilizar a estrutura de repetio Repita que se repetir indefinidamente at que a string de texto No seja inserida. - Sintaxe C# Do { bloco de instrues a ser executado } While(condio);
Microsoft Innovation Center 33 Desenvolvimento em .Net Em C# utilizamos a palavra-chave Do ento entre chaves ( { } ), inserimos o trecho de cdigo ser repetido. Aps a chave ( } ) que fecha o bloco de cdigo, inserimos a palavra-chave While com a condio que desejamos satisfazer para interromper a repetio entre parnteses. A estrutura Repita em Visual Basic .Net representada nas linguagens de programao dessa maneira pelas palavras Do...While: - Sintaxe Visual Basic .Net Do bloco de instrues a ser executado Loop While condio No caso do Visual Basic .Net utilizamos a palavra chave Do, ento em seguida inserido o trecho de cdigo a ser executado repetidamente. Aps o trecho de cdigo, inserimos as palavras-chave Loop While e a condio que queremos satisfazer para que a repetio seja interrompida.
Laboratrio 1 Repita
Neste Laboratrio iremos utilizar a estrutura Repita para calcular a mdia de vrios alunos. Como o numero de alunos no ser definido, utilizaremos a estrutura repita para calcular as mdias quantas vezes forem necessrias. Exerccio: 1. Para criar um novo projeto, no menu do Visual Studio selecione File\New Project... 2. Aparecer a tela abaixo, onde voc poder escolher a linguagem e verso do .NET Framework. Crie um projeto Console Application chamado LoopRepita como mostra a Figura 1.
3. Agora vamos declarar as variveis que sero utilizadas para realizar os clculos e apresentar os resultados. Declare quatro variveis do tipo Double com os nomes: nota1, nota2, nota3 e media. E por fim declare uma varivel do tipo String chamada resp, est ser nossa varivel sentinela (ou varivel de controle). O cdigo dever ficar semelhante Figura 2 em C# ou 3 em Visual Basic .Net.
static void Main(string[] args) { double nota1; double nota2; double nota3; double media; string resp; Figura 2 Declarao das variveis em C#.
Sub Main() Dim Dim Dim Dim
nota1 nota2 nota3 media
As As As As
Double Double Double Double
Dim resp As String

Figura 3 Declarao das variveis em Visual Basic .Net.
4. Criaremos agora o bloco de cdigo que ser repetido caso o usurio necessite. Com o comando Console.WriteLine() mostraremos na tela o pedido para o usurio digitar a nota (Lembrando que nmeros decimais devem ser digitados utilizando vrgula ex: 5,5). E com o comando Console.ReadLine() atribuiremos varivel o valor que o usurio digitou. Como em C# o comando Console.ReadLine() s captura string, teremos que utilizar o comando de converso Convert.ToDouble() para converter o que o usurio digitar na tela para o tipo Double. Por fim atribuiremos varivel media o valor da soma das trs notas divido por trs e mostraremos uma mensagem na tela com o valor da media. O cdigo dever ficar semelhante Figura 4 em C# ou 5 em Visual Basic .Net.
Console.WriteLine("Digite a primeira nota"); nota1 = Convert.ToDouble(Console.ReadLine()); Console.WriteLine("Digite a segunda nota"); nota2 = Convert.ToDouble(Console.ReadLine()); Console.WriteLine("Digite a terceira nota"); nota3 = Convert.ToDouble(Console.ReadLine()); media = (nota1 + nota2 + nota3) / 3; Console.WriteLine("Sua mdia : " + media); Figura 4 Visualizao e captura de texto em C#. Console.WriteLine("Digite a primeira nota") nota1 = Console.ReadLine() Console.WriteLine("Digite a segunda nota") nota2 = Console.ReadLine() Console.WriteLine("Digite a terceira nota") nota3 = Console.ReadLine() media = (nota1 + nota2 + nota3) / 3 Console.WriteLine("Sua mdia : " & media) Figura 5 Visualizao e captura de texto em Visual Basic .Net.
5. Caso o usurio queria realizar outra consulta de mdia, devemos colocar o cdigo de leitura das notas e apresentao da mdia dentro da estrutura de repetio e alimentar a varivel de controle resp, para o usurio interromper a repetio quando
Microsoft Innovation Center 36 Desenvolvimento em .Net desejar. Iremos mostrar na tela a pergunta Deseja realizar outro calculo de mdia?, e com a resposta dada pelo usurio alimentaremos a varivel resp, ento colocaremos como condio para interromper a repetio que a varivel resp seja igual string Sim. O cdigo dever estar semelhante Figura 6 em C# ou 7 em Visual Basic .Net.
do { Console.WriteLine("Digite a primeira nota"); nota1 = Convert.ToDouble(Console.ReadLine()); Console.WriteLine("Digite a segunda nota"); nota2 = Convert.ToDouble(Console.ReadLine()); Console.WriteLine("Digite a terceira nota"); nota3 = Convert.ToDouble(Console.ReadLine()); media = (nota1 + nota2 + nota3) / 3; Console.WriteLine("Sua mdia : " + media); Console.WriteLine("Deseja realizar outro calculo de media?"); resp = Console.ReadLine(); }while(resp == "sim"); Figura 6 Estrutura de repetio em C#.
Do Console.WriteLine("Digite a primeira nota") nota1 = Console.ReadLine() Console.WriteLine("Digite a segunda nota") nota2 = Console.ReadLine() Console.WriteLine("Digite a terceira nota") nota3 = Console.ReadLine() media = (nota1 + nota2 + nota3) / 3 Console.WriteLine("Sua mdia : " & media) Console.WriteLine("Deseja realizar outro calculo de mdia?") resp = Console.ReadLine() Loop While resp = "sim" Figura 7 Estrutura de repetio em Visual Basic .Net
6. Agora salve o seu projeto e execute-o apertando Ctrl + F5 para realizar os testes.
Estrutura Para
Esta estrutura executa um grupo especfico de instrues em uma quantidade prdeterminada de vezes. A estrutura Para testa uma condio para executar um bloco de cdigo e, at que essa condio seja verdadeira, este trecho de cdigo ser executado. Para usar esta estrutura necessrio declarar sua inicializao, a condio e o incremento. Representada na linguagem de programao pela palavra-chave For, desta maneira: - Sintaxe C#:
For(varivel = valor inical;condio;incremento) { bloco de instrues a ser executado }
No caso do C#, utilizamos a palavra-chave For e atribumos varivel de controle o valor que desejamos que ela iniciasse na repetio. Ento separando por ponto e vrgula ( ; ) colocamos a condio para interromper a repetio e novamente separando com ponto e vrgula inserimos o incremento(ex: varivel++, ser sempre incrementado +1 no valor da varivel). Agora entre as chaves ( { } ) inserimos o trecho de cdigo que ser repetido. - Sintaxe Visual Basic .Net:
Ex:. 1 For varivel = valor inicial To valor final bloco de instrues a ser executado Next varivel Ex:.2 For varivel = valor inicial To valor final Step incremento bloco de instrues a ser executado Next varivel
No Visual Basic .Net utilizamos a palavra-chave For e atribumos varivel de controle o valor que desejamos que ela iniciasse na repetio. Ento utilizamos a palavra-chave To e aps ela colocamos o valor que desejamos que a varivel de controle ao chegar, encerre a repetio. Inserimos o bloco de cdigo a ser repetido e por fim, utiliza-se a palavra Next e aps ela, a varivel que ser incrementada. No caso do exemplo dois colocada a palavra-chave Step, sendo esta responsvel por definir o valor que ser incrementado. Quando esta palavrachave no utilizada o valor padro do incremento igual a um (1).
Laboratrio 2 Para
Neste Laboratrio iremos adicionar elementos a um ComboBox utilizando a estrutura de repetio Para. Exerccio: 1. Vamos criar um novo projeto, no menu do Visual Studio selecione File\New Project... 2. Aparecer a tela abaixo, onde voc poder escolher a linguagem e verso do .NET Framework. Crie um projeto Windows Forms Application chamado LoopFor como mostra a Figura 8.
3. Agora utilizando a Toolbox,daremos um clique no controlador Button e vamos arrastlo ate o topo do Form que est presente na tela. Faremos o mesmo com a ComboBox e com uma Label. O Form dever ficar semelhante Figura 9.
Figura 9 Organizao do Form.
Microsoft Innovation Center 39 Desenvolvimento em .Net 4. Agora dando apenas um clique sobre o controle button1, podemos acessar suas propriedades. Ento mudaremos a propriedade Text do Button para Carregar, como mostra a Figura 10.
Figura 10 Propriedades do controlador Button.
5. Clique duas vezes sobre o boto Carregar, e ento ser aberta a tela com o cdigo do arquivo Form1.cs no mtodo button1_Click, onde iremos inserir os eventos que ocorrero aps um clique sobre o boto. Dentro deste mtodo, primeiramente vamos declarar uma varivel do tipo Int em C# ou Integer em Visual Basic .Net, chamada i. O cdigo deve estar semelhante Figura 11 em C# ou 12 em Visual Basic .Net.
using using using using using using using using
System; System.Collections.Generic; System.ComponentModel; System.Data; System.Drawing; System.Linq; System.Text; System.Windows.Forms;
namespace LoopFor { public partial class Form1 : Form { public Form1() { InitializeComponent(); } private void button1_Click(object sender, EventArgs e) { int i; Figura 11 Chamada do evento button1_Click em C#. Public Class Form1 Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click Dim i As Integer Figura 12 Chamada do evento button1_click em Visual Basic .Net.
Microsoft Innovation Center 40 Desenvolvimento em .Net 6. Agora criaremos a estrutura For usando como varivel de controle a varivel que acabamos de declarar. Ento colocaremos dentro do For o comando comboxBox1.Items.Add(Linha + i) em C#, em Visual Basic .Net apenas substitumos o + por &, para adicionar a ComboBox um nmero de linhas i, conforme especificado na estrutura do nosso For (este caso iremos inserir 10 linhas). O prximo passo mudar a propriedade Text da Label para Itens Inseridos quando o For inserir as linhas ao ComboBox. O cdigo deve ficar semelhante Figura 13 em C# e 14 em Visual Basic .Net.
private void button1_Click(object sender, EventArgs e) { int i; for (i = 1; i <= 10; i++) { comboBox1.Items.Add("Linha " + i); label1.Text = "Itens Inseridos"; } } Figura 13 Estrutura do For em C#.
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click Dim i As Integer For i = 1 To 10 ComboBox1.Items.Add("Linha " & i) Label1.Text = "Itens Inseridos" Next End Sub Figura 14 Estrutura do For em Visual Basic .Net.
7. Agora salve o seu projeto e execute-o apertando Ctrl + F5. Note que a ComboBox est vazia, ento realize o teste.
Estrutura Enquanto
A estrutura Enquanto geralmente utilizada quando o nmero de repeties desconhecido. Nesta estrutura efetuado um teste antes de se entrar no bloco de repetio e a continuidade da execuo deste cdigo verificada pelo mesmo teste. A diferena bsica da estrutura Enquanto para as demais estruturas a existncia do teste antes de entrar no bloco de repetio. Enquanto as outras estruturas realizam o teste no final do bloco, garantindo assim que o trecho de cdigo seja executado ao menos uma vez. Na estrutura Enquanto o teste ocorre no comeo, e caso seja False o trecho de cdigo existente dentro do Enquanto no executado nenhuma vez e o programa salta para a primeira linha aps o termino da estrutura. A estrutura Enquanto representada nas linguagens de programao desta maneira:
- Sintaxe C#: while(condio) { bloco de instrues a ser executado }
No C# utilizamos a palavra-chave While e entre parnteses ( ) a condio que deve ser saciada para que o trecho de cdigo entre as chaves ( { } ), que significam a abertura e fechamento da estrutura, seja executado.
- Sintaxe Visual Basic .Net: Do While Condio bloco de instrues a ser executado Loop
No Visual Basic .Net utilizamos as palavras-chave Do e While,em seguida a condio que dever ser True para que o bloco de instrues seja executado. E fechando a estrutura utiliza-se a palavra Loop.
Laboratrio 3 Enquanto
Neste laboratrio iremos simular um controle de login utilizando a estrutura Enquanto. Exerccio: 1. Vamos criar um novo projeto, no menu do Visual Studio selecione File\New Project... 2. Aparecer a tela abaixo, onde voc poder escolher a linguagem e verso do .NET Framework. Crie um projeto Console Application chamado LoopWhile como mostra a Figura 15.
Figura 15 Criando novo projeto.
3. Primeiramente, iremos declarar as variveis do tipo String que utilizaremos para armazenar o login e a senha, que sero digitados pelo usurio. 4. Em seguida, utilizaremos os comandos Console.WriteLine() para mostrar na tela uma mensagem para o usurio digitar o login e a senha, e Console.ReadLine() para capturar o que o usurio digitar. O cdigo dever ficar semelhante Figura 16 em C# e 17 em Visual Basic .Net.
using using using using System; System.Collections.Generic; System.Linq; System.Text;
namespace LoopWhile { class Program { static void Main(string[] args) { string login; string senha; Console.WriteLine("Digita seu Login: "); login = Console.ReadLine(); Console.WriteLine("Digita sua senha: "); senha = Console.ReadLine();
Figura 16 Mensagem e captura de texto em C#.
Sub Main() Dim login As String Dim senha As String Console.WriteLine("Digite o seu Login: ") login = Console.ReadLine() Console.WriteLine("Digite a sua senha: ") senha = Console.ReadLine() Figura 17 Mensagem e captura de texto em Visual Basic .Net.
5. Agora criaremos a estrutura Enquanto para gerenciar o que o usurio digitar. Caso ele digite o login e senha corretos, mostraremos na tela a mensagem: Login Realizado com Sucesso! e, caso contrario, mostraremos a mensagem: Login ou Senha invlidos e tambm ser pedido que o usurio digite novamente as informaes. Lembrando que o login e senha corretos sero definidos pelo programador na estrutura do seu Enquanto. 6. Nosso Enquanto ficar com as seguintes condies:
while ((login != "aluno") || (senha != "123")) { } Figura 18 Condies em C#.
Do While ((login <> "aluno") OrElse (senha <> "123")) Loop Figura 19 Condies em Visual Basic .Net.
O operador ! = em C# e <> em Visual Basic .Net, significac diferente e o operador lgico || significa ou, quer dizer, enquanto login for diferente de aluno ou senha for diferente de 123, o trecho de cdigo dentro do enquanto vai se repetir. Isso garante que enquanto o usurio no digitar o login e senha corretos (ou seja, aluno e 123), no conseguir prosseguir no aplicativo. 7. Agora dentro do Enquanto utilizando os comandos Console.WriteLine() e Console.ReadLine(), iremos mostrar a mensagem Login ou Senha invlidos e pedir para o usurio digitar novamente. Aps a chave ( } ) de fechamento do Enquanto, utilizando o Console.WriteLine() mostraremos a mensagem Login Realizado com Sucesso caso o usurio digite o login e senha corretos e a repetio seja interrompida. O trecho de cdigo deve ficar semelhante Figura 20 em C# e 21 em Visual Basic .Net.

static void Main(string[] args) { string login; string senha; Console.WriteLine("Digita seu Login: "); login = Console.ReadLine(); Console.WriteLine("Digita sua senha: "); senha = Console.ReadLine(); while ((login != "aluno") || (senha != "123")) { Console.WriteLine("Login ou Senha invalidos "); Console.WriteLine("Digita seu Login: "); login = Console.ReadLine(); Console.WriteLine("Digita sua senha: "); senha = Console.ReadLine(); } Console.WriteLine("Login Realizado com Sucesso!"); } Figura 20 Estrutura do Enquanto em C#. Sub Main() Dim login As String Dim senha As String Console.WriteLine("Digite o seu Login: ") login = Console.ReadLine() Console.WriteLine("Digite a sua senha: ") senha = Console.ReadLine() Do While ((login <> "aluno") OrElse (senha <> "123")) Console.WriteLine("Login ou Senha invlidos") Console.WriteLine("Digite o seu Login: ") login = Console.ReadLine() Console.WriteLine("Digite a sua senha: ") senha = Console.ReadLine() Loop Console.WriteLine("Login Realizado com Sucesso!") End Sub Figura 21 Estrutura do Enquanto em Visual Basic .Net.
8. Agora salve o seu projeto, execute-o apertando as teclas Ctrl + F5 e faa os testes.
Laboratrios extras
1) Soma de nmeros utilizando estruturas de repetio. Crie um Console Application, que capture um nmero digitado pelo usurio, ento some todos os nmeros inteiros entre 1 e o nmero que foi digitado e mostre o resultado desta soma na tela.
2) Diviso encadeada. Crie um Console Application, que capture um nmero digitado pelo usurio e divida-o por dois (sucessivamente) at que o resultado seja menor que 1. E mostre o resultado da ultima diviso efetuada.
3) Verificando intervalo de dados. Crie um Console Application, que capture uma quantidade desconhecida de nmeros digitados pelo usurio e conte quantos deles esto nos seguintes intervalos: [0,25], [26,50], [51,75], [76,100]. A entrada de dados deve terminar quando for lido um nmero negativo. 4) Somando intervalo de dados . Crie um Console Application. Capture um valor N inteiro positivo digitado pelo usurio, ento realize a seguinte soma: S = 1 + 1/2 + 1/3 + 1/4 + ... + 1/N . O aplicativo deve mostrar cada termo gerado e o valor final de S.
Captulo III Vetores

Tpicos abordados:
Conhecendo e utilizando vetores; Vetores unidimensionais; Vetores multidimensionais; Aplicaes especficas para vetores; Laboratrios - Desenvolvendo solues com vetores.
Todo desenvolvedor chega a um momento onde suas aplicaes comeam a crescer e juntamente a necessidade de armazenar uma grande quantidade de dados. Existem varias solues para suprir esse problema, porm, cabe a ns desenvolvedores, saber qual maneira utilizar em cada situao. Como visto anteriormente, podemos armazenar valores dentro de variveis, e esse valor deve corresponder ao tipo de varivel declarada. Mas agora se imagine na situao de armazenar cinco valores inteiros, criar cinco variveis para cuidar disso no uma tarefa difcil e nem trabalhosa, mas e quando nosso programa deve atingir um escala maior, em vez de cinco, precisamos guardar cinqenta, claro que podemos criar cinqenta variveis para armazenar nossos valores, contudo isso vai deixar nosso programa com o cdigo sujo, vai ser mais trabalhoso, e dependendo a forma de preencher essas variais, vai ser mais complexo tambm. Para solucionar isso temos duas maneiras, armazenar em um banco de dados, contudo isso algo mais complexo ainda e se nosso objetivo for variveis temporrias, ou seja, que no necessariamente preciso ficar armazenadas em uma base de dados, por isso devemos utilizar a nossa segunda opo, o que chamamos de vetores (ou conhecido tambm como array). Vetores possibilitam armazenar grandes conjuntos de dados, de um determinado tipo de valor, o que para ns desenvolvedores, economiza tempo e trabalho. No decorrer desse captulo voc vai entender melhor como utilizar os vetores, e aprender seu contexto dentro de aplicaes.
Caractersticas dos vetores
Uma definio bem simples de vetores dizer que so um tipo de varivel, que possui a capacidade de armazenar um determinado tipo de valor em uma determinada quantidade de vezes. Indiferente da linguagem de programao que vamos utilizar, vetores possuem as mesmas caractersticas, porm, sintaxes diferentes.
Microsoft Innovation Center 47 Desenvolvimento em .Net Abaixo temos as principais caractersticas que compem um vetor: I. II. III. IV. V. Podem armazenar um nmero definido de valores. Esse nmero deve ser informado pelo desenvolvedor na declarao de cada vetor; Na sua declarao devemos informar qual o tipo de valor que ser armazenado; Vetores podem armazenar qualquer tipo de dado, at mesmo vetores, ou seja, um vetor que armazena vetor; Vetores podem ser tanto globais como locais; Podem funcionar como forma temporria de armazenar grande quantidade de dados.
No podemos esquecer que os valores armazenados dentro dos vetores so temporrios assim como qualquer outro tipo de varivel.
Vetores unidimensionais
Esse o tipo de vetor que podemos chamar como simples, possui apenas uma dimenso, o que pode ser representado quando imaginamos uma fila de dados, ou seja, vetores com apenas uma dimenso armazenam seu dados em forma de fila, e como uma fila, cada valor tem sua posio. Observe o exemplo abaixo, ele representa a forma como devemos imaginar um vetor, no caso um vetor unidimensional, que pode guardar sete elementos, os quais estabelecidos como do tipo inteiro.
Exemplo Vetor de valores inteiros: 22 17 14 5 6 8 9
Os valores embaixo do vetor representam seu ndice.
Tanto na linguagem C# como em Visual Basic .Net, o ndice de cada vetor comea no valor zero, sendo assim, seu segundo valor tem o ndice de nmero um e assim sucessivamente. Algo que no podemos confundir que um vetor de sete elementos tem seu ndice de zero a seis e no de zero a sete (nesse caso estaria errado, pois o vetor teria ento oito posies). Cada ndice respectivo para cada elemento, podemos imaginar que cada elemento uma varivel que foi declarada, mas no caso, de uma forma bem mais simples e rpida. Utilizando o ndice podemos acessar cada elemento, e assim fazer o que for necessrio, atribuir um valor, aplicar algum clculo, ou mesmo esvazi-lo. Para executar estas aes existe um conjunto de mtodos que sero abordados mais adiante.
Microsoft Innovation Center 48 Desenvolvimento em .Net Vamos agora analisar como fica a sintaxe responsvel pelos vetores em cada linguagem. Por padro vetores devem sempre conter quatro especificaes na sua sintaxe: I. II. Nome do vetor assim como outro tipo de varivel, precisamos de um nome para trabalhar com o vetor dentro da nossa aplicao; Tipo de dados o tipo de dados que os elementos do vetor armazenaram, lembre-se que se o vetor guarda valores inteiros, no podemos armazenar valores do tipo real sem antes fazer uma converso, pois poder acontecer um erro no programa; Nmero de elementos a quantidade mxima que o vetor dar suporte; Nmero de dimenses - a maioria unidimensional ou bidimensional, mas possvel fazer vetores mais complexos com mais dimenses.
III. IV.
- Sintaxe de declarao em Visual Basic .Net: Dim NomeDoVetor ( Index ) As TipoDado Dim meuVetor (7) As Integer
Acima podemos conferir a sintaxe de declarao de um vetor na linguagem Visual Basic .Net. Vamos entender cada passo de sua declarao. Aps o uso da palavra-chave Dim, colocamos no espao NomeDoVetor o nome que usaremos para reconhecer nosso vetor dentro da aplicao (no caso ficou como meuVetor), logo em seguida entre parnteses colocamos o seu tamanho onde est escrito Index (estabelecido como sete no exemplo), por final, logo aps a palavra-chave As colocamos em TipoDado qual o tipo de dados que nosso vetor armazenar (utilizamos o tipo Integer). Dessa maneira podemos declarar vetores em nossas aplicaes, deixando prontos para serem utilizados.
- Sintaxe de declarao em C#: TipoDado[] NomeDoVetor= new TipoDado[ Index ]; int[] meuVetor = new int[7];
A sintaxe de declarao em C# um pouco diferente, mas no nada complicado. Primeiramente informamos qual ser o tipo de dado armazenado (utilizamos o tipo int), o tipo de dados vem acompanhado [] isso permite dizer que a varivel que estamos criando ser um vetor, logo aps damos o nome para o nosso vetor, para que seja reconhecido em nossa aplicao (no caso meuVetor), essa primeira parte nos permite criar o vetor, porm, apenas a segunda parte permite concretizar sua implementao, digitando as palavras-chave = new e completando novamente com o tipo de dado e seu tamanho entre os colchetes no lugar da
Microsoft Innovation Center 49 Desenvolvimento em .Net palavra-chave Index (como mostrado no exemplo, o valor sete). Feito isso temos nosso vetor declarado e pronto para ser utilizado em nossa aplicao C#. Note que em ambos os exemplos, os vetores eram declarados para armazenar sete elementos. Porm, no se esquea que ali especificamos seu tamanho, mas seus ndices ainda sero de zero a seis.
- Sintaxe de acesso C#: meuVetor[2] = 22; meuVetor[5] = 17 + 14; Console.WriteLine ( meuVetor[0] ); //imprime na janela console o valor do primeiro elemento meuVetor[7] = 3 * 3 //essa operao gera um erro - Sintaxe de acesso em Visual Basic .Net: meuVetor(2) = 22 meuVetor(5) = 17 + 14 Console.WriteLine( meuVetor(0) ) imprime na janela console o valor do primeiro elemento meuVetor(7) = 3 * 3 essa operao gera um erro
Vamos analisar os exemplos de acesso ao vetor. Nas duas linguagens a sintaxe bem parecida, a diferena que no local de parnteses em Visual Basic .Net para informar o ndice utilizamos colchetes em C# e ponto e virgula para finalizar a linha de cdigo. Com vetores, realizar uma atribuio ou mesmo alterar um elemento, simples, apenas definimos qual o elemento que desejamos modificar. O mesmo vale para a impresso de valores na tela, apenas indicamos qual valor apresentar. Dessa mesma maneira, podemos utilizar valores de diferentes elementos e realizar clculos com eles e tambm interagir com vetores diferentes. Olhando o ltimo exemplo de cada linguagem, temos um comentrio que indica que acontecer um erro. Isso no devido ao tipo de operao que est sendo feita (no caso uma multiplicao), mas sim imaginando que o vetor utilizado o declarado nos exemplos anteriores, ento possui sete elementos, sendo assim no podemos acessar o ndice sete, pois este representa o oitavo elemento, o qual nosso vetor chamado meuVetor no possui.
Vetores multidimensionais
Vetores como visto anteriormente, podem ter mais de uma dimenso, o que proporciona relaes e construo de estruturas mais complexas para as nossas aplicaes. Podem ser definidos tambm como sendo uma matriz ou comparado como uma tabela. Mesmo tendo a possibilidade de criar vetores com inmeras dimenses, a forma mais utilizada acaba sendo a utilizao de vetores bidimensionais.
Microsoft Innovation Center 50 Desenvolvimento em .Net Geralmente utilizamos vetores multidimensionais quando queremos armazenar dados e queremos por relaes entre eles, claro que essa relao feita imaginariamente por ns, contudo utilizando essas formas de variveis que conseguimos tempo e qualidade em nossos servios. Utilizando como exemplo a necessidade de armazenar em um vetor a temperatura mxima e mnima de cada dia da semana. Para isso precisaramos de dois vetores com sete elementos, mas pensando em varias dimenses poderamos criar um vetor bidimensional, imaginando ele como uma tabela, onde possuiria duas linhas e sete colunas. Uma coluna para cada dia da semana, e uma linha para cada tipo de temperatura. Olhando o exemplo abaixo podemos entender melhor essa situao:
Exemplo Vetor bidimensional 12 22 22 28 14 20 15 25 17 26 25 30 28 31
Veja como ficaria fcil acessar as temperaturas de um determinado dia. Por exemplo: digamos que devemos analisar a temperatura armazenada na Segunda-Feira, sendo assim vamos pegar os valores que esto na segunda coluna. Pensando como uma matriz, esses dois valores seriam (0, 1) e (1, 1), e praticamente com essa forma de pensamente que realizamos nossas aes dentro das aplicaes com vetores multidimensionais. Vamos conhecer a sintaxe de declarao dos vetores multidimensionais:
- Sintaxe em C#: TipoDado[][]... NomeDoVetor = new TipoDado[Index1][Index2]...; int[ , ] tempDia = new int[2 , 7];
- Sintaxe em Visual Basic .Net: Dim NomeDoVetor ( Index1, Index2, ... ) As TipoDado Dim tempDia (2, 7) As Decimal
Repare que a sintaxe de declarao apenas incrementou o que tnhamos com vetores unidimensionais. Independente da linguagem, o que adicionamos so as quantidades de Index, sendo que cada Index adicionado equivale a uma dimenso a mais no nosso vetor. Lembrando, que assim como unidimensionais, a sua declarao corresponde ao nmero total de elementos, mas quando vamos acess-los devemos usar o ndice de zero ao seu tamanho menos um. Os prximos exemplos mostram como realizar acesso a esses dados, leve em conta que suas declaraes so as do exemplo anterior.

- Sintaxe de acesso em C#: int diftemp; tempDia[0 , 2] = 27; diftemp = tempDia[0, 3] - tempDia[1,3]; tempDia[3 , 6] = 21;
- Sintaxe de acesso em Visual Basic .Net: Dim diftemp As Integer tempDia(0, 2) = 27 diftemp = tempDia(0, 3) - tempDia(1, 3) tempDia(3, 6) = 21
Analisando os exemplos, podemos ver que a utilizao desse vetor no muda muito do tipo unidimensional, a diferena que para cada nova dimenso necessitamos especificar seu ndice tambm, o que fica muito parecido quando realizamos clculos de matrizes.
Aplicaes especficas para vetores
Existem algumas particularidades quando trabalhamos com vetores. Conhec-las pode ajudar muito o desenvolvimento de nossas aplicaes. Essas particularidades quando no so iguais so muito parecidas entre as linguagens Visual Basic .Net e C#, graas ao fato de ambas terem como base a utilizao da plataforma .Net. Duas dessas particularidades so propriedades, chamadas Rank e Length. A primeira utilizada quando precisamos do nmero de dimenses que o nosso vetor possui, e a segunda se trata do nmero de elementos. A segunda propriedade, Length muito utilizada quando trabalhamos com estruturas de repetio que devem percorrer todo o vetor, assim em vez de escrever o nmero da quantidade de elementos que o vetor possui, escrevemos apenas o nome do vetor, colocamos um ponto e depois a palavra-chave Length. Mas por que utilizar essa propriedade? Vamos imaginar um exemplo: temos um vetor com vinte e duas posies, esse vetor percorrido no programa, inmeras vezes em estruturas de repetio, que analisam cada elemento por vez. Agora imagine que voc est pondo o nmero vinte e dois nos laos de repetio em vez da propriedade Length, se ocorrer uma mudana no tamanho do vetor, voc ter que alterar todos os laos de repetio tambm, para que no acontea nenhum erro. Mas se voc estiver trabalhando com a propriedade Length, nenhum esforo para arrumar os laos de repetio ser necessrio, j que essa propriedade sempre retorna o valor total de elementos do vetor. Veja abaixo um exemplo de utilizao do Length:
- Sintaxe em C#: int[] vetor = new int[22]; . . For (int i = 0; i < vetor.Length; i++) { // instrues do lao for }
- Sintaxe em Visual Basic .Net: Dim i As Integer Dim vetor(22) As Integer . . For i to vetor.Length instrues do lao for Next i
Um detalhe que no podemos esquecer que o Length retorna o nmero de elementos do vetor, mas quando for utilizar isso em um lao, o ndice do vetor vai de zero at nmero de elementos menos um. Outra aplicao que podemos realizar com vetores, o preenchimento na prpria declarao. Assim como os outros tipos de variveis que podem receber um valor na prpria declarao, vetores tambm podem receber valores durante suas declaraes. Observe o prximo exemplo para entender melhor como realizar isso:
- Sintaxe em C#: int[] Lista = {15, 17, 22, 8};
- Sintaxe em Visual Basic .Net: Dim Lista() As Integer = {15, 17, 22, 8}
Esse tipo de aplicao funcionar para qualquer quantidade de dimenses. Perceba que no precisamos identificar qual ser o tamanho do vetor, pois, ele considera esse tamanho pelo nmero de elementos adicionados na declarao. Sendo assim o vetor Lista, declarado no exemplo teria um tamanho de quatro elementos. Dependendo a situao em que nos encontramos, estabelecer os valores inicialmente pode ser de grande ajuda para o
Microsoft Innovation Center 53 Desenvolvimento em .Net nosso desenvolvimento. Vetores possuem muitas outras aplicaes prprias, mas conforme suas aplicaes forem crescendo, haver a necessidade de conhec-las. Por enquanto voc j aprendeu as principais.
Laboratrio 1 Vetores unidimensionais e barras de progresso
Neste laboratrio, vamos desenvolver uma aplicao que faa uso de um vetor unidimensional, para carregar valores em uma TextBox utilizando tambm barra de progresso para demonstrar o processo do nosso programa. - Desenvolvendo a soluo: 1. Primeiramente inicie o Visual Studio 2008. Voc pode encontr-lo acessando o menu Iniciar, depois procure em seus programas a pasta Microsoft Visual Studio, ento execute-o; 2. Espere o processo de inicializao do programa terminar. Navegue para o menu superior. Em File, escolha a opo New, depois Project, como mostra a Figura 1.
Figura 1 Caminho para criao de novos projetos.
3. Na nova janela que apareceu, devemos configurar as caractersticas do nosso projeto. D o nome de vetorProgresso para soluo, em Location coloque o local em que deseja salvar o projeto, marque a opo do Framework na mais recente (atualmente 3.5) e, em templates escolha a opo Windows Forms Application, lembrando que o projeto poder utilizar tanto a linguagem C# como Visual Basic .Net. Confira com a Figura 2 antes de finalizar a criao do novo projeto.
Figura 2 Janela para criao de novos projetos.
4. Feito isso vamos navegar para o design do nosso formulrio Form1. Adicione a ele os seguintes controles: uma ListBox, uma TextBox, dois Button, uma Label e uma ProgressBar. 5. Ao selecionar um desses controles depois de inseridos no formulrio, possvel acessar as suas propriedades pela janela Properties ou utilizando o atalho F4. Acesse as propriedades de cada controle e modifique de acordo com a tabela abaixo: Controle Label1 Button1 Button2 Button3 TextBox1 listBox1 Form1 Propriedade (Text) Digite um nmero para ser calculado: Calcular Exibir Limpar Propriedade (Name)
btnCalcular btnExibir btnLimpar txtNum lstLista
Vetores
6. Agora vamos alterar uma opo mais particular. Selecione o controle lstLista e procure sua propriedade ScrollAlwaysVisible, e mude seu valor para True. 7. Vamos organizar nosso formulrio, altere o tamanho dos controles e faa os ajustes necessrios para que fique parecido com a Figura 3.
Figura 3 Formulrio Form1 alterado.
8. Feito isso de um duplo clique no boto Calcular, o que far com que o Visual Studio crie automaticamente o evento click para esse boto. Todo cdigo implementado dentro desse boto ser sempre iniciado quando o usurio clicar sobre ele.
Microsoft Innovation Center 55 Desenvolvimento em .Net 9. Nosso laboratrio tem como objetivo utilizar um vetor, carreg-lo com clculos do nmero digitado pelo usurio, e depois exibir dentro da ListBox. Sendo assim vamos precisar utilizar um vetor declarado de maneira global, para que sempre tenhamos acesso. Faa sua declarao como mostra a Figura 4 e 5.
int[] lista = new int[500];
Figura 4 Implementao do vetor de inteiros chamado lista em C#.
Dim lista(500) As Integer
Figura 5 Implementao do vetor de inteiros chamado lista em Visual Basci .Net.
10. Agora vamos voltar para o cdigo do nosso boto Calcular. Esse evento ser responsvel por receber o nmero digitado pelo usurio na TextBox e realizar alguns clculos. Para isso vamos utilizar um lao de repetio e dentro dele fazer a atribuio para cada elemento do vetor. Vamos tambm programar a nossa barra de progresso para que cada vez que o evento do boto seja iniciado, ela retorne para configuraes padres. Como tambm o seu incremento dentro do lao. O cdigo em C# para o evento click dever ficar parecido com a Figura 6, e em Visual Basic .Net como a Figura 7.
lista[0] = Convert.ToInt32(txtNum.Text) * 2; progressBar1.Minimum = 0; progressBar1.Maximum = 500; progressBar1.Value = 0; for (int i = 1; i < lista.Length; i++) { lista[i] = lista[i - 1] * Convert.ToInt32(txtNum.Text); progressBar1.Value++; } Figura 6 Implementando o cdigo do boto Calcular em C#. lista(0) = Convert.ToInt32(txtNum.Text) * 2 ProgressBar1.Minimum = 0 ProgressBar1.Maximum = 500 ProgressBar1.Value = 0 For i As Integer = 1 To lista.Length lista(i) = lista(i - 1) * Convert.ToInt32(txtNum.Text) ProgressBar1.Value += 1 Next i Figura 7 Implementando o cdigo do boto Calcular em Visual Basic .Net.
11. No primeiro comando foi atribuindo um valor inicial para o elemento zero, como o nosso calculo utiliza o elemento anterior no seria possvel estabelecer algo para o
Microsoft Innovation Center 56 Desenvolvimento em .Net primeiro elemento. Note tambm os comandos da ProgressBar, o comando Minimum estabelece o valor mnimo para a barra de progresso, o Maximum o valor mximo, e Value o valor atual, sendo assim, a propriedade Value dever ser incrementado para mostrar seu progresso, por isso ele modificado dentro do lao de repetio. No vamos esquecer que a caixa de texto retorna sempre uma varivel do tipo string, logo temos que usar o comando de converso para atribuir os valores dentro do vetor que inteiro. O ltimo detalhe est dento do lao de repetio, repare que na atribuio do vetor no ndice i, estamos realizando uma multiplicao, possvel fazer clculos nos comandos de atribuio, o que permiti realizar instrues especficas na atribuio, como tambm economizar cdigo. 12. Vamos voltar para o design do nosso formulrio Form1. Vamos adicionar o cdigo para o boto Exibir, o qual muito parecido com o anterior. Mas antes temos que criar o evento click desse boto, sendo assim, d um duplo clique sobre ele, o que far a adio automtica desse evento para o nosso programa. 13. Dentro do evento, vamos precisar colocar novamente os comandos da barra de progresso, assim como foi feito no evento do boto Calcular. Vamos precisar utilizar um lao de repetio novamente, mas agora para carregar nossa ListBox com as informaes a serem mostradas. Tudo isso dever ficar parecido com a Figura 8 na linguagem C# ou como a Figura 9 em Visual Basic .Net.
progressBar1.Minimum = 0; progressBar1.Maximum = 500; progressBar1.Value = 0; for (int i = 0; i < lista.Length; i++) { lstLista.Items.Add(lista[i]); progressBar1.Value++; } Figura 8 Implementando o cdigo do boto Exibir em C#. ProgressBar1.Minimum = 0 ProgressBar1.Maximum = 500 ProgressBar1.Value = 0 For i As Integer = 1 To lista.Length lstLista.Items.Add(lista(i)) ProgressBar1.Value += 1 Next i Figura 9 Implementando o cdigo do boto Exibir em Visual Basic .Net.
14. Falta apenas o evento para o boto Limpar agora. Navegue novamente para o Form1, e crie o evento desse boto. Adicione o cdigo responsvel por esvaziar a nossa ListBox, assim como mostra a Figura 10 e 11.
lstLista.Items.Clear();
Figura 10 Cdigo para esvaziar o controle lstLista em C#.
lstLista.Items.Clear()
Figura 11 Cdigo para esvaziar o controle lstLista em Visual Basic .Net.
15. Com isso nosso programa est pronto para executar. Salve tudo, e execute para realizar os testes. O resultado esperado se parece muito com a Figura 12.
Figura 12 Resultado esperado com o laboratrio.
Laboratrio 2 Vetores multidimensionais
Neste laboratrio, voc far uso de um vetor multidimensional chamado Temperatura para registrar diariamente as altas e baixas temperaturas durante os sete dias de uma semana. O programa demonstra como utilizar um vetor para armazenar e processar um grupo de valores relacionados em um formulrio. A varivel do vetor Temperatura declarada na parte superior do formulrio e ento as temperaturas so atribudas ao vetor. Para que a mdia das temperaturas seja calculada e exibida. - Desenvolvendo a aplicao: 1. Primeiramente inicie o Visual Studio 2008. Voc pode encontr-lo acessando o menu Iniciar, depois procure em seus programas a pasta Microsoft Visual Studio, ento execute-o; 2. Espere o processo de inicializao do programa termina. Navegue para o menu superior. Em File, escolha a opo New, depois Project, como mostra a Figura 13.
3. Na nova janela que apareceu, devemos configurar as caractersticas do nosso projeto. D o nome de vetorTemperatura para soluo, em Location coloque o local em que deseja salvar o projeto, marque a opo do Framework na mais recente (atualmente 3.5) e, em templates escolha a opo Windows Forms Application, lembrando que voc pode desenvolver essa aplicao tanto em C# como em Visual Basic .Net. Confira com a Figura 14 antes de finalizar a criao do novo projeto.
4. Vamos fazer as modificaes no nosso formulrio Form1. Navegue at seu modo design, e adicione os seguintes controles pela Toolbox: quatro Labels, trs Buttons, duas TextBox e uma ListBox. 5. Vamos fazer as alteraes necessrias em suas propriedades, de acordo com a tabela abaixo: Controle Form1 Button1 Button2 Button3 Label1 Label2 Label3 Label4 Propriedade (Name) btnNovas btnAdicionar btnCalcular Propriedade (Text) Temperatura Novas temperaturas Adicionar Calcular temperatura Mnimo: Mximo: Erro! Informe a temperatura de todos os dias! Propriedade (Visible)
False False False False False
lblDias lblErro
TextBox1 TextBox2 ListBox1
txtMin txtMax lstLista
False False
6. Vrios controles foram alterados para no aparecerem na inicializao do programa. Eles ficaram visveis apenas quando o usurio for adicionar novas temperaturas. 7. Organize seu formulrio para que fique parecido com a Figura 15.
Figura 15 Formulrio Form1.
8. Agora clique com o boto direito em cima de qualquer parte do formulrio, escolha a opo View Code. Isso far que tenhamos acesso ao cdigo do nosso programa.
9. Nosso programa faz o uso de um vetor bidimensional que armazena a temperatura mxima e mnima dos dias de uma semana. Como as temperaturas podem ser valores reais, teremos que criar um vetor do tipo Double. D o nome de temperaturas. Devemos adicionar tambm uma varivel do tipo inteiro que usaremos para controlar o nosso programa. Primeiramente declare-a junto com o vetor bidimensional, com o andamento da construo do cdigo, voc entender melhor a sua funo. As declaraes deveram ficar parecidas como a Figura 16 na linguagem C# e na Figura 17 na linguagem Visual Baisc .Net.
double[,] temperaturas = new double[2,7]; int contador = 0; Figura 16 Declarao dos componentes da aplicao em C#.
Dim temperaturas(2, 7) As Double Dim contador As Integer = 0

Figura 17 Declarao dos componentes da aplicao em Visual Basic .Net.
10. Lembre-se que essas duas adies que acabamos de fazer no programa, devem ser declaradas de maneira global, j que sero acessados por vrios mtodos distintos. 11. Vamos comear a criar os eventos de click do mouse. Primeiramente vamos adicionar o evento referente ao boto Novas temperaturas. Navegue para o modo design do formulrio e d um duplo clique sobre este boto. 12. Com isso temos nosso evento criado. Ele ser responsvel por deixar os controles de adio de temperatura visveis, restaurar o valor inicial da nossa varivel de controle
Microsoft Innovation Center 61 Desenvolvimento em .Net chamada contador e, tambm configurar o texto da nossa lblDias para um valor inicial. Esse cdigo dever ficar parecido com as Figuras 18 e 19.
txtMax.Visible = true; txtMin.Visible = true; label1.Visible = true; label2.Visible = true; btnAdicionar.Visible = true; txtMin.Visible = true; txtMax.Visible = true; lblErro.Visible = false; lblDia.Visible = true; lblDia.Text = "Adicione as temperaturas do dia 1"; contador = 0; Figura 18 Cdigo do evento do boto Novas temperaturas em C#.
txtMax.Visible = True txtMin.Visible = True label1.Visible = True Label2.Visible = True btnAdicionar.Visible = True txtMin.Visible = True txtMax.Visible = True lblErro.Visible = False lblDia.Visible = True lblDia.Text = "Adicione as temperaturas do dia 1" contador = 0 Figura 19 Cdigo do evento do boto Novas temperaturas em Visual Baisc .Net.
13. Perceba que o nico controle que recebe o valor de false na propriedade Visible, a lblErro, j que seu propsito apenas ser apresentada quando faltar temperaturas a serem adicionadas. Como o boto possibilita a adio de novas temperaturas, no temos motivos ento de deix-la visvel. 14. Volte novamente para a edio de design do formulrio. Adicione ento o evento clique do boto Adicionar, faa isso da mesma maneira como foi feito no boto anterior. 15. Esse boto ser responsvel por verificar o valor da nossa varivel contador, para que seja atribuda a temperatura no ndice certo do vetor. Vamos utiliz-la tambm para controlar a alterao do texto da lblDias. Para isso utilizaremos a estrutura de condio Switch em C# e Select em Visual Basic .Net. Essa parte de cdigo um pouco repetitiva, contudo seu entendimento fcil e simples. Veja como esse cdigo deve ficar nas linguagens C# e Visual Bais .Net pelas Figuras 20 e 21;
switch (contador) { case 0: temperaturas[0, 0] = Convert.ToDouble(txtMin.Text); temperaturas[1, 0] = Convert.ToDouble(txtMax.Text); lblDia.Text = "Adicione as temperaturas do dia 2"; txtMax.Text = ""; txtMin.Text = ""; contador = 1; break; case 1: temperaturas[0, 1] = Convert.ToDouble(txtMin.Text); temperaturas[1, 1] = Convert.ToDouble(txtMax.Text); lblDia.Text = "Adicione as temperaturas do dia 3"; txtMax.Text = ""; txtMin.Text = ""; contador = 2; break; case 2: temperaturas[0, 2] = Convert.ToDouble(txtMin.Text); temperaturas[1, 2] = Convert.ToDouble(txtMax.Text); lblDia.Text = "Adicione as temperaturas do dia 4"; txtMax.Text = ""; txtMin.Text = ""; contador = 3; break; case 3: temperaturas[0, 3] = Convert.ToDouble(txtMin.Text); temperaturas[1, 3] = Convert.ToDouble(txtMax.Text); lblDia.Text = "Adicione as temperaturas do dia 5"; txtMax.Text = ""; txtMin.Text = ""; contador = 4; break; case 4: temperaturas[0, 4] = Convert.ToDouble(txtMin.Text); temperaturas[1, 4] = Convert.ToDouble(txtMax.Text); lblDia.Text = "Adicione as temperaturas do dia 6";

txtMax.Text = ""; txtMin.Text = ""; contador = 5; break; case 5: temperaturas[0, 5] = Convert.ToDouble(txtMin.Text); temperaturas[1, 5] = Convert.ToDouble(txtMax.Text); lblDia.Text = "Adicione as temperaturas do dia 7"; txtMax.Text = ""; txtMin.Text = ""; contador = 6; break; case 6: temperaturas[0, 6] = Convert.ToDouble(txtMin.Text); temperaturas[1, 6] = Convert.ToDouble(txtMax.Text); txtMax.Text = ""; txtMin.Text = ""; lblDia.Visible = false; contador = 7; break; } Figura 20 Implementao do Switch do evento do boto Adicionar em C#.
Select Case contador Case 0 temperaturas(0, 0) = Convert.ToDouble(txtMin.Text) temperaturas(1, 0) = Convert.ToDouble(txtMax.Text) lblDia.Text = "Adicione as temperaturas do dia 2" txtMax.Text = "" txtMin.Text = "" contador = 1 Case 1 temperaturas(0, 1) = Convert.ToDouble(txtMin.Text) temperaturas(1, 1) = Convert.ToDouble(txtMax.Text) lblDia.Text = "Adicione as temperaturas do dia 3" txtMax.Text = "" txtMin.Text = "" contador = 2 Case 2 temperaturas(0, 2) = Convert.ToDouble(txtMin.Text) temperaturas(1, 2) = Convert.ToDouble(txtMax.Text) lblDia.Text = "Adicione as temperaturas do dia 4" txtMax.Text = "" txtMin.Text = "" contador = 3 Case 3 temperaturas(0, 3) = Convert.ToDouble(txtMin.Text) temperaturas(1, 3) = Convert.ToDouble(txtMax.Text) lblDia.Text = "Adicione as temperaturas do dia 5" txtMax.Text = "" txtMin.Text = "" contador = 4 Case 4 temperaturas(0, 4) = Convert.ToDouble(txtMin.Text) temperaturas(1, 4) = Convert.ToDouble(txtMax.Text) lblDia.Text = "Adicione as temperaturas do dia 6" txtMax.Text = "" txtMin.Text = "" contador = 5 Case 5 temperaturas(0, 5) = Convert.ToDouble(txtMin.Text)

temperaturas(1, 5) = Convert.ToDouble(txtMax.Text) lblDia.Text = "Adicione as temperaturas do dia 7" txtMax.Text = "" txtMin.Text = "" contador = 6 Case 6 temperaturas(0, 6) = Convert.ToDouble(txtMin.Text) temperaturas(1, 6) = Convert.ToDouble(txtMax.Text) txtMax.Text = "" txtMin.Text = "" lblDia.Visible = False contador = 7 End Select Figura 21 Implementao do Switch do evento do boto Adicionar em Visual Baisc .Net.
16. Vamos analisar cada linha de cdigo. As duas primeiras linhas fazem a atribuio das temperaturas mxima e mnima digitas nas caixas de texto para dentro do vetor bidimensional. Conforme cada caso, mudamos o valor da lblDias, para que o usurio saiba qual ser a prxima temperatura referente ao dia da semana que dever ser inserida. Feito isso, temos mais duas linhas de cdigo que cuidam para apagar o texto das TextBox. E antes do break para finalizar cada caso, temos o cdigo que modifica o contador. O que possibilita que cada fez que o boto Adicionar for pressionado, o Switch acesse uma condio diferente, fazendo com que possamos armazenar as temperaturas de todos os dias de uma semana. Todo os case tem a sua estrutura muito familiar, menos o ltimo, que deixa invisvel a lblDias, j que depois dessa adio no haver mais temperaturas a serem adicionadas. 17. Aps o Switch vamos adicionar uma nova condio pela estrutura If. Ela cuidar para deixar a propriedade visible dos controles de adio de temperatura como false. Porm, a sua condio para que isso acontea, ser quando a varivel de controle tiver o valor sete. Veja como fica o cdigo pela Figura 22 e 23.
if (contador == 7) { txtMax.Visible = false; txtMin.Visible = false; label1.Visible = false; label2.Visible = false; btnAdicionar.Visible = false; txtMin.Visible = false; txtMax.Visible = false; } Figura 22 Cdigo da estrutura If em C#.
If contador = 7 Then txtMax.Visible = False txtMin.Visible = False Label1.Visible = False Label2.Visible = False btnAdicionar.Visible = False txtMin.Visible = False txtMax.Visible = False End If Figura 23 Cdigo da estrutura If em Visual Basic .Net.
18. Lembre-se que o cdigo da estrutura If deve vir logo aps a estrutura Swtich. Com isso nosso evento clique do boto Adicionar est pronto. 19. Vamos criar o evento do nosso ultimo boto, o Calcular. Volte para o modo de design e adicione seu evento de mouse click dando um duplo clique sobre sua ilustrao.
20. Esse evento ser responsvel por verificar se o contador j passou por todos os casos no Switch, ou seja, tem como valor o nmero sete. E caso seja verdadeiro, adicionar a mdia das temperaturas de cada dia na nossa ListBox. Caso contrrio, ou seja, o valor da varivel de controle no seja sete, deixar visvel a nossa lblErro. Esse cdigo dever ficar parecido com a Figura 24 na linguagem C# e Figura 25 em Visual Basic .Net.
if (contador == 7) { lstLista.Items.Add("Temperatura mdia dos dias:"); for (int i = 0; i <= 6; i++) { lstLista.Items.Add("Dia " + (i + 1) + ": " + (temperaturas[0, i] + temperaturas[1, i]) / 2); } } else lblErro.Visible = true; } Figura 24 Cdigo responsvel pelo evento do boto Calcular em C#.
If contador = 7 Then lstLista.Items.Add("Temperatura mdia dos dias:") For i As Integer = 0 To 6 lstLista.Items.Add("Dia " & (i + 1) & ": " & (temperaturas(0, i) + temperaturas(1, i)) / 2) Next i Else lblErro.Visible = True

End If Figura 25 Cdigo responsvel pelo evento do boto Calcular em Visual Basic .Net.
21. Dentro do If, primeiramente iniciamos uma linha de apresentao para os dados. Logo em seguida, utilizamos um lao de repetio para acessar todos os registros e carreglos na ListBox. Esses valores so concatenados em uma frase para aparecer de forma coerente para o usurio. Veja que a conta para a temperatura media de cada dia feito dentro da prpria concatenao, economizando trabalho e linhas de cdigo. 22. Salve sua aplicao e execute para realizar os testes. O resultado final dever ficar parecido com a Figura 26.
Figura 34 Resultado final do laboratrio.
Laboratrios extras
1) Multiplicando vetores bidimensionais. Esse laboratrio pode ser resolvido nas duas linguagens abordadas. Para sua realizao crie uma aplicao Windows Forms Application, chamada matriz. Utilizaremos apenas um formulrio, o qual dever conter trs vetores bidimensionais, sendo cada dimenso de nmero total trs. Construa o layout do seu formulrio de modo que fique fcil a adio de valores a dois desses vetores. Feito isso prepare um local para apresentar ao usurio o terceiro vetor. Esse deve conter a multiplicao dos dois primeiros vetores. Exatamente como feito em multiplicao de matrizes, j que um vetor bidimensional pode ser considera como uma matriz tambm. Caso queira, voc pode alterar seu laboratrio colocando uma ProgressBar e alterando o tamanho dos vetores. 2) Construindo uma agenda com vetores. Vamos utilizar um vetor como uma forma de armazenagem de informaes de uma agenda. Para isso cria uma aplicao Windows Forms Application, podendo ser tanto na linguagem C# como em Visual Basic .Net. Sua agenda dever armazenar certas caractersticas, como nome, telefone, sexo e idade. Adicione ao programa um vetor com nmero de elementos e dimenses necessrias para receber o cadastro de no mximo dez pessoas. Organize seu formulrio com os controles necessrios. Lembrando que mesmo utilizando vetores seus dados ainda sero perdidos quando o programa finalizar, mas est uma boa pratica para entender melhor os captulos futuros.
Microsoft Innovation Center 68 Desenvolvimento em .Net Voc pode modificar seu laboratrio, caso deseje, adicionando uma ListBox que mostre todos os itens cadastrados. E ao ter um item selecionado, mostrar suas informaes ao usurio.
Captulo IV Tratamento de Excees e Mtodos

Tpicos abordados:
Tratamento de Excees; Exemplo: Gerando um erro em tempo de execuo; Mtodos; Laboratrio 1 Mtodos; Foreach; Laboratrio 2 Foreach;
Neste captulo iremos ver como realizar o tratamento de excees nos aplicativos, o que so mtodos e aprenderemos a utilizar tambm uma estrutura de repetio avanada chamada Foreach.
Tratamento de Excees
O tratamento de excees o mecanismo responsvel pelo tratamento da ocorrncia de condies que alteram o fluxo normal de um aplicativo, ou seja, erros em tempo de execuo, que s sero percebidos quando o programa estiver em execuo. Por exemplo: se cria um aplicativo para realizar a diviso entre dois nmeros, porm o usurio digita como divisor zero, isso vai gerar um erro que pra bruscamente o programa. Com o tratamento o erro seria identificado e deveria ser mostrada uma mensagem na tela para o usurio. Felizmente as linguagens do .Net Framework oferecem um recurso muito eficiente para o tratamento de excees.
Try...Catch
O Try o bloco de cdigo para escopo normal. As linhas de cdigo que voc acredita que podem gerar uma exceo passam a ficar dentro do bloco try, onde ser executada uma tentativa normal. O Catch o bloco que trata o erro gerado. Dentro deste bloco poder ser vista a mensagem do erro e possibilita que o desenvolvedor realize o tratamento adequado, como fechar o programa, reportar o acontecimento do erro um mecanismo de gerenciamento, ou simplesmente mostrar a mensagem de erro que foi gerada.
Exemplo:
- Sintaxe em C# Try { bloco que tentar ser executado. } Catch(Exception ex) { bloco que ser executado caso ocorra uma exceo no bloco Try. }
Em C#, o Catch recebe um parmetro Exception e, que armazena a exceo que ocorreu, sendo possvel manipular essa varivel como o desenvolvedor desejar, mostrando seu valor na mensagem ou apenas armazenado-a.
-Sintaxe Visual Basic .Net Try bloco que tentar ser executado. Catch ex As Exception bloco que ser executado caso ocorra uma exceo no bloco Try. End Try
Em Visual Basic .Net, o Catch tambm recebe um parmetro para que seja manipulado assim como no C#.
Finally
O Finally o como o prprio nome diz, o bloco de finalizao. Este executado em qualquer circunstancia. Mesmo que o programa gere ou no uma exceo, o bloco finally ser executado. A idia que existe um escopo rodando mesmo que o erro faa o programa parar. Assim possvel fazer com que voc possa fechar conexes, ou coisas do tipo, para que estas coisas no consumam carga de processamento e memria.
Exemplo: - Sintaxe em C#
Try { bloco que tentar ser executado. } Catch(Exception ex) { bloco que ser executado caso ocorra uma exceo no bloco Try. } Finally { bloco que ser executado de qualquer maneira. }
Em C#, o bloco finally colocado aps o Catch.

-Sintaxe Visual Basic .Net
Try bloco que tentar ser executado. Catch ex As Exception bloco que ser executado caso ocorra uma exceo no bloco Try. Finally bloco que ser executado de qualquer maneira. End Try
Microsoft Innovation Center 71 Desenvolvimento em .Net Em Visual Basic .Net, ele tambm colocado aps o Catch e antes do End Try, que fecha o bloco de tratamento de exceo.
Exemplo: Gerando um erro em tempo de execuo
Vamos criar agora um aplicativo simples para demonstrar a utilizao do tratamento de exceo. - Exemplo: 1. Crie um novo projeto Console Application chamado ExemploExcecao. 2. Dentro do mtodo Main, declare duas variveis Int em C# ou Integer em Visual Basic .Net, uma chamada num inicializada com o valor 2, e outra chamada num2 inicializada com o valor 0. Em Visual Basic .Net ser necessrio declarar uma varivel chamada result do tipo Integer.
namespace ExemploExceo { class Program { static void Main(string[] args) { int num = 2; int num2 = 0; Figura 1 Declarao das variveis em C#.
Module Module1 Sub Main() Dim num As Integer = 2 Dim num2 As Integer = 0 Dim result As Integer Figura 2 Declarao das variveis em Visual Basic .Net.
3. Agora use o comando Console.WriteLine() para mostrar na tela o valor da diviso de num/num2 como mostra a figura 3 em C#, e em Visual Basic .Net, atribuindo o valor da diviso a varivel result como mostra a figura 4.
Console.WriteLine(num / num2);
Figura 3 Comando Console em C#. result = num / num2 Figura 4 Atribuindo a diviso a varivel em Visual Basic .Net.
4. Agora execute o aplicativo apertando Ctrl + F5, e veja o resultado. 5. Voc deve ter notado que apareceu uma mensagem de erro e o aplicativo foi bruscamente fechado, isso ocorreu porque a tentativa de diviso por 0, ser um erro em tempo de execuo.
Figura 4 Aviso de erro.
6. Vamos introduzir no cdigo o tratamento de erro, para que o aplicativo no seja bruscamente fechado sem nenhuma considerao ao usurio. Coloque o comando Console.WriteLine() em C# ou a atribuio a varivel result em Visual Basic .Net, entre as chaves do Try, porque esse ser o trecho de cdigo que tentaremos executar e que provavelmente ocorrer um erro.
try { Console.WriteLine(num / num2); } Figura 5 Bloco Try em C#. Try result = num / num2 Figura 6 Bloco Try em Visual Basic .Net.
7. Aps o Try, colocaremos o bloco Catch, que nesse caso ir capturar o erro e mostr-lo ao usurio. Daremos como parmetro a ele uma varivel ex do tipo Exception. E faremos mostrar na tela o erro que foi encontrado.
catch (Exception ex) { Console.WriteLine("Erro Encontrado: " + ex); } Figura 8 Bloco Catch em C#.
Catch ex As Exception

Console.WriteLine("Erro Encontrado: " & ex.Message)
Figura 9 Bloco Catch em Visual Basic .Net.
8. Agora colocaremos o bloco Finally, que o bloco de cdigo que executado de qualquer maneira, havendo erro ou no, para mostrar uma mensagem ao usurio que o aplicativo est sendo encerrado. Seu cdigo deve estar semelhante Figura 10 em C# ou 11 em Visual Basic .Net.
try { Console.WriteLine(num / num2); } catch (Exception ex) { Console.WriteLine("Erro Encontrado: " + ex); } finally { Console.WriteLine("Encerrando Aplicativo!"); }
Figura 10 Bloco de Tratamento completo em C#.
Try result = num / num2 Catch ex As Exception Console.WriteLine("Erro Encontrado: " & ex.Message) Finally Console.WriteLine("Encerrando Aplicativo!") End Try
Figura 11 Bloco de Tratamento completo em Visual Basic .Net.
9. Execute o aplicativo agora e note as mudanas.
Mtodos
Um mtodo um bloco de cdigo que contm uma serie de instrues. Mtodos so extremamente teis porque lhe permitem separar sua lgica em unidades diferentes. Voc pode passar informaes aos mtodos, que executam as declaraes, e retornam um valor. A capacidade de passar parmetros ou retornar valores opcional e depende do que voc quer que o mtodo faa. A declarao de um mtodo formada pelos: modificadores, tipos de retorno, nome do mtodo e parmetros. Modificadores Abaixo esto alguns dos principais modificadores:
Modificador Public Private Protected Internal Static Abstract Virtual Readonly Tipos de retorno
Descrio Permite que os mtodos sejam acessados por qualquer outro escopo. Acesso restrito ao escopo da classe. Acesso restrito a classe e as derivadas. Permite acesso somente por classes do mesmo assembly. Permite acesso, sem a necessidade do objeto ser instanciado. So mtodos de classes abstratas que no possuem implementao. Permite que os mtodos sejam sobrescritos por classes filhas. Limita acesso de somente leitura aos atributos.
Caso um mtodo retorne algum valor, na declarao do mtodo declaramos o tipo de retorno que ele far: String, Integer, Double, etc., ou Function em Visual Basic .Net. Caso ele no retorne algum valor, utilizaremos a palavra void ou sub, para demonstrar essa situao. Nome do mtodo Sobre o nosso critrio, simplesmente o nome que daremos ao mtodo, por exemplo, caso construssemos um mtodo para limpar a tela de um formulrio, poderamos usar o nome Limpar. Parmetros Um parmetro define como uma varivel pode ser passada para um mtodo. Uma subrotina utiliza os valores atribudos aos parmetros para alterar o seu comportamento em tempo de execuo. As duas principais maneiras de passagem de parmetro, so por valor e por referncia Exemplo de declarao de um mtodo:
- Sintaxe em C#: <modificador> <tipo de retorno> <nome do mtodo> (parmetros) { bloco de cdigo. }
- Sintaxe em Visual Basic .Net:
<modificador> <tipo de retorno> <nome do mtodo> (parmetros) bloco de cdigo End <tipo de retorno>
Por valor, o tipo padro, ou seja, se o parmetro no tiver nenhum modificador ele um parmetro por valor e seu valor real passado para o mtodo, o que significa que qualquer mudana no valor do parmetro feita localmente no mtodo e no passada de volta para o cdigo que o chamou. Parmetros por valor em Visual Basic, necessita do modificador ByVal. Em C# a varivel passada normalmente sem um modificador. Por referncia, so parmetros de entrada e sada, ou seja, o que significa que eles podem ser usados tanto para passar um valor com para receber de volta o valor de um mtodo. Esse tipo de parmetro em Visual Basic .Net, necessita do modificador ByRef, e em C#, utiliza-se o modificador ref.
Exemplo:
- Sintaxe em C#: Public void Metodo( int x, ref int y) { Bloco de cdigo; }
- Sintaxe em Visual Basic .Net: Public Sub Metodo(ByVal x As Integer, ByRef y As Integer) Bloco de cdigo End Sub
Laboratrio 1 Mtodos
Neste laboratrio iremos realizar um exerccio simples utilizando o conceito de mtodo. Criaremos um formulrio que o usurio digitar seu salrio, e ser mostrado seu salrio reajustado em 15%. - Exerccio: 1. Crie um projeto Windows Forms Application chamado Metodo. 2. No Form1, arraste um Button, uma Label e uma TextBox. Ao Button, editaremos sua propriedade Text para Calcular e Name para btn_Calcula, a Label editaremos a propriedade Name para lbl_Resultado e a TextBox editaremos a propriedade Name tambm para txt_salario.
Figura 12 Formulrio.
3. Clique com o boto direito do mouse sobre o formulrio, e acesse a opo View Code.
Figura 13 Acessando o cdigo do formulrio.
4. Vamos criar o mtodo CalculaAumento() dentro do formulrio, ele receber como parmetro uma String chamada salrio. Dentro deste mtodo vamos declarar uma varivel do tipo Double chamada result, que receber o valor da operao: salrio * 1.15. Essa operao far o incremento de 15% no salrio que foi digitado. Agora atribuiremos o valor de result propriedade Text da nossa Label.
public void CalculaAumento(String salario) { double result = Convert.ToDouble(salario) * 1.15; lbl_Resultado.Text = "Novo Salrio: " + result.ToString(); }
Figura 14 Mtodo CalculaAumento em C#.
Public Sub CalculaAumento(ByVal salario As String)

Dim result As Double = Convert.ToDouble(salario) * 1.15 lbl_Resultado.Text = "Novo Salrio: " + result.ToString() End Sub Figura 15 Mtodo CalculaAumento em Visual Basic .Net.
5. Agora voltamos ao modo design do formulrio, e vamos dar dois cliques sobre o Button Calcular para criar seu evento clique. Nele vamos chamar o mtodo que criamos a pouco, passando como parmetro a propriedade Text da TextBox, onde o usurio vai digitar o salrio original.
private void btn_Calcula_Click(object sender, EventArgs e) { CalculaAumento(txt_salario.Text); }

Figura 16 Evento clique do boto em C#. Private Sub btn_Calcula_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles btn_Calcula.Click CalculaAumento(txt_salario.Text) End Sub Figura 17 Evento clique do boto em Visual Basic .Net.
6. Execute o aplicativo usando Ctrl+F5 e faa os testes.
Foreach
A Estrutura Foreach utilizada para mover-se pelos elementos de uma estrutura de dados, como um vetor ou uma collection, e realizar aes para cada um dos elementos. O Foreach trabalha de forma semelhante estrutura Para, mas sem a varivel de controle, que limitaria a quantidade de repeties. Ele possui apenas uma varivel-elemento que guarda o valor que est sendo percorrido na estrutura. Percorre uma estrutura de dados completamente, parando a repetio apenas ao final da estrutura.
- Sintaxe C#:

foreach ( <tipo> elemento in estrutura_de_dados ) { Executa o bloco para cada elemento da estrutura de dados. }
Em C#, colocamos a palavra-chave foreach, em seguida o tipo e um nome qualquer que ser o nome do elemento, que nada mais que uma varivel que utilizada apenas dentro do foreach para armazenar o valor correspondente ao que esta sendo percorrido no momento, na estrutura de dados (Lembrando que o tipo deve ser o mesmo da estrutura que ser percorrida). Depois colocamos a palava in para referenciar a estrutura que queremos percorrer e, o nome da estrutura. Ento se abre chaves ( { ) e inserido o bloco de cdigo que desejamos que seja executado, aps isso fechamos chaves ( } ).
-Sintaxe Visual Basic .Net: For Each elemento In estrutura_de_dados Executa o bloco para cada elemento da estrutura de dados. Next elemento
Em Visual Basic .Net, segue a sintaxe parecida com C#, apenas tendo ao fim o Next elemento, que ordena a estrutura a passar para o prximo elemento.
Laboratrio 2 Foreach
Neste laboratrio, desenvolveremos um exerccio simples para implementar a estrutura Foreach. - Exerccio em C#: 1. Crie um projeto Windows Forms Application chamado Foreach. 2. Arraste para o formulrio que apareceu na tela: 2 ListBox e 1 Button. Mude o texto do Button para Mostrar Pares.
Figura 18 Organizao do formulrio.
3. Clique com o boto direito sobre o formulrio e selecione View Code. 4. Vamos declara um vetor chamado lista e inici-lo com os seguintes nmeros: { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }. 5. Agora dentro do construtor Form1() em C# ou no Public Sub New() em Visual Basic .Net, vamos carregar a ListBox1 com os valores do vetor usando o foreach. Lembrando que em Visual Basic .Net o construtor fica oculto no cdigo, para que ele aparecer preciso clicar na ComboBox que contm o texto: Declarations, selecione New e ele aparecer. O cdigo dentro do construtor dever ficar semelhante a figura 19 em C# e 20 em Visual Basic .Net.
foreach (int n in lista) { listBox1.Items.Add(n); } Figura 19 Carregando ListBox em C#.
For Each n In lista ListBox1.Items.Add(n) Next n Figura 20 Carregando Listbox em Visual Basic .Net.
6. Agora vamos voltar ao modo design, dar dois cliques sobre o boto: Mostrar Pares, para criar seu evento clique. 7. Voltando ao cdigo, dentro do evento clique do boto, vamos fazer um foreach que vai percorrer nosso vetor e vai calcular o %2 de cada elemento, ou seja, o resto da diviso por 2 de cada elemento e, armazenar em uma varivel Int ou Integer chamada r. Agora colocamos um Se para caso r seja igual a 0, carregue o elemento n na outra
Microsoft Innovation Center 81 Desenvolvimento em .Net ListBox, a nossa ListBox2. Assim apenas os elementos que so pares devero ser carregados para a outra ListBox.
private void button1_Click(object sender, EventArgs e) { foreach (int n in lista) { int r = n % 2; if (r == 0) { listBox2.Items.Add(n); } } } Figura 21 Evento clique do boto em C#.
Private Sub Button1_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles Button1.Click For Each n In lista Dim r As Integer = n Mod 2 If r = 0 Then ListBox2.Items.Add(n) End If Next End Sub Figura 22 Evento clique do boto em Visual Basic .Net.
8. Agora execute o aplicativo usando Ctrl+F5 e faa os testes.
Laboratrios Extras
1) Crie um formulrio com 2 TextBox, e 1 Button. Na primeira TextBox, o usurio dever digitar um valor em Graus Celsius, e ao apertar o Button, o valor digitado na TextBox seja enviado como parmetro a um mtodo de converso. Esse mtodo dever converter os Graus Celsius para Fahrenheit, e mostrar o resultado na outra TextBox. Obs.: No se esquea de utilizar o tratamento de excees, para tratar qualquer erro que possa ocorrer na converso, ou quando o usurio digite o valor.
2) Vamos criar um sistema de encriptao simples. Crie dois vetores, um que com os seguintes elementos: {a,b,c,d,e,f,g,h,i,j,k,l,m}, e o outro com o restante do alfabeto: {n,o,p,q,r,s,t,u,v,w,x,y,z}. Cada um dos vetores tem 13 letras. Agora crie um aplicativo usando foreach que quando o usurio digite uma palavra, suas letras sejam trocadas pelas letras correspondentes a ela que esto no vetor oposto. Exemplo: A a posio 0 do o seu vetor, seria trocada por N que a posio 0 do vetor oposto.
Captulo V Formulrios
Tpicos abordados:
Formulrios; Formulrios MDI; Instanciao de Formulrios Menus; Laboratrio 1 Formulrios e Menus; Controles;
Microsoft Innovation Center 83 Desenvolvimento em .Net Principais Controles; Laboratrio 2 Formulrios e controles;
Neste capitulo abordaremos a importncia dos formulrios para o desenvolvimento de aplicativos de alta qualidade e os controles essenciais para a manipulao de formulrios.
Formulrios
Formulrios so arquivos que possuem a parte de design como tambm o cdigo desse modo da aplicao. Ele contm toda a parte visual da aplicao, que tambm chamada de Interface Grfica. Nos formulrios podemos adicionar todos os controles (botes, caixas de textos, imagens, etc.) que vo fazer parte do layout. Exemplo:
Formulrios no deixam de ser tambm um tipo de objeto, porm so objetos que englobam outros objetos. Podem ser chamados por varias nomes: form, design, container, janela de aplicao, etc. Por serem objetos (controles) possuem propriedades que podem ser modificadas conforme a necessidade.
Microsoft Innovation Center 84 Desenvolvimento em .Net As propriedades so definies que um controle possui. Com elas podemos fazer alteraes no design, como configuraes especficas para o funcionamento de um determinado aplicativo. Podemos modificar as propriedades tanto pela caixa Properties (visualmente), como por comandos no cdigo do programa. Exemplo:
Formulrios MDI
Os formulrios MDI (Multiple Document Interface) possuem a capacidade de carregar vrios outros formulrios. Chamamos estes formulrios de pai e os outros que esto dependentes a ele, de filhos. A funo do formulrio pai carregar os filhos, enquanto eles ficam responsveis pelas implementaes de regras de negcio da aplicao.
Exemplo:
Instanciao de formulrios
Formulrios tambm so Classes, portanto, podem ser feitas instancias. Instanciamos formulrios em ocasies como a criao de formulrios filhos, quando precisamos abrir um , novo formulrio para o usurio, um dos modos fazer sua instancia e utilizar o mtodo Show() para trazer o formulrio para frente do programa. Exemplo C#:
Exemplo Visual Basic .Net:
Menus
Para construir aplicaes mais profissionais, que agradem os usurios fornecendo qualidade nos aspectos de usabilidade, devemos utilizar menus que facilitam a navegao dentro da aplicao. Para isso o Visual Studio proporciona aos desenvolvedores alguns s controles prontos para serem utilizados como menus. Esses controles podem ser configurados ara tanto visualmente, como diretamente pelo cdigo.
Microsoft Innovation Center 86 Desenvolvimento em .Net Podemos tambm criar estruturas que preencham os menus com determinados elementos em determinadas condies, ou mesmo criar menus dinmicos que possuem seu contedo dentro de banco de dados.
MenuStrip: Esse menu mais tradicional, por padro ele aparece na parte superior do Visual Studio, porm, podemos fazer alteraes na sua localizao, como tambm adicionar seus elementos. Alm dos tradicionais botes em forma de texto, podemos colocar outros controles como uma ComboBox ou mesmo uma TextBox.
StatusStrip: Quando adicionamos esse menu ao formulrio, por padro aparece no rodap da pgina. Contudo, podemos alterar suas opes, e modificar sua posio na janela. Com este menu podemos utilizar barras de progresso, dropdownlist, como tambm botes entre outros controles.
ToolStrip: Essa verso de menu que podemos considerar mais genrica. Com ela configuramos particularmente o menu. Por ser um menu geral, os controles que podem ser adicionados so todos os controles que StatusStrip e MenuStrip, dessa forma, podemos modelar um menu mais diferenciado.
Configurando o design dos menus: Quando selecionamos um menu, e acessamos a setinha que fica na parte superior, podemos realizar algumas alteraes em seu design. Essas opes so mostradas logo abaixo: RenderMode altera as cores e a forma como vai funcionar sua renderizao; Dock configura o local onde o menu vai ser exibido no formulrio. Podemos escolher tambm a opo None e alterar a sua localizao manualmente; GripStyle define se ala de movimentao do menu estar visvel ou no. Exemplo:
ContextMenuStrip: So menus que aparecem suspensos quando clicamos com o boto direito sobre algum controle, formulrio, etc. Esse menu disponibilizado pelo Visual Studio, permite apenas adio de botes de texto, porm, podemos trabalhar com eles em forma de cascata tambm.
Microsoft Innovation Center 88 Desenvolvimento em .Net Ao adicionar um novo menu ContextMenuStrip no formulrio, configuramos seus botes, e depois suas aes. Depois disso precisamos escolher quais os controles vo poder acessar o menu de contexto quando o boto direito do mouse for utilizado. Para isso alteramos a propriedade ContextMenuStrip com o nome do nosso menu. Exemplo:
Laboratrio 1 Formulrios e menus
- Exerccio:
1. Para crie um novo projeto Windows Applications chamado Agenda.
Microsoft Innovation Center 89 Desenvolvimento em .Net 2. Nossa agenda ter duas janelas principais. Uma para cadastro e outra para consulta.Contudo, vamos comear pelo formulrio principal, o qual vai carregar os outros dois. 3. Navegue para a ToolBox, e adicione o controle MenuStrip ao Form1. Crie nele duas DropDownList uma chamada Arquivo e outra Aes. Na primeira crie um item para o menu, chamado Sair. No segundo adicione Cadastrar e Consulta. Seu formulrio dever ficar parecido com a Figura 1:
Figura 1 Criando MenuStrip.
4. Vamos passar agora para a criao do formulrio de cadastro. Na Solution Explorer, clique com o boto direito em cima do projeto, escolha a opo Add, depois New item.
Figura 2 Adicionando um novo item ao projeto.
5. Escolha Windows Form, de o nome Cadastrar e clique em Add.
Figura 3 Adicionando um formulrio.
6. Nesse novo formulrio vamos adicionar da ToolBox uma GroupBox e dois botes. Expanda a GroupBox e dentro dela coloque tambm duas caixas de texto, uma MaskedTextBox (para o nmero de telefone), quatro label, e dois RadioButton. Configure as propriedades desses controles de acordo com a tabela abaixo:
Controle GroupBox1 Button1 Button2 Label1 Label2 Label3 Label4 MaskedTextBox1 TextBox1 TextBox2 RadioButton1 RadioButton2
Propriedade (Text) Informaes Salvar Limpar Nome Idade Sexo Telefone
Propriedade (Name) btnSalvar btnLimpar
Masculino Feminino
mtxtTelefone txtNome txtIdade rbtnMasculino rbtnFeminino
7. Acesse a mscara da MaskedTextBox , clicando na setinha que aparece acima dela e, escolha o tipo Phone Number, mude a opo Mask para (99) 0000-0000 e clique em OK. Organize seu formulrio para ficar parecido com a Figura 5:
Figura 4 Formulrio Cadastrar.
8. Vamos agora criar o nosso formulrio de consulta. Clique com o boto direito no nosso projeto na Solution Explorer, escolha Add, e depois New Item. Escolha um arquivo Windows Forms. De o nome de Consulta, e clique em Add. 9. Expanda um pouco o novo formulrio. V para a ToolBox, escolha e adicione um controle ListBox, adicione tambm nove labels e uma GroupBox. O formulrio dever ficar semelhante Figura 5.
Figura 5 Formulrio de Consulta.
10. Faa a modificao nas propriedades dos controles de acordo com a tabela abaixo: Controle ListBox1 Label1 Label2 Label3 Label4 Label5 Label6 Label7 Label8 Label9 GroupBox1 Propriedade (Text) Nome: ... Idade: ... Sexo: ... Telefone: ... Consulta: Informaes Propriedade (Name) lstConsuta lblNome lblIdade lblSexo lblTelefone
11. Agora vamos comear a implementar nosso cdigo. V ao design do Form1, clique com o boto direito sobre ele, e selecione a opo View Code.
Figura 6 Acessando o cdigo do formulrio.
12. Iremos declarar nossas variveis que sero passadas como parmetro para os outros formulrios. Iremos declarar uma varivel do tipo Int ou Integer chamada Max que ser designada esttica, para ser nossa varivel que controlar o total de registros de nossa agenda, e a inicializaremos com valor 10. Outra varivel do tipo Int ou Integer chamada controle, para controlarmos os registros que sero mostrados e, por fim, nossa matriz do tipo String chamada cadastro, que ir guardar o nome, idade, sexo e telefone de casa pessoa que cadastrarmos.
namespace AgendaC { public partial class Form1 : Form { public Form1() { InitializeComponent(); } static int max = 10; int controle; String[,] cadastro = new String[max,4]; Figura 7 Variveis do Form1.
Public Class Form1 Dim max As Integer = 10 Dim controle As Integer Dim cadastro(max, 4) As String Figura 8 Variaveis do Form1 em Visual Basic .Net.
13. Voltando ao design do Form1, vamos criar os mtodos do evento clique para cada um dos botes que colocamos no menu, para o boto Sair, Cadastrar e para o Consultar. 14. No mtodo do boto Cadastrar, iremos instanciar um novo objeto da Classe Cadastrar chamado cadastrar, que o formulrio que adicionamos no projeto. Nesta instanciao, para a criao do formulrio, passaremos trs parmetros para ele: nossa matriz, a varivel max e a varivel controle. Ento usaremos o comando ShowDialog(), para que o usurio no consiga trocar de janela enquanto realiza cadastros e, vamos usar o comando de incremento para a varivel controle, para que
Microsoft Innovation Center 93 Desenvolvimento em .Net cada vez que o boto cadastrar seja apertado, o cadastro seja realizado na prxima linha da matriz.
private void cadastrarToolStripMenuItem_Click(object sender, EventArgs e) { Cadastrar cadastrar = new Cadastrar(cadastro,max,controle); cadastrar.ShowDialog(); controle++; }
Figura 9 Mtodo clique do boto Cadastrar em C#. Private Sub CadastrarToolStripMenuItem_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles _ CadastrarToolStripMenuItem.Click Dim cadastrar As Form = New Cadastrar(cadastro, max, controle) cadastrar.ShowDialog() controle = controle + 1 End Sub Figura 10 Mtodo clique do boto Cadastrar em Visual Basic .Net.
15. No mtodo do boto Consultar, ser semelhante ao do boto Cadastrar, instanciaremos um novo objeto do tipo Consulta chamado consulta, passando a ele os mesmos parmetros do boto Consultar e, usaremos o comando Show(), para que o formulrio seja mostrado na tela.
private void consultarToolStripMenuItem_Click(object sender, EventArgs e)
{ Consulta consulta = new Consulta(cadastro,max,controle); consulta.Show(); } Figura 11 Mtodo clique do boto Consultar em C#.
Private Sub ConsultarToolStripMenuItem_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles _ ConsultarToolStripMenuItem.Click Dim consulta As Consulta = New Consulta(cadastro, max, controle) consulta.Show() End Sub Figura 12 Mtodo clique do boto Consultar em Visual Basic .Net.
16. E para o mtodo do boto Sair, ser apenas implementado o comando this.Close(), para que o formulrio seja fechado.
private void sairToolStripMenuItem_Click(object sender, EventArgs e) { this.Close(); } Figura 13 Mtodo clique do boto Sair em C#. Private Sub SairToolStripMenuItem1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles SairToolStripMenuItem1.Click

Close() End Sub Figura 14 Mtodo clique do boto Sair em Visual Basic .Net.
17. Agora vamos acessar o cdigo do formulrio Cadastrar pra implementar suas funes. Primeiro vamos declarar as variveis que receberam os valores que sero passados por parmetro: String[,] Matriz, Int ou Integer Maximo e Int ou Integer ctrl. Depois no mtodo construtor da classe, iremos implementar os parmetros de entrada, e atribuir os valores que viro das variveis contidas na classe.
namespace AgendaC { public partial class Cadastrar : Form { String[,] matriz; int maximo; int ctrl; public Cadastrar(String[,] cadastro, int max, int controle) { InitializeComponent(); matriz = cadastro; maximo = max; ctrl = controle; } Figura 15 Variveis e atribuio do valor que vir por parmetro em C#. Public Class Cadastrar Dim matriz(,) As String Dim maximo As Integer Dim ctrl As Integer Public Sub New(ByVal cadastro As String(,), ByVal max As Integer, ByVal controle As Integer) InitializeComponent() matriz = cadastro maximo = max ctrl = controle End Sub Figura 16 Variveis e atribuio do valor que vir por parmetro em Visual Basic .Net.
18. Vamos criar um mtodo chamado Limpar(), que ser utilizado para limpar os campos do formulrio sempre que o usurio desejar, ou quando ele for realizar um novo cadastro. O mtodo dever ficar semelhante Figura 17 em C# ou 18 em Visual Basic .Net.
public void Limpar()

{ txtIdade.Text = ""; txtNome.Text = ""; mtxtTelefone.Text = ""; rbtnFeminino.Checked = false; rbtnMasculino.Checked = false; } Figura 17 Mtodo Limpar() em C#. Public Sub Limpar() txtIdade.Text = "" txtNome.Text = "" mtxtTelefone.Text = "" rbtnFeminino.Checked = False rbtnMasculino.Checked = False End Sub Figura 18 Mtodo Limpar() em Visual Basic .Net.
19. No design do formulrio Cadastrar, vamos dar um duplo clique sobre o boto Salvar, para criar seu mtodo clique. Dentro do mtodo utilizaremos a estrutura Se para verificar se h espao para realizar um novo cadastro, em qual linha da matriz vamos realizar o cadastro e se o usurio aps terminar um cadastrado deseja realizar outro. Para isso utilizaremos a varivel maximo, que recebeu o valor mximo de registro que poderemos ter, e a varivel ctrl, que ir realizar os cadastros, cada um em uma linha diferente da matriz. Depois utilizando a classe MessageBox, mostraremos ao usurio a mensagem de Cadastrado com Sucesso!, e utilizando a formula (Maximo-Ctrl)-1, mostraremos ao usurio o numero de registros disponveis. Para verificar se o usurio deseja realizar outro cadastro, utilizaremos a opo de botes MessageBoxButtons.YesNo do mtodo Show da classe MessageBox. Caso o usurio selecione a opo Yes, os campos do Formulrio sero limpos com o mtodos Limpar(), caso ele selecione No, o formulrio Cadastrar ser fechado. No fim do mtodo clique do boto Salvar, utilizaremos o comando ctrl++ em C# ou ctrl = ctrl +1 em Visual Basic .Net, para que o prximo cadastro seja realizado na prxima linha da matriz.
if (ctrl < maximo)

{ matriz[ctrl, 0] = txtNome.Text; matriz[ctrl, 1] = txtIdade.Text; if (rbtnMasculino.Checked) { matriz[ctrl, 2] = "Masculino"; } if (rbtnFeminino.Checked) { matriz[ctrl, 2] = "Feminino"; } matriz[ctrl, 3] = mtxtTelefone.Text; MessageBox.Show("Cadastrado com Sucesso!"); MessageBox.Show((maximo-ctrl)-1 + " Registros Disponiveis!"); if (MessageBox.Show("Deseja Realizar outra Cadastro?", "", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes) { Limpar(); } else { this.Close(); } } else { MessageBox.Show("Memria Cheia!"); } ctrl++; Figura 19 Mtodo clique do Salvar em C#. If ctrl < maximo Then matriz(ctrl, 0) = txtNome.Text matriz(ctrl, 1) = txtIdade.Text If rbtnMasculino.Checked Then matriz(ctrl, 2) = "Masculino" End If If (rbtnFeminino.Checked) Then matriz(ctrl, 2) = "Feminino" End If matriz(ctrl, 3) = mtxtTelefone.Text MsgBox("Cadastrado com Sucesso!") MsgBox((maximo - ctrl) - 1 & " Registros Disponiveis!") If MsgBox("Deseja Realizar outro Cadastro?", MsgBoxStyle.YesNo, "") = DialogResult.Yes Then Limpar() Else Close() End If Else MessageBox.Show("Memria Cheia!") ctrl = ctrl + 1 End If Figura 20 Mtodo clique do Salvar em Visual Basic .Net.
Microsoft Innovation Center 97 Desenvolvimento em .Net 20. Agora vamos acessar o cdigo do formulrio Consulta, nele assim como no formulrio Cadastrar, vamos declarar variveis para receber os trs parmetros: uma matriz do tipo String chamada matriz, um Int/Integer chamado max e outro chamado ctrl. Dentro do construtor que recebe os trs parmetros, iremos atribuir o valor que vem dos parmetros as nossas variveis. Como elas tm o mesmo nome, utilizaremos a palavra reservada this em C# ou Me em Visual Basic .Net, para referenciar a varivel pertencente classe onde esto declarados e, sem o this ou Me, ser a varivel que veio do parmetro. Alm disso, criaremos uma estrutura de repetio Para, para que ela percorra a coluna da matriz que possui os nomes (no caso a coluna 0), e adicione cada nome contido na matriz na nossa ListBox. O cdigo dever ficar semelhante figura 21 em C# ou 22 em Visual Basic .Net.
public partial class Consulta : Form { String[,] matriz; int max; int ctrl; public Consulta(String[,] matriz,int max, int ctrl) { InitializeComponent(); for (int i = 0; i < max; i++) { if (matriz[i, 0] != null) { lstConsulta.Items.Add(matriz[i, 0]); } } this.matriz = matriz; this.max = max; this.ctrl = ctrl; } Figura 21 Construtor do Consulta em C#.
Public Class Consulta Dim lista As String(,) Dim maximo As Integer Dim controle As Integer Public Sub New(ByVal lista As String(,), ByVal maximo As Integer, ByVal controle As Integer) InitializeComponent() lista = Me.lista maximo = Me.maximo controle = Me.controle For i As Integer = 0 To maximo If lista(i, 0) <> "" Then lstConsulta.Items.Add(matriz(i, 0)) End If Next i End Sub Figura 22 Construtor do Consulta em Visual Basic .Net.
Microsoft Innovation Center 98 Desenvolvimento em .Net 21. Agora voltando ao design do formulrio Consulta, selecione a nossa ListBox e acesse seus eventos nas Properties, procure por um evento chamado SelectedValueChanged, e d um duplo clique sobre seu nome, com isso, ser criado o evento para nossa ListBox. Este evento far com que quando selecionemos com um clique um nome da ListBox, todos os dados referentes a este nome, apareceram nas labels ao lado. Dentro do evento que foi criado iremos criar uma estrutura Para, para percorrer a coluna da matriz que possui os nomes, ento usaremos um Se para encontrar na matriz o mesmo nome selecionado na ListBox e mostrar todos os seus dados nas Labels. Seu cdigo dever ficar semelhante Figura 23 em C# ou 24 em Visual Basic .Net.
private void lstConsulta_SelectedValueChanged(object sender, EventArgs e) { for (int i = 0; i < max; i++) { if (matriz[i, 0] == lstConsulta.SelectedItem.ToString()) { lblNome.Text = matriz[i, 0]; lblIdade.Text = matriz[i, 1]; lblSexo.Text = matriz[i, 2]; lblTelefone.Text = matriz[i, 3]; } } }
Figura 23 Evento da ListBox em C#.

Private Sub lstConsulta_SelectedValueChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles lstConsulta.SelectedValueChanged For i As Integer = 0 To maximo If lista(i, 0) = lstConsulta.SelectedItem.ToString() Then lblNome.Text = lista(i, 0) lblIdade.Text = lista(i, 1) lblSexo.Text = lista(i, 2) lblTelefone.Text = lista(i, 3) End If Next i End Sub
Figura 24 Evento da ListBox em Visual Basic .Net.
22. Agora salve seu projeto e faa os testes.
Controles
Controles so ferramentas grficas para a construo da interface do usurio com o programa. Eles so encontrados na caixa Toolbox. O Visual Studio possui controles especficos para dados, entrada e sada de informaes, apresentao de relatrios, entre outras funcionalidades. Assim como os formulrios, os controles tambm so um tipo de classe. Eles podem ter suas propriedades alteradas pela caixa Properties ou diretamente dentro do cdigo. Exemplo:
Os controles podem ser adicionados aos formulrios de duas maneiras: I. II. Escolher o controle desejado na Toolbox, segurar e arrastar para o local desejado no formulrio; Escolher o controle e dar um clique duplo sobre ele, adicionando assim uma copia dele para o formulrio.
- Principais controles Button:

A principal finalidade de um boto de executar uma operao ou um conjunto de operaes quando for pressionado. Para que suas aes ocorram, devemos introduzir no cdigo um evento referindo-se ao clique do mouse. Podemos criar esse evento pela suas propriedades ou ento dando um duplo clique nele no modo de design. Essas duas maneiras criam automaticamente o evento onde devemos adicionar suas funes.
Microsoft Innovation Center 100 Desenvolvimento em .Net Principais propriedades:

Name; Font; Enabled; Visible; Top; Left; Height; Width.
Label:
So componentes que se destinam principalmente a apresentao de textos (ttulos, legendas ou outros tipos de informaes). O texto apresentado ou a ser apresentado definido na propriedade Text. Principais propriedades:
Name; Text; Font; Enabled; Visible; TextAlign.
TextBox:
Permitem a apresentao de textos e, diferente das labels, as caixas de texto possibilitam a entrada de informaes (inputs). As informaes escritas dentro de uma TextBox por um usurio, ficam contidas dentro da propriedade Text, o mesmo lugar que alteramos quando queremos mostrar informaes. Principais propriedades:
o o o o o o o Name; Font; Enabled; Visible; TextAlign; Multiline; PassowordChar.
ListBox:
Permite mostrar uma lista de itens sobre determinada informao. possvel tambm para o usurio selecionar um ou mais itens dessa lista, para executar determinada ao. Principais propriedades:
o o o o o o o o Name; Font; Enabled; Visible; Items; SelectionMode; ScrollAlwaysVisible; MultiColumn.
Laboratrio 2 Formulrios e controles
Neste Laboratrio vamos manipular formulrios e tambm controles, configurando suas propriedades e criando eventos. Criaremos uma calculadora simples, que realize as quatro operaes matemticas bsicas. - Exerccio: 1. Abra o Visual Studio 2008, e crie um projeto Windows Forms Application, com o nome de Calculadora.
2. Neste formulrio iremos adicionar os seguintes controles. Uma TextBox para ser o visor de nossa calculadora e seis Buttons, onde quatro sero os botes para a escolha da operao matemtica a ser feita, um ser o boto = para mostrar o resultado, e o outro o boto CE para limpar a tela e a memria da calculadora. Nosso Formulrio dever ficar semelhante Figura 25.
Figura 25 Formulrio.
3. Agora iremos editar as propriedades dos controladores seguindo a tabela abaixo: Controlador Textbox1 Button1 Button2 Button3 Button4 Button5 Button6 Form1 Propriedade (Name) txt_visor btn_soma btn_subtracao btn_multiplicacao btn_divisao btn_CE btn_resultado Calculadora Propriedade (Text) + X / CE = Calculadora
Agora nosso formulrio dever ficar semelhante Figura 26.
Figura 26 Formulrio configurado.
4. Primeiramente, clicando com o boto direito do mouse sobre o Formulrio, iremos acessar a opo View Code.
Figura 27 Acessando o cdigo da pagina.
Iremos declarar as trs variveis do tipo Int ou Integer que iremos utilizar na nossa calculadora, elas se chamaram: valor, resultado e x.
public partial class Form1 : Form { public Form1() { InitializeComponent(); } int valor; int resultado; int x; Figura 28 Declarao das variveis em C#.
Public Class Calculadora Dim valor As Integer Dim resultado As Integer Dim x As Integer Figura 29 Declarao das variveis em Visual Basic .Net.
Microsoft Innovation Center 104 Desenvolvimento em .Net 5. Agora dando um duplo clique sobre o boto +, iremos criar seu evento. Nele iremos capturar o primeiro valor que o usurio digitar e armazenar na varivel valor (lembrando que em C# teremos que converter o que foi digitado para Int). Depois atribuiremos propriedade Text do visor uma string vazia, para que o nmero que acabamos de utilizar desaparea da tela. Ento atribumos x o valor 1, para que quando formos mostrar o resultado utilizando o boto =, os valores capturados sejam enviados ao mtodo Soma() (que ainda vamos criar) , para que o clculo correto seja realizado. E por fim utilizamos o comando Focus(), para que o foco do cursor volte a TextBox do visor para que digitemos o segundo valor da operao.
private void btn_soma_Click(object sender, EventArgs e) { valor = Convert.ToInt32(txt_visor.Text); txt_visor.Text = ""; x = 1; txt_visor.Focus(); } Figura 30 Evento soma em C#.
Private Sub btn_soma_Click(ByVal sender As System.Object, ByVal e _ As System.EventArgs) Handles btn_soma.Click valor = txt_visor.Text txt_visor.Text = "" x = 1 txt_visor.Focus() End Sub Figura 31 Evento soma em Visual Baisc .Net.
Os eventos de clique dos botes -,X e / ficaram idnticos ao do soma, porm, no boto - o valor atribudo para x ser 2, o boto X ser 3 e no boto / ser 4. 6. Agora vamos criar mtodos para cada uma das operaes matemticas. Todos os mtodos sero semelhantes, apenas ser trocado o operador matemtico. Nossos mtodos tero dois parmetros de entrada, um Int/Integer chamado valor e uma String chamada valor2. O parmetro Int/Integer valor receber a varivel valor, que foi o primeiro nmero digitado no visor da calculadora e o parmetro String valor2 receber a propriedade Text do nosso visor, que pegar o numero digitado aps clicarmos na operao desejada. Dentro do mtodo, atribuiremos varivel resultado, o valor d operao que realizada entre a varivel valor, e o valor2, lembrando que como valor2 uma String, para que possamos capturar o valor da propriedade Text ela deve ser convertida para Int/Integer para que o calculo seja realizado. E por fim atribumos propriedade Text do visor o valor de resultado, para que seja mostrado o valor final da operao (lembrando que em C# a varivel resultado por ser Int, deve ser convertida para String, para ser atribuda propriedade Text do visor. Abaixo o exemplo do mtodo Soma() ).

public void Soma(int valor, string valor2) { resultado = valor + Convert.ToInt32(valor2); txt_visor.Text = resultado.ToString(); } Figura 32 Mtodo Soma() em C#.
Public Sub Soma(ByVal valor As Integer, ByVal valor2 As Integer) resultado = valor + valor2 txt_visor.Text = resultado End Sub Figura 33 Mtodo Soma() em Visual Basic .Net.
Baseado neste exemplo, apenas modificando o operador matemtico, criamos os outros mtodos necessrios. 7. Iremos implementar o evento clique do Boto =. Clique duas vezes sobre o boto e ser criado o mtodo btn_resultado_Click. Dentro deste mtodo iremos criar uma estrutura Se, utilizando a varivel de controle x, que atribumos valores diferentes no evento clique de cada boto. Se o valor de x for 1, devemos chamar o mtodo Soma(), se for 2 o mtodo Subtracao(), se for 3 Multiplicacao(), e se no for nenhum destes valores chamamos o mtodo Divisao(). Lembrando que para cada mtodo devemos passar dois parmetros, a varivel valor e a propriedade Text do visor. O cdigo dentro do evento clique do boto = dever ficar semelhante Figura 34 em C# ou 35 em Visual Basic .Net.
private void btn_resultado_Click(object sender, EventArgs e) { if (x == 1) { Soma(valor, txt_visor.Text); } else if (x == 2) { Subtracao(valor, txt_visor.Text); } else if (x == 3) { Multiplicacao(valor, txt_visor.Text); } else { Divisao(valor, txt_visor.Text); } } Figura 34 Estrutura Se em C#.

Private Sub btn_resultado_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles btn_resultado.Click
If (x = 1) Then Soma(valor, txt_visor.Text) ElseIf (x = 2) Then Subtracao(valor, txt_visor.Text) ElseIf (x = 3) Then Multiplicacao(valor, txt_visor.Text) Else Divisao(valor, txt_visor.Text) End If End Sub Figura 35 Estrutura Se em Visual Basic .Net.
8. Agora dando um clique duplo sobre o boto CE iremos implementar o seu evento. Como o boto CE utilizado para limpar o visor e a memria nas calculadoras, ele dever realizar est funo aqui tambm. Ento dentro do seu evento iremos atribuir propriedade Text do visor uma String vazia, iremos atribuir o valor 0 varivel valor e usaremos o comando Focus(), para o cursor ficar disponvel no visor.
private void btn_ce_Click(object sender, EventArgs e) { txt_visor.Text = ""; valor = 0; txt_visor.Focus(); } Figura 36 Evento do boto CE em C#.
Private Sub btn_ce_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles btn_ce.Click txt_visor.Text = "" valor = 0 txt_visor.Focus() End Sub Figura 37 Evento do boto CE em Visual Basic .Net.
9. Salve seu projeto e execute-o apertando Ctrl + F5 para ver o resultado.
Laboratrios extras
1) Trabalhando com menus. Crie um Windows Forms Application e adicione um MenuStrip, nele dois botes: um Listar e um Consultar. No cdigo do nosso formulrio, declare e inicialize uma matriz com cinco nomes: Luis,Ricardo,Bruna,Selma e Paulo,com suas respectivas idades e RG,ento crie dois formulrios no projeto e faa com que ao clicar no menu Listar,seja carregado um novo formulrio com uma ListBox com os nomes contidos na matriz e, ao clicar em Consultar carregue um outro formulrio com todos os dados de cada pessoa registrada na matriz.
2) Trabalhando com controles. Crie um Windows Forms Application e nele adicione um Button, uma TextBox e duas Label. O aplicativo vai simular o reajuste de salrios em uma empresa, faa com que ao digitar seu salrio na TextBox, o salrio seja comparado a tabela abaixo: Salrio < = 540,00 >540,00 >980,00 <1.500,00 >1.500,00 Reajuste 15% 10% 7% 5%
Em uma das Label deve aparecer a porcentagem de reajuste que ser aplicado ao salrio e na outra o valor atualizado do salrio do funcionrio.
Captulo VI Acesso ao banco de dados

Tpicos abordados:
Mecanismos de acesso ao banco de dados; ADO .Net e seus componentes; Desenvolvendo a primeira aplicao com ADO .Net; Construir um banco de dados; Utilizando ferramentas RAD para acesso a base de dados; Introduo ao acesso por cdigo a uma base de dados; Trabalhando com pesquisas a uma base de dados por meio de cdigo.
O acesso a banco de dados parte fundamental da construo de uma aplicao comercial, pois os dados armazenados subsidiaro a extrao de informaes para a empresa atravs de relatrios gerenciais ou ferramentas de BI (Business Intelligence). Para acessar uma fonte de dados atravs de uma aplicao desenvolvida utilizando o Microsoft .Net Framework necessrio utilizar a tecnologia ADO .Net.
Viso geral do ADO .Net
O ADO.Net (um acrnimo para ActiveX Data Objects) um conjunto de classes e interfaces definidas dentro do .Net Framework destinadas manipulao de dados provenientes de uma ampla quantidade de fontes de dados, como bancos de dados relacionais (SQL Server, Access, Oracle, etc.), XML (eXtensible Markup Language), planilhas e arquivos texto.
Viso geral dos .Net Framework Data Providers
A tarefa de manipulao de dados do ADO .Net est dividida em diversos componentes que podem ser utilizados em conjunto ou separadamente para este fim. Para realizar a conexo com a base de dados o ADO .Net utiliza os data providers.
Microsoft Innovation Center 109 Desenvolvimento em .Net Um data provider utilizado para conectar a uma fonte de dados, executar comandos e recuperar os resultados da execuo do comando. Os resultados da execuo podero ser armazenados em um DataSet (veja explicao adiante) para serem mesclados com outros dados (at mesmo dados provenientes de outras fontes) ou enviar os resultados da execuo para outra camada de aplicao. Os data providers nativos do .Net Framework so listados a seguir: I. II. III. IV. .NET Framework Data Provider for SQL Server: prov o acesso aos dados para o Microsoft SQL Server verso 7.0 ou superior; .NET Framework Data Provider for OLE DB: prov acesso aos dados para fontes de dados OLE DB; .NET Framework Data Provider for ODBC: prov acesso aos dados para fontes de dados ODBC; .NET Framework Data Provider for Oracle: prov o acesso aos dados para o banco de dados Oracle atravs do programa Oracle cliente verso 8.1.7 ou superior.
Arquitetura do ADO .Net

A Figura 1 mostra a estrutura e os componentes existentes no ADO.Net.
Figura 1 - Arquitetura do ADO .Net.
A seguir sero listadas as principais classes existentes dentro de um data provider: I. II. Connection: responsvel por estabelecer a conexo com uma fonte de dados especfica atravs de uma connection string; Command: executa um comando em uma fonte de dados. Possui propriedades do tipo Parameter que sero utilizadas pelo contedo do comando (o comando executado poder ser uma instruo SQL ou a chamada de uma stored procedure); DataReader: manipula um conjunto de dados da forma somente para frente (forwardonly) e somente leitura (read-only); DataAdapter: preenche um DataSet e realiza atualizaes na fonte de dados.
III. IV.
Microsoft Innovation Center 110 Desenvolvimento em .Net Conforme exposto na Figura 1, a classe DataAdapter trabalha em conjunto com a classe DataSet. A classe DataSet foi projetada para atuar em cenrios que trabalham com dados desconectados e distribudos atravs do ADO .Net. O DataSet pode ser considerado uma representao em memria dos dados e sua estrutura semelhante de um banco de dados relacional, onde existe a representao de tabelas, relacionamentos e restries sobre as tabelas. Alm de todas as funcionalidades descritas acima, o DataSet ainda possibilita persistir e carregar seu contedo no formato XML, utilizando um esquema XML criado atravs da XML Schema definition language. A Figura 2 exibe de forma mais detalhada a estrutura do DataSet.
Figura 2 - Viso geral do DataSet.
Laboratrio 1 Primeira aplicao de acesso ao banco de dados

O .Net Framework nos permite realizar de diversas maneiras o acesso ao uma base de dados. Entre elas podemos utilizar a classe DataSet, onde atravs de linhas de cdigo realizamos a manipulao dos dados. Outra forma de se utilizar a classe DataSet atravs de um DataSet tipado, indicando que o DataSet uma cpia da estrutura de uma base de dados relacional. Alm das formas citadas anteriormente, tambm possvel realizar a manipulao dos dados somente atravs de linhas de cdigo e objetos de coleo para recuperar, armazenar e atualizar dados em uma fonte de dados. O programa que criaremos neste momento, ser responsvel por armazenar informaes de contatos pessoais, exatamente como uma agenda. Utilizaremos um DataSet tipado para auxiliar na construo do programa. - Criando o banco de dados: O primeiro procedimento a ser seguido ser a criao do banco dados. Nosso objetivo nesse capitulo abordar a utilizao do ADO .Net para realizar acessos em uma base de dados. Sendo assim no vamos focar detalhadamente na construo do banco utilizando SQL Server. Contudo, se voc no possui muita familiaridade com este assunto, poder ento analisar algumas terminologias sobre a construo de banco de dados logo abaixo: I. Entidades so as tabelas de um banco de dados, onde os dados so armazenados. Todas as linhas da tabela contm o mesmo nmero de colunas. Um banco de dados pode ter uma ou vrias entidades; Campo (tambm chamado de coluna, ou atributo) so as informaes armazenadas em um banco de dados pertencente a uma entidade. Campos tpicos em uma entidade de Clientes de uma empresa: Nome, Endereo, Telefone e Comentrios; Registros so todas as informaes inseridas nas entidades. Pode ser chamada tambm como linha das tabelas; Banco de dados relacional conjunto de tabelas de dados organizadas em torno de um tema em particular. Em geral a maioria dos bancos de dados trabalha com as entidades vinculadas dessa forma; Chaves as tabelas relacionam-se umas as outras atravs de chaves. Uma chave um conjunto de um ou mais atributos que determinam a unicidade de cada registro;
II.
III.
IV.
V.
Microsoft Innovation Center 112 Desenvolvimento em .Net VI. Chave primria (PK - Primary Key) - a chave que identifica cada registro dando-lhe unicidade. A chave primria nunca se repetir; Chave estrangeira (FK - Foreign Key) - a chave formada atravs de um relacionamento com a chave primria de outra tabela. Define um relacionamento entre as tabelas e podem ocorrer repetidas vezes. Caso a chave primria seja composta na origem, a chave estrangeira tambm o ser.
VII.
Caso tenha interesse em aprender sobre como trabalhar com o SQL Server, voc pode acessar o site da MSDN, onde pode ser encontrado grande nmero de material didtico. http://msdn.microsoft.com/pt-br/sqlserver/default.aspx
Vamos comear a construo da nossa base de dados, temos varias formas de realizar isto. Neste laboratrio criaremos a base diretamente do prprio Visual Studio. 1. Para executar o Visual Studio navegue ao menu Iniciar, em seus programas procure pela pasta Microsoft Visual Studio, e ento execute-o. 2. Com o Visual Studio carregado acesse a Server Explorer. Clique com o boto direito do mouse no cone Data Connections que dever aparecer, e selecione a opo Create New SQL Server Database. 3. Nessa nova janela devemos preencher alguns campos para criar uma nova base de dados. Como nossa base vai ficar no prprio computador, informaremos em Server name o contedo localhost\SQLEXPRESS, o que permite armazenar bancos de dados no prprio computador. Em New database name, coloque o nome de labCapituloVI. Feito isso clique em Ok para finalizar a criao. Esse formulrio dever estar como a Figura 3.
Figura 3 Criando uma nova base de dados.
Microsoft Innovation Center 113 Desenvolvimento em .Net 4. Nosso banco de dados est criado, porm, precisamos adicionar uma entidade para poder utilizar seu armazenamento. Volte para Server Explorer, expanda o cone Data Connections. Observe que a agora o banco de dados encontra-se l.
5. Expanda tambm o cone referente nossa base de dados. Com isso voc pode ter acesso a todas as configuraes e opes do nosso banco. Perceba que a pasta Tables est vazia. Clique com o boto direito sobre ela e escolha a opo Add New Table. 6. Uma nova rea para gerenciar banco de dados aparecer. Voc pode modificar o banco pelo prprio Visual Studio ou mesmo outra ferramenta para este fim. Nesse laboratrio usaremos apenas o Visual Studio. Pode perceber que temos uma tabela em branco, nela vamos adicionar o nome das colunas, seu tipo e se pode ou no deixar aquele campo da tabela em branco ao fazer um novo registro, preencha esse modelo de tabela de acordo com as informaes abaixo: Column name codigo nome idade dataNascimento telefone Data type int varchar(50) int datetime Varchar(30)
7. Deixe a opo Allow Nulls desmarcada em todos os campos. Na coluna codigo, clique com o boto direito e selecione a opo Set Primary Key, isso faz com que esse campo da tabela se torne a chave primria. 8. Ainda com a coluna codigo selecionada, logo embaixo na Column Properties, procure o campo Identity Specification, expanda-o e mude o campo (Is Identity) de No para Yes. O campo Identity, quando ativado, faz com que cada novo registro inserido nesta tabela seja sempre incrementado com o valor especificado em Identity Increment e, por essa coluna tambm ser uma chave primaria, faz com que esse cdigo nunca se repita dentro da entidade. O local dessa propriedade pode ser visto na Figura 4.
Figura 4 Propriedade Identity da coluna codigo.
9. Sua tabela dever ficar parecida com a Figura 5.
Figura 5 Declaraes dos campos da tabela.
10. Clique no boto para salvar, aparecer uma janela pedindo para informar o nome da tabela, digite pessoa, e salve sua tabela. 11. Voltando na janela Server Explorer, voc ver que agora possvel expandir a pasta Tables. Verifique se sua tabela criada est dentro da pasta. 12. Com isso temos nossa base de dados pronta para ser utilizada. Vamos ao processo de desenvolvimento da aplicao. - Desenvolvendo a soluo: 1. Adicione um novo projeto. Preencha o campo Name, com acessoBD. Em Location escolha o local onde deseja salvar, e em templates marque a opo Windows Forms Application. Lembre-se que voc pode realizar esse laboratrio nas linguagens C# ou Visual Basic .Net. 2. Primeiramente, vamos preparar o nosso programa para receber e guardar as informaes da base de dados. Navegue at o menu superior chamado Data, clique no comando Add New Data Source. A janela Data Source Configuration Wizard dever aparecer como mostrada na Figura 6.
Figura 6 Janela Data Source Configuration Wizard.
3. Essa ferramenta um recurso do Visual Studio que prepara sua aplicao para receber informaes do banco de dados. O assistente pede para que voc informe qual o tipo de banco de dados voc utilizar (local, remoto, um servio web ou personalizado), estabelece uma conexo com o banco de dados, e cria um DataSet para armazenar as tabelas definidas dentro do programa. 4. Escolha o cone Database e ento clique em Next. Nessa etapa devemos escolher qual string de conexo vamos utilizar. A string de conexo armazena as informaes necessrias para que a aplicao encontre corretamente a base de dados que ser utilizada. Mude o valor da combo para selecionar a string de conexo referente ao banco de dados criado anteriormente, depois disso clique em Next. 5. Continuando, o wizard de configurao oferece a opo de salvar essa string de conexo com um nome prprio, por padro j fornecido um nome, mas pode ser alterado. Utilizar essa opo permite que futuramente, caso seja necessrio possamos alterar ou configurar a string por meio desse nome, no nosso projeto no chegaremos a utilizar este recurso, contudo, uma boa pratica sempre deixar essa opo habilitada. Clique em Next para continuar. 6. Na prxima etapa voc deve selecionar quais sero os objetos que o seu Data Source ir armazenar. Neste caso vamos selecionar a entidade inteira que temos na nossa base de dados. Assim como demonstra a Figura 7.
Figura 7 Seleo de objetos para o Data Source.
Microsoft Innovation Center 116 Desenvolvimento em .Net 7. Feito isso clique em Finish. A partir deste momento o Data Source est disponvel para a aplicao. 8. Abra agora o design do seu arquivo Form1. Navegue para a ToolBox, procure o controle TabControl, arraste e solte para o seu formulrio. Nesse novo controle clique no TabPage1 e depois clique no corpo do controle, v em suas propriedades e altere o campo Text para Consulta, faa a mesma coisa clicando em TabPage2, porm altere o texto para Cadastro. Organize para que fique parecido com a Figura 8.
Figura 8 Formulrio Form1 modificado.
9. Se a janela auxiliar Data Source no estiver aberta navegue novamente para o menu superior, acesse Data e escolha a opo Show Data Sources, ou ento use o atalho Shift-Alt-D. A janela Data Source deve estar parecida com a Figura 9.
Figura 9 Janela Data Source.
10. Perceba que aqui voc tem acesso aos dados do seu DataSet, utilizaremos agora essa janela, para integrar de forma bem simples o banco com controles, juntos no seu formulrio. Clique no primeiro campo de sua tabela que aparece na janela Data Source e arraste-o para dentro do corpo da Tab Consulta. Veja que seu formulrio foi alterado, agora ele possui um menu na parte superior, como tambm uma label e uma caixa de textos representando esse campo do banco de dados. 11. Voc pode fazer alteraes nesses dois campos criados automaticamente. Agora arraste para o formulrio os outros campos da tabela. 12. Agora selecione o menu que foi criado automaticamente, clique na setinha que fica na parte superior para acessar as opes de configurao. Na opo Dock, mude a combo para None. Isso permite organizar o local desse menu da maneira que voc quiser.
Microsoft Innovation Center 117 Desenvolvimento em .Net Arraste ele para o corpo da Tab Consulta tambm. Organize seu formulrio, altere as labels e deixe tudo parecido com a Figura 10.
Figura 10 Formulrio Form1 com novos controles adicionados.
13. Depois de organizados, apague a caixa de textos referente ao campo telefone. Navegue para janela ToolBox e procure o controle MaskedTextBox, como mostra a Figura 11. Adicione uma MaskedTextBox na frente da label telefone. Utilizaremos esse campo mascarado para apresentar os nmeros de telefone.
Figura 11 Controle MaskedTextBox.
14. Depois de adicionado, selecione e clique na setinha que aparece na parte superior direita. Escolha a opo Set Mask. 15. Nessa nova janela, escolha a opo Phone Number. Mude o campo Mask para (99) 0000-0000. Clique em OK para finalizar. 16. Agora nas Properties da MaskedTextBox, expanda o campo (DataBindings). No campo Text que apareceu clique na combo e escolha a opo PessoaBindingSource, expanda-o e escolha o campo telefone. 17. Antes de executar o programa para alguns testes, vamos criar alguns registros na nossa entidade. Volte na Server Explorer, expanda a nossa conexo, e depois clique em Tables. Na nossa entidade criada, clique com o boto direito e escolha a opo Show Table Data.
18. Agora podemos adicionar registros na nossa tabela, voc pode seguir o exemplo da Figura 12 para fazer os seus registros. Perceba que o campo cdigo no tem como alterar seu valor, como tambm adicionado automaticamente, j que ele foi marcado como Identity. Na data de nascimento, digite apenas o dia/ms/ano, o prprio Visual Studio se encarrega de completar o resto de informaes nesse atributo.
Figura 12 Exemplo de registros
19. Fazer a ligao dos controles com o DataSet foi bem simples, porm, como estamos utilizando um DataSet, todos os dados que modificarmos no programa, no estaro alterados quando o programa for iniciado novamente, j que estamos utilizando a entidade com os dados salvos na memria sem retornar suas alteraes para o prprio banco de dados. Salve o projeto, e faa os testes. 20. Vamos adicionar um campo para consulta, assim podemos realizar filtros em nossas visualizaes do banco de dados. Em primeiro lugar, selecione o campo de texto de cdigo (poderia ser qualquer outro campo que est recebendo dados do dataset). Clique agora na setinha em sua parte superior, nas opes que aparece, escolha Add Query. 21. Nessa nova janela, temos a possibilidade de configurar o nosso acesso ao banco de dados com comando em SQL para criar os filtros. No campo New Query Name, digite Pesquisar. 22. Na parte Query Text apague tudo e cole o cdigo como mostra a Figura 13. Depois clique em Ok para salvar a alterao.
Figura 13 Adicionando o comando em SQL para filtragem.
23. Repare que o Visual Studio criou algo parecido com o menu anterior, porm agora temos uma label, uma caixa de texto e um boto. Esse menu tambm possui algumas opes a mais que podem ser editadas acessando o menu Task pela setinha superior enquanto o controle estiver selecionado. 24. Essa query que adicionamos no programa faz com que o valor digitado no campo de texto seja recuperado e com ele acontea uma filtragem dos dados do banco, dessa forma simples podemos elaborar nossas consultas e estabelecer filtros para os nossos projetos. 25. Selecione o novo menu criado na parte superior e clique na setinha para acessar as opes. Como feito anteriormente, modifique o campo Dock para None. Agora arrasteo para o corpo da Tab Consulta, de modo que fique do lado direito do outro menu. Seu projeto deve estar se parecendo com a Figura 14.
Microsoft Innovation Center 120 Desenvolvimento em .Net 26. Antes de realizar seus novos testes, crie mais registros do mesmo modo que foi feito anteriormente, para que voc possa perceber melhor o novo resultado. Salve tudo e execute o programa. 27. Vamos agora comear a alterao do formulrio para permitir a insero de novos registros. Clique na Tab Cadastro, o corpo da Tab ficara vazio, vamos adicionar alguns controles, v para ToolBox e arraste para dentro da Tab quatro labels. Mude as propriedades delas de acordo com a tabela abaixo: Controle Label1 Label2 Label3 Label4 Campo (Text) Nome: Idade: Data nascimento: Telefone:
28. Agora vamos adicionar mais um controle respectivo para cada uma dessas labels, coloque dois TextBox para os campos Nome e Idade, e dois MaskedTextBox, um para Data nascimento e outro para Telefone. Mude suas propriedades tambm, siga a tabela abaixo: Controle TextBox1 TextBox2 MaskedTextBox1 MaskedTextBox2 Campo(Name) txtNome txtIdade mtxtData mtxtTelefone
29. Ainda faltam dois botes para serem adicionados. V para ToolBox e arraste dois controles Button para a Tab. Modifique suas propriedades tambm. Controle Button1 Button2 Campo(Name) btnLimpar btnSalvar Campo(Text) Limpar Salvar
30. Vamos as mascaras nas nossas MaskedTextBox, siga o mesmo processo feito na MaskedTextBox da Tab Consulta. Na mtxtData escolha marcao Short date, e na mtxtTelefone escolha Phone number, e mude a Mask para (99) 0000-0000. Seu projeto deve ficar parecido com a Figura 15.
Figura 15 Controles para cadastro.
31. De um clique duplo no boto Limpar. Vamos adicionar o cdigo para que quando executado, deixe em branco os campos de texto. Ao dar um clique duplo em um controle, o Visual Studio cria automaticamente o evento respectivo ao click para aquele controle. Adicione o cdigo como aparece na Figura 16 para C# ou para Visual Basic .Net na Figura 17, dentro do evento do boto Limpar:
txtIdade.Text = ""; txtNome.Text = ""; mtxtData.Text = ""; mtxtTelefone.Text = ""; Figura 16 Cdigo para o boto Limpar em C#. txtIdade.Text = "" txtNome.Text = "" mtxtData.Text = "" mtxtTelefone.Text = "" Figura 17 Cdigo para o boto Limpar em Visual Basic .Net.
32. Agora necessrio introduzir o cdigo para o evento do boto Salvar. Novamente de um clique duplo para criar o evento, e adicione o cdigo que mostrado na Figura 19 ou 20.

string sql; string strConn = Properties.Settings.Default.labCapituloVIConnectionString.ToString(); if (valida()) { sql = "Insert into pessoa(nome, idade, dataNascimento, telefone) values ('" + txtNome.Text + "','" + txtIdade.Text + "','" + mtxtData.Text + "','" + mtxtTelefone.Text + "')"; SqlConnection con = new SqlConnection(strConn); SqlCommand cmd = new SqlCommand(sql, con); try { con.Open(); cmd.ExecuteNonQuery(); MessageBox.Show("Cadastro efetuado com sucesso."); con.Close(); } catch (SqlException ex) { MessageBox.Show(ex.Message); } } else { MessageBox.Show("Dados incompletos."); } Figura 19 Cdigo para o boto Salvar na linguagem C#. Dim sql As String = "" Dim strConn As String = My.Settings.CadastroConnectionString.ToString() If valida() Then sql = "Insert into pessoa(nome, idade, dataNascimento, telefone) values ('" _ + txtNome.Text + "','" _ + txtIdade.Text + "','" _ + mtxtData.Text + "','" _ + mtxtTelefone.Text + "')" Dim con As New SqlConnection(strConn) Dim cmd As New SqlCommand(sql, con) Try con.Open() cmd.ExecuteNonQuery() MsgBox("Cadastro efetuado com sucesso.") con.Close() Catch ex As Exception MsgBox(ex.Message) End Try Else MsgBox("Dados incompletos.") End If Figura 20 Cdigo para o boto Salvar na linguagem Visual Basic .Net.
Microsoft Innovation Center 123 Desenvolvimento em .Net 33. Quando vamos gerenciar nossa base de dados por meio de cdigo, precisamos seguir alguns passos. Utilizamos nossa string de conexo com informaes de onde de est localizada a base de dados e como acess-la para criar uma conexo com o banco. Depois de ter a conexo criada, precisamos escrever um comando em SQL para posteriormente execut-lo. O resultado obtido pode variar dependendo do comando que voc est querendo utilizar. Podemos realizar comandos para insero, ou mesmo busca de dados. Antes de executar o comando em SQL, precisamos abrir nossa conexo, e fech-la apenas depois de ter certeza que no estamos mais acessando nada. Um erro muito comum deix-la aberta, o que pode causar excees ou mesmo diminuir o desempenho da rede. 34. Vamos analisar cada linha do cdigo que foi adicionada no boto Salvar. Primeiramente, declaramos duas variveis do tipo string. A primeira (sql) ser utilizada para armazenar o nosso comando em SQL. A segunda (strConn) guarda a string de conexo. Como j tnhamos criado anteriormente essa string, podemos recuper-la por meio de cdigo, diminuindo o trabalho que teramos caso fossemos escrev-la. 35. Depois disso declaramos uma estrutura de condio. Nela fazemos a validao de um mtodo, o qual ser declarado logo mais. Esse mtodo cuida para validar se todos os campos realmente esto com valores. J que o nosso banco de dados no permite que nenhum valor seja nulo. 36. Logo em seguida declaramos mais duas variveis. A primeira (con) responsvel por gerenciar a string de conexo, essa varivel tem um tipo prprio para isso. Como mostrado, na prpria declarao passamos o valor da varivel strConn, assim deixando-a pronta para uso. A segunda varivel (cmd) responsvel por utilizar os comandos em SQL. Esta varivel contm inicialmente o comando SQL e tambm qual varivel de conexo utilizar. 37. A prxima instruo uma estrutura de tratamento de erros. uma boa prtica utilizar essas estruturas para evitar que erros parem o funcionamento do programa. Nessa situao vamos tentar executar certo trecho que cdigo. Na primeira linha dele abrimos a nossa conexo, isso feito de forma bem simples, j que os comandos oferecidos pelo Framework .Net so intuitivos. Com a conexo aberta chamados a varivel cmd e utilizamos o mtodo responsvel para executar o cdigo. O mtodo ExecuteNonQuery utilizado quando queremos realizar comandos que no retornam nada. Para outros tipos de comandos, como por exemplo, um select, que j retorna informaes, precisamos usar outro tipo de Execute, entre eles podemos utilizar o ExecuteReader. Finalmente, depois de executar o comando utilizamos uma caixa de mensagem para informar ao usurio que o cadastramento ocorreu com sucesso, caso ocorra um erro durante esse trecho de cdigo, utilizamos uma caixa de mensagem tambm, informando que ocorreu um erro e a descrio do mesmo.
Microsoft Innovation Center 124 Desenvolvimento em .Net 38. No podemos nos esquecer de fechar a conexo depois de finalizarmos a execuo do comando. Logo em seguida adicionamos uma mensagem caso o mtodo valida() no seja executado com sucesso. 39. Adicione tambm o cdigo para o evento valida() como mostra a Figura 21 para C# e a Figura 22 para Visual Basic .Net. No esquea que voc deve copiar esse trecho de cdigo agora para fora do evento click do boto Salvar.
public bool valida() { if (txtNome.Text == "") return false; else if (txtIdade.Text == "") return false; else if (mtxtData.Text == "") return false; else if (mtxtTelefone.Text == "") return false; else return true; } Figura 21 Cdigo para o mtodo valida() em C#.
Private Function valida() As Boolean If txtNome.Text = String.Empty Or txtIdade.Text = String.Empty Or _ mtxtData.Text = String.Empty Or mtxtTelefone.Text = String.Empty Then Return False Else Return True End If End Function
Figura 22 Cdigo para o mtodo valida() em Visual Basic .Net.
40. Note que no adicionamos nem uma label e nem uma caixa de texto para o campo cdigo. J que na criao da entidade pessoa, autorizamos a preencher o valor de cdigo automaticamente (Identity) no precisamos nos preocupar em representar ele durante a efetuao de novos cadastros. 41. Salve o projeto e execute-o para fazer os testes. Crie novos registros para o banco de dados utilizando a Tab de cadastro. Verifique depois na Tab de consulta se os dados esto sendo inseridos corretamente.
Laboratrio 2 Trabalhando com uma base de dados por meio de cdigo
Esse laboratrio tem como objeto aplicar diferentes formas que temos para acessar uma base de dados com ADO .Net. Sero apenas formulrios simples que executaram funes especificadas utilizando as funes de busca em uma base de dados. - Criando a base de dados para a aplicao: Para est aplicao criaremos uma base de dados bem simples, apenas para aplicarmos as funes propostas no laboratrio. Como nosso programa no tem um foco especifico, vamos criar uma entidade que atenda o armazenamento de dados genricos, que podem sem encontrados em quase todos os tipos de aplicaes. O banco de dados ser criado de uma maneira bem simples, utilizando a prpria interface de gerenciamento que o Visual Studio fornece. Vamos ento iniciar o processo de criao da base de dados. 1. Para executar o Visual Studio navegue ao menu Iniciar > Programas e procure pela pasta Microsoft Visual Studio para execut-lo. 2. Com o Visual Studio carregado acesse a janela Server Explorer. Clique com o boto direito do mouse no cone Data Connections que dever aparecer e selecione a opo Create New SQL Server Database. 3. Nessa nova janela devemos preencher alguns campos para criar uma nova base de dados. Como nossa base vai ficar no prprio computador, informamos em Server name, essa opo preenchendo com localhost\SQLEXPRESS, o que permite armazenar bancos de dados no prprio computador. Em New database name, coloque o nome de bancoTeste. Feito isso clique em Ok para finalizar a criao. Esse formulrio dever estar como a Figua 23.
Figura 23 Criando uma nova base de dados.
Microsoft Innovation Center 126 Desenvolvimento em .Net 4. Agora que temos a base de dados pronta, podemos adicionar a entidade que ser responsvel por armazenar nossos dados. Sendo assim, navegue novamente para Server Explorer. Expanda o cone Data Connections para temos acesso a todas as conexes estabelecidas entre o Visual Studio e os bancos de dados. Procure pela nossa base de dados e expanda seu cone tambm. Feito isso, temos acesso a todas as configuraes que nosso banco de dados permite. V at o cone Tables, e clique sobre ele com o boto direito do mouse. Entre as suas opes escolha Add New Table. 5. Siga a Figura 24 para preencher os campos que sua tabela vai conter.
Figura 24 Modelo para criao de uma nova entidade.
6. Selecione o campo codigo, clique com o boto direito sobre ele e escolha a opo Set Primary key. Perceba que aparece um cone na frente desse campo representando a mudana. Esse campo foi estabelecido como chave primaria, para que possamos fazer o controle e manter a organizao da entidade por ele. 7. Como uma chave primaria no pode ter seu valor repetido dentro de uma entidade, vamos acionar uma opo que facilitara na hora da criao de novos registros. Vamos optar por deixar o preenchimento desse campo por conta do prprio gerenciador da base de dados, pois ele sempre preencher esse campo, de forma crescente em cada registro inserido. Exemplo: no primeiro registro, ele atribui o valor inteiro um, no segundo registro adicionado, ele atribui o ultimo valor adicionado nesse campo, mas com o incremento de mais um, ou seja, o segundo registro ter o valor do nmero inteiro dois em seu atributo cdigo. Essa opo bem simples de ser acionada, selecione o campo codigo, navegue at a janela Column Properties, localizada por padro na parte inferior do Visual Studio. Procure pela opo Identity Specification, expanda-o e altere para Yes o valor do campo Is Identity, assim como mostra a Figura 25.
Figura 25 Alterando as propriedades da coluna codigo.
Microsoft Innovation Center 127 Desenvolvimento em .Net 8. Com essas configuraes alteradas, salve a tabela e d o nome de cadastro. 9. Vamos deixar alguns registros prontos na nossa entidade, para isso, navegue de volta para Server Explorer, v at nossa base de dados, dessa vez expanda o cone da pasta Tables. Veja que agora nossa nova tabela se encontra l. Clique com o boto direito sobre ela e escolha opo Show Table Data. 10. Nesta etapa, vamos fazer a insero diretamente de novos registros. Faa alguns cadastros, voc pode usar como exemplo a Figura 26.
Figura 26 Exemplo de registros.
11. Feito isso, salve as alteraes. A base de dados est pronta e vamos agora para o desenvolvimento da aplicao. 1. Aps criar a base de dados, acesse o menu superior do Visual Studio para criar um novo projeto. Em File, escolha a opo New, e depois Project. coloque o nome aplicacaoTeste em Name, em Location escolha o local que deseja salvar, e por final escolha qual template voc ir utilizar, no nosso caso, marque a opo Windows Forms Application. Lembre-se que voc pode realizar essa atividade tanto em C# como em Visual Basic .Net. 2. Com o projeto criado, navegue at a Solution Explorer, e dentro do projeto adicione um novo formulrio, chamado selecao. 3. V at o design do seu formulrio Form1, adicione um novo controle ContextMenuStrip, observe a Figura 27 para saber onde encontr-lo.
Figura 27 Localizao do controle ContextMenuStrip.
4. Com o controle adicionado no formulrio, adicione os seguintes itens a ele: Seleo, e Sair. Dever ficar parecido com a Figura 28.
Figura 28 Criando itens para o novo controle.
5. Selecione agora as propriedades do nosso formulrio Form1, procure pela opo chamada ContentMenuStrip, e marque nela o nome do nosso menu adicionado. Esse menu ser sempre ativado quando o usurio estiver no formulrio Form1 e der um clique com o boto direito do mouse. Aproveite para alterar a propriedade Text o formulrio para Aplicao teste. 6. Agora acione novamente o nosso controle ContentMenuStrip, nos itens adicionados, d um duplo clique sobre Sair. Assim ser criado o evento responsvel para essa ao. 7. Dentro do evento criado, digite a linha de cdigo: close(); . Esse cdigo responsvel por finalizar a aplicao quando acionado. 8. Vamos trabalhar agora com o nosso outro formulrio. Ele ir mostrar como podemos realizar buscas em nossas bases de dados, por meio de cdigo. 9. O objetivo desse formulrio ser mostrar algumas formas de como podemos introduzir a ao de seleo em nosso programa com a base de dados. Primeiramente, navegue para o modo design desse formulrio. Agora adicione alguns controles a ele: uma TextBox, uma ListBox, um Button, uma ComboBox e uma GroupBox. Altere suas propriedades de acordo com a tabela abaixo. Controle Form1 Button1 TextBox1 ComboBox1 GroupBox1 ListBox1 Propriedade (Text) Seleo Pesquisar Propriedade (Name) btnPesquisar txtPesquisar cmbPesquisar lstResultado
Busca
10. Vamos alterar algumas propriedades mais especificas agora. Selecione a lstResultado, procure em suas propriedade pela opo ScrollAlwaysVisible e mude seu valor para True. Na cmbPesquisar, procure pela opo Items e clique para adicionar novos dados. Isso far com que aparea uma nova janela. Aqui podemos adicionar quais sero os itens da nossa combo. Adicione os itens Nome e Idade, sendo um por linha, assim como mostra a Figura 29.
Figura 29 - Adicionando itens a uma combo.
11. Com isso o layout inicial do nosso formulrio est pronto. Vamos para a parte de cdigo da nossa aplicao. 12. Inicialmente nosso programa vai ter duas funes. Uma delas cuida para verificar se existe algum contedo na caixa de texto e se ela est de forma correta referente ao tipo de busca que poder ser feito (por nome ou idade). A outra funo faz a conexo com o banco de dados, e monta a linha de comando de acordo com a opo de busca estabelecida, retornando os resultados obtidos dentro da lstResultado. 13. Vamos ento criar a primeira funo citada. Abra a pgina de cdigo do seu formulrio selecao, voc pode clicar com o boto direito sobre o design do formulrio e escolher a opo View Code para acessar essa rea. 14. Insira o cdigo da Figura 30 ou 31 em seu arquivo logo aps o final do mtodo que inicializa a criao do formulrio.

public bool Valida() { try { if (cmbPesquisar.SelectedItem.ToString() == "Nome") { if (txtPesquisar.Text != "") return true; } else { if (Convert.ToInt32(txtPesquisar.Text) <= 0) { MessageBox.Show("O cdigo no pode ser menor que zero!"); return false; } else return true; } } catch (Exception ex) { MessageBox.Show("No possvel realizar a busca com esse valor!"); return false; } return false; } Figura 30 Cdigo para a funo de validao em C#.
Private Function Valida() As Boolean Try If cmbPesquisar.SelectedItem.ToString() = "Nome" Then If txtPesquisar.Text <> "" Then Return True End If Else If Convert.ToInt32(txtPesquisar.Text) < 0 Then MessageBox.Show("O cdigo no pode ser menor que zero!") Return False Else Return True End If End If Catch ex As Exception MessageBox.Show("No possvel realizar a busca com esse valor!") Return False End Try End Function Figura 31 Cdigo para a funo de validao em Visual Basic . Net.
Microsoft Innovation Center 131 Desenvolvimento em .Net 15. Vamos analisar cada parte dessa funo. Utilizamos uma estrutura de controle de exceo para tratar os erros que possam acontecer e no prejudicar o funcionamento do programa. Logo depois utilizamos uma estrutura de condio, para verificar qual opo da combo de busca foi selecionada. Perceba que na linha de cdigo do primeiro If, estamos pegando a nossa combo cmbPesquisar, acessando o item selecionado e convertendo para String, assim podemos comparar com uma palavra, no caso Nome. Sendo assim, caso o item selecionado seja o item Nome, ser realizado uma nova verificao para ver se a caixa de texto para buscas no vazia. J que no podemos mand-la vazia para a prxima funo,pois isso causaria uma exceo no momento da busca de informaes no banco de dados. Voltando a primeira estrutura de condio, perceba agora, que no verificamos se o item selecionado igual a Idade, isso acontece por que temos apenas duas opes na combo, caso no seja a primeira, sobra apenas a segunda. Mas imaginando uma situao com trs escolhas ou mais, ento seria necessria a utilizao de mais comparaes. Na parte da verificao de idade, convertemos o valor digitado na caixa de texto para um inteiro, e se ele no for maior que zero, retornamos com uma mensagem avisando que o valor foi digitado errado. A comparao por zero j elimina duas possibilidades de erro, a primeira se o item digitado for realmente menor ou igual a zero, o que causaria um erro, j que no temos idades com esse valor. O segundo erro eliminado a converso para comparar o valor digitado com zero causar uma exceo, significa que o usurio no digitou um valor numrico, e sim algum caractere alfabtico. Terminando a estrutura de tratamento de exceo, enviamos uma mensagem ao usurio caso ocorra um erro. 16. Depois de adicionar essa funo, vamos ento para a prxima. Essa nova funo realizar a consulta na base de dados. Insira o cdigo da Figura 32 para C# ou a Figura 33 para Visual Basic .Net logo aps o final da funo Valida().

public void Consulta() { string strConn = @"Aqui vai sua string de conexo"; string sql = "Select nome from cadastro where "; if (cmbPesquisar.SelectedItem.ToString() == "Nome") sql += "nome like '%" + txtPesquisar.Text + "%'"; else sql += "idade = " + Convert.ToInt32(txtPesquisar.Text); SqlConnection con = new SqlConnection(strConn); SqlCommand cmd = new SqlCommand(sql, con); try { con.Open(); SqlDataReader dr = cmd.ExecuteReader(); lstResultado.Items.Clear(); while (dr.Read()) { lstResultado.Items.Add(dr["nome"]); } dr.Close(); con.Close(); } catch (SqlException ex) { MessageBox.Show(ex.Message); } } Figura 32 Cdigo para funo de conexo a base de dados em C#. Public Sub Consulta() Dim strConn As String = "Aqui vai sua string de conexo" Dim sql As String = "Select nome from cadastro where " If cmbPesquisar.SelectedItem.ToString() = "Nome" Then sql = sql & "nome like '%" & txtPesquisar.Text & "%'" Else sql = sql & "idade = " & Convert.ToInt32(txtPesquisar.Text) End If Dim con As New SqlConnection(strConn) Dim cmd As New SqlCommand(sql, con) Try con.Open() Dim dr As SqlDataReader = cmd.ExecuteReader() lstResultado.Items.Clear() Do While dr.Read lstResultado.Items.Add(dr("nome")) Loop dr.Close() con.Close() Catch ex As Exception MsgBox(ex.Message) End Try End Sub Figura 33 Cdigo para funo de conexo a base de dados em Visual Basic .Net.
Microsoft Innovation Center 133 Desenvolvimento em .Net 17. Inicialmente nessa funo, adicionamos duas strings. A primeira receber a nossa string de conexo, a qual armazena informaes da localizao do banco e de como se conectar a ele. Perceba que na prpria declarao dessa varivel j introduzimos um valor. Passa conseguir sua string de conexo abra a Server Explorer, selecione a nossa base de dados, com isso v at a janela Properties e veja que existe um campo chamado Connection String, copie todo o seu contedo para dentro das aspas na nossa declarao da varivel strConn. A segunda varivel do tipo String receber a nossa linha de comando em SQL. Logo em seguida temos uma estrutura de condio para verificar qual item da combo de busca foi selecionado. Utilizamos essa estrutura de forma bem parecida funo anterior. A diferena que dependendo o resultado da comparao, concatenamos a nossa String sql com um final diferente. Ou seja, dependendo o item selecionado temos um tipo de filtro diferente para nossa busca. Com isso iniciamos nossas variveis de acesso ao banco, uma para conexo e outra para executar o comando. Ao escrever a declarao dessas duas variveis, veja que seus os nomes dos seus respectivos tipos no mudam de cor, e possvel que o Visual Studio acuse um erro. Isso ocorre por que cada arquivo novo que criamos no vem com referncias para todas as classes do .Net Framework (using ou import) adicionados, apenas as principais, isso aumenta o desempenho do programa, j que ajuda aos desenvolvedores a no adicionarem classes que no sero utilizados. Para resolver o problema coloque o mouse sobre o nome SqlConnection por exemplo, clique sobre a caixinha de erro com sinal de exclamao, e escolha a opo import, para que seja adicionada a classe que o Visual Studio recomenda para tratar o erro. Essas situaes podem ocorrer muito durante o desenvolvimento de uma soluo e voc pode resolver isso facilmente com a opo import. Uma maneira de perceber a necessidade de implementar novas classes a mudana de cores na estrutura do cdigo. Como uma boa prtica, utilizaremos a estrutura de tratamento de excees para no permitir que um erro atrapalhe o funcionamento do programa. Dentro dela, tentamos executar a seqncia de cdigo para conectar ao banco, fazer a busca e retornar o resultado na nossa lstResultado. Primeiramente abrimos nossa conexo, de forma bem intuitiva. Como o comando que vamos executar retorna uma quantidade de informaes, precisamos guardar isso para podermos utilizar em nossa aplicao. Para isso utilizamos um tipo chamado DataReader, que recebe informaes de buscas em bases de dados. Existe um tipo DataReader para cada tipo de base de dados e, no nosso caso utilizamos um SqlDataReader. Veja que o preenchimento realizado assim que atribumos o resultado da execuo do nosso comando (cmd). Diferente de um comando para insero onde usamos um ExecuteNonQuery, pois, no retorna nenhum tipo de dado, aqui precisamos utilizar um ExecutreReader, para que possamos receber os resultados dos comandos.
Microsoft Innovation Center 134 Desenvolvimento em .Net O prximo passo limpar o componente lstResulta e, para isso acessamos seus itens e utilizamos o mtodo Clear. Isso foi executado nessa parte do cdigo para termos certeza que acontecer caso a conexo ocorra com sucesso e retorne dados sem nenhum erro. Finalmente vamos utilizar nosso DataReader para passar os dados para ListBox. Antes de lermos um valor recuperado pelo DataReader devemos utilizar o comando Read, que recebe uma linha desse resultado obtido. Veja que utilizamos uma estrutura de repetio para fazer isso. Ou seja, cada vez que o comando Read for acionado e retornar que existem resultados da busca ser aplicado nosso comando dentro da estrutura de repetio. Nossa anlise agora no cdigo dentro da estrutura de repetio. Observe que podemos acessar o DataReader como se fosse um vetor atravs de seu ndice que, neste caso, o nome da coluna que buscamos e veio como resultado da pesquisa. Dessa maneira podemos acessar as colunas que pedimos na busca atravs da coluna nome. Lembre-se que cada vez que o comando Read for executado, nosso vetor avana uma posio. Finalmente fechamos a conexo e o DataReader. E caso ocorra algum erro, exibimos isso para o usurio com a exceo capturada. 18. Com nossas duas funes adicionadas, volte para o design do nosso formulrio e d um duplo clique sobre o boto limpar, vamos adicionar o cdigo necessrio para esse evento para que execute nossas funes. Faa como mostra a Figura 34 ou 35.
if (Valida()) { Consulta(); } Figura 34 Cdigo para o evento click do boto pesquisar em C#.
If Valida() Then Consulta() End If Figura 35 Cdigo para o evento click do boto pesquisar em Visual Basic .Net.
19. Essa parte do cdigo simples, primeiramente ele executa a funo Valida() dentro da prpria condio, caso retorne um valor verdadeiro, executamos a funo de consulta a base de dados. 20. Volte agora para o formulrio Form1, acesse o nosso controle ContentMenuStrip, e crie o evento de clique para o item Seleo, adicione o cdigo para criar o novo formulrio e exibi-lo para o usurio, assim como mostra a Figura 36 para C# e a Figura 37 para Visual Basic .Net.

selecao Selecao = new selecao(); Selecao.Show(); Figura 36 Cdigo para o evento click do item Seleo em C#. Dim Selecao As Form = New selecao() Selecao.Show() Figura 37 Cdigo para o evento click do item Seleo em Visual Basic .Net.
21. Salve tudo e execute para realizar seus testes. O resultado esperado dever ficar parecido com a Figura 38.
Figura 38 Resultado esperado do formulrio selecao.
22. Vamos modificar mais uma vez o formulrio selecao. Volte ao seu modo design, expanda seu tamanho e adicione um controle DataGridView. Organize tudo e deixe parecido como a Figura 39.
Figura 39 Formulrio selecao com novo controle adicionado.
23. Ainda no modo design, selecione o novo controle e acesse seu menu de opes Tasks, como mostra a Figura 40. Desmarque as check que vieram por padro acionadas e deixe apenas marcada a ultima, que possibilita a reordenao dos itens apresentados.
Figura 40 Alterando as opes do menu Task do controle DataGridView.
24. Utilizaremos esse controle para apresentar todos os campos dos registros que temos na nossa tabela. A diferena que apresentaremos apenas os itens do registro que tiver seu nome selecionado na lstResultado. 25. Primeiramente vamos criar uma funo nova para cuidar disso. Esta funo ser bem parecida com a que fizemos anteriormente, mas com algumas modificaes. Acesse novamente o cdigo deste arquivo, utilize a opo View Code, dando um clique com o boto direito do mouse dentro da rea de trabalho do Visual Studio. 26. O resulta dessa nova funo ser selecionar todos os itens do registro e exibi-los ao usurio em um DataGridView. Para isso utilizaremos um tipo DataTable que representa uma tabela, preenchemos e ento carregamos diretamente no controle. Insira a nova funo logo aps o ultimo evento adicionado. O cdigo deve ficar igual Figura 41 ou 42.
public void SelecaoGrid() { string strConn = @"Aqui vai sua string de conexo"; string sql = "Select * from cadastro where nome = '" + lstResultado.SelectedItem.ToString() + "'"; SqlConnection con = new SqlConnection(strConn); try { con.Open(); DataTable dt = new DataTable(); SqlDataAdapter da = new SqlDataAdapter(sql, con); da.Fill(dt); dataGridView1.DataSource = dt; con.Close(); } catch (SqlException ex) { MessageBox.Show(ex.Message); } } Figura 41 Cdigo para nova funo de busca em C#.

Public Sub SelecaoGrid() Dim strConn As String = "Aqui vai sua string de conexo" Dim sql As String = "Select * from cadastro where nome = '" & _ lstResultado.SelectedItem.ToString() & "'" Dim con As New SqlConnection(strConn) Try con.Open() Dim dt As New DataTable Dim da As New SqlDataAdapter(sql, con) da.Fill(dt) dataGridView1.DataSource = dt con.Close() Catch ex As Exception MsgBox(ex.Message) End Try End Sub Figura 42 Cdigo para nova funo de busca em Visual Basic .Net.
27. O comeo dessa funo muito parecido com a anterior. Temos as duas variveis responsveis pela conexo e pelo comando. Dessa vez a que armazena o comando em SQL faz sua concatenao com o item selecionado ListBox. Vamos apenas declarar a varivel de conexo. A maneira que utilizaremos agora no faz uso de um tipo SqlCommand. Dentro do bloco da estrutura de tratamento de excees vamos abrir a conexo. Logo em seguida criamos um tipo DataTable como citado anteriormente, criamos um SqlDataAdapter (esse tipo serve para receber o comando criado na sql) e o executamos. Utilizamos um de seus comandos especficos para jogar seus resultados no tipo DataTable, e ento preenchemos diretamente as informaes do DataGridView, a partir de sua propriedade DataSource, que armazena os dados que sero apresentados. Finalmente fechamos a conexo e exibimos uma mensagem de erro caso acontea alguma exceo. 28. Volte ao modo design do formulrio. Selecione o controle lstResulta e, navegue para suas propriedades. Perceba que nessa janela temos alguns cones na sua parte superior, escolha o que se parece como um raio. Desse modo podemos visualizar todos os tipos de eventos que esse controle suporta como mostra a Figura 43. Procure pelo evento SelectedIndexChanged, d um clique duplo sobre seu campo, isso far com que seja criado automaticamente o evento para essa opo. Esse evento ser sempre acionado quando um dos itens da ListBox for selecionado.
Figura 43 Propriedades do controle lstResultado.
29. Dentro desse evento, escreva a linha de cdigo: selecaoGrid(), que executar a funo quando o evento for acionado. Salve seu projeto, e execute para testar. O resultado dever ficar parecido com a Figura 44.
Figura 44 Resulta final obtido com o formulrio seleo.
Laboratrios extras
1) Trabalhando com comandos em SQL. Continuando o laboratrio dois, crie mais trs formulrios, chamados: insercao, exclusao e alteracao. Aplique em cada um deles a funo o comando em SQL referente aos seus nomes. Utilize apenas o acesso base de dados por meio de cdigo. Lembre-se que comandos em na linguagem SQL que no retornam valores como, por exemplo, insert e update, no utilizam o comando ExecuteReader, mas sim, o comando ExecuteNonQuery. Se desejar, aumente seu projeto, melhore o banco de dados para armazenar mais informaes, construa um menu fixo no formulrio principal e tambm aumente as possibilidades de filtros na seleo de dados. Dessa maneira voc ter uma agenda pessoal personalizada e feita por voc. 2) Gerenciamento de carros. Imagine a seguinte situao: uma oficina mecnica precisa fazer o controle dos veculos que passam por ela, sendo assim foi requisitado a voc fazer construir a aplicao que cuidar desse problema. Voc pode fazer o uso de qualquer componente, e de quantos formulrios desejar para realizar essa funo. Contudo, voc precisar criar uma base de dados para armazenar esses registros, utilize a Figura 45 como base para construir esse banco.
Veiculo Marca
Codigo Nome
Codigo Renavam Marca Modelo AnoFabricacao AnoModelo
Combustivel
Codigo Nome
Combustivel Placa
Figura 45 Exemplo de base de dados.
Se for necessrio faa o uso dos laboratrios anteriores para chegar ao resultado desejado. E caso voc no tenha muita experincia em trabalhar com SQL, visite o link abaixo, onde voc pode encontrar mais informaes sobre esse assunto. http://msdn.microsoft.com/pt-br/sqlserver/default.aspx
Captulo VII Relatrios

Tpicos abordados:
Importncia da utilizao de relatrios; Criao de relatrios; Componentes do Visual Studio para aplicao de relatrios; Relatrios com Microsoft Report Viewer; Relatrios com Crystal Report; Desenvolvendo relatrios simples, com parmetros e com juno.
A construo de uma soluo completa e robusta, principalmente para aplicaes comerciais, tem que possuir em seus elementos a capacidade de gerar e visualizar relatrios. Para muitas empresas, as tomadas de decises so essenciais, e so as informaes geradas pelos relatrios que auxiliam nas melhores escolhas. Relatrios so uma das ferramentas mais importantes que as empresas utilizam para monitorar seu desenvolvimento, e mostrar isso de maneira eficiente e com bons resultados faz parte de uma boa soluo. Como desenvolvedores, estamos encarregados de construir interfaces rpidas, fceis e objetivas, fornecendo com qualidade relatrios aos usurios. Para isso podemos aproveitar os recursos do Visual Studio, aplicando em nossas solues modelos de relatrios, que possuem fcil implementao e timo rendimento.
Criao de relatrios
Cada empresa possui suas prprias regras de negocio, determina certas necessidades e exigncias de informaes diversas, como tambm combinadas em seus relatrios. Podemos tomar como exemplo situaes onde necessrio apresentar: nmero de pedidos realizados por cada cliente em cada ms, total de produtos que foram vendidos acima de certa quantidade, ou mesmo relao de horas de trabalho de cada funcionrio. possvel mostrar essas informaes para os usurios de vrias maneiras diferentes. Uma forma de apresentao simples e bsica, porm, mais trabalhosa de elaborar seria montando uma estrutura, que com o resultado de uma busca em determinada base de dados, apresenta-se ao usurio as informaes requisitados em um controle gerenciador de dados, como um GridView. Mas uma aplicao utilizando essa maneira renderia um tempo maior para ser desenvolvida e pode ser que o resultado final no realize todas as expectativas do cliente. Sendo assim utilizaremos nesse captulo dois componentes que fazem parte do Visual Studio para elaborar nossas solues. So duas ferramentas que possuem a mesma finalidade, porm, possuem algumas diferenas entre si. Microsoft Report Viewer e o Crystal Report.
Microsoft Innovation Center 141 Desenvolvimento em .Net Os componentes para adicionar essas duas ferramentas podem ser encontrados dentro da Toolbox, como aparece na Figura 1.
Figura 1 Ferramentas para relatrios na Toolbox.
Microsoft Report Viewer
Essa ferramenta desenvolvida pela prpria Microsoft tem o objetivo de ajudar os desenvolvedores a aplicarem o uso de relatrio em suas solues de forma fcil e rpida, o que antigamente era de muito trabalho e complexidade. Abaixo seguem algumas das caractersticas mais relevantes para utilizar essa ferramenta em nossas aplicaes: I. II. III. Fcil integrao com o banco de dados SQL Server; Suporta impresso e visualizador de impresso; Exporta para Excel como tambm para PDF.
O Microsoft Report Viewer distribudo gratuitamente com o Visual Studio e o .Net Framework. Sua utilizao em solues no necessita nenhum custo extra, o que torna esse componente uma ferramenta bem interessante para ser explorada nas aplicaes.
Crystal Reports
O primeiro componente do Visual Studio a se dedicar especialmente na criao e gerenciamento de relatrios, foi o Crystal Reports, porm, ele no uma ferramenta desenvolvida pela prpria Microsoft. Por possuir uma grande procura no mercado, pois sua utilizao realmente facilita o trabalho dos desenvolvedores, teve sua funcionalidade integrada ao Visual Studio. Possui vrias vantagens, assim como o Microsoft Report Viewer, pode ser utilizado tanto para solues desktop como para web. Seu tempo no mercado garante a essa ferramenta um bom aprimoramento, principalmente na sua facilidade em trabalhar com o desenvolvedor. O Crystal Reports tem facilidade para trabalhar com vrios tipos de banco de dados. Porm, sua distribuio com aplicaes comerciais necessita de uma licena. Informaes sobre o custo dessa licena como outras caractersticas podem ser vistas neste site: http://support.microsoft.com/kb/317789/pt-br.
Laboratrio 1 Relatrio simples com Microsoft Report Viewer
Este laboratrio tem como objetivo, a aplicao de um relatrio simples por meio visual, utilizando o Microsoft Report Viewer, como tambm, a integrao de uma base de dados pronta ao SQL Server. - Integrando uma base de dados pronta ao SQL Server. 1. Navegue para o menu Iniciar, procure nos seus programas a pasta Microsoft SQL Server 2005 e abra o gerenciador de banco de dados SQL Server Management Studio Express. 2. Assim que o programa terminar de inicializar aparecer uma janela pedindo para informar o Server name e a Authentication. Como essa aplicao apenas um exerccio, vamos usar como servidor o nosso prprio computador, digite localhost\SQLEXPRESS no campo Server name, e certifique-se que a opo Windows Authentication est marcada logo abaixo. Nossa janela para realizar a conexo com o gerenciador dever ficar parecida com a Figura 2.
Figura 2 Janela para conexo com banco de dados.
3. Agora voc pode acessar todos os recursos que o seu SQL Server disponibiliza. Criar banco de dados, fazer insero de registros, modificaes ou mesmo excluso. A interface que voc se encontra deve seguir o padro da Figura 3.
Figura 3 Tela principal do SQL Server Management Studio.
Microsoft Innovation Center 143 Desenvolvimento em .Net 4. Vamos comear a integrao com um banco de dados pronto. Primeiramente certifique-se que voc possui os arquivos desse laboratrio, a pasta Arquivos captulo 5 com os arquivos northwind.mdf e northwind.ldf. 5. Para que a integrao funcione, necessrio copiar os dois arquivos para a pasta Data onde est instalado o SQL Server, normalmente voc pode chegar at ela pela seqncia de pastas: C:\Program Files\Microsoft SQL Server\MSSQL.1\MSSQL\Data. 6. No gerenciador de banco de dados, navegue para a janela Object Explorer, por padro ela inicializada a esquerda do programa. Ela deve se parecer com a Figura 4.
Figura 4 Janela Object Explorer.
7. Dentro da Object Explorer, clique em cima do cone Databases com o boto direito para aparecer as opes. Repare que temos vrios itens para escolher, entre eles: criar nova base de dados, atualizar e restaurar. No nosso caso, vamos escolher a opo Attach, como mostrado na Figura 5.
Figura 5 Menu com opes do Database.
Microsoft Innovation Center 144 Desenvolvimento em .Net 8. Nessa nova janela aberta (representada na Figura 6), adicionamos e configuramos as bases de dados prontas que desejamos integrar. Clique no boto Add para adicionar os arquivos do banco de dados Northwind.
Figura 6 Janela Attach Databases.
9. Na janela de busca, navegue at a pasta onde voc adicionou os arquivos e escolha o northwind.mdf, clique em Ok. Perceba que agora ele foi adicionado a janela Attach Databases, como representa a Figura 7.
Figura 7 Janela Attach Databases com o arquivo .mdf adicionado.
10. Vamos finalizar a integrao com a base de dados pronta, clique em Ok. O processo pode levar alguns minutos. 11. Novamente na Object Explorer, expanda o cone Databases. Dentro dele podemos encontrar todas as nossas bases de dados, e a partir dos seus respectivos cones, podemos gerenciar cada um. A nossa nova base Northwind est adicionada tambm, por padro o SQL Server costuma adicionar bancos prontos em formato Read-Only, como mostra a Figura 8. No nosso laboratrio vamos apenas realizar buscas e pesquisas, sendo assim no precisamos alterar a opo de apenas leitura, contudo, para deixar nosso banco mais flexvel para alteraes, vamos mudar essa propriedade.
Figura 8 Base de dados Northwind ainda com a propriedade Read-Only.
12. Clique com o boto direito sobre a nossa nova base de dados. Entre as opes escolha Properties. Como aparece na Figura 9.
Figura 9 Menu com as opes para gerenciar a nova base de dados.
13. A nova janela que apareceu nos permite realizar alteraes na nossa base de dados. Podemos modificar suas permisses, opes, arquivos e muitos outros detalhes. A janela Database Properties deve estar parecida com a Figura 10.
Figura 10 Janela Database Properties.
14. Repare que para navegar entre as opes das propriedades da base de dados temos um menu a esquerda. Clique na opo Options para que o contedo da janela se altera para acessar essas configuraes.
Microsoft Innovation Center 146 Desenvolvimento em .Net 15. Feito isso, procure pelo campo Database Read-Only nas novas opes que apareceram. Ele dever estar marcado como True. Assim como representa a Figura 11.
Figura 11 Campo Database Read-Only marcado como True.
16. D um duplo clique em cima de True, isso far com o que seu valor seja modificado para False. Com o campo marcado dessa maneira, o banco de dados no ficar limitado apenas para leitura. Contudo, cabe ao desenvolvedor alterar as opes de sua base de dados em suas solues. Nosso projeto, mesmo utilizando uma base de dados flexvel para alteraes ter apenas a funo de realizar consultas. 17. Finalize clicando no boto Ok. Pronto, agora temos uma base de dados j carregada com entidades e registros para utilizar em nosso projeto. Feche o SQL Server Management Studio para comearmos a prxima etapa.
- Aplicando os componentes do Microsoft Report Viewer em nossa soluo. 1. Novamente navegue para o menu Iniciar, procure nos programas e execute o Microsoft Visual Studio 2008. 2. Feito isso, espere a inicializao terminar, e ento acesse o menu File do programa para criao de um novo projeto. Os recursos para criao do relatrio neste laboratrio so todos visuais, e tanto uma aplicao em C# como em Visual Basic .Net possuem os mesmos procedimentos. O caminho que voc deve seguir para criar um novo projeto mostrado na Figura 12.
3. Na janela New Project que apareceu, escolhemos o nome da nossa soluo, local de destino onde ficar armazenada, como tambm a linguagem utilizada, verso do Framework, e modelo de projeto. No nosso caso vamos criar uma aplicao Windows, com o nome de RelatorioSimples. O exemplo contido nesse laboratrio far o uso da linguagem C#, mesmo assim fica a sua escolha qual utilizar.
Microsoft Innovation Center 147 Desenvolvimento em .Net 4. Escolha o destino a ser salvo o projeto, deixe o Framework marcado na verso mais recente (atualmente est na 3.5), confira se o nome do projeto est correto. Escolha o template Windows Forms Application, sua janela dever estar parecido com a Figura 13, ento clique em Ok para criar a soluo.
Figura 13 Janela New Project, com template Windows Forms Application selecionado.
5. Agora com o nosso projeto pronto, vamos comear as modificaes. Abra o formulrio Form1 em seu modo de design. Navegue at a janela Toolbox, procure o grupo de controles Reporting, como mostrado na Figura 14. Clique sobre o componente MicrosoftReportViewer e arraste para o centro de seu formulrio.
Figura 14 Controles Reporting da Toolbox.
6. Expanda um pouco seu formulrio. Agora clique sobre o novo controle adicionado, feito isso abra as opes do menu Task dele, clicando na setinha superior que aparece quando selecionamos um controle. Lembrando que essas so algumas opes que temos a mais em certos controles. Escolha a opo Dock in parent container, como visto na Figura 15. Isso far com que o controle ocupe todo o espao disponvel no formulrio.
Figura 15 Acessando o menu Task.
Microsoft Innovation Center 148 Desenvolvimento em .Net 7. Com isso seu formulrio dever ficar parecido com a Figura 16.
Figura 16 Formulrio Form1 modificado.
8. Novamente vamos selecionar o menu Task do nosso novo controle. Porm, agora vamos escolher a opo Design a new report. 9. A janela que vai se abrir apenas um informativo que voc acionou o modo de configurao wizard, e o que possvel fazer com ele. Apenas clique em Next para continuar. 10. Agora devemos escolher que tipo de arquivo o nosso relatrio vai se relacionar. Selecione a opo Database como mostra a Figura 17, e clique em Next.
Figura 17 Seleo do tipo de arquivo que o relatrio utilizar.
11. Nessa prxima etapa devemos criar a conexo da aplicao com a base de dados. Clique no boto New Connection para abrir a janela de criao de conexo. 12. No se preocupe com a grande quantidade de informaes que esse formulrio possui, pois, vamos apenas preencher algumas. Em Server name necessrio especificar o nome do servidor e, como criamos o banco de dados no prprio computador, deve-se informar que o servidor local. Escreva dentro dele localhost\SQLEXPRESS. Feito isso vamos escolher qual base de dados ser utilizada. Na combo referente Select or enter a database name, mude seu valor e escolha a base de dados Northwind. Essa janela deve ter as configuraes iguais a Figura 18. Feito isso clique em Test Connection, se tudo der certo clique em Ok para criar a conexo.
Figura 18 Janela Add Connection configurada.
13. Voltando a janela anterior, na combo perto do boto New Connection, mude seu valor de acordo com a conexo que acabamos de criar. Clique em Next para continuar. 14. A prxima etapa pergunta se voc quer salvar a conexo criada com um nome especifico, deixe marcado que sim e tambm o nome padro que o Visual Studio determina. Esse nome que escolhemos pode ser til quando formos trabalhar com aplicaes mais complexas, para que possamos reconhecer facilmente cada componente que forma nossa soluo. 15. Chegou hora de escolher quais entidades o nosso design de relatrio vai possuir. Por ser um exemplo de relatrio simples, vamos escolher apenas a entidade Customers. Marque ela como mostrado na Figura 19.
Figura 19 Seleo de entidades.
16. Clique em Finish, feito isso o wizard para configurao ser salvo com as nossas opes. O prprio Visual Studio vai nos redirecionar para outra janela, Report Wizard.
Microsoft Innovation Center 150 Desenvolvimento em .Net 17. Deixe a nossa entidade Customers selecionado e clique em Next. A prxima etapa pede para escolhermos o formato em que ser exibido o relatrio, Matrix ou Table. Deixe a opo Table marcada. E pressione Next. 18. Nessa seo vamos escolher quais campos da tabela vo aparecer e em quais posies. Veja que podemos dividir em trs partes, Page, Group, Details. Com eles podemos definir a maneira como as informaes sero mostradas para o usurio. No nosso caso deixe esse formulrio configurado igual Figura 20.
Figura 20 Modelo de configurao do relatrio.
19. Feito isso clique em Next. Agora temos as opes de layout do relatrio, escolha a opo Stepped e clique em Next novamente. 20. Nessa parte podemos mudar o style que o relatrio vai assumir. Escolha o que mais lhe agradar. Logo aps clique em Finish para que nossas opes sejam salvas. 21. Perceba que um novo arquivo foi criado, chamado Report1.rdlc. Esse o arquivo que contm as nossas configuraes do relatrio. Voc pode abrir esse arquivo e fazer todas as alteraes que desejar: tanto nos dados que ele recebe ou at a forma visual em que vai ser apresentado. Seu relatrio quando aberto deve ter um contedo parecido com a Figura 21.
Figura 21 Demonstrao do arquivo Report1.rdlc.
Microsoft Innovation Center 151 Desenvolvimento em .Net 22. Agora vamos voltar para o nosso formulrio Form1 novamente. Em seu modo design selecione o controle MicrosoftReportViewer, e acesse seu menu Task. Desta vez vamos alterar a opo Choose Report, deixe marcado na combo o arquivo de relatrio que acabamos de criar. 23. Salve sua aplicao. Execute a soluo e realize seus testes. Perceba que o relatrio vem com muita funcionalidade implementada, e que utilizando esse controle economizamos tempo e ganhamos qualidade em nossas solues. Seu relatrio dever ficar parecido com a Figura 22 quando executado.
Figura 22 Resultado final do laboratrio 1.
Laboratrio 2 Relatrio com parmetros e Crystal Reports
Neste laboratrio voc desenvolver uma aplicao utilizando os conceitos de relatrios com parmetros, ou seja, relatrios que possuem filtros, o que os torna ferramentas importantes para sua soluo. Diferentemente do laboratrio anterior veremos como trabalhar com o modelo de relatrios do Crystal Reports. - Trabalhando com o Crystal Reports em nossa soluo. 1. Nossa aplicao vai necessitar de uma base de dados, utilizaremos a mesma do laboratrio anterior, caso voc no a possua, siga os passos do comeo do laboratrio um para carregar o banco de dados. 2. Assim como o Microsoft Report Viewer, a ferramenta Crystal Reports pode ser utilizada da mesma maneira tanto na linguagem C# e Visual Basic .Net. Sendo assim, a escolha que voc fizer no afetar o nosso resultado final. 3. Vamos comear a construo do nosso relatrio com parmetro. Primeiramente abra o Visual Studio 2008, voc pode encontr-lo no menu Iniciar, em seus programas dentro da pasta Microsoft Visual Studio 2008. 4. Espere o programa inicializar corretamente. Feito isso vamos criar um novo projeto, desta vez vamos utilizar alguns atalhos que o Visual Studio permite. Para acessar a janela de criao de novos projetos aperte o atalho Ctrl + Shift + N. 5. Nessa janela configuramos algumas informaes iniciais, nome da soluo, template que ser utilizado, local de destino onde ser salvo o projeto como tambm que verso do Framework utilizar. 6. Nomeie o projeto como RelatorioParametro. Escolha um local de destino apropriado e deixe a opo do Framework marcado na mais recente (atualmente 3.5). Como dito anteriormente, o foco do laboratrio a utilizao das ferramentas de relatrio, sendo assim, a linguagem definida fica ao seu critrio. Entre os vrios tipos de templates, vamos selecionar Windows Forms Application. Sua janela de criao de projetos dever ficar parecida com a Figura 23.
Figura 23 Janela de criao de projetos.
7. Com o projeto criado, vamos verificar se nossa conexo com o banco ainda existe. O Visual Studio possibilita que elas fiquem salvas e que os desenvolvedores possam reutiliz-las. Navegue para a janela Server Explorer, caso no a encontre ou tenha fechado por engano, utilize o atalho Ctrl + W + L. 8. Vamos modificar o formulrio Form1. Acesse seu modo design, navegue para a janela Toolbox ou use o atalho Ctrl + W + X. Procure pelos controles Reporting, como mostra a Figura 24. Clique no CrystalReportViewer e arraste para o centro do formulrio.
Figura 24 Controles Reporting da janela Toolbox.
9. Diferente do Microsoft Report Viewer, o Crystal Reports j vem por padro com a opo Dock in parent container ativada, mas isso pode ser alterado pelo o menu Task do controle. Esse menu acessado quando selecionamos um controle e clicamos na setinha que aparece na parte superior do seu contorno, nele podemos encontrar vrias opes que no esto inclusas na janela Properties. Expanda um pouco o tamanho de seu formulrio para que fique parecido com a Figura 25.
Microsoft Innovation Center 154 Desenvolvimento em .Net 10. Vamos acessar o menu Task do nosso controle como mostra a Figura 26. Escolha a opo Create a New Crystal Report para criar um arquivo que contenha as configuraes do que queremos exibir com o nosso relatrio.
Figura 26 Opes do menu Task.
11. A primeira coisa que aparece ao selecionar essa opo definir um nome para o nosso arquivo. Deixe o nome padro, e clique em Ok. 12. Feito isso o Visual Studio ir redirecionar voc para o wizard de criao do Crystal Reports. O primeiro passo dele oferece opes de formao como aparece na Figura 27, modifique algumas opes para ver suas alteraes, mas certifique-se de deixar no padro antes de continuar.
Figura 27 Configurao wizard para criao de relatrios com Crystal Reports.
13. Nessa prxima etapa vamos realizar a conexo com a nossa base de dados. Antes de continua certifique-se que ela esteja realmente criada. Na nova janela, expanda o cone Create New Connection, logo em seguida devemos escolher qual tipo de conexo vamos utilizar, no cabe agora tratar cada tipo de conexo, mas no laboratrio utilizaremos a OLE DB (ADO). Assim que expandir esse cone, voc ser redirecionado para uma janela onde far as escolhas para sua conexo, como apresenta a Figura 28.
Figura 28 Wizard para configurao da conexo.
14. Na seleo do Provider, procure por Microsoft OLE DB Provider for SQL Server, e clique em Next. Aqui selecionamos qual o tipo de conexo iremos utilizar para trabalhar com determinado banco de dados. 15. Agora precisamos informar o nome do servidor onde se encontra o banco de dados e qual banco ser utilizado. Como o banco trabalha no mesmo computador que a aplicao, vamos passar o endereo local. Em Server name escreva localhost\SQLEXPRESS. Marque a opo Integrated Security, ento escolha a base de dados Northwind em Databases. Esse formulrio dever ficar como mostra a Figura 29.
Figura 29 Configurando conexo por meio OLE DB (ADO).
16. Clique em Next, nessa parte voc ver algumas informaes sobre a conexo que acabou de realizar, clique em Finish para salvar suas escolhas. 17. Com a conexo pronta, podemos voltar a configurar as opes do nosso relatrio. Voc dever visualizar uma janela igual Figura 30.
Figura 30 Janela da configurao wizard do relatrio.
18. Repare que sua base de dados agora aparece entre as conexes OLE DB (ADO). Expanda o cone do banco Northwind, depois expanda a pasta dbo, e depois Tables. Agora devemos selecionar as entidades que queremos e apertar o boto com sinal > para que fique marcada como escolhida. Podemos selecionar uma ou mais tabelas, de um ou mais banco de dados diferentes. Adicione a entidade Customers para o nosso relatrio. Antes de continuar, verifique se est tudo como a Figura 31.
Figura 31 Escolha das entidades para o relatrio.
19. Na prxima etapa devemos escolher quais sero os campos que vamos apresentar no relatrio. Para isso, expanda as entidades escolhidas anteriormente, no nosso caso apenas a entidade Customers. Utilizando novamente o boto com sinal >, vamos marcar os campos que queremos apresentar. Marque os respectivos campos: CustomerID, ContactName, Country, City, e Phone. Compare com a Figura 32, se estiver tudo certo clique em Next.
Figura 32 Escolha dos campos que sero apresentados.
20. As prximas etapas so destinadas para uma configurao mais personalizada do relatrio. No vamos detalhar cada etapa aqui, o nosso objetivo utilizar parmetros como filtros, sendo assim, vamos avanar at chegar janela de escolha do layout do formulrio, como mostra a Figura 33. Voc pode realizar outras aplicaes depois, alterando os valores das outras etapas para conhecer melhor o Crystal Reports.
Figura 33 Janela para escolha do layout do relatrio.
21. Entre os estilos de layout disponveis, deixe marcada a opo Standard, e clique em Finish para finalizar a criao do arquivo do nosso relatrio. 22. Agora temos o arquivo configurado com as informaes necessrias para exibir como relatrio. Perceba que o Visual Studio por padro redireciona o contedo para o arquivo criado e nele voc pode fazer todas as alteraes de design como de negocio. Na parte inferior do contedo do Visual Studio encontramos duas opes quando estamos trabalhando com arquivos do Crystal Reports, a Main Report e Main Report Preview. Voc pode alternar entre elas para ter uma visualizao previa de como ficar seu relatrio. Observe na Figura 34 a localizao dessas opes.
Figura 34 Opes de visualizao do nosso arquivo CrystalReport1.rpt.
23. Vamos agora incrementar o nosso filtro, ou seja, um parmetro que seja necessrio toda vez que o relatrio for iniciado. No nosso arquivo CrystalReport1.rpt em seu modo de exibio Main Report, navegue para a nova janela Field Explorer. Nela encontre o campo Parameter Fields e clique com o boto direito para acessar a opo New, como mostra a Figura 35.
Figura 35 Adicionando parmetros na janela Field Explorer.
24. Na nova janela, devemos preencher alguns campos para criar o parmetro que servira como filtro. Em Name, de o nome Cidade, em Prompting Text, escreva Informe o nome da cidade: e, em Value Type marque a opo string. De acordo com a Figura 36.
Figura 36 Janela para criao de parmetros.
25. Feito isso, clique no boto Default Values para configurar o nosso parmetro. Perceba que nessa nova janela, na parte superior temos dois combos, uma para escolher a entidade e outro para o campo. Deixe a entidade como Customers, e o campo como City. O filtro ser em cima do atributo cidade e, com ele poderemos especificar uma cidade para selecionar especificamente informaes. 26. Com as duas opes marcadas, o wizard mostrar todos os registros que esse campo possui. Clique no boto >> para adicionar os registros, para que o relatrio considere a existncia deles dentro do filtro. Esse formulrio de configurao dever ficar parecido com a Figura 37.
Figura 37 Formulrio de configurao de parmetros.
27. Clique em Ok para salvar as opes. Finalize tambm a janela de criao de parmetros. Agora faltam apenas algumas configuraes para acabar o nosso parmetro. No menu superior do Visual Studio procure pelo item Crystal Reports, dentro da opo Report, selecione Select Expert, como aparece na Figura 38.
Figura 38 Menu Crystal Report.
28. Nessa nova janela, devemos escolher qual campo da entidade Customers ser registrado no modo visual de busca. Neste caso vamos escolher o campo City dentro da tabela Customers, como mostra a Figura 39.
Figura 39 Janela Choose Field.
Microsoft Innovation Center 160 Desenvolvimento em .Net 29. Pressione o boto Ok para continuar. Agora devemos especificar como ser nossa busca. Para isso mude o valor da combo para is equal to. Isso far com que aparea uma nova combo do lado, mude o valor dela para {?Cidade}. Essas mudanas permitem introduzir um valor para filtrar o relatrio por meio visual. Essa janela dever ser parecida com a Figura 40.
Figura 40 Janela Select Expert;
30. Feitas as alteraes, clique em Ok. O arquivo de relatrio est pronto e agora devemos voltar para o Form1. Na sua edio de design selecione o controle Crystal Report. Navegue para o menu tasks na opo Choose a Crystal Report, selecione o nosso arquivo de relatrio. 31. Salve seu projeto e execute para realizar os testes. Seu resultado final dever ficar parecido com a Figura 41.
Figura 41 Relatrio filtrado pela palavra London.
Laboratrio 3 Relatrio com juno e Crystal Reports
Com este laboratrio veremos como criar um relatrio que utiliza juno, ou seja, trabalha com mais de uma entidade por vez. Este laboratrio trar informaes mais detalhadas e com bem mais utilidade. Para isso faremos o uso do Crystal Reports novamente. - Desenvolvendo um relatrio com junes. 1. Assim como os dois outros laboratrios, a utilizao das ferramentas de relatrio possuem a mesma seqncia. Sendo assim, podemos construir a soluo desse laboratrio, tanto em C# como em Visual Basic .Net. 2. Para esse exerccio utilizaremos novamente a base de dados Northwind. Voc pode conferir os passos para adicionar ela ao projeto se for necessrio. Se j possuir o banco de dados correntemente no computador, inicie ento o Visual Studio 2008. Voc pode encontr-lo no menu Iniciar, entre seus programas na pasta Microsoft Visual Studio. 3. Com o Visual Studio aberto, vamos criar um novo projeto, acesse o menu File, depois escolha New e ento Project. Assim como mostra a Figura 42.
Figura 42 Criando um novo projeto no Visual Studio.
4. Na janela de criao, nomeie o projeto para RelatorioJuncao, escolha o local onde ficar salvo o projeto. Certifique-se que a verso do Framework est na mais recente (atualmente 3.5) e em templates escolha a opo Windows Forms Application. Sua janela de criao de projetos deve estar parecida com a Figura 43, feito isso clique em Ok.
Microsoft Innovation Center 162 Desenvolvimento em .Net 5. Navegue para o design do formulrio Form1. Aumente um pouco seu tamanho. Depois acesse a Toolbox e nos controles Reporting como mostra a Figura 44, escolha o CrystalReportViewer, segure e arraste para o centro do formulrio. Repare que este controle j vem modificado para trabalhar com a opo Dock in parent container ativada. O que faz com que ocupe todo o espao disponvel no formulrio.
Figura 44 Acessando controles Reporting.
6. Ainda no modo design do nosso formulrio, selecione o novo controle e acesse o menu tasks, clicando na setinha superior que aparece quando selecionamos um controle. Nesse menu possvel alterar algumas configuraes que no esto disponveis na janela Properties. Com isso desabilite o check chamado Display Group Tree. Isso far com que a rvore de relao no seja mostrada. Confira com a Figura 45 como seu menu tasks dever ficar.
Figura 45 Menu tasks do controle CrystalReportViewer.
7. Acesse novamente o menu tasks, porm desta vez vamos criar o arquivo do nosso relatrio. Clique na opo Create a New Crystal Repor para iniciar o wizard de criao. 8. A primeira etapa definir o nome do arquivo. Nomeie-o como relatorio1.rpt e clique em Ok. 9. Nessa prxima janela devemos escolher qual ser o tipo de relatrio. Deixe as definies padro e continue. 10. Na janela Standard Report Creation Wizard, expanda o item Create New Connection. Depois expanda a opo OLE DB (ADO) (isso far com que apaream as opes de qual tipo de conexo iremos utilizar), procure por Microsoft OLE DB Provider for SQL Server, como mostra a Figura 46, selecione e clique em Next.
Figura 46 Criando nossa conexo com a base de dados.
11. Nessa etapa devemos indicar onde se localiza o banco de dados e qual banco desejamos utilizar. Como estamos utilizando o prprio computador, escreva em Server: localhost\SQLEXPRESS. Marque a check chamada Integrated Security e na combo Database escolha Northwind. Dever ficar parecido com a Figura 47.
Figura 47 Escolhendo a base de dados.
12. A prxima janela mostra as informaes sobre nossa conexo, clique em Finish. 13. Repare que agora temos o banco Northwind adicionado dentro de OLE DB (ADO). Com isso, expanda seu cone para acessar suas tabelas. Dessa vez, vamos escolher duas tabelas para fazer a relao entre seus dados. Marque a entidade Products e Categories, como mostra a Figura 48.
Figura 48 Escolhendo as entidades para o nosso relatrio.
Microsoft Innovation Center 164 Desenvolvimento em .Net 14. Ao clicar em Next voc ver uma nova janela. Aqui podemos ver e configurar as ligaes existentes entre as entidades. Repare que existe uma ligao entre o CategoryID das duas entidades, como mostra a Figura 49.
Figura 49 Analisando as ligaes entre as nossas entidades.
15. No modifique nada e siga para prxima etapa. Agora devemos escolher quais os campos das duas entidades vamos querer apresentar. Adicione da tabela Categories, os campos CategoryID e CategoryName. Da entidade Products, adicione os campos ProductID, ProductName, e UnitPrice. Aps estes passos o formulrio dever ficar parecido com a Figura 50.
Figura 50 Escolhendo as informaes a serem exibidas no relatrio.
16. Na prxima parte podemos definir algum campo responsvel por agrupar as informaes, neste caso selecione a opo CategoryName. 17. As prximas etapas no preciso ser alteradas, continue avanando at chegar configurao de layout. Escolha o modelo Drop Table e clique em Finish para concluir a criao do arquivo Crystal Reports.
Microsoft Innovation Center 165 Desenvolvimento em .Net 18. Vamos voltar para o formulrio Form1 e entre na opo de design. Selecione o controle CrystalReportViewer e acesse seu menu tasks. 19. No menu tasks escolha a opo Choose a Crystal Report e escolha o arquivo criado, como mostra a Figura 51.
Figura 51 Escolhendo qual arquivo .rpt utilizar.
20. Salve seu projeto e execute-o para fazer o teste. O Resultado final dever ficar parecido com a Figura 52.
Figura 52 Resultado final, exibindo relatrio com informaes agrupadas de duas entidades.
Laboratrios extras
1) Trabalhando com relatrios. Crie um novo projeto Windows Forms, com o nome de Relatorios. Voc dever construir uma pequena base de dados com duas entidades, Produtos e Vendas. Os campos de cada entidade ficam a sua escolha, porm, lembre-se que a tabela Produtos dever possuir elementos como cdigo, nome, descrio, preo, etc., da mesma forma que Vendas ter tambm seu cdigo, data, e o nmero do cdigo do produto vendido, assim criando uma relao com as duas tabelas. Essa aplicao dever utilizar os conceitos de formulrios MDI, trabalhar com menus, ter um formulrio filho especifico para cadastrar novos produtos e outro para visualizar, um formulrio para cadastrar vendas, como tambm um formulrio onde o usurio possa ter a escolha de visualizar dois relatrios, um com parmetros na entidade de produtos e outro com juno entre as duas entidades. Caso deseje, voc pode elaborar algumas coisas a mais, como um formulrio inicial requisitando usurio e senha, e tambm o cadastro de novos usurios, necessitando assim a criao de uma entidade Usuario para registrar essas informaes. Lembre-se de utilizar os laboratrios passados para auxiliar na criao dessa aplicao. 2) Relatrios com juno e parmetros. Utilize a base de dados carregada nos laboratrios do capitulo V, chamada Northwind para realizar essa atividade. Construa um formulrio inicial que possua um menu que contenha trs itens: Editar dados, Visualizar dados, e Sair. Os dois primeiros itens se referem a um novo formulrio com suas prprias aes. Editar dados deve possibilitar o usurio de modificar por meio de um GridView a tabela Products ou Categories. O Visualizar dados deve permitir que o usurio visualize um relatrio que junte informaes das duas entidades e que possibilite a filtragem de dados por um campo a sua escolha. Se desejar, elabore um formulrio que inicie antes do principal, requerendo login e senha, e se os dados baterem com um especificado por voc para ser o admin, poder ento acessar o formulrio de editar dados. Faa utilizao dos laboratrios anteriores para carregar o banco de dados, caso necessrio, ou mesmo para auxiliar na criao dessa aplicao.

Desenvolvimento .Net C# VB.Net

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Desenvolvimento .Net C# VB.Net

Enviado por

Direitos autorais:

Formatos disponíveis

Desenvolvimento em .

Microsoft Innovation Center

Microsoft Innovation Center 2 Desenvolvimento em .Net

Microsoft Innovation Center 4 Desenvolvimento em .Net

Figura 1 Modelo de funcionamento do Framework .Net.

Microsoft Innovation Center 6 Desenvolvimento em .Net

Microsoft Visual Studio

Principais linguagens da plataforma .Net

Conhecendo a rea de trabalho do Microsoft Visual Studio

Figura 2 Apresentao inicial do Visual Studio.

Microsoft Innovation Center 8 Desenvolvimento em .Net

Criando novas solues e aplicaes

Figura 3 Acessando o menu superior para criar um novo projeto.

Figura 4 Janela de criao de novos projetos.

Viso geral das janelas de auxlio

Figura 5 Janela Solution Explorer.

Figura 6 rea para alterao de formulrios.

Figura 7 Controles na janela Toolbox.

Microsoft Innovation Center 11 Desenvolvimento em .Net Properties:

Figura 8 Janela para alterar as propriedades de um controle.

Figura 9 Janela Server Explorer.

Microsoft Innovation Center 12 Desenvolvimento em .Net

Viso geral sobre os captulos

Microsoft Innovation Center 13 Desenvolvimento em .Net

Captulo I Variveis, Operadores e Estruturas de Deciso

Microsoft Innovation Center 14 Desenvolvimento em .Net

- Sintaxe C#: String i; - Sintaxe Visual Basic .Net: Dim i As String

Um nico caractere unicode de 16 bits. Um Unicode com at 1 gigabyte de caracteres. Unicode

Microsoft Innovation Center 15 Desenvolvimento em .Net

Figura 1 Criando um novo projeto.

Figura 2 Tela principal do projeto em C#.

Microsoft Innovation Center 16 Desenvolvimento em .Net

Figura 3 Tela principal do projeto em Visual Basic .Net.

using using using using

System; System.Collections.Generic; System.Linq; System.Text;

Module Module1 Sub Main() Dim nome As String nome = "Jos"

End Sub End Module

using using using using

System; System.Collections.Generic; System.Linq; System.Text;

6. Salve seu projeto, execute-o apertando o atalho Ctrl + F5 e veja o resultado.

Microsoft Innovation Center 18 Desenvolvimento em .Net

Soma de dois nmeros, ou concatenao

Subtrao de dois nmeros

Diviso de dois nmeros

Multiplicao de dois nmeros

Nesse caso, atribuio de valor

Resto da diviso inteira de um nmero por outro Exponenciao

No lgico: "nega", ou melhor, inverte o valor lgico da expresso

< <= > >= == / = != / <>

Microsoft Innovation Center 20 Desenvolvimento em .Net

Figura 8 Criando um novo projeto.

Figura 9 Tela principal do projeto em C#.

Microsoft Innovation Center 21 Desenvolvimento em .Net

Figura 10 Tela principal do projeto em Visual Basic .Net.

Figura 16 Apresentao dos resultados em Visual Basic .Net.

Microsoft Innovation Center 23 Desenvolvimento em .Net

- Sintaxe em Visual Basic .Net:

Microsoft Innovation Center 24 Desenvolvimento em .Net

Microsoft Innovation Center 26 Desenvolvimento em .Net

Laboratrio 3 Estrutura de Deciso

Figura 17 Criando um novo projeto.

Figura 18 Tela principal do projeto em C#.