Curso Prático de Visual

Curso Prático de Visual Studio.
NET
Curso Prático de Visual

Studio.NET
Autor: Mauricio Junior

www.ascompras.com
www.aspneti.com.br
mauricio@ascompras.com
mauricio@aspneti.com.br
1
Este material não pode ser usado
em treinamentos e em Sala de Aula
Curso Prático de Visual Studio.NET
Nota sobre direitos autorais:
Este e-book é de autoria de Mauricio Junior, sendo comercializado

diretamente através do site www.juliobattisti.com.br ou através do site de
Comércio Eletrônico: www.ascompras.com.br / www.ascompras.com ,
mediante contato através do email: mauricio@ascompras.com ou através
do site www.aspneti.com.br, mediante ao e-mail mauricio@aspneti.com.br
, diretamente pelo autor. Nenhum outro usuário/email e/ou empresa está
autorizada a comercializar este ebook.
Ao adquirir este ebook você tem o direito de lê-lo na tela do seu

computador e de imprimir quantas cópias desejar. É vetada a distribuição
deste arquivo, mediante cópia ou qualquer outro meio de reprodução, para
outras pessoas. Se você recebeu este ebook através do e-mail ou via ftp de
algum site da Internet, ou através de um CD de Revista, saiba que você está
com uma cópia pirata, ilegal, não autorizada, a qual constitui crime de
Violação de Direito Autoral, de acordo com a Lei 5988. Se for este o caso
entre em contato com o autor, através do e-mail
webmaster@juliobattisti.com.br ou mauricio@ascompras.com , para
regularizar esta cópia. Ao regularizar a sua cópia você irá remunerar,
mediante uma pequena quantia, o trabalho do autor e incentivar que novos
trabalhos sejam disponibilizados. Se você tiver sugestões sobre novos
cursos que gostaria de ver disponibilizados, entre em contato pelo e-mail:
webmaster@juliobattisti.com.br.
Visite periodicamente o site www.juliobattisti.com.br para ficar por dentro

das novidades:
• Cursos de informática.
• Guias de Estudo para os Exames de Certificação da Microsoft.
• Artigos e dicas sobre Certificações da Microsoft.
• Artigos sobre Carreira e Trabalho.
• Dicas de livros e sites sobre diversos assuntos.
2
• Simulados gratuitos, em português, para os exames da Microsoft.
• ESTE E-BOOK NÃO PODE SER

FORNECIDO EM UM CD OU DVD DE
NENHUMA REVISTA
• SE VOCÊ OBTEVE UMA CÓPIA DESTE E-

BOOK ATRAVÉS DO E-MULE, KAZAA,
MORPHEUS OU OUTRO PROGRAMA DE
COMPARTILHAMENTO, SAIBA QUE VOCÊ
ESTÁ COM UMA CÓPIA ILEGAL, NÃO
AUTORIZADA
• USAR UMA CÓPIA NÃO AUTORIZADA É

CRIME DE VIOLAÇÃO DE DIREITOS
AUTORAIS, COM PENA PREVISTA DE
CADEIA
• VOCÊ SÓ PODE USAR ESTE E-BOOK SE

VOCÊ COMPROU ELE DIRETAMENTE COM
O AUTOR: MAURÍCIO JÚNIOR
3
PIRATARIA É CRIME, COM PENA DE CADEIA. EU

AGRADEÇO PELA SUA HONESTIDADE. SE VOCÊ
COMPROU UMA CÓPIA DESTE CURSO,
DIRETAMENTE EM WWW.JULIOBATTISTI.COM.BR
OU DIRETAMENTE COM O AUTOR, NÃO
DISTRIBUA CÓPIAS PARA OUTRAS PESSOAS.
SE VOCÊ BAIXOU UMA CÓPIA DESTE ARQUIVO

USANDO UM SOFTWARE TAL COMO O E-MULE OU
O KAZAA, SAIBA QUE VOCÊ ESTÁ COM UMA
CÓPIA PIRATA, ILEGAL. USAR UMA CÓPIA
ILEGAL É CRIME DE VIOLAÇÃO DE DIREITOS
AUTORAIS.
ESTE ARQUIVO NÃO PODE SER DISTRIBUIDO

GRAVADO EM UM CD OU DVD DE REVISTA OU
LIVRO. A ÚNICA MANEIRA DE OBTER ESTE
ARQUIVO É COMPRANDO DIRETAMENTE COM O
AUTOR OU ATRAVÉS DO SITE
WWW.JULIOBATTISTI.COM.BR
SE VOCÊ RECEBEU UMA CÓPIA ILEGAL DESTE

ARQUIVO, NÃO ADQUIRIDA DIRETAMENTE
4
PELOS MEIOS DESCRITOS NO INÍCIO DA

PÁGINA, ENTRE EM CONTATO E REGULARIZE A
SUA CÓPIA.
Algumas palavras do autor:
Este curso foi criado com o objetivo de ajudá-lo a entender e a utilizar no

seu dia-a-dia, os recursos avançados do Visual Studio.NET, para a criação
de sistemas e relatórios profissionais de software. O curso é composto de
325 páginas e com módulos diferentes para qualquer tipo de sistema e
software que quiser desenvolver. Os conceitos apresentados são válidos
para o Visual Studio.NET 2003 e outros para o Visual Studio.NET 2005.
Em cada lição são apresentados conceitos teóricos, seguidos por exemplos

práticos, passo-a-passo, para que você possa consolidar os conceitos
teóricos apresentados.
Um bom estudo a todos e espero, sinceramente, que este curso possa ajudá-
los a utilizar melhor os recursos avançados dessa nova plataforma da
Microsoft .NET.
5
6
7
ÍNDICE
INTRODUÇÃO E INSTALAÇÃO..........................................................13
TRABALHANDO COM VISUAL STUDIO.NET .......................................33
PRIMEIRA PÁGINA PARA INICIAR FORMALMENTE ..............................34
ESTUDANDO O ID DOS OBJETOS .....................................................42
FIM DAS SUBS PROPRIEDADES DO FONT. .........................................48
USANDO COMPONENTES DINAMICAMENTE .......................................50
USANDO COMPONENTE DROPDOWNLIST ........................................56
USANDO VERDADEIRAMENTE ORIENTAÇÃO A OBJETOS .......................58
CLIQUE DUAS VEZES NO COMPONENTE CMBOPCOES ..........................61
INSERINDO MAIS UM COMPONENTE (CHEKBOX) ...............................67
INSERINDO MAIS UM COMPONENTE (BUTTON) ..................................70
USANDO O COMPONENTE LISTBOX .................................................77
VALIDANDO CAMPOS DO FORMULÁRIO ...........................................81
ADO.NET CONECTANDO COM MYSQL ...........................................89
VISÃO GERAL DO ADO.NET .........................................................89
CONNECTION: CONEXÃO COM O BANCO DE DADOS .............................90
CRIANDO CLASSE PARA INSERIR NO BANCO DE DADOS ........................97
INSERINDO NO BANCO DE DADOS ..................................................101
USANDO COMPONENTE DATAGRID PARA MOSTRAR DADOS ...............108
INTRODUÇÃO AO WEB SERVICES ..................................................129
ALGUMAS VANTAGENS DE UMA APLICAÇÃO DE WEB SERVICES ..........130
INTEGRAÇÃO DE APLICAÇÕES ......................................................131
COMPUTAÇÃO DISTRUIDA ...........................................................133
1987 .......................................................................................133
1989 .......................................................................................133
8
1990 .......................................................................................133
1991 .......................................................................................134
1996 .......................................................................................134
1999 .......................................................................................134
ARQUITETURA ORIENTADA A SERVIÇOS .........................................135
PROVEDOR DE SERVIÇO..............................................................135
REQUISITOR DE SERVIÇO ............................................................135
REGISTRADOR DE SERVIÇO .........................................................135
PILHAS DE INTEROPERABILIDADE ................................................136
EXTENSIBLE MARKUP LANGUAGE (XML) .....................................136
XML ? ....................................................................................136
DISTRIBUIÇÃO ..........................................................................137
ORIENTAÇÃO A DADOS ...............................................................137
ESTRUTURA DO DOCUMENTO XML ..............................................138
ELEMENTOS .............................................................................138
ATRIBUTOS ..............................................................................138
COMENTÁRIOS ..........................................................................139
PRATICANDO WEB SERVICES.......................................................139
CODIFICANDO WEBSERVICE .......................................................146
ACESSANDO O WEBSERVICE ATRAVÉS DE OUTRO PROGRAMA ............152
INSTANCIANDO E CODIFICANDO O WEBSERVICE ............................156
CRIANDO BANCO DE DADOS SQL SERVER...................................162
CRIANDO TABELA DO BANCO DE DADOS .......................................165
CRIANDO STORE PROCEDURE PARA INSERIR NO BANCO DE DADOS ....167
ACESSO A BANCO DE DADOS .......................................................170
CRIANDO CLASSE PARA ACESSAR BANCO DE DADOS .......................170
CODIFICANDO CLASSE DE ACESSO A BANCO DE DADOS ...................174
CRIANDO MÉTODOS PARA CONEXÃO NO BANCO DE DADOS ..............177
9
CRIANDO O MÉTODO PARA FECHAR O BANCO DE DADOS ...................178
INSERINDO DADOS NO BANCO .....................................................181
CRIANDO WEBSERVICE PARA INSERIR DADOS NO BANCO ................185
MOSTRANDO WEBSERVICE CRIADO .............................................188
CRIANDO WEBSERVICE QUE RETORNA STRING ..............................194
CONSUMINDO WEBSERVICES ......................................................199
CRIANDO WEBSERVICE QUE CRIPTOGRAFA DADOS.........................211
USO DE CRIPTOGRAFIA EM SISTEMA DA INFORMAÇÃO ....................212
GERANDO CHAVE DE CRIPTOGRAFIA ............................................212
QUANDO USAR CRIPTOGRAFIA DE DADOS ? ...................................214
CRIANDO A CLASSE DE CRIPTOGRAFIA..........................................216

CRIANDO WEBSERVICE PARA CRIPTOGRAFAR E DESCRIPTOGRAFAR
DADOS ....................................................................................224
MOBILIDADE ............................................................................236
INTERFACE ..............................................................................237
ARQUIVOS ................................................................................237
INSTALAÇÃO DE ALGUNS DISPOSITIVOS SMARTPHONE .....................238
PROBLEMAS DO DISPOSITIVO .......................................................239
O APLICATIVO É ENCERRADO PELO SISTEMA ..................................239
SEGURANÇA .............................................................................240
USO DE RAPI NO SMARTPHONE...................................................240
HARDWARE ..............................................................................241
CONEXÃO COM A INTERNET ........................................................241
PRIMEIRO APLICATIVO MÓBILE...................................................244
INSTALANDO O MYSQL .............................................................245
INSTALANDO O GERENCIADOR DE BANCO DE DADOS .......................251
PRATICANDO ............................................................................258
OBJETOS DO FORM FRMLOGIN ....................................................267
10
INSERINDO CLASSE PARA CONEXÃO COM O BANCO DE DADOS ..........270
ANALISANDO O MÉTODO PARA ABRIR O BANCO DE DADOS ...............274
ANALISANDO MÉTODO PARA FECHAR O BANCO DE DADOS ...............275
CRIANDO CLASSE DE LOGIN ........................................................283
DEPURANDO CÓDIGO CRIADO ......................................................288
CRIANDO MÉTODO PARA LOGAR NO SISTEMA ................................293
EXPLICAÇÃO DO MÉTODO LOGAR ................................................295

CRIANDO OS FORM’S MENU DO APLICATIVO E CADASTRO DE FINANÇAS
..............................................................................................301
CADASTRO DE DESPESAS ............................................................307
GERANDO RELATÓRIOS DE MOVIMENTOS ......................................323
CRIANDO MÉTODO DE RETORNO DATAREADER .............................325
EXPLICANDO MÉTODO LISTARELATORIO ......................................327
CODIFICANDO DENTRO DA CLASSE DEFAULT.ASPX .........................329
DESENVOLVENDO APLICATIVO PARA O POCKET PC .........................334
USANDO BANCO DE DADOS .........................................................334
CRIANDO PROJETO DO TIPO SMART DEVICE APPLICATION...............334

CRIANDO CLASSE PARA CONEXÃO COM BANCO DE DADOS SQL SERVER
CE ..........................................................................................338
ANALISANDO O PRIMEIRO MÉTODO CONECTAR() ............................338
ANALISANDO O SEGUNDO MÉTODO DESCONECTAR() .......................339
DICA C#.NET: .........................................................................342
CRIANDO CLASSE DE INSERÇÃO DE VALORES .................................342
ALTERANDO CLASSE FORM1.CS ...................................................347
CRIANDO BANCO DE DADOS NO POCKET PC ...................................348
11
12
Introdução e instalação
Nesta introdução, irei demonstrar a instalação do Visual Studio.NET, com

as devidas explicações e ilustrações.
A versão completa e original do Visual Studio. Net é composta de 6 cds,

sendo 3 do sistema com as devidas linguagens e objetos necessários para
usá-los, e 3 de instalação do HELP MSDN. Coloquei o cd 1. O sistema vai
checar o produto e algumas informações no seu computador, para a
instalação do mesmo, deve ter a partir de uma certa quantidade de
memória, pelo contrário o software não deixar instalar. Além de memória,
deve ter certa quantidade de espaço onde serão colocados os arquivos. Esse
primeiro cd também verifica se tem algum framework instalado no seu pc,
se tiver o mesmo não é instalado novamente. Chamo isso de instalação
inteligente.
Referência: 1-1
Depois que for feita toda a verificação necessária, aparecerá outra tela para
a instalação dos requisitos do sistema. Lembre-se de que para usar
aplicações para Web usando o Visual Studio. Net, deve-se ter o IIS
(Internet Information Services) instalado. Caso você não tenha, na entrada
do primeiro cd será requisitada a sua instalação, antes de tudo. Lembro que
para a versão do Visual Studio.NET 2005 não é necessário ter instalado no
pc o IIS, ou seja, o desenvolvedor por usar a ferramenta tranquilamente
sem IIS comentado anteriormente. Para o alívio do desenvolvedor, a
13
ferramenta já possui um servidor de aplicação dentro e automatizada onde

já pode diminuir um tempo para compilação de depuração. Falarei mais
dessa ferramenta nos próximos capítulos.
Referência: 1-2
Clicando no único item habilitado, Visual Studio.Net Prerequisites, o

sistema de instalação pedirá automaticamente o cd de pré-requisitos, que
vem junto com os demais. Esse pré-requisito é para terminar de instalar
algumas ferramentas e frameworks que não estão instalados no seu pc,
antes de instalar o verdadeiro Visual Studio.Net esses pacotes de serviços
precisam ser instalados para não dar nenhum tipo de erro ou pau na
14
instalação. Se algum aplicativo tivesse esses mesmo tipos de instalação,

grande parte do mesmo não teria erros no decorrer da utilização.
Referência:1-3
Colocando o cd de pré-requisitos, clique no o.k. da tela acima ou indique o

local onde se encontra o cd.
15
Referência: 1-4
No meu caso, indiquei o local da instalação, para que o sistema possa

acessar os objetos e arquivos corretos. Aconselho a você também usar as
mesmas configurações.
16
Referência: 1-5
Existe uma licença que você deve ler e em seguida aceitar. Embora
normalmente ninguém leia as licenças que quase todo sistema exibe, é
sempre bom ler as informações contidas nelas, para depois aceitar ou não.
Todas as informações contidas na licença são importantes e devem ser
lidas.
17
Referência: 1-6
Depois de clicar em I agree (eu aceito), clique no link continue.

Se você estiver utilizando Windows 2000, numa rede de computadores,
aparecerá a tela a seguir, referente ao login. Não marque nada e siga
adiante. Descrevo todos os passos para que siga corretamente a forma de
instalação.
18
Referência: 1-7
Clicando em Install Now, ocorrerá a instalação dos componentes que estão

faltando no seu sistema operacional, sendo servidor ou desktop. Veja a tela
a seguir:
19
Referência: 1-8
Nessa tela foram detectados os objetos e sistemas que precisam ser

instalados no meu computador. Na ilustração a seguir, você confere os
mesmos sendo instalados.
20
Referência: 1-9
Os requisitos estão sendo instalados, o que levará algum tempo. Perceba

que os itens instalados com sucesso recebem uma marca azul, enquanto os
impossibilitados de serem instalados recebem uma marcação vermelha.
21
Referência: 1-10
Veja que na minha máquina a instalação foi feita com sucesso. Logo após a
instalação do pré-requisito, clique no link done para fechar a janela.
Automaticamente se abrirá outra janela para definitivamente instalar o
Visual Studio.Net.
22
Referência: 1-11
Clicando no link Visual Studio.Net, o sistema de instalação abrirá uma tela

para você indicar o local ou colocar o cd, e clicar Enter.
23
Referência: 1-12
Após colocar o cd ou indicar o local, na tela seguinte deverá ser digitada a

chave do produto e aceita a licença representada na imagem acima.
Digitando tudo corretamente e aceitando, o link continue será habilitado
automaticamente, dando continuidade à instalação. Na próxima tela, você
poderá escolher as linguagens que gostaria de desenvolver, exemplos de
sistemas desenvolvidos e objetos como o Crystal Report, dentre outros. O
Visual Studio. Net veio com algumas habilidades para trabalhar com várias
linguagens dentro de um mesmo sistema. Confira a imagem a seguir:
24
Referência: 1-13
No meu caso, prefiro o desenvolvimento com C#.NET. Para não encher o

meu computador de coisas inúteis, vou desmarcar algumas opções:
25
Referência: 1-14
Ao desmarcar algumas opções que não irei usar, observe que houve um
aumento de cerca de 1 Giga de espaço livre. Quando terminar, clique em
Install Now. Outra tela surgirá, gerando um script para instalar tudo o que
foi marcado.
26
Referência: 1-14
No decorrer do processo, o instalador irá pedir o outro cd de instalação (o

cd 2) para continuar.
27
Referência: 1-16
No término do processo, o sistema vai gerar um relatório informando as

opções instaladas com sucesso e a eventual presença de erros na instalação.
28
Referência: 1-17
Na instalação que foi feita no computador, não deu erro. Nesse relatório
pode ser visto o log da instalação e muito mais. Clicando depois em done,
uma outra tela surgirá para a instalação do Msdn Help.
29
Referência: 1-18
Para instalar o MSDN Help do Visual Studio.Net, é só clicar no link e

colocar os cds em ordem. No meu caso, não instalei o Help e cliquei no link
exit para sair do sistema de instalação.
30
Referência: 1-19
Depois do sistema ser instalado, execute o comando iniciar / programas /

Microsoft Visual Studio.net 2003 / Microsoft Visual Studio.NET 2003, e o
sistema abrirá corretamente. Confira o caminho a seguir:
31
Referência: 1-20
32
Trabalhando com Visual Studio.Net
Estaremos falando mais a frente sobre uma linguagem de programação

muito esperada pelo usuário, chamada C#.NET para Web, usando
ASP.NET, da Microsoft. Você poderá aprender como fazer a sua primeira
página usando C#.NET com ASP.NET. Para o desenvolvimento dos
exemplos, será usado o Visual Studio.NET 2003. Neste primeiro aplicativo
que irei fazer, começo a abordar assuntos interessantes que poderá servir
para a vida toda como desenvolvedora. É importante dizer que a ferramenta
Visual Studio.NET é muito poderosa, podendo fazer qualquer tipo de
aplicativo que quiser como para celular, cliente servidor, pocket pc, web,
serviços e muito mais. Hoje em dia não está mais sendo tão importante em
saber qual a linguagem que está sendo programado dentro da aplicação,
dentro de uma aplicação podemos desenvolver em qualquer tipo de
linguagem.
33
No lugar de WebApplication1, coloque o nome do seu projeto, da seguinte

forma: PrimeiroSistema. Logo após o Visual Studio 2003.NET criar no IIS
(Internet Information Services) um diretório virtual, crie uma página
chamada default.aspx.
Acompanhe os passos seguintes para criar a página descrita acima:
Primeira página para iniciar formalmente
Observação: não se preocupe com o layout da página, nem com estilos, mas
primeiramente com a programação. Mais tarde usarei estilos para colocar
em ordem todos os nossos problemas em relação a layout. É bom usar
também tableless, uma nova forma de criar sites e sistemas. Ficam mais
rápidos para ser mostrados no browser que irá utilizar. O interessante é que
pode abrir em qualquer cliente, como firefox, internet explorer e outros que
existem no mercado.
34
Clique com o botão direito em cima do nome do projeto PrimeiroSistema,

depois em add; em seguida em Add Web Form, e, finalmente, nomeie o
arquivo (default.aspx).
Clique em Properties Window e depois na página em branco. A janela que

aparecerá do lado direito apresentará todas as propriedades da mesma.
Veja como vai ficar a sua tela para programação; note que do seu lado
direito existe mais uma aba com ferramentas. Há uma barra lateral do lado
esquerdo da sua tela chamada Toolbox, além de palestras e ferramentas que
podem ser usadas, facilitando o desenvolvimento de qualquer sistema.
Primeiro vou colocar na página um Label. Clique nele e arraste-o dentro da
página.
35
Logo após colocar o Label, seguindo na tela de Properties, na propriedade

Text digite o seguinte texto: “Seja bem-vindo ao meu primeiro sistema”.
Continuando na mesma aba, clique na propriedade Font, para mudar o
estilo de fonte, escolher seu tamanho e optar pelo itálico. A propriedade
ForeColor serve para mudar a cor da fonte do seu label. Todo componente
possui um ID na aba de propriedade. Cada objeto ou componente deve ter
um ID e todos na mesma página devem ter nomes diferentes. Não existe
um objeto ou componente com o mesmo nome na mesma página. Veja
como ficou:
Vamos ver como ficou a página funcionando. Para isso, entre na aba
Solution Explorer e clique com o botão direito do mouse em cima da
página default.aspx. Clique na opção Set as Start Page, com isso
colocando-a como a página principal do seu sistema. Veja como fazer:
36
Agora irei executá-la; veja como ficará no seu browser ou cliente. Clique
no menu Debug e logo após em Start. A tela a seguir indica o
procedimento. Existem alguns atalhos, como F5.
37
Veja como ficará a sua página no browser. Note que ficará do mesmo jeito
construído no seu cliente.
38
Veja o endereço na parte de cima do cliente,

http://localhost/PrimeiroSistema/default.aspx.
O nome também pode ser alterado para o nome da sua maquina e o nome
do projeto, por exemplo:
http://NOMEDASUAMAQUINA/PrimeiroSistema/default.aspx
O Visual Studio.Net 2003 possui dois códigos fontes para você trabalhar,
mais à frente falarei sobre eles. Se você notar, a parte de código visual que
se encontra logo que você abre a página, quando entra no projeto, é a parte
de Design. Vou passar para a parte HTML, e tudo o que fizer na parte de
Design do Visual Studio automaticamente será programado pelo sistema no
código HTML. Clique na aba HTML.
Para quem sabe um pouco de TAGS HTML, vale notar que são diferentes
do próprio HTML puro. Essa parte de HTML é chamada de TAGLIB. Tags
prontas para receber um tipo de parâmetro pelo servidor. Veja a seguir o
39
código fonte onde será realizada a programação, chamada de CodeBehing.

Para acessar, clique na aba design e dê um clique duplo na página; ou então
clique na página pela aba direita na opção View Code. Não gosto de usar o
código fonte na página, falo diretamente o código fonte do projeto. Sempre
gosto de usar CodeBehing, dessa forma o código fica mais seguro quando
for colocado dentro do servidor.
Note que é criada uma outra página automática, com extensão .CS. A
extensão .CS é um produto da linguagem C# (C Sharp). Todo código é
orientado aos objetos, seguindo todo o padrão necessário. No método
private void page_load (object sender, System.EventArgs e) digite o
seguinte código:
Label1.Text = "Sistema Pronto para começar";
40
Explicando código:
Lembre-se que falei que todos os objetos da tela precisam ter um ID (o
LABEL colocado acima tem o ID chamado LABEL1). Todo LABEL tem
uma propriedade chamada TEXT. O código acima está sendo atribuído ao
seu LABEL da tela através de um valor entre aspas duplas (“ ”). O motivo
do uso das aspas duplas é devido ao fato de serem uma STRING. Agora,
salve o que foi feito e execute o programa.
Mais adiante estarei falando sobre o ID dos componentes na sua tela, de

como é o padrão de cada um. Veja que o seu LABEL vai mudar, com a
atribuição feita no código .CS acima.
41
Estudando o ID dos objetos
Para ver o ID do objeto na tela, basta clicar no mesmo e na aba properties; a

última opção será referente ao ID, onde você poderá mudar o nome do seu
objeto, para que ele possa ser usado no seu projeto.
Para cada objeto existe um padrão de nomenclatura, utilizado para facilitar

a aplicação. O tipo de nomenclatura é sempre o
padrão+NomeDoSeuCampo. Por exemplo:
Label – lblTitulo
TextBox – txtNome
Button – cmdEnviar
42
DataGrid – dtGridRelatorio
CheckBox – ckRevista
CheckBoxLis – ckListaRevista
RadioButton – rdOpcao
RadioButtonList – rdListaOpcao
Quando quiser usar um ID muito grande ou colocar um separador entre o

nome, utilize lblTitulo_Nome.
Antigamente em vez de usar o ID era usado e um atributo chamado NAME.

Essa versão do Visual Studio.NET 2003 esse atributo NAME foi
substituído pelo atributo ID; isto é; é a mesma propriedade e da mesma
forma pode ser usado. Veja a figura abaixo:
43
Na figura acima, mostra apenas como clicar com o botão direito no projeto
e adicionar mais uma página aspx, coloque o nome da mesma como
frmId.aspx..
Abra a barra de ferramentas e adicione um componente chamado Label na

página que acabei de criar. Irei mostrar um pouco sobre as propriedades do
mesmo na apostila. Não podemos esquecer que qualquer componente na
plataforma ASP.NET dever ter um tag chamado RUNAT=”SERVER” ou
RUNAT=SERVER. Em relação ao ASP 3.0, essa tag foi adicionada para
ser executada no servidor.
44
Na figura acima, está apenas indicando onde está o componente Label.

Agora adicione o mesmo na sua página, selecione o componente e clique
em Properties Window. Note-se que mostrará todas as propriedades do
componente selecionado no seu Visual Studio.NET. Veja a figura abaixo:
45
Irei mostrar as propriedades mais comuns do Label, não posso esquecer que
todos os componentes que usamos no Visual Studio.NET tem Properties.
Veja a figura abaixo e a explicação de cada propriedade:
46
BackColor: muda a cor do fundo do label;

BorderColor: muda a cor da borda da label;
BorderStyle: nessa propriedade posso escolher qual tipo de borda para o
meu label, dependendo da cor que escolhi na propriedade acima;
BorderWidth: muda a largura da borda escolhida, por exemplo se escolher
100 ficará uma borda bem grossa;
47
CssClass: nessa propriedade posso colocar um arquivo de stylo como valor

para o label, ficando o stylo configurado para ser usado;
Font: percebe-se que, existe uma seta ao lado dessa propriedade no Visual
Studio.NET, clicado nela irá abrir outras propridades para dentro dessa,
como se fosse sub-propriedade.
Sub propriedades do font, segue abaixo:

Bold: deixa o label com estilo negrito;
Italic: deixa o label com estilo itálico;
Name: nessa propriedade, posso escolher o tipo de fonte que gostaria de
exibir no meu label, por exemplo: Verdana, Arial e etc...;
Names: nessa propriedade posso colocar uma coleção de string;
OverLine: deixa o espaço do label na parte de cima mais curto quando está
false e deixa menos espaço quando está true, nessa propriedade só existe
true e false nos valores;
Size: deixa o label maior ou menor dependendo da opção que escolher;
Strikeout: deixa o label com um traço ao meio do label quando o valor for
true e tira o mesmo quando for false, os valores são apenas true e false;
Underline: deixa o label sublinhado quando escolhe true e tira o mesmo
quando escolhe false, essa propriedade possui apenas true ou false nos
valores;
Fim das subs propriedades do Font.
Enabled: significa que irá deixar o label habilitado ou não, os valores são
true e false, se true está habilitado, se false desabilitado, quando
desabilitado o usuário não pode clicar no label;
TabIndex: nessa propriedade indico qual o objeto da tela coloco o foco
primeiro quando clico na tecla TAB do teclado;
ToolTip: nessa propriedade pode-se colocar uma descrição qualquer, com
isso o usuário posicionando o mouse em cima do label aparecerá uma ajuda
para o mesmo, chamamos isso grosseiramente de HINT;
48
Visible: coloca o label ou objeto da tela invisível ou visível para o usuário,

os valores que são usados é true ou false;
Width: propriedade que pode aumentar ou diminuir o tamanho do label;
Id: como falado anteriormente, essa propriedade é nova, antes era usado o
atributo name, agora passou a ser usado o atributo Id, esse id é para
identificar o nome do objeto na tela e código fonte.
No começo desse capítulo, falei um pouco sobre os objetos de tela que são
mais usados no Visual Studio.NET e em uma aplicação WEB, estarei
detalhando mais os objetos e informando para que serve.
Na figura acima já falamos um pouco desse objeto nesse mesmo capítulo,

portanto colocarei apenas alguns detalhes do mesmo. Label é um objeto de
tela cujo pode ser colocado qualquer texto para ser mostrado ao usuário ou
cliente, esse texto pode ser formatado, mudado a fonte, colocado nova cor,
mudado o tamanho e ainda mais. O importante é que usando o Visual
49
Studio.NET, os códigos estarão separados chamado de “code behing”,

(estarei explicando melhor mais a frente sobre o code behing), com isso o
valor do objeto da tela poderá ser pego também dentro do código C#.NET
orientado a objetos tranquilamente. O label é muito útil para o
desenvolvimento via WEB hoje em dia.
Antigamente esse objeto texbox
Usando componentes dinamicamente
50
A tela dinâmica acima possui os seguintes campos e IDs (nomes):
RadioButtonList
Id = rdListaOpcao
AutoPostBack = True
Items
Text = Email
Value = 1
Text = Telefone
Value = 2
Label’s
Label
Text = Email:
Id = lblEmail
51
Visible = False
Label
Text = Telefone:
Id = lblTelefone
Visible = False
TextBox’s
TextBox
Id = txtEmail
Visible = False
TextBox
Id = txtTelefone
Visible = False
Clique duas vezes no componente dListaOpcao, e insira os códigos a

seguir:
52
private void rdListaOpcao_SelectedIndexChanged(object sender,

System.EventArgs e)
{
if (rdListaOpcao.SelectedValue == "1")
{
lblTelefone.Visible = false;
txtTelefone.Visible = false;
lblEmail.Visible = true;
txtEmail.Visible = true;
}
else
{
lblTelefone.Visible = true;
txtTelefone.Visible = true;
lblEmail.Visible = false;
txtEmail.Visible = false;
}
}
53
Execute o código no e-mail ou telefone. Note que conforme for escolhida

uma opção, a tela mudará dinamicamente os campos. Ao configurar o
campo RadioButtonList como AutoPostBack = true, a página se auto
atualizará quando for escolhida alguma opção, mudando, portanto, sem que
você tenha feito nenhum código javascript. Da forma antiga, apenas com
javascript essa operação poderia ser realizada.
54
A tela acima exibirá o resultado final dessa primeira etapa. Agora digite
alguma coisa no campo “e-mail”. Clicando na opção “telefone”, digite algo,
volte para o campo “e-mail” e note que o programa mantém
automaticamente o que foi digitado, sem nenhum problema ou interferência
de código.
55
Além desses componentes que usamos, existem vários que poderemos

utilizar em nossa aplicação.
Usando Componente DropDownList
O próximo componente que irei mostrar é o que chamamos erradamente de

“combo”. Aqui será chamado de “DropDownList”.
56
Preencha o campo com as seguintes definições de propriedades:

Id = cmbOpcoes
Items
Select = true
Text = Selecione
Value = 0
Text = Email
Value = 1
Text = Telefone
Value = 2
AutoPostBack = true
57
Usando verdadeiramente orientação a objetos
Agora estarei praticando a orientação do objeto de verdade, escrevendo

outras formas de código a partir do mesmo exemplo que fiz.
Irei inserir mais quatro métodos dentro da classe default.cs, métodos
públicos e sem nenhum retorno.
/// <summary>
/// Metodo para sumir com os campos de email
/// dinamicamente
/// </summary>
public void sumirEmail()

{
txtEmail.Visible=false;
lblEmail.Visible=false;
}
/// <summary>
/// Metodo para sumir com os campos de Telefone
/// dinamicamente
/// </summary>
public void sumirTelefone()
{
txtTelefone.Visible=false;
lblTelefone.Visible=false;
}
/// <summary>
/// Metodos para aparecer os campos de email
/// dinamicamente
58
/// </summary>
public void aparecerEmail()
{
lblEmail.Visible=true;
txtEmail.Visible=true;
}
/// <summary>
/// Metodos para aparecer os campos de telefone
/// dinamicamente
/// </summary>
public void aparecerTelefone()
{
txtTelefone.Visible=true;
lblTelefone.Visible=true;
}
Explicando o código:
Os métodos foram criados porque, quando precisamos deles, basta acessá-
los normalmente, economizando linha de códigos.
public void sumirEmail()

{
txtEmail.Visible=false;
lblEmail.Visible=false;
}
No começo do método colocamos public; isto significa que esse método

pode ser acessado por qualquer outra classe sem nenhum problema de
permissão. Logo após vem o void, que significa que esse método criado
não retornará nenhum valor. Para citar um exemplo sobre um método em
que há retorno de algum tipo de valor, eu colocaria string no lugar de void,
para que, no final do método, houvesse a seguinte linha: return
59
sua_variável, que por sinal deveria ser string. Dentro do método, peguei os
objetos da tela e optei por visível ou não visível. No caso do código acima,
txtEmail.Visible=false, o objeto “e-mail” estará invisível, quando o método
for chamado.
Terei que mudar o método construído acima, de funcionamento orientado a

objetos. Para ver o código que será refeito, clique duas vezes no objeto
rsListaOpcao. Confira o código mudado:
private void rdListaOpcao_SelectedIndexChanged(object

sender, System.EventArgs e)
{
if (rdListaOpcao.SelectedValue == "1")
{
sumirTelefone();
aparecerEmail();
}
else
{
aparecerTelefone();
sumirEmail();
}
}
Perceba que agora estou apenas chamando os métodos criados, eles que vão
se encarregar de sumir com os objetos da tela, automática e dinamicamente.
60
Clique duas vezes no componente cmbOpcoes
Insira o seguinte código, depois de ter clicado duas vezes no objeto de tela
“cmbOpcoes”.
private void cmbOpcoes_SelectedIndexChanged(object sender,

System.EventArgs e)
{
if (cmbOpcoes.SelectedValue == "1")
{
sumirTelefone();
aparecerEmail();
}
else
{
aparecerTelefone();
sumirEmail();
}
}
Note que estou colocando o mesmo código que usei no outro objeto da
tela; a única diferença é o if (cmbOpcoes.SelectedValue == “1”).
“SelectedValue” serve apenas para verificar o valor do objeto selecionado.
Logo após o “if” chamarei somente os métodos criados anteriormente, para
aparecer ou sumir com os objetos de tela.
Veja como ficou o código na página:
61
Execute o seu sistema com a tecla F5 ou no menu Degub / Start, como na

tela a seguir:
62
Agora vou escolher ou selecionar qualquer objeto, que fará a mesma rotina.
Selecione pela “combo” a opção “e-mail”, como na tela a seguir:
Depurando o código linha por linha
Estarei explicando como depurar o código que estou escrevendo, linha por
linha. Dentro do seu Visual Studio.Net, acesse a classe default.cs e marque
na linha do lado esquerdo, criando uma bolinha vermelha na linha toda.
63
Depois de marcar a linha, deve-se iniciar o sistema com F5 ou no menu

“debug”. Logo após iniciar o sistema, você perceberá que o seu Visual
Studio.Net ficará com uma linha amarela no ponto marcado.
64
Para continuar depurando o código existem duas teclas, uma para entrar no
método e outra para não entrar no método de outra classe, por exemplo.
F10 = passa direto, sem entrar no método, porém continuando na linha.

F11 = depura linha por linha, entrando no método automaticamente.
F5 = passa direto por todas as linhas se você depurar.
Teste seguindo com o seu código. Marque a depuração no início do código

dos objetos da tela (na primeira linha do código) e clique em F5 para iniciar
o sistema e começar a depuração.
65
Selecione “objeto da tela combo”, e começando a depurar passe linha por

linha, como no exemplo:
66
Existem vários tipos de objetos que usei no C#.Net junto com o Visual
Studio.Net; alguns complicados e outros simples. Adiante utilizaremos
conexão com banco de dados mysql.
Inserindo mais um componente (ChekBox)
Na aba de ToolBox, clique no componente CheckBox e arraste-o no

sistema. Observe a ilustração a seguir:
67
A seguir as propriedades do CheckBox:

Id = ckSistema
Text = Sistema
Visible = false
Veja o código:
/// <summary>
/// dinamicamente
/// </summary>
{
ckSistema.Visible=true;
68
/// <summary>
/// dinamicamente
/// </summary>
{
ckSistema.Visible = true;
}
Nos métodos criados anteriormente, faça com que os objetos fiquem

visíveis.
69
Execute o sistema com F5, escolha uma opção.
Inserindo mais um componente (Button)
Irei colocar mais um componente no sistema. Se você prestar atenção, verá

que está faltando o componente chamado “button”. Nesse botão, iremos
passar parâmetros escolhidos nessa página para outra página,
conseqüentemente para outro método e classe que criaremos mais tarde.
Use a barra de ferramentas “ToolBox” e coloque na sua página default.aspx

o componente “button”, com as seguintes propriedades:
Button
Id = cmdEnviar
Text = Enviar
Visible = False
70
Primeiro coloque o cmdEnviar junto com os objetos que aparecem. Ficará

da seguinte forma:
/// <summary>
/// dinamicamente
// </summary>
{
cmdEnviar.Visible=true;
}
71
/// <summary>
/// dinamicamente
/// </summary>
{
cmdEnviar.Visible=true;
}
72
Execute o seu sistema com a tecla F5, compilando-o e observando se

aparece algum erro. Se não houver nenhum erro.
Clique duas vezes no componente cmdEnviar, e digite o seguinte código:
private void cmdEnviar_Click(object sender, System.EventArgs e)

{
Server.Transfer("pagina.aspx");
}
Crie uma outra página chamada pagina.aspx. A partir de agora, você já

aprendeu as coisas mais básicas, como criar páginas e classes.
Clique duas vezes na página pagina.aspx e digite o seguinte código:
private void Page_Load(object sender, System.EventArgs e)

{
string telefone = Request.Params["txtTelefone"];
string email = Request.Params["txtEmail"];
73
string sistema = Request.Params["ckSistema"];
if (telefone != null)
Response.Write("Seu telefone: " + telefone);
if (email != null)
Response.Write(" Seu email: " + email);
if (sistema != null)
Response.Write(" Opção de Sistema
Marcado");
}
Explicando o código de PAGINA.ASPX:
O método void Page_Load é criado automaticamente quando você clica

duas vezes na página (parte do Design). Analisando o código:
string telefone = Request.Params["txtTelefone"];
Nessa parte do código estou criando uma string chamada “telefone”,

pegando o parâmetro que passei da outra página (chamada default.aspx) e
atribuindo-lhe a minha string telefone.
Request.Params["txtTelefone"];
No código acima, o que está dentro do colchete deve ter o mesmo nome
que está na página anterior, default.aspx. Perceba que a linha está
terminando com ponto e vírgula (;). Isso deve ser feito para todos os
parâmetros, com uma nova atribuição (string) para cada um deles.
if (telefone != null)
74
No código acima, texto a variável “telefone” perguntando se é diferente de

null entre parênteses (“”) para que possa escrever o valor da mesma.
O código acima mostrará o valor da variável concatenada, com a string

“Seu telefone”, somente se for diferente de “null”. Isso acontece com todas
as variáveis, cada uma com a sua concatenação.
Execute o sistema e verifique se ele funcionou. Agora você terá duas

páginas para exibir. Preencha os dados e clique em enviar para aparecer a
outra página.
75
Resultado depois de clicar no botão “enviar”:
Essa última parte que você estudou é sobre transferência de dados entre
páginas usando o “form via post”.
76
Usando o componente ListBox
Use a barra ToolBox para adicionar o componente na sua página nova. Crie
uma outra página, e conseqüentemente outra classe, chamada
frmLista.aspx. Confira a figura a seguir:
Coloque os seguintes componentes com as suas respectivas propriedades:
LISTBOX’S
id = lstOrigem
Items
Text = << Selecione >>
Value = 0
Text = Macarrão
77
Value = 1
Text = Carne Moída

Value = 2
SelectionMode = Multiple
Id = lstDestino
Items
Text = << Selecione >>
Value = 0
SelectionMode = Multiple
BUTTON’S
Id = cmdEnviar
Text = >>
Id = cmdRemover
Text = <<
Veja a seguir como ficará a parte que colocamos no design:
Clique no botão (>>) cmdEnviar e digite o código a seguir:

{
if (lstOrigem.SelectedIndex > 0)
{
78
this.lstDestino.Items.Add(this.lstOrigem.SelectedItem);
this.lstOrigem.Items.RemoveAt(this.lstDestino.SelectedIndex);
}
}
Explicando o código acima
if (lstOrigem.SelectedIndex > 0)
Se o objeto (lstOrigem) da tela tiver o index maior que zero (SelectedIndex

> 0), entra na condição. Significa que, se o cliente ou usuário não passar o
valor, não adiciona no outro componente da tela.
lstDestino.Items.Add(this.lstOrigem.SelectedItem);
Adicione um item do componente de origem no componente de destino. A

parte da linha this significa “buscar” o componente. Digitando esse código
e clicando ponto (.), você buscará todos os componentes da tela.
lstOrigem.Items.RemoveAt(this.lstDestino.SelectedIndex);
Remova do componente que transmitiu os valores, passando o “index” do

componente de destino. Clique no botão remover ( << ) e insira o código a
seguir:
private void cmdRemover_Click(object sender, System.EventArgs e)

{
if (lstDestino.SelectedIndex > 0)
{
79
this.lstOrigem.Items.Add(this.lstDestino.SelectedItem);
this.lstDestino.Items.RemoveAt(this.lstDestino.SelectedIndex);
}
}
Explicando o código.
Primeiramente verificamos se existe um “index” selecionado de valor

maior do que zero (para adicionar na lista “origem”) e logo depois fazemos
sua remoção do componente “destino”. É praticamente igual à outra
explicação, porém com componentes diferentes.
Execute o sistema e a funcionalidade criada acima.
80
Validando Campos do Formulário
Neste capítulo estudaremos a validação de campos do formulário. Nas

linguagens anteriores, tínhamos que fazer tudo em javascript. Quando
ninguém sabia fazer um “script” para validar e-mail, sempre se buscava na
internet, pegando um código que nem mesmo era entendido. Mesmo não
entendendo, pegavam o código e colocavam-no no sistema. Muitas das
vezes faziam coisas erradas com javascript, e eram mostradas no browser
do cliente aquelas mensagens amarelinhas. Quem nunca fez um “alert”
errado na vida? Sempre coloquei na página do cliente os scripts, o que
possibilitava que o código fosse roubado ou copiado por alguma pessoa; as
páginas ficavam monstruosas devido apenas aos scripts de validação de
campos do formulário.
Não posso deixar de falar que, no Visual Studio.NET 2005 beta II já está
podendo validar por grupos, posso escolher um grupo de validadores e
depois validar com os botões. No 2003 existe um problema um pouco grave
quando é usado validador dentro de um webcontrol. Usando um webcontrol
e na pagina principal também estiver usando um validador,
obrigatoriamente os dois formulários terão que ser preenchidos para que o
validator funcione corretamente. No 2005 Beta II posso definir por grupo
usando uma propriedade.
Com o Visual Studio.Net 2003, não preciso saber mais uma linguagem de
programação para validar os campos. Estarei usando alguns componentes
da própria ferramenta, onde automaticamente serão criados scripts para a
validação dos mesmos. Primeiramente, crie uma nova página e uma nova
classe no mesmo projeto, chamada validaCampos.aspx.
81
Coloque na página alguns campos, tais como e-mail, nome, senha,

confirmação de senha e um botão. Especificação dos campos:
TextBox
Id= txtEmail
Label
Id = lblEmail
Text = Email:
TextBox
Id = txtNome
Width = 232px
Label
Id = lblNome
82
Text = Nome:
TextBox
Id = txtSenha
Width = 128px
TextMode = Password
Label
Id = lblSenha
Text = Senha:
TextBox
Id = txtConfirmacao
Width =128px
TextMode = Password
Label
Id = lblConfirmacao
Text = Confirmação de Senha:
Button
Id = cmdEnviar
Text = Enviar
Veja na página a seguir como ficará o formulário:
83
Até agora, foram colocados somente os campos que você já sabe fazer.
Agora usarei alguns componentes. Veja a figura a seguir:
84
Primeiro componente (serve para indicar que o preenchimento de um

campo é obrigatório): RequiredFieldValidator
Id = valEmail
ErrorMessage = Digite o Email:
Display = Static
ControlToValidate = txtEmail (ID do campo do formulário: ao clicar na
aba “properties”, você poderá escolher o campo do formulário, entre todos
os campos).
Veja o resultado na tela a seguir:
85
Segundo componente: RequiredFieldValidator
Id = valSenha
Display = Static
ErrorMessage = Digite a Senha
ControlToValidate = txtSenha
Terceiro componente: RequiredFieldValidator
Id = valConfirmacao
ControlToValidate = txtConfirmacao
ErrorMessage = Digite a Confirmação da Senha
Display = Static
Quarto componente: CompareValidator
86
Id = validaComparacao
ControlToCompare = txtConfirmacao
ControlToValidate = txtSenha
ErrorMessage = Digite a confirmação da senha corretamente !!
Display = Static
Veja a tela a seguir para verificar como ficou o código digitado:
Quando for executar o sistema colocando a página acima como “Set As

Start Page”, clique no botão “enviar”, e com isso os campos serão
validados automaticamente e mostrarão as mensagens criadas na aba
“properties”. Antes mesmo de preencher algum campo do sistema, clique
duas vezes no botão “enviar” e digite o código a seguir:

{
87
///Perguntando se a pagina é valida com todas as

validaçoes
///feitas antes de ir para outra página.
if (Page.IsValid)
{
}
}
Clicando no botão “enviar” na área de design, insira o código acima. O

código if (Page.IsValid) significa que se a página for toda validada, será
executada a linha a seguir. O código tem uma sincronização com os
”validators” colocados na página. Se estiver tudo validado e correto, o
código irá voltar “true” e passará para a linha de transferência.
Veja a página em execução a seguir:
88
ADO.NET conectando com MySQL
Farei a aplicação com um banco de dados MYSQL. Usarei apenas uma

tabela do banco de dados para desenvolver a aplicação, inserindo, alterando
e excluindo dados.
Visão Geral do ADO.NET
O ADO.NET é um conjunto de classes do DotNet Framework, que foi

desenvolvido para facilitar o acesso das aplicações ao banco de dados, de
qualquer tipo. Sendo uma evolução do ADO (VB6), foi feito do zero, sem
aproveitar a tecnologia ADO antiga. A única coisa parecida é o nome,
embora ADO não signifique ActiveX Data Objects.NET e sim
simplesmente ADO.NET.
A Microsoft manteve muitos conceitos do ADO tradicional para o

ADO.NET. Mudou totalmente a arquitetura, mantendo conceitos. Os
desenvolvedores antigos podem se familiarizar bem mais rápido com o
novo ADO.NET. O acesso desconectado serve para manipular os dados
sem precisar manter a conexão aberta, possibilitando um melhor
desempenho na aplicação para a web ou para dispositivos móveis. O
ADO.NET faz sua comunicação nativa em XML, permitindo uma
operabilidade mais eficiente com qualquer tipo de plataforma. Muito
diferente do antigo ADO, que servia apenas como banco de dados, o novo
ADO.NET pode mostrar dados de fontes diversas, inclusive bancos
relacionais e orientação a objetos, com uma facilidade incrível, usando
arquivos de diversas extensões.
Vejamos alguns objetos que são usados para fazer a conexão a seguir:
89
Connection: conexão com o banco de dados

Command: utilizado para o envio de comandos sql para o banco de dados,
podendo utilizar store procedures.
DataReader: objeto que serve para ler um conjunto de dados
seqüencialmente no modo ReadOnly, muito utilizado para preencher alguns
objetos de tela e controles de dados.
DataAdapter: um container para objetos do command, comunicando-se
com a fonte de dados, pesquisando, inserindo, alterando e excluindo.
DataSet: objeto que armazena os dados, independente do tipo de fonte de
dados. É guardado em memória, tendo coleções de tabelas (DataTables),
campos (DataColumns), registros (DataRows), constraints (Constraints) e
relacionamentos (DataRelations). Todos os dados são controlados em
XML, por padrão.
Typed DataSet: um DataSet especial, que possui um Schma (XSD)
associado para descrever os tipos de dados. Com esse tipo de objeto, é
possível a validação de nomes e campos em tempo de design,
possibilitando ganhos com a produtividade e o desempenho do sistema ou
aplicação.
DataView: um objeto muito semelhante ao View contido em vários bancos
de dados, com o qual podemos filtrar e ordenar os dados de uma tabela.
Pelo fato de estarmos trabalhando com o MYSQL, teremos que instalar um

componente chamado ODBC.NET Data Provider, usando uma linha de
conexão na classe como uma linha de código. Não se esqueça que teremos
que instalar o banco de dados MYSQL versão 1.4.
Importando a classe que será usada.

Para importar essa linha, o objeto ODBC.NET deve estar instalado na sua
máquina (objeto / sistema).
Se não estiver instalado, esta opção não estará disponível.
using System.Data.Odbc;
90
/// <summary>
/// Fazendo conexao com o banco de dados
/// MYSQL
/// </summary>
public OdbcConnection sConn = new

OdbcConnection("Driver={MySQL ODBC 3.51
Driver};Server=SERVIDOR;DataBase=BANCO DE
DADOS;uid=root;pwd=;option=3");
Essa string de conexão será gerada em uma classe criada. Estou chamando
um objeto OdbcConnection, passando uma string de conexão com banco de
dados, usuário e senha.
Estarei partindo do pressuposto que já foi instalado o banco de dados na sua

máquina ou mesmo no servidor. Crie um banco de dados chamado
bd_primeiraaplicacao.
Depois de estabelecer o banco, crie uma tabela chamada tb_usuario. Segue

abaixo o script para criar a tabela do banco de dados:
DROP TABLE IF EXISTS `tb_usuario`;

CREATE TABLE `tb_usuario` (
`ch_usu` int(3) unsigned NOT NULL auto_increment,
`no_usu` varchar(255) NOT NULL default '',
`email_usu` varchar(255) NOT NULL default '',
PRIMARY KEY (`ch_usu`),
KEY `ch_usu` (`ch_usu`)
) TYPE=InnoDB;
91
Campos:
Ch_usu = chave do usuário que será criada automaticamente
No_usu = nome do usuário cadastrado
Email_usu = e-mail do usuário cadastrado
Criarei a classe chamada clsBanco.cs que estará dentro da pasta

componentes, onde estará o código para abrir e fechar o banco de dados,
com a possibilidade de acessar de outra classe normalmente, chamando
apenas os métodos.
Veja a seguir o código da classe:
using System;
namespace PrimeiroSistema.componentes
{
/// <summary>
/// Classe com métodos para conectar no banco de dados mysql
/// </summary>
public class clsBanco
{
/// <summary>
/// Fazendo conexao com o banco de dados
/// MYSQL
/// </summary>
public OdbcConnection sConn = new
OdbcConnection("Driver={MySQL ODBC 3.51
Driver};Server=bsb066666;DataBase=bd_geral;uid=root;pwd=;option=3");
92
/// <summary>
/// Metodo para conectar no banco de dados
/// </summary>
public void Conecta()
{
try
{
///Estamos verificando se o status
///da conexão está fechada
if (sConn.State==0)
{
sConn.Open();
}
else
{
sConn.Close();
}
}
catch(Exception e)
{
throw new Exception("Banco de dados Fora:
classe clsBanco.cs "+ e.StackTrace);
}
}
/// <summary>
/// Metodo para desconectar do banco de dados
/// </summary>
public void Desconecta()
{
try
93
{
///Verifico se o status do
///banco de dados está ///diferente de fechado
if (sConn.State!=0)
{
sConn.Close();
}
else
{
sConn.Close();
}
}
catch(Exception e)
{
throw new Exception("Erro no Banco de
Dados: classe clsBanco.cs "+ e.StackTrace);
}
}
}
}
Primeiro estou criando uma nova instância do objeto de conexão

ODBC.NET para conectar com o banco de dados MYSQL, que já foi
explicado.
No decorrer do código existem alguns comentários explicando algumas

linhas. No método Conectar(), verifico primeiro se a conexão está fechada;
se estiver, abro-a com a linha sConn.Open(). A variável sConn foi
declarada no topo do método como pública; e por isso você poderá usá-la
em qualquer outra classe ou mesmo dentro do método todo.
94
Explicação da linha: public void Conectar()
public = o método é público e pode ser acessado de outra classe quando

instanciado.
void = o método não retornará nada.
Conectar = nome do método que foi criado.
() = a questão de abrir e fechar parâmetros significa que não existe nenhum
parâmetro de entrada.
Seguindo com o código, você verá que ele está dentro de uma linha
chamada “try e catch”. No momento não estou explicando muito esses
códigos; trataremos deles em capítulos posteriores. O que posso adiantar é
que se ocorrer algum erro, em qualquer parte do código, o mesmo gerará
uma “exception” com o código de erro e descrição.
O método public void Desconectar() é público, sem parâmetro de entrada e

saída. Logo após verificar se o status do banco de dados está diferente de
“fechado”, fecho o banco de dados com o código sConn.Close();. Se
ocorrer algum erro o sistema vai gerar uma “exception” com o código do
erro e descrição. Veja a seguir como foi criada a classe:
95
96
Criando classe para inserir no banco de dados
Dentro da pasta “componentes” insira uma classe chamada clsInserir.cs. Os

capítulos anteriores informam como criar novas páginas, arquivos ou
classes. Seguindo com o banco de dados criado acima, temos apenas os
campos nome e email do usuário, portanto apenas dois parâmetros de
entrada no método dentro da classe. O mesmo método terá um retorno para
o método que o chamou, e nesse caso será um tipo Boolean (true / false).
Veja a seguir:
Agora irei inserir o código da classe “clsInserir”, onde existem alguns

comentários criados para te ajudar. Segue abaixo o código de toda a página:
97
///importando métodos para serem usados

using System;
{
/// <summary>
/// Classe para inserir usuario.
/// </summary>
public class clsInserir
{
/// <summary>
/// Chamando primeiro a classe de banco de dados para ser
/// usada mais tarde dentro desta classe
/// </summary>
PrimeiroSistema.componentes.clsBanco sBanco = new
clsBanco();
/// <summary>
/// Método para inserir usuário no banco de dados MYSQL
/// </summary>
/// <param name="nome">nome do usuario</param>
/// <param name="email">email do usuario</param>
/// <returns>true / false</returns>
public Boolean inserirUsuario(string nome, string email)
{
Boolean bResultado = false;
try
{
///Abrindo a conexão com o banco de dados
sBanco.Conecta();
98
///Criando query string para usar mais a frente

na execucao
string sql = "insert into tb_usuario (no_usu,
email_usu) values ('" + nome + "', '" + email + "')";
///chamando objeto ODBC e passando a query

string e o objeto de conexao
OdbcCommand sqlC = new
OdbcCommand(sql,sBanco.sConn);
///executando o código
bResultado =
Convert.ToBoolean(sqlC.ExecuteNonQuery());
///retornando resultado
return bResultado;
}
catch(OdbcException e)
{
///se ocorrer algum erro, passará o erro
ocorrido
throw new Exception("Erro ao inserir, método
clsInserir.cs" + e.StackTrace);
}
finally
{
///fechando conexao aberta do banco
sBanco.Desconecta();
}
}
}
}
99
Primeiramente, estou importando dos métodos que irei usar dentro da

classe: using System.Data.Odbc;.
Em seguida estou chamando a classe de banco de dados criada

anteriormente: PrimeiroSistema.componentes.clsBanco sBanco = new
clsBanco(). A variável criada, chamada sBanco, pode ser chamada de
qualquer parte do código desta classe; mais a frente você verá que chamarei
dentro do método.
O método public Boolean inserirUsuario(string nome, string email)

significa que será público, com retorno do tipo “Boolean” e com dois
parâmetros de entrada, “string nome” e “string email” que serão
obrigatoriamente passados pelo método que os chamar. Mais a seguir no
código, você verá a variável criada sBanco sendo utilizada no método da
classe dela. Chamando a classe e usando a variável depois, e colocando
ponto (.), aparecerão automaticamente todos os métodos que podem ser
usados por você. Veja que estou usando o método da classe clsBanco.cs,
chamado Conectar(). O resultado é sBanco.Conectar().
Logo após abrir o banco de dados, é criada uma “query string” com a
sintaxe de inserir valores no banco de dados. A parte de sintaxe do banco
será vista em outra apostila, sobre como aprender as sintaxes de inserir,
excluir, alterar e deletar. Enquanto isso, a string de inserir — string sql =
"insert into tb_usuario (no_usu, email_usu) values ('" + nome + "', '" +
email + "')"; — inclui na tabela do banco e nos campos, passando os
valores (values).
Seguindo com o código, instancio um novo objeto ODCBCommand,

passando a string e o objeto de conexão:
100
///chamando objeto ODBC e passando a query string e o objeto de conexao

OdbcCommand sqlC = new OdbcCommand(sql,sBanco.sConn);
Prosseguindo com o código, veja que primeiramente declarei uma variável

chamada bResultado, recebendo o valor de false. Na variável sqlC, quando
digitado o ponto (.), são mostrados todos os métodos. O método que
executaremos chama-se ExecuteNonQuery(). Veja o código a seguir:
sqlC.ExecuteNonQuery();
Esta linha está incompleta, de acordo com o código que foi digitado.
Executando apenas do modo acima, o método retornará um “int”, e com
isso o nosso método aguardará um retorno em Boolean. Por isso converti o
resultado do método para Boolean. Observe o código a seguir:
///executando o código
bResultado = Convert.ToBoolean(sqlC.ExecuteNonQuery());
Convertendo o código acima para Boolean, o retorno será de true ou false.
Inserindo no banco de dados
A tela validaCampos.aspx, que foi desenvolvida nos capítulos anteriores,

será utilizada para incluir os dados no banco, através do método criado
anteriormente.
101
Clique duas vezes no botão “enviar” — chamado cmdEnviar —, e substitua

os códigos que já existem pelo código a seguir (lembre-se que o código
todo do botão está sendo colocado, incluindo a classe, que já é criada
automaticamente quando clicamos no botão):

{
///Perguntando se a pagina é valida com todas as
validaçoes
///feitas antes de ir para outra página.
if (Page.IsValid)
{
///Chamando metodo que foi criado
anteriormente
///Criando uma nova instancia de objetos
102
PrimeiroSistema.componentes.clsInserir
sInserir = new PrimeiroSistema.componentes.clsInserir();
///Criando uma variável Boolean

///Pegando a variável criada acima, clicando
.(ponto) aparecerá todos
///os métodos disponíveis para acesso, no caso
desse método
///esse parâmetro está esperando dois valores
(nome e email).
Boolean resultado =
sInserir.inserirUsuario(txtNome.Text, txtEmail.Text);
///Se o resultado criado acima for true

///é passado para a página posterior
if (resultado)
{
}
}
}
A única coisa diferente no código acima é a parte que instancia o método

criado na classe “clsInserir.cs”.
O primeiro código que coloco para chamar o objeto é o nome do projeto,
depois o nome da pasta que criamos, e finalmente o nome da classe. Se
conferir junto ao namespace da classe clsInserir.cs, você verá que ele estará
da mesma forma que já foi vista anteriormente.
PrimeiroSistema.componentes.clsInserir sInserir = new

PrimeiroSistema.componentes.clsInserir();
103
No código acima, chamando uma classe nova, é necessário colocar uma

variável recebendo um “new” da mesma classe, em seguida abrindo e
fechando parênteses. Essa variável criada recebendo a instância pode ser
usada mais à frente, colocando um ponto na frente do método para verificar
os métodos disponíveis para ela.
Boolean resultado = sInserir.inserirUsuario(txtNome.Text, txtEmail.Text);
Os campos “txtNome.Text” e “txtEmail.Text” foram criados num dos

capítulos anteriores, sobre validação. Vamos aproveitá-los, passando como
parâmetro e inserindo no banco de dados. É necessário colocar o “.Text”
para indicar que o valor do texto digitado pelo usuário nos campos será
capturado. Se quiser depurar o código, você verá que passará pela classe
que criou, logo após a classe de conexão com o banco de dados, conectando
e inserindo.
Veja a tela a seguir, depurando o código. Não esqueça de marcar no seu

Visual Studio.Net 2003 no canto esquerdo, preenchendo os dados e
clicando “enviar”.
104
Na tela a seguir, o código estará passando pela classe clsInserir.cs.
105
Na próxima tela o debug passará na classe de banco de dados chamada

clsBanco.cs.
106
Na continuação do debug, você verá que o sistema voltará automaticamente

para a classe clsInserir.cs, e vai inserir valores no banco de dados. Veja o
resultado a seguir, que foi inserido no banco.
107
Usando componente DataGrid para mostrar dados
No capítulo anterior, você notou que incluí no banco de dados alguns dados
inseridos pelo usuário. Esse capítulo mostrará como montar dados na tela
usando DataGrid.
Estarei montando uma nova classe chamada clsRelatorio.cs dentro da pasta

componentes. Para criar uma classe, clique com o botão direito no Solution
Explorer, em cima da pasta componentes, e depois em ADD, ADD NEW
ITEM, escolhendo a opção “class”.
108
Como foi dito antes, essa classe mostra os dados do banco. O método
retorna um objeto chamado DataSet. Veja o código a seguir:
///importando classes para serem usadas

using System;
using System.Data;
{
/// <summary>
/// Classe para gerar relatorio
/// </summary>
public class clsRelatorio
{
/// <summary>
109
/// Conectando no banco de dados

/// </summary>
clsBanco();
/// <summary>
/// Metodo que busca relatorio e traz dataSet
/// </summary>
/// <returns>DataSet</returns>
public DataSet buscaRelatorio()
{
try
{
///Abrindo conexao
sBanco.Conecta();
///Gerando query string

string sql = "select ch_usu, no_usu, email_usu
from tb_usuario order by no_usu";
///Criando um novo dataset para preencher

abaixo
///o mesmo
DataSet dtSet = new DataSet();
///Gerando uma instancia do objeto

OdbcDataAdapter
///passando a query string e o objeto do banco
de dados
OdbcDataAdapter dtAdapter = new
OdbcDataAdapter(sql,sBanco.sConn);
///pegando a variavel criada do dataadapter e

110
///preenchendo dataset para ser passado

dtAdapter.Fill(dtSet);
///retornando dataset
return dtSet;
}
{
///gerando uma exception e mostrando onde
está dando o erro
throw new Exception("Erro na classe
clsRelatorio " + e.StackTrace);
}
finally
{
///fechando a conexao com o banco de dados
}
}
}
}
Seguindo cada linha do código, você verá que existe um comentário,

mostrando o que é feito em cada linha. No começo do código, importei
classes para serem usadas, com seus respectivos objetos. Note que foi
importada uma classe que você não tinha visto:
using System.Data;
A classe acima é responsável pelo objeto chamado DataSet.

111
using System.Data.Odbc; A classe acima serve para usar o objeto de banco

de dados, fazendo conexão com a base de dados.
PrimeiroSistema.componentes.clsBanco sBanco = new clsBanco();
Depois é necessário chamar a classe de banco de dados que criamos, que

tem a string de conexão junto com os métodos de abrir e fechar a
comunicação com a base de dados.
public DataSet buscaRelatorio()
Observando o código acima, note que ele é um método público, que retorna
um objeto DataSet. O método chama-se “buscarelatório”, e não tem
nenhum parâmetro de entrada, e por isso está apenas abrindo e fechando
parênteses.
///Abrindo conexao
sBanco.Conecta();
Antes de abrir a conexão, veja essa variável que criei mais acima, com o
nome sBanco. Digitando o mesmo nome e colocando “ponto”, abri todos os
métodos disponíveis para usar. Com isso, veja que o método “conectar”
está disponível apenas pelo fato de ser público. Para fazer um teste, vá até a
classe e coloque o método “public void Conectar()”.Depois clique em
private void Conectar(), e você verá que quando digitar a variável e colocar
(ponto), nessa classe clsRelatorio.cs, o método “Conectar()” não estará
disponível para ser usado.
///Gerando query string

string sql = "select ch_usu, no_usu, email_usu from tb_usuario order by
no_usu";
112
Estou criando a “query string” apenas selecionando os dados do usuário,

ordenando-os pelo nome.
///Criando um novo dataset para preencher abaixo

///o mesmo
Lembre-se que nessa classe o método retornará um objeto DataSet, por isso
estamos apenas chamando uma variável do tipo DataSet.
///Gerando uma instancia do objeto OdbcDataAdapter

///passando a query string e o objeto do banco de dados
OdbcDataAdapter dtAdapter = new OdbcDataAdapter(sql,sBanco.sConn);
No código acima, estamos apenas chamando um objeto

ODBCDataAdapter, passando uma “query string” que setamos acima, junto
ao objeto de conexão. Com esse objeto criado, teremos depois que
preencher o objeto DataSet e retornar para o método que o chamou.
///pegando a variavel criada do dataadapter e

///preenchendo dataset para ser passado
O objeto criado anteriormente serve para preencher um objeto chamado

DataGrid, os dados foram todos carregados em memória. Quando digitar o
objeto e colocar (ponto), esse método do objeto “DataAdapter”, chamado
fill, significa suficiência para preencher o método e logo após retornar.
///retornando dataset
return dtSet;
113
De acordo com o método criado, é necessário retornar um objeto DataSet.

Com isso, estarei retornando o objeto que chamei e preenchi.
finally
{
///fechando a conexao com o banco de dados
}
Nessa parte do código, depois que executar todas as linhas, antes de sair do
método, você irá finalizar, desconectando o banco de dados.
Finalmente, depois de criada a classe e o método responsáveis para trazer o

relatório, vamos fazer a parte de HTML usando o objeto “DataGrid” do
Visual Studio.Net 2003.
114
Clique e arraste o objeto “DataGrid”:
Agora saia da parte “design” do Visual Studio.Net 2003 e vá para a parte de

HTML. Veja o código gerado:
115
Veja o código do DataGrid:
<asp:DataGrid id="DataGrid1" runat="server"

AutoGenerateColumns="False">
<Columns>
<asp:TemplateColumn>
<HeaderTemplate>
<asp:CheckBox
id="ckHead" runat="server"></asp:CheckBox>
</HeaderTemplate>
<ItemTemplate>
<asp:CheckBox
id="ckItem" runat="server"></asp:CheckBox>
<asp:Label id="lblId"
Visible=False runat="server" Text='<%#
DataBinder.Eval(Container.DataItem, "CH_USU")%>'>
116
</asp:Label>
</ItemTemplate>
</asp:TemplateColumn>
<asp:BoundColumn
DataField="ch_usu" Visible="False"></asp:BoundColumn>
<asp:BoundColumn
DataField="no_usu" HeaderText="Nome"></asp:BoundColumn>
<asp:BoundColumn
DataField="email_usu" HeaderText="Email"></asp:BoundColumn>
<asp:HyperLinkColumn
Text="Alterar" DataNavigateUrlField="ch_usu"
DataNavigateUrlFormatString="../alterar/alteraProduto.aspx?CH_PROD={
0}"
HeaderText="Alterar
Produto"></asp:HyperLinkColumn>
</Columns>
</asp:DataGrid>
Esse objeto que coloquei acima serve para exibir os dados que irei trazer do
banco de dados, usando aquela classe que desenvolvemos.
<asp:DataGrid id="DataGrid1" runat="server"

AutoGenerateColumns="False">
O código acima, chamado de “taglib”, é criado pelo Visual Studio.Net

automaticamente. Acrescentei o código AutoGenerateColumns=false para
que o objeto não crie as colunas que vem do “select” que criei
automaticamente. Posso escolher quais colunas quero que apareçam no
código.
<Columns>
117
A “tag” acima é uma “sub tag” dentro da “taglib DataGrid”. Dentro dela
poderei colocar as colunas que mostrarei. Esse objeto dataGrid terá um
“checkBox” onde poderei marcar os itens que deletarei do banco de dados.
Aproveitarei a tabela com o nome do usuário e e-mail para excluir os
cadastrados. Analisando o código, você verá como foi feito.
<asp:BoundColumn DataField="no_usu" HeaderText="Nome">

</asp:BoundColumn>
A “tag” do DataGrid mostra os campos. Veja que o DataField recebe o

mesmo nome do campo que colocamos no “select” da classe de relatório,
com o mesmo nome da tabela do banco de dados.
Clique duas vezes no código da página frmRelatorio.aspx e veja na página

a seguir o código todo comentado:
118
using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
namespace PrimeiroSistema
{
/// <summary>
/// Summary description for frmRelatorio.
/// </summary>
119
public class frmRelatorio : System.Web.UI.Page

{
protected System.Web.UI.WebControls.DataGrid
DataGrid1;
protected System.Web.UI.WebControls.Button cmdDeletar;
private void Page_Load(object sender, System.EventArgs e)

{
///Se a página nao for reload
if (!Page.IsPostBack)
{
///chamando o metodo para preencher o objeto
grid
///do html que já foi criado
preencheGrid();
}
}
/// <summary>
/// Metodo para preencher o objeto datagrid com os dados
/// vindo do banco
/// </summary>
private void preencheGrid()
{
PrimeiroSistema.componentes.clsRelatorio sRel =
new PrimeiroSistema.componentes.clsRelatorio();
this.DataGrid1.DataSource = sRel.buscaRelatorio();
this.DataGrid1.DataBind();
}
private void DataGrid1_ItemCreated(object sender,

System.Web.UI.WebControls.DataGridItemEventArgs e)
{
120
////////////////////////////////////////////////////////////////
///Adicionando o Javascript ao CheckBox
////////////////////////////////////////////////////////////////
if (e.Item.ItemType == ListItemType.Header)
{
CheckBox ck =
(CheckBox)e.Item.FindControl("ckHead");
if(ck != null)
ck.Attributes.Add("onclick","selecionarTodos(this);");
}
if (e.Item.ItemType == ListItemType.Item ||
e.Item.ItemType == ListItemType.AlternatingItem)
{
CheckBox ck =
(CheckBox)e.Item.FindControl("ckItem");
if (ck != null)
ck.Attributes.Add("onclick","desselecionarTodos();");
}
///////////////////////////////////////
///Fim
//////////////////////////////////////
}
private void cmdDeletar_Click(object sender,

System.EventArgs e)
{
///chamando o metodo para ser usado mais abaixo
121
///no método
PrimeiroSistema.componentes.clsExcluir sExcluir =
new PrimeiroSistema.componentes.clsExcluir();
///fazendo um for para deletar apenas os objetos

///da tela marcados
foreach( DataGridItem itens in this.DataGrid1.Items )
{
CheckBox ck = (CheckBox)
itens.FindControl("ckItem");
Label id = (Label) itens.FindControl("lblId");
if (ck !=null && ck.Checked)
{
sExcluir.excluirDados(Convert.ToInt32(id.Text));
}
}
preencheGrid();
}
}
}
No código acima você verá todos os comentários e entenderá melhor

quando estiver fazendo o mesmo. Existe um método “void” chamado
preencherGrid(), que apenas irá chamar o objeto de relatório e usar a classe
que foi feita retornando um “dataSet”. Esse objeto retornado irá apenas
preencher o outro objeto chamado DataGrid.
122
No método ItemCreated, estamos inserindo no objeto a interação do

javascript com o C#. Adiante estarei colocando o código javascript que
você deve inserir na parte HTML desta página. Criei um botão chamado
cmdDeletar, no qual você deve clicar duas vezes e inserir o conteúdo do
código acima (private void cmdDeletar_Click). Veja que estou chamando
outro objeto que criei de uma outra classe, chamada “clsExcluir”. Mostrarei
mais à frente o código dessa classe.
Para acessar uma propriedade do DataGrid chamada “ItemCreated”, veja a

seguir na figura.
Clique na parte de design, selecione o objeto, clique na parte de properties,

passe o mouse sobre a figura “events” como na figura acima e clique nela.
O Visual Studio.Net 2003 mostrará todos os eventos desse objeto DataGrid.
Clique duas vezes no evento ItemCreated e insira o código acima. O
123
programa Visual Studio facilita muito o processo, através desses eventos e

propriedades.
Como havia falado anteriormente, segue agora o código javascript que

precisa estar na parte javascript.
<script>
function selecionarTodos(ckall){
var actVar = ckall.checked;
for (i=0; i<Form1.length; i++){
if (Form1.elements[i].type ==
"checkbox"){
if
(Form1.elements[i].name.indexOf("ckItem")!= -1){
Form1.elements[i].checked = actVar;
}
}
}
}
function desselecionarTodos(){
var status = true;
for(i=0; i<Form1.length; i++){
if(Form1.elements[i].type=="checkbox" &&
Form1.elements[i].name !="ckHead"){
if(Form1.elements[i].name.indexOf("ckItem") != -1){
if(Form1.elements[i].checked==false){
status=false;
}
124
}
}
}
}
</script>
Esse código de javascript acima é para quando você for selecionar um

checkbox que existe no DataGrid, selecionar automaticamente todos os
outros. Quando ele for desmarcado, automaticamente todos os outros
checkbox também serão desmarcados.
Montando a página a seguir, veja como ficará a tela se houver dados no

banco:
Criando classe para excluir dados
125
Criarei agora uma classe para excluir os dados do objeto que criamos
acima, chamado DataGrid. A classe tem um método público e sem retorno,
que passa um parâmetro que é a chave do banco “ch_usu”. Clique com o
botão direito em cima da pasta “componentes” e crie uma classe chamada
clsExcluir.cs. Veja a figura a seguir:
Depois de criada a classe, insira o código a seguir:
///importando classes que iremos usamos

using System;
{
126
/// <summary>
/// Classe para excluir dados do banco
/// </summary>
public class clsExcluir
{
/// <summary>
/// Metodo chamando classe do banco de dados
/// para ser usada abaixo
/// </summary>
clsBanco();
/// <summary>
/// Metodo responsável para deletar dados do banco
/// nao retona nada
/// </summary>
/// <param name="chave">chave do usuario</param>
public void excluirDados(int chave)
{
try
{
///Conectando com o banco de dados
///abrindo conexao
sBanco.Conecta();
///Criando a query string para deletar os dados

string sql = "delete from tb_usuario where
ch_usu = " + chave;
///Gerando um novo objeto de comando

passando
///a query string e o objeto de conexao
127
OdbcCommand sqlc = new

OdbcCommand(sql,sBanco.sConn);
///executando o objeto criado

sqlc.ExecuteNonQuery();
}
{
///Gerando uma nova exception
throw new Exception("Erro na classe
clsExcluir" + e.StackTrace);
}
finally
{
///desconectando o banco de dados
}
}
}
}
Analisando os códigos acima, veremos que não existe uma grande

diferença, embora a “query string” e alguns parâmetros de entrada e saída
sejam diferentes. O resto é basicamente igual. No próprio código existem
os comentários que cada linha faz.
O método desta classe é público, sem parâmetro de saída e com um

parâmetro de entrada do tipo “int”. Veja que a minha “query string” é um
“delete” comum de banco de dados. Se não estiver acostumado com isso,
não se preocupe: perceba apenas que estou deletando um dado do banco e
128
passando uma chave. Essa chave eu peguei do objeto DataGrid e passei.

Observe que estou usando o objeto “OdbcCommand”, passando a “query
string” e o objeto de conexão. Depois executo o código com a seguinte
linha: sqlc.ExecuteNonQuery().
Após criar a classe e o método de excluir os dados no banco, sua página

“frmRelatorios.aspx” funcionará perfeitamente, para excluir e exibir os
dados. Essa classe/método será usada no clique do botão “excluir” que fez
o código, lembra-se do capítulo passado? Observe a tela a seguir e tente
excluir algum dado:
Introdução ao Web Services
Web Services é um componente de software independente de plataforma e

implementação. Pode-se considerar os Web Services como a união da
infraestrutura da internet, com a rápida comunicação da linguagem XML.
Sua utilização permite a disponibilização de funcionalidades de uma
129
aplicação através da internet, de uma forma padronizada. Aplicações que

não podiam ser acessadas exceto através de protocolos rígidos e
proprietários, agora são acessíveis via web.
Os Web Services representam um fragmento de informação que

pode ser acessado por qualquer um, em qualquer lugar utilizando qualquer
tipo de dispositivo. O consumidor desde informação pode ser tanto uma
pessoa acessando o serviço através de um cliente brownser ou de uma
aplicação desktop, ou mesmo um celular usando o mesmo Web Services.
Algumas vantagens de uma aplicação de Web Services
As vantagens de uma aplicação de Web Services dentro das

empresas são inúmeras e podem ser observadas. A infraestrutura atual dos
sistemas nas empresas precisa ser modificada. Não é necessário apenas que
os sistemas internos de patrimônio, contabilidade, produção e atendimento
a cliente possam interagir entre si, é necessário também que estes sistemas
estejam disponíveis para os parceiros e consumidores e possam interagir
com os sistemas desses. No caso de Web Services, é que eles permitem que
esta integração seja feita sem a necessidade de uma ligação permanente
com um parceiro em particular.
Utilizando-se dos Web Services, a indústria de tecnologia está

tentando colocar em prática um dos mais antigos conceitos da computação
distribuída; localização e acesso de sistemas remotos. A grande diferença é
que agora a indústria está olhando para este problema usando tecnologias
abertas (XML e protocolos de internet), padrões abertos e gerenciados pela
WEB (WWW).
Como foi dito antes, os Web Services podem ser chamados por
aplicações desktop, sistemas mainframe, web brownsers e até mesmo
130
dispositivos móveis como: celulares, PocketPC e PDAs. Independente da

aplicação, os Web Services serão usados para integração de sistemas,
tornando-se flexíveis e pouco acoplados, permitindo que sejam
decompostos e recompostos para refletir as mudanças de negócio.
Aplicações que são expostas como Web Services são acessíveis por outras
aplicações rodando em diferentes plataformas escritas em diferentes
linguagens.
A promessa de que ocorrerão iniciativas para interoperabilidade é

baseada em que, com o decorrer do tempo, será possível desenvolver um
conjunto de padrões, tecnologias e ferramentas que permitam que empresas
grandes e pequenas integrem facilmente os sistemas internos, e então
combinem e misturem a implementação de várias atividades dentro do
processo, mantendo a opção de, a qualquer hora, escolher terceirizar as
atividades se necessário.
Integração de Aplicações
Desenvolvedores corporativos sabem que uma boa parte dos

esforços de desenvolvimento é gasto na integração de aplicações escrtias
em várias linguagens e rodando em diferenes sistemas. Eles tipicamente
necessitam importar dados para uma aplicação vindos de outra aplicação
existente rodando em um mainframe IBM ou precisam enviar dados de uma
aplicação para uma aplicação UNIX. Mesmo trabalhando na mesma
plataforma, aplicações de diferentes fornecedores frequentimente precisam
ser integradas. Se os dados e funcionalidades de uma aplicação são
expostos através de um Web Service, este fornecer um mecanismo padrão
de integração com outras aplicações.
A reutilização de software pode ocorrer de várias formas em

diferentes níveis. A mais básica forma de reutilização de código é através
do reuso de módulos ou classes do código fonte. Outra forma de
131
reutilização de código é a reutilização binária baseada em componentes.

Mas a reutilização de código sempre foi limitada por um favor: a
impossibilidade de se reutilizar dados. A razão para isto é que pode-se
facilmente distribuir componentes ou código fonte, mas não os dados, a não
ser que sejam dados estáticos.
Os Web Services permitm que a reutilização de código seja

acompanhada da reutilização dos dados necessários. Ao invés de comprar e
instalar um componente de terceiros, e chamá-lo localmente em uma
aplicação; esta aplicação poderia se beneficiar de um Web Service remoto.
Por exemplo, se o usuário de uma aplicação entra com o endereço de
correspondência e é necessário validá-lo, isto poderia ser feito por Web
Service de verificação de endereço. Este serviço pode procurar o endereço
de rua, a cidade, o estado e o CEP para certificar que tal endereço existe e
que ele está dentro do CEP especificado. O provedor do serviço pode
cobrar uma taxa periódica para utilização de seu serviço ou até uma taxa
única por cada utilização. Um serviço como esse é difícil de ser feito com
reutilização de componentes, pois a própria empresa teria que manter um
banco de dados atualizado de endereços, cidade, estados e CEP’s; isto é;
foge do escopo de seu negócio.
Outra possibilidade para reutilização de software é quando se está

contruindo uma aplicação que agrega a funcionalidade de muitas outras
aplicações. Por exemplo, pode-se contruir um portal na intranet que permita
que o usuário cheque o status de um pacote enviado pelo correio, saiba a
cotação da bolsa, veja o calendário, e compre entradas para o cinema.
Todas essas funções podem ser realizadas hoje na internet utilizando
aplicações separadas, disponibilizadas por diferentes fornecedores. Se estas
aplicações expuserem suas funcionalidade através de Web Services, pode-
se facilmente escrever uma aplicação de portal que combine todas as
funcionalidades em uma interface cliente acessível e consistente.
132
Computação Distruida
A computação distribuida surgiu para solucionar o problema da

interação entre sistemas que trabalham juntos na solução de um problema.
O conceito de computação distrubuída mais utilizado é o RPC (Remote
Procedure Call ou Chamada Remota de Procedimento), que permite que
uma função seja invocada de qualquer lugar como se ela fosse uma função
local.
1987
A Sun Microsystems desenvolve o Open Network Computing
(ONC), sistema RPC que estabelece um mecanismo de comunicação básica
para o Network File System (NFS).
A Apollo Computer desenvolve o Network Computing System (NCS),
sistema RPC para seu sistema operacional Domain.
1989
A Open Software Foundation (OSF, hoje The Open Group) solicita
submissões para incorporar um sistema RPC ao seu Distributed Computing
Environment (DCE). O sistema escolhido é o NCS, agora da HP.
O Object Management Group (OMG) foi formado para desenvolver

especificações de linguagens e plataformas neutras para computação
distribuída. O OMG inicia o desenvolvimento de especificações para a
arquitetura CORBA, uma plataforma de objetos distribuídos.
1990
A Microsoft baseia suas iniciativas em RPC em uma versão modificada do
DCE/RPC.
133
1991
A versão 1.0 do DCE é apresentada pela OSF.
CORBA 1.0 é lançado com uma linguagem única de mapeamento para a
linguagem C. O termo Object Request Broker (ORB) ganha popularidade
como uma infraestrutura para objetos distribuídos.
1996
Microsoft lança o Distributed Component Object Model (DCOM), que
segue a linha dos esforços anteriores da Microsoft na área de
componentização e tendo como base as tecnologias de RPC da Microsoft.
O CORBA 2.0 é lançado com melhorias no modelo de computação

distribuída bem como nos serviços de alto nível que os objetos distribuídos
podem utilizar. O Internet Inter-ORB Protocol (IIOP) fez parte desta
especificação.
1997
Sun lança o JDK 1.1 e inclui o Remote Method Invocation (RMI), que
define um modelo para computação distribuída usando objetos Java. RMI é
similar ao CORBA e DCOM mas trabalha apenas com objetos Java e
possui um protocolo ORPC chamado Java Remote Method Protocol
(JRMP).
A Microsoft anuncia a primeira versão do COM+, o sucessor do DCOM.

As capacidades do COM+ o tornam semelhante ao modelo CORBA para a
computação distribuída.
1999
Sun apresenta a J2EE (Java 2 Platform Enterprise Edition), que integra
RMI com IIOP, tornando fácil a interoperabilidade entre Java e sistemas
CORBA.
134
O Simple Object Acess Protocol (SOAP) aparece pela primeira vez. Tem
inicio a era dos web services.
Arquitetura orientada a serviços
A tecnologia por trás dos Web Services está baseada em um padrão

de arquitetura service-oriented architecture (SOA). O SOA possui um
conceito simples, o que torna facilmente aplicável em uma grande
variedade de situações no desenvolvimento de Web Services.
Provedor de Serviço
Um provedor de serviço é responsável por criar a descrição de um serviço,
publicando esta descrição para um ou mais registros de serviços, e
recebendo chamdas de um ou mais requisitores de serviço. Pode ser
comparar um Provedor de Serviço com o servidor de um relacionamento
cliente-servidor.
Requisitor de Serviço
Um requisitor de serviço é responsável por encontrar a descrição de um
serviço publicado em um ou mais Requisitores de Serviço. E é responsável
pelo uso das descrições de serviços para chamar o Web Service hospedado
em um Provedor de Serviço. Um consumidor de Web Services pode ser
considerado um requisitor de serviço.
Registrador de Serviço
Um registrador de serviço é responsável por divulgar as descrições de
serviços publicados nele pelo Provedor de Serviço e por permitir que o
requistor de serviço procure um serviço qualquer nesta lista de descrições.
135
O que o registrador faz é sim: é apenas um intermediador entro o requisito

de serviço e o provedor de serviço.
Pilhas de interoperabilidade
Os Web Services são aprensetados como uma tecnologia de acesso e

integração de aplicações e não uma tecnologia de implementação. Portanto,
uma variedade de padrões e tecnologias estão envolvidas tais como: XML,
SOAP, WSDL, UDDI, WSEL, WSFL e etc. Isto faz com que a construção
de Web Services pareça complicada. Sendo assim, a W3C, IBM e
Microsoft apresentaram o conceito de pilhas de interoperabilidade para
facilitar o entendimento e construção de Web Services.
Extensible Markup Language (XML)
XML é uma meta-linguagem, ou seja; uma linguagem eu possibilita a

criação de outras linguagens a partir dela. XML surgiu do Standart
Generalized Markup Language – SGML, um padrão de marcação criado
pelo Dr. Charles Goldfarb.
Surgiu na necessidade básica de se realizar o armanazenamento de
dados independente da plataforma adotada, ou seja, uma linguagem para
descrição de linguagens de marcação. O HTML é um tipo de linguagem de
marcação, sendo assim é um aplicação do SGML. Como XML, existem
várias outras linguagens de marcação.
XML ?
136
XML surgiu da necessidade de uma linguagem comum para comunicação

entre dispositivos, browsers da web, computadores e aplicativos. As
alternativas viáveis existentes, HTML e SGML, não se mostraram práticas
para este propósito. Sendo assim, o XML herdou o melhor do SGML,
HTML e de outras linguagens de marcação de sucesso, além de acrescentar
uma lista de características que a torna mais adequada que SGML ou
HTML.
Distribuição
Além da ligação, o XML introduz um método de inclusão de alvos de

ligação na instância atual muito mais sofisticado. Isso abre a porta para um
novo mundo de documentos de composição – documentos compostos de
fragmentos de outros documentos que são automaticamente (e
transparentemente) montados para formar o que é mostrado num momento
particular. O conteúdo pode ser instantaneamente adequado ao momento, à
mídia e ao leitor, e pode ter somente uma passageira existência: uma
realidade de informações virtuais composta de documentos virtuais.
Orientação a Dados
Apesar de documentos XML serem legíveis por humanos, o comércio

eletrônico requer que o formato dos dados seja legível por máquinas. O
XML torna isso possível ao e definir um formulário de XML que pode ser
mais facilmente criado por uma máquina, mas ele também adiciona um
controle de dados mais rígido através das iniciativas mais recentes de
esquemas XML.
137
Estrutura do Documento XML
Um documento XML é compoe-se de marcações e conteúdo. Veja o

exemplo abaixo:
<ROOT>
<PESSOA>
<NOME>Maurilio Paulo Alberto Santos</NOME>
<ENDERECO>SQN 908 BL.3 AP.199</ENDERECO>
<DATA_NASC>23/03/2002</DATA_NASC)
<EMAIL>maurilio@asc.com.br</EMAIL>
</PESSOA>
</ROOT>
Elementos
Considerados a mais trivial forma de marcação.

São delimitados por “<” e “>” e identificam a natureza do conteúdo que
delimitam. Alguns elementos podem ser vazios, nos casos em que eles não
possuem conteúdo. Se um elemento não é vazio, ele inicia com uma tag
inicial e termina com uma tag final. Ou seja, tag inicial elemento tag final.
Veja o exemplo abaixo:
<objetivo>Livro</objetivo>
Atributos
Atributos são pares de nomes e valores que ocorrem dentro de uma tag
inicial depois do nome de um elemento. Veja o exemplo a seguir:
138
<objetivo tipo=”qualquer”>Livro</objetivo>
Comentários
Em um documento XML, os comentários poder ser incluídos da seguinte

forma: 
<objetivo tipo=”qualquer”>Livro</objetivo>
Praticando Web Services
Antes de tudo, gostaria de infomar que estarei usando no decorrer da

apostila a linguagem C#.NET, ou seja o arquivo de código fonte será com a
extenção .cs. Agora vou estar mostrando como criar o primeiro
WebServices usando o Visual Studio.NET. No capítulo anterior mostrei
como instalar o Visual Studio.NET e agora estarei utilizando o mesmo.
Estarei mostrando passo a passo agora abaixo de como criar uma aplicação
WebServices, segue abaixo:
139
A figura acima mostra escolhendo a opção para criar o WebService; veja

que está selecionado a opção ASP.NET Web Service, coloque o nome de
PrimeiroWebService na barra Location e clique no botão OK. O Visual
Studio.NET criará primeiramente a sua aplicação no IIS (Internet
Information Service), logo após criará uma pasta chamada WWWROOT
com o mesmo nome que criou o projeto. Veja a figura abaixo de como
ficará o seu projeto:
140
A figura acima mostra apenas depois que foi criado o projeto no seu Visual
Studio.NET. Na figura abaixo estaremos criando um arquivo chamado
Servico.asmx, essa é a extensão do arquivo para o WebService. Clique com
o botão direito em cima do projeto, clique na opção ADD, logo após ADD
New Item. Segue a figura abaixo mostrando o exemplo citado acima:
141
O Visual Studio.NET mostrará para você as opções de arquivo que tem

para ser escolhido, existe uma opção de arquivo chamada Web Service,
escolha essa mesma e coloque o nome de Servico.asmx. Veja a figura
abaixo:
142
Logo após colocar o nome do arquivo, clique Open.

Na figura abaixo mostra o arquivo criado, clique duas vezes no mesmo para
entrar no código fonte, ou seja o arquivo .cs. Veja as figuras abaixo:
143
144
145
Codificando WebService
Para começar, vou estar criando um WebService simples e rápido, apenas

para uma noção, veja o exemplo abaixo:
/// <summary>
/// Metodo que apenas retorna o que escrevi
/// no campo solicitado do webservices.
/// </summary>
/// <param name="minha_pagina">valor de retorno</param>
/// <returns>string</returns>
[WebMethod(Description="Meu primeiro webservices")]
public string Testando(string minha_pagina)
{
return minha_pagina;
}
Estou fazendo apenas um simples e prático WebService para que veja como
funciona. Ele apenas recebe uma string e retorna essa mesma string passada
para o XML.
Esse comentário [WebMethod ... é apenas para que o desenvolvedor que
for utilizar o mesmo, veja o comentário abaixo do sistema mostrando como
utilizar.
Não posso esquecer de colocar o <summary> na parte de cima do código,
depois do sistema todo criado e funcionando corretamente, a documentação
pode ser criada automaticamente pela ferramenta Visual Studio.NET; isso
mostrei como fazer nos capítulos posteriores.
Dica: Para colocar o sumário automaticamente, clique apenas três na barra

a seguir ///. O Visual Studio.NET criará automaticamente os parâmetros de
146
saída e de entrada, possibilitando apenas para colocar um comentário do

código criado.
Na figura abaixo veja como ficará o seu código:
Na próxima figura, estarei mostrando como colocar a página ou o serviço

para iniciar; isto é; quando clicar F5 a primeira página ou serviço será
iniciado automaticamente.
Clique com o botão direito em cima da página desejada e escolha a opção
SET AS START PAGE.
Veja a figura abaixo:
147
Cliquei F5 para iniciar o sistema, como foi explicado anteriormente a

página primeiramente aberta foi a que indiquei como na figura acima.
Na figura abaixo percebe-se que, é mostrado o método com o comentário
colocado no código, veja abaixo:
148
Ao inicar o sistema, veja que a ferramente Visual Studio.NET já abre o

Brownser, ou seja deixa pronto para executar o código construído.
Cliquei no método Testando e veja na figura abaixo o que aconteceu:
149
Não pode ser esquecido dos comentários que existem nessa página onde
encontra-se o método que crei.
Existem um comentário sobre o SOAP, mostrando as variáveis ou variável
do método e o tipo dela em forma de tag XML.
Mais abaixo em HTTP POST mostra a variáevel que será retornada, junto
com o tipo dela, no meu caso string.
Coloque um valor no campo texto na tela e clique no botão INVOKE, o
sistema abrirá outra tela e mostrará com o resultado em XML, veja na
figura abaixo de como fazer:
150
Veja como foi retornado o valor na figura abaixo, explicarei depois da

amostra da mesma.
151
Não estranhe esse valor retornado, é normal e simples.

Veio como uma tag ou forma esquisita de retornar dados; explico que é
dessa forma que o seu webservice irá retornar os valores para qualquer
outro programa que o chamar. É uma forma bastante leve e simples, o
sistema retornou o arquivo XML com o resultado. Qualquer programa que
o chamar, pegará o XML retornado e tratará os valores, mais a frente irei
mostrar como fazer um outro tipo de programa chamar o webservice
criado, tratar o valor e mostrar na tela. No caso do Visual Studio.NET é
muito mais fácil fazer, irei explicar mais a frente.
Portanto, continuando com o nosso exemplo, qualquer valor que colocar lá
no campo e clicar no botão INVOKE, mostrará o valor como resposta
dentro do XML criado pela aplicação.
Na figura acima, preste atenção na extensão do webservice criado, é
bastante importante: .asmx.
Acessando o WebService através de outro programa
152
Estarei criando outro programa para acessar o mesmo feito no capíutlo

acima. Não se preocupe, estarei fazendo apenas mais um sistema que estará
acesando o serviço disponibilizado. Primeiramente, irei criar um arquivo
.aspx chamando o método criado no webservice anteriormente, para não
esquecer, o método criado chama-se: Testando.
Você deve estar se perguntando, qual a idéia sobre o sistema acessando o
webservice ? Primeiro, criei um serviço da web, portanto posso deixar a
disposição para qualquer programa utilizar o mesmo, o serviço da Web é
para isso mesmo, disponibilizar serviços.
Para refletir: “A pouco tempo atrás, perguntaram a um senhor da

informática, qual seria o futuro em relação a software e qual a forma de
ganhar dinheiro com o software; como sábio que és respondeu:
- será a venda de serviços pela internet, por exemplo, criará um serviço
novo e irá colocar na internet, com isso você poderá disponibilzar o mesmo
cobrando por acesso ou por usuário que o acessou, esse será o futuro
(venda de serviços pela internet).”
Portanto, um serviço criado na internet que pode ser muito usado por
empresas ou pessoas, por exemplo, a verificação de nomes de pessoas no
SPC (CERASA), pode criar uma idéia e cobrar por acesso a pesquisa, o
mais importante é que podes criar para ter acesso até pelo celular,
funcionando sem problemas com a mais rápida tecnologia e rapidez de
acesso.
Voltando para a página que irei criar, onde acessará o WebService, o nome
da página será acessando.aspx e terá alguns componentes simples de tela.
Veja a figura e a especificação abaixo:
153
Especificação de objetos de tela, página acessando.aspx.
Label
Id = lblDados
Text = Dados:
Label
Id = lblResultado
TextBox
Id = txtDados
Button
Id = cmdAcessar
154
Text = Acessar
Depois da especificação dos objetos de tela, terei que instanciar o

WebServices criado anteriormente. Não esqueça, criei o serviço da internet
e agora estarei utilizando desse mesmo serviço. Antes de tudo preciso
instanciar o mesmo criado.
Dentro da Solution Explorer do Visual Studio.NET existe um pasta
chamada References, clique com o botão direito do mouse nessa pasta,
depois na opção Add Web Reference..., veja a tela abaixo e como fazer:
Clicando no botão indicado acima, irá aparecer uma tela para eu colocar o
endereço do WebService criado. O endereço que coloquei foi:
http://localhost/primeirowebservice/servico.asmx.
155
O serviço que mandei procurar pelo Visual Studio.NET mostrou apenas um

link chamado Testando e com o comentário debaixo do mesmo escrito:
Meu primeiro webservices; preste atenção em uma coisa, o mesmo foi feito
por mim usando uma opção description.
Depois de indicar o local do serviço disponibilizado, clique no botão ao
lado direito e na parte debaixo chamado Add Reference.
Veja a figura abaixo mostrando como fazer:
Instanciando e Codificando o WebService
156
Depois de clicando no botão indicado acima, foi indicado um nome de

localhost dentro do seu Solution Explorer do Visual Studio.NET. Esse deve
ser o nome que irei instanciar para chamar o método de dentro do seu
programa que irá usar o serviço disponibilizado na Internet.
Voltando a página acessando.aspx, cliquei duas vezes no botão cmdAcessar
colocando o seguinte código abaixo:
/// <summary>
/// Metodo para acessar o webservice passando o parâmetro
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void cmdAcessar_Click(object sender, System.EventArgs e)
{
///instanciando o serviço da web que criei
localhost.Servico sServico = new PrimeiroWebService.localhost.Servico();
///chamando o método do webservice pela variável que criei acima.

lblResultado.Text = sServico.Testando(txtDados.Text);
Explicando o código acima:

Depois de ter chamado o serviço da web, coloquei o nome do mesmo, logo
depois o nome da classe, seguido por uma variável qualquer que digitei. O
new já me mostra a instância criada. Coloquei o nome da minha variável e
clicando (ponto) “.”, a ferramenta me mostrará todos os métodos
disponíveis para poder acessar. Estou passando o parâmetro do TextBox
que criei de objetos da página; o mesmo método precisará retornar alguma
String, com isso coloquei o retorno do mesmo em uma Label que criei
chamada lblResultado.text.
157
Veja a figura abaixo para que entendas:
Ok, agora fiz o primeiro webservice, porém ainda não coloquei para
funcionar, nem mesmo sei se funciona direito.
Marquei para depurar na linha de depois de clicar no botão. Para marcar
uma linha, basta clicar do lado esquerdo em direção a linha do código. Não
podendo esquecer que o mesmo ficará marcado de vermelho.
Veja a figura abaixo, depois clique F5 para iniciar o programa, não esqueça
de colocar a página acessando.aspx como SET AS START PAGE.
158
Depois de inicar o programa, aparecerá a página com um campo e um

botão, onde irei colocar um texto e retornará o mesmo texto passando pelo
WebService. Isso não é nada demais, porém é um grande avanço. Lembre-
se do serviço criado para web que, foi feito apenas para retornar a String
que foi passada.
159
Coloquei duas palavras no campo apropriado e cliquei no botão

cmdAcessar. O mesmo parou na linha de código que marquei para a
depuração. Fui andando linha a linha para ver o que o código estaria
fazendo, passei pela instância, vi a String que estava sendo passada com o
mouse em cima do txtDados.text. Poderei depurar linha por linha, até o
próprio webservices (serviço da web).
Veja na figura abaixo:
160
A figura abaixo mostra o resultado do código feito acima do serviço da

web.
161
Usar WebService não é difícil usando Visual Studio.NET, fiz acima o

primeiro serviço da web com poucas linhas e poucas configurações. Nos
próximos capítulos estarei aprofundando mais serviços da web, inserindo
dados no banco de dados usando WebServices.
Criando Banco de Dados SQL SERVER
Passando do pre-suposto que já está instalado o banco de dados SQL

SERVER, entrei no Enterprise Manager, iniciei o servidor de banco de
dados, cliquei na pasta Databases com o botão direito do mouse e fui na
opção New Database.
Criei um banco de dados chamado BD_Mobile.
Veja a figura:
162
Veja a figura abaixo colocando o nome do banco de dados. Depois terei

que criar uma tabela para que possa inserir os dados.
163
164
Criando Tabela do Banco de Dados
Depois do banco de dados criado acima, agoro irei criar uma tabela para
inserir os registros. Para criar a mesma, clique com o botão direito em cima
do nome do banco de dados criado anteriormente, passe para a opção New,
depois escolha a outra opção Table. Estarei criando uma tabela de banco de
dados bem simples e rápida para depois fazer o código acessá-la, inserindo
os dados. Mais a frente estarei mostrando como fazer uma STORE
PROCEDURE, dentro de um banco de dados. Para que o mesmo fique com
mais rapidez e performace esatrei usando SP. Depois de ter escolhido as
opções acima, veja a figura abaixo e analise se está tudo se saindo bem.
Não estarei aprofundando muito sobre banco de dados, estou ensiando

apenas as coisas básicas e simples. Para aprofundar em um banco de dados,
165
seria necessário desenvolver uma apostila apenas para o assunto. Portanto

em um banco de dados existem tabelas e colunas, onde os dados podem ser
gravados, selecionados, excluídos com rapidez e agilidade. Essas
informações são básicas e úteis para quando for utilizar mais
profundamento o mesmo.
Estarei informando agora os nomes dos campos e tipos de dados que
poderão ser gravados em cada um deles.
Descrição e especificação da tabela
Column Name Data Type Length Allow Nulls

IDPaciente int 4 no
Nome char 50 yes
Telefone char 10 yes
Email char 100 yes
No campo IDPaciente coloquei as opções identity igual a YES. Significa

que, esse campo será de auto-incremento e de 1 em 1; isto é; o campo será
um número criado automaticamente de 1 em 1, no caso, ainda não precisei
me preocupar com ele. Não posso esquecer de marcar esse mesmo campo
citado como PRIMARY KEY (chave primária).
Veja a figura abaixo de como irá ficar:
166
Criando Store Procedure para Inserir no Banco de Dados
Estarei mostrando agora como fazer uma SP para inserir dados no banco. É
uma STORE PROCEDURE que recebe os dados enviados e insere no
banco de dados e na tabela de pacientes.
Continuando ainda no Enterprise Manager clique com o botão direito do
mouse na opção Stored Procedure e logo em seguida clique em outra opção
New Stored Procedure..... Dessa forma estarei criando uma nova desde o
início.
167
Depois que fiz os passos acima, a ferramenta mostra uma outra tela para
inserir os dados. STORE PROCEDURE usa uma linguagem chamada
PLSQL, com isso insira o código abaixo:
CREATE PROCEDURE SP_INSERE_PACIENTES
@NOME AS NVARCHAR(50),
@TELEFONE AS NVARCHAR(10),
@EMAIL AS NVARCHAR(100)
AS
INSERT INTO PACIENTES (NOME, TELEFONE, EMAIL)

VALUES (@NOME, @TELEFONE, @EMAIL)
168
GO
Toda SP começa com a linha de CREATE PROCEDURE e logo após

coloquei o nome da mesma SP_INSERE_PACIENTES. Todos as variáveis
que possui o @ antes do nome quer dizer que, são parâmetros que irão ser
passados ou setados. Por exemplo, @NOME quer dizer que a SP receberá
um parâmetro e cujo o primeiro atributo indicará que será o nome. Veja que
a frente de cada atributo que possui o tipo do valor que o mesmo irá
receber. No caso da variável NOME é NVARCHAR(50); esse (50) quer
dizer que o tamanho do mesmo será de no máximo cinquenta caracteres.
Todos as variáveis que estão no começo da SP e que ficaram antes do AS

são as que deverão ser passadas. Mais abaixo estou usando a linguagem
PSQL para inserir no banco de dados INSERT INTO PACIENTES, isso
quer dizer que irá inserir os valores na tabela chamada PACIENTES.
Dentro do PLSQL primeiro coloco as colunas e depois do VALUES coloco
as variáveis primeiramente declaradas.
Veja abaixo a figura e mostrar como ficou:
169
Acesso a Banco de Dados
Criando Classe para Acessar Banco de Dados
Depois do o Banco de Dados e a Store Procedure criados, irei mostrar

como criar uma classe para acessar os mesmos com rapidez e flexibilidade.
Nesta classe, mostrarei como abrir o banco de dados onde o mesmo pode
ser usado para inserir, exlcuir ou selecionar qualquer dados de dentro do
banco. É simples e fácil desenvolver isso.
Vamos para a prática agora; primeiramente crie uma pasta chamada
componentes, depois crie uma classe chamada clsBanco.cs.
170
Na figura abaixo, estou criando apenas a pasta, não esqueça que depois de
criar a pasta, devo criar uma classe dentro dela.
171
Clicando com o botão direito do mouse em cima da pasta componentes,

vou até a opção ADD, logo após escolho a opção ADD New Item..., com
isso mostrará uma outra tela onde irei escolher a opção de arquivo que
gostaria de criar, coloco o nome e clico OPEN. A figura abaixo ilustrará um
pouco do que descrevi acima:
172
A opção que irei escolher é as CLASS, no caso essa classe que irei criar é
apenas um componente onde irei instanciar de qualquer outro tipo de
componente, podendo assim acessar os métodos do mesmo instanciado.
Coloque o nome da classe de clsBanco.cs e clique OPEN.
A figura abaixo mostra como escolher a opção de classe indicada acima,

colocando o nome.
173
Codificando Classe de Acesso a Banco de Dados
Seguindo todos os passos anteriormente, agora com a classe de acesso a

banco de dados, terei que importar um pacote onde me disponibilitará os
métodos para acesso ao banco. Essa classe se chamada SqlCliente.
Veja o código:
using System.Data.SqlClient; //importando classe para ser usada
Terei que criar uma string para conexão do banco de dados, onde tenho que
indicar senha, usuário, servidor e banco de dados. No meu caso também
estou utilizando um POOL máximo e mínimo de conexões. Veja a linha de
código abaixo:
// variável criada para conexao com o banco de dados
174
public SqlConnection sConexao = new SqlConnection("Initial

Catalog=BD_Mobile; user id=sa ;password=; Data Source=bsb066666;
Max Pool Size=80; Min Pool Size=5");
Explicando código:
Primeiro, estou criando a variável sConexao como pública pelo fato de que
outras classe irão ter que acessa essa variável. Veja que o tipo dela é
SqlConnection, com isso ela é do tipo de conexão do método importado
acima, chamado SqlClient. O catalog está recebendo um parâmetro
chamado BD_Mobile, esse nome significa o mesmo nome do banco de
dados que gostaria de conectar. Logo depois estou colocando um user id
que recebe outro parâmetro chamado sa, esse valor passado é o usuário do
meu banco de dados; não esqueça que o talvez o usuário do seu banco de
dados seja diferente do meu usuário, com isso favor colocar o usuário que
irá conectar ao seu banco.
Depois estou colocando a senha do usuário que estará conectando-se ao

banco, o meu banco de dados não possui senha, por isso ela está vazia.
Seguindo, o próximo atributo que irei colocar é Data Source, indica que
tenho que colocar o nome do servidor onde está o meu banco de dados, no
meu caso estou colocando o nome do meu computador, se for o caso do seu
banco de dados estar na internet, podes colocar IP ou ENDEREÇO do site
onde está o mesmo.
O próximo atributo de MAX POOL indica que o máximo de POOL de

conexão de banco é de 80 conexões. O atributo MIN POOL indica o
mínimo de POOL de conexões que no caso coloquei 5. POOL de conexões
significa que o servidor de banco de dados irá usar o mesmo objeto de
conexão criado anteriormente, com isso diminui ou polpa memória do
mesmo, possibilitando o sistema ficar mais rápido e ágil.
175
176
Criando Métodos para Conexão no Banco de Dados
Primeiramente estou criando um método dentro da classe criada acima

chamado conectar(). A asssinatura do método criado é: public void
conectar().
Explicando assinatura do método:

Public, significa que o método é público e pode ser acessado por qualquer
outro método de qualquer outra classe. Lógico que depois de instanciar a
classe de acesso a dados que o mesmo pode enxergar os métodos públicos.
Void, significa que o método retornará nada depois de executar toda a
informação de instância. Lógico que posso colocar para retornar um tipo
boolean, com isso depois de conectar poderia colocar true/false, isso vem
da necessidade de cada usuário ou aplicação.
Conectar(), é apenas um nome de método que escolhi, porém veja que o
mesmo só abre e fecha os parênteses. Isso significa que, o mesmo não
possui parâmetros de entrada.
Estarei mostrando agora o método que conecta no banco de dados, veja
abaixo o mesmo:
/// <summary>
/// metodo que conecta no banco de dados
/// abre o banco
/// </summary>
public void conectar()
{
if (sConexao.State==0)
{
sConexao.Open();
}
else
177
{
sConexao.Close();
}
}Explicando código acima:
Essa classe de conexão ao banco de dados, é simples e fácil de entender.

Primeiramente, estou perguntando para a variável de conexão que criei
acima chamada sConexao, se o estado da dela é igual a zero (0), significa
que o banco de dados está fechado. Se o mesmo estiver fechado, falo para o
código abrir o banco com a linha de seguinte: sConexao.Open();, pego a
minha variável criada, clicando apenas o ponto (.), será mostrado todas as
funções para trabalhar com o banco de dados / string de conexao criada.
Veja que existe um else, significa que se o estado dela não for fechada,
estará aberta, portanto coloco a linha sConexao.Close(); que fechará o meu
banco de dados. Como disse anteriormente, é fácil entender essa classe,
simples e é essencial para trabalhar com banco de dados. Hoje em dia é
difícil fazer uma aplicação que não use o banco de dados.
Criando o método para fechar o banco de dados
Agora irei mostrar um outro método para fechar o banco de dados, com a
sua aplicação. Nesse método é apenas para essa funcionalidade citada
acima mesmo. Irei mostrar o código da mesma abaixo:
/// <summary>
/// metodo que desconecta do banco de dados
/// fecha o banco de dados
/// </summary>
public void desconectar()
{
if (sConexao.State!=0)
{
178
sConexao.Close();
}
}
Explicando código acima:

Percebe-se que a classe de fechar o banco de dados chama-se desconectar(),
portanto a assinatura é a mesma do método de conectar(), é um método
público e que não retornará valor algum. Pergunto se o estado da conexão é
diferente de zero (0), se for eu fecho a conexão com seguinte linha
sConexao.Close(), bem simples mesmo.
Veja a classe toda abaixo:
using System;
using System.Data.SqlClient; //importando classe para ser usada
namespace PrimeiroWebService.componentes
{
/// <summary>
/// Classe de acesso a banco de dados
/// </summary>
public class clsBanco
{
public SqlConnection sConexao = new
SqlConnection("Initial Catalog=BD_Mobile; user id=sa ;password=; Data
Source=bsb066666; Max Pool Size=80; Min Pool Size=5");
/// <summary>
/// metodo que conecta no banco de dados
/// abre o banco
/// </summary>
{
179
if (sConexao.State==0)
{
sConexao.Open();
}
else
{
sConexao.Close();
}
}
/// <summary>
/// metodo que desconecta do banco de dados
/// fecha o banco de dados
/// </summary>
{
if (sConexao.State!=0)
{
sConexao.Close();
}
}
}
}
180
Inserindo Dados no Banco
Agora irei fazer um classe que possuirá um método para inserir no banco de
dados os dados passados. Esse método criado usará a STORE
PROCEDURE criada anteriormente para inserir os dados no banco de
dados.
Da mesma forma que criei uma classe para conexão dentro da pasta
componentes, crie uma outra classe chamada clsInsere.cs. O nome do
método criado será insereDados.
Na própria classe estou instanciando a outra classe de conexão, abrindo a
conexão com o banco de dados, gerando a string de inserir os dados no
banco de dados e executando a mesma. Veja o código abaixo:
public Boolean insereDados(string nome, string telefone, string email)

{
///Instanciando a classe de banco de dados
///usarei os objetos da classe que tem a string de conexao
PrimeiroWebService.componentes.clsBanco sBanco = new
clsBanco();
try
{
///abrindo o banco de dados
sBanco.conectar();
string sql = "SP_INSERE_PACIENTES '" + nome + "', '" +
telefone + "', '" + email + "'";
SqlCommand sqlc = new SqlCommand(sql,sBanco.sConexao);
return true;
}
catch(SqlException e)
{
181
//jogando o erro para cima

throw new SystemException("erro na classe insere dados
(insereDados): "+ e.StackTrace);
}
finally
{
//desconectando o banco de dados
sBanco.desconectar();
}
}
Explicando assinatura do método
Veja que criei um método público e que retornará um tipo Boolean, ou seja
true ou false. O nome do método é insereDados, não posso esquecer de
comentar dos parâmetros que estão sendo passados. No caso de nome,
telefone e email, significa que quando eu for chamar esse método tenho que
passar os seguintes valores, se eu não passar os valores o código dará erro.
PrimeiroWebService.componentes.clsBanco sBanco = new clsBanco();
Logo a primeira linha de código dentro da classe, estou instanciando a

classe criada que conecta no banco de dados. Veja que criei uma variável
chamada sBanco, significa que estarei usando a mesma mais abaixo no
código.
try
{
///abrindo o banco de dados
182
sBanco.conectar();
Seguindo o código, veja o que coloquei o código dentro de um try, significa

que tudo que ocorrer está dentro da classe estará sendo protegido, ou seja,
se ocorrer algum tipo de erro, o mesmo irá para a parte de catch. Mais a
frente estarei explicando isso melhor. Em seguida estou usando a variável
criada acima chamda sBanco, depois que coloco a mesmo e clico ponto (.),
aparecerá todos os métodos públicos acessíveis para serem usados. Estou
chamando o método para conectar no banco, veja que todo método que não
parâmetro de entrada, coloco apenas um parêntese abrindo e fechando.
string sql = "SP_INSERE_PACIENTES '" + nome + "', '" + telefone + "', '"
+ email + "'";
SqlCommand sqlc = new SqlCommand(sql,sBanco.sConexao);
Continuando com o código dentro da classe, veja o mesmo acima. Criei

uma string chamada sql, para usá-la na mesma hora. Coloquei o nome da
SP que fiz antes acrescentando os parâmetros nome, telefone e email. Esses
mesmos parâmetros tenho que receber na STORE PROCEDURE, criei
apenas uma variável para ser executada mais a frente. Não posso esquecer
de falar que, para parâmetros que podem ser qualquer tipo de dado, coloco
aspas simples (‘), depois duplas (“), no caso de variável apenas como
números, coloco apenas aspas simples (‘).
Mais abaixo no código, instancio um objeto SqlCommand que irá passar a
minha string sql junto com a variável de conexão do banco. Logo depois
estou usando a variável criada do SqlCommand, chamada sqlc e chamando
um método do objeto para executar a minha string chamado
ExecuteNonQuery(). Resumindo, peguei a minha instrução SQL criada e
executei no inserindo os dados no banco de dados.
return true;
183
O código acima, é a última linha do código dentro da chave TRY, isso

significa que se tudo ocorrer bem durante todo o código, o método
retornará true, alcançando o seu objetivo.
catch(SqlException e)
{
//jogando o erro para cima
throw new SystemException("erro na classe insere dados
(insereDados): "+ e.StackTrace);
}
Para entrar dentro do laço catch, é necessário que ocorra algum tipo de erro
dentro do laço try, quando ocorrer esse tipo de erro o código passará
automaticamente para dentro do catch, com isso o mesmo tratará o erro. O
código throw new SystemException trata o erro e lança para o método
acima, isto é, o erro irá ser lançado para o método que chamou. Estou
colocando uma mensagem mostrando o nome do classe e depois coloco
qual o foi o tipo de erro com o código e.StackTrace.
finally
{
//desconectando o banco de dados
}
Esse laço finally significa que mesmo que o código der certo ou ocorrer
algum erro, passará pelo finally. Dentro desse laço eu sempre coloco para
desconectar o banco de dados. Estou usando a variável que criei e chamado
o método desconectar(), que também criei dentro da classe clsBanco.cs.
184
Criando WebService para Inserir Dados no Banco
Depois de criado a classe para inserir no banco, a STORE PROCEDURE,

classe de conexão do banco, agora vou criar o WebService onde chamará
essas classes que criamos passando os parâmetro necessários. Lembre-se
que vou precisar apenas dos parâmetro nome, telefone e email.
O código do WebService irá simples, e curto, praticamente terá duas linhas
de códigos, porque quem faz mesmo o a inserção dos dados no banco e
tudo mais, são as outras classes, a classe clsBanco.cs que conecta no banco
e a classe clsInsere.cs, que irá inserir os dados no banco de dados.
O retorno desse WebService será true ou false. Irei fazer o código do
WebService dentro da classe Servico.asmx.cs, com isso esta classe terá dois
serviços de WebServices para serem usados.
Veja o código abaixo:
185
[WebMethod(Description="WebServices que insere no banco de dados, é

necessário colocar os campos: Nome, Telefone e Email")]
{
///instanciando a classe criado anteriormente
PrimeiroWebService.componentes.clsInsere sInserer = new
PrimeiroWebService.componentes.clsInsere();
///chamando o metodo da classe acima

return sInserer.insereDados(nome, telefone, email);
}
Primeiramente estou colocando uma descrição do webservice, dizendo o

que o mesmo faz. O método é público e retorna dados true ou false, o nome
do mesmo é insereDados, não esquecendo que estou passando três
parâmetros do tipo string. São: nome, telefone e email.
Logo após criar a assinatura do método estou instanciando a classe que
insere dados chamada clsInsere(), lembra que fiz a classe no mesmo
diretório do que a classe de banco de dados, veja que criei uma variável na
instância, chamada sInsere, com isso depois que coloco o nome da mesma
de clico em ponto (.), aparecerá todos os métodos públicos disponíveis
passando as variáveis criadas mais acima. O método que estou usando da
classe é insereDados.
186
Irei executar o programa da classe Servico.asmx. Primeiro coloque a figura

como Set As Start Page clicando com o botão direito em cima da classe.
Veja a figura abaixo mostrando como fazer:
187
Mostrando WebService Criado
Clique no link chamado insereDados e o mesmo mostrará os campos para

inserir os dados e clique no botão invoke.
Veja a figura mostrando o programa sendo executado abaixo:
188
Preencha os dados e clique no botão.
189
Estarei preenchendo os dados nos campos apropriados.

No campo nome coloquei o valor teste qualquer, no campo telefone
coloquei o valor 090909090 e no último campo email, coloquei o valor de
a@b.com.br.
Para ver os dados que inseri nos campos, veja a figura
:
190
Quase ia esquecendo iniciar o servidor de banco de dados SQL SERVER,

por favor inicie o servidor e continue os procedimentos; irei abrir a
ferramente SQL Server Enterprise Manager, estarei vendo se existe algum
dado inserido na tabela Pacientes.
191
Agora irei clicar no botao de invoke para inserir os dados que digite no
banco de dados. Depois de clicado, veja o que o WebService retornou um
XML com um resultado true dentro da tag, estou mostrando na figura:
192
Na figura abaixo estou mostrando os dados que foram inseridos no banco

de dados. Todos os dados que foram passados estão incluidos no banco de
dados SQL Server. O WebService instancia o método da classe clsInserir.cs
que o mesmo abre a conexão com o banco de dados instanciado no método
da classe clsBanco.cs, e por sua vez abre o banco, volta para a classe que a
chamou e insere os dados no banco de dados.
193
Resumindo, fiz agora um WebService que insere dados no banco de dados,

crie a classe de conexão com o banco, fiz uma classe que utiliza a instrução
SQL, criei a Store Procedure que insere realmente os dados passados dentro
da tabela Pacientes. O serviço da Web mostrará o resultado via XML,
dentro de uma TAG XML. Nesse caso retornará true ou false.
Criando WebService que Retorna String
Irei fazer um serviço para Web simples e prático. No último serviço criado
no capítulo anterior retorna um tipo Boolean, ou seja true ou false, agora
estarei criando um WebService que retornará um tipo string, ou seja nome e
data.
O nome do método será retornaOla com um parâmetro de entrada do tipo
string chamado nome, ficará do jeito a seguir retornaOla(string nome).
194
/// <summary>
/// Metodo simples e responsável para retornar um olá com o
/// nome colocado pelo usuário com a data atual
/// </summary>
/// <param name="nome">nome do usuario</param>
[WebMethod(Description="WebServices simple e responsável para
retornar um olá com o nome colocado pelo usuário junto com a data
atual.")]
public string retornaOla(string nome)
{
return "Olá " + nome + " hoje é: " +
DateTime.Today.Date.ToString("dd/MM/yyyy");
}
O Description do WebService explica o que o método irá fazer. Veja que o

método retornará apenas um Olá mais o nome que o usuário digitará mais a
data atual, veja o mesmo abaixo:
[WebMethod(Description="WebServices simple e responsável para
retornar um olá com o nome colocado pelo usuário junto com a data
atual.")]
A assinatura do método mostra que o mesmo é um público, o tipo de
retorno é uma string e existe um parâmetro de entrada do tipo string, cujo o
nome da variável que criei foi nome.
Depois de mostrar a assinatura do método veja o que mesmo já passa para a
linha de retorno.
return "Olá " + nome + " hoje é: " +

DateTime.Today.Date.ToString("dd/MM/yyyy");
195
O return, já pega todo o que está na frente e já retorna para o método, o

mesmo criará um xml colocando o valor que estou passando. Concatenei o
“Olá” junto com o nome que está sendo passado pelo método,
concatenando mais a data atual do formato dia, mais barra, mais mês e mais
ano.
196
Irei mostrar o funcionamento do serviço da web.

Clique no F5 na ferramenta Visual Studio.NET e veja iniciando o Internet
Explorer.
O WebService retornará um XML de resposta.
Veja que agora o serviço da web terá três links, um chamado insereDados,
outro Testando e por último retornaOla, todos esses métodos retornará um
XML de resposta, não esqueça de que cadas serviço da web possui um
comentário abaixo.
Clique no link retornaOla.
Na a figura abaixo, terá um campo nome para ser preenchido, irei colocar
um nome e clicar no botão invoke.
197
Coloquei o nome de Luiz Carlos e cliquei no botão invoke.
198
Consumindo WebServices
Até agora criei e testei apenas serviços da web, junto fiz apenas um
programa para consumir webservice, portanto irei mostrar como usar esses
webservices que criamos via outro sistema. Estarei fazendo um outro
sistema para acessar e ler os resultados, mostrando na tela o retorno do
XML. Não é dificil, estarei consumindo um serviço da web em apenas três
ou quatro linhas apenas, no máximo.
Para utilizar o WebService chamado insereDados, estarei criando uma
página ASPX e instanciando o objeto ASMX passando os parâmetros
necessários, todas as classes encarregarão de fazer todo o trâmite de dados,
inserindo os dados no banco de dados.
Não esqueça que os dados são passados de classe a classe até chegar ao
banco de dados normalmente, junto a STORE PROCEDURE terminando
dentro de uma tabela de banco de dados.
199
Essa nova tecnologia que está ainda alcançando o mercado não se difcundiu
totalmente, portanto temos muitas possibilidades de criar serviços e
começar a comercializar.
Estarei criando uma nova classe ASPX chamada insereDados.aspx dentro
do mesmo projeto do Visual Studio.NET.
Segue os atributos abaixo da página:
TextBox’s
ID = txtNome
ID = txtTelefone
ID = txtEmail
Label’s
ID = Label1
Text = Nome:
ID = Label2
Text = Telefone:
ID = Label3
Text = E-mail:
ID = lblResultado
Text = “”
Button
ID = cmdEnviar
Text = Enviar
A figura da página abaixo será melhor para o entendimento de todos os
componentes acima criados.
200
Depois de criado a página insereDados.aspx, terei que criar um serviço de

WebService dentro do projeto do Visual Studio.NET.
Clique com o botão direito em cima da pasta Web References, depois
clique na opção Add Web Reference...
201
A figura abaixo mostra qual o endereço tive que colocar para achar os
serviços criados nos capítulos anteriores. O endereço digitado foi o
seguinte: http://localhost/primeirowebservice/servico.asmx
Depois de digitado o endereço clique no botão para adicionar.
202
Voltando a página criada acima (insereDados.aspx), clique duas vezes no

botão cmdEnviar e coloque o código abaixo:

{
PrimeiroWebService.localhost.Servico sServico = new
PrimeiroWebService.localhost.Servico();
Boolean bRetorno = sServico.insereDados(txtNome.Text, txtTelefone.Text,
txtEmail.Text);
if (bRetorno)
{
lblResultado.Text = "Dados inserido com sucesso !!";
}
else
{
lblResultado.Text = "Erro ao inserir dados !!";
203
}
}
Explicando código:
Primeiramente, esse código irá ser executado quando clicar no botão
Enviar, logo após veja que estou instanciando o serviço que criei. Coloquei
o nome variável de sServico, estarei utilizando a mesma logo abaixo.
PrimeiroWebService.localhost.Servico sServico = new

PrimeiroWebService.localhost.Servico();
No código acima estou chamando o meu método para poder usá-lo sem
problemas depois. Coloquei o nome do projeto, (ponto), o nome do serviço
que está no meu projeto, cujo foi (localhost) e por último coloquei o nome
da classe; que é se chama Servico. A minha variável sServico pode ser
colocada com qualquer outro nome, mas poderá ser utilizada com o mesmo
nome mais abaixo.
Boolean bRetorno = sServico.insereDados(txtNome.Text, txtTelefone.Text,

txtEmail.Text);
Despois de instanciar o método acima, estou usando a variável que criei.

Veja que depois de passada a variável, cliquei (ponto) e mostrou todos os
métodos públicos para que possa usar. Não esqueça que estamos fazendo
um programa para utilizar os serviço da Web para inserir dados no banco
de dados, passando os objetos de tela.
Analisando código por código, primeramente coloquei uma variável do tipo
Boolean chamada bRetorno, ela está recebendo a outra variável sServico,
mais o nome do método dentro do WebService, chamado insereDados, o
mesmo recebe parâmetros, na realidade são três parâmetros. O primeiro
nome, o segundo telefone e por último e-mail. Lembre-se que em páginas
anteriores, estive colocando os objetos de tela tipo textbox, os mesmos que
irei passar para o método do WebService.
Esse bRetorno é porque o método insereDados retorna um valor do tipo
Boolean, ou seja, true ou false. True se os dados forem inseridos no banco
204
de dados ou false se os mesmos derem erro na hora de inserir os valores no

banco de dados.
if (bRetorno)
{
lblResultado.Text = "Dados inserido com sucesso !!";
}
else
{
lblResultado.Text = "Erro ao inserir dados !!";
}
}
No código acima, estou apenas pegando a variável bRetorno que criei e
perguntando: Se o bRetorno for igual a true, mostra no label de resultado a
seguinte mensagem “Dados inserido com sucesso !!”, senão, ou seja, se for
false mostra a mensagem “Erro ao inserir dados !!” para o usuário final.
Perceba que o quem irá fazer todo o trâmite de dados, inserir dados no
banco de dados, usar conexão com o banco de dados, usar STORE
PROCEDURE e tudo mais é o serviço WebService e não a página ou
sistema que criamos chamada insereDados.aspx.
Executando o código criado anteriormente
Coloquei a página insereDados.aspx como página de inicialização do
projeto, veja na figura abaixo como fazer isto.
205
Depois de ter colocado a página como inicialização do projeto, irei iniciar o

projeto para que veja o trâmite de dados. Para iniciar o projeto basta clicar
F5 (tecla de atalho).
Não esqueça de iniciar o servidor de banco de dados, se não for
inicializado, o sistema não conseguirá conectar no banco de dados,
consequentimente não inserirá os dados.
206
Na figura acima, mostro apenas como estará a página inicializada do

sistema. Antes de tudo, ou seja, antes de inserir os dados e clicar no botão
Enviar, estarei mostrando primeiramente como verificar no banco de dados
os dados da tabela.
Estarei entrando na ferramenta Enterprise Manager, irei até a tabela de
banco de dados, passando pelo servidor e pelo banco de dados chamado
BD_Mobile, continuando, estarei indo pelo ítem Tables, onde encontra-se
as tabelas. Agora nas tabelas, clique com o botão direito em cima da tabela
chamda Pacientes, logo após Open Table e por último Return all rows,
dessa forma abrirá os dados da tabela citada anteriormente.
207
Na figura abaixo mostro apenas que não existem dados na tabela Pacientes.
208
Continuando com o nosso sistema, agora sim vou inserir os dados nos
campos para gravar no banco de dados através do WebService.
Inseri alguns dados básicos mesmo, apenas para verificar se tudo foi
inserido mesmo no banco.
209
Depois de inserido os dados, clique no botão Enviar e verifique a

mensagem na tela, logo após verifique no banco de dados, se os dados
foram inseridos com sucesso.
Veja a figura abaixo, junto com a mensagem que retornou do WebService:
210
Na figura abaixo, apenas mostro no banco de dados que os dados passados

foram inseridos com sucesso.
Isso quer dizer que o WebService junto com o programa que estou
consumindo o mesmo, está funcionando corretamente.
Veja que Não foi tão difícil fazer um WebService (serviço da web) que
insere os dados no banco de dados SQL SERVER.
Esse exemplo de serviço da Web foi simples, porém foi usado tudo de
necessário para criar e usar o mesmo serviço. Com esse exemplo, você terá
uma base boa para criar qualquer outro tipo de serviço da Web com
tremenda facilidade e rapidez.
Criando WebService que Criptografa Dados
211
Neste capítulo estarei mostrando como fazer um serviço da Web

criptografar qualquer tipo de dados com segurança e rapidez, usando Visual
Studio.NET.
Uso de Criptografia em Sistema da Informação
Se precisarmos desenvolver um sistema que faça uso de criptografia,

devemos ter em mente que o aspecto mais importante da criptografia não é,
como pode parecer, o tamanho da chave ou o algorítimo usado. O aspecto
mais importante está principalmente na definição do ciclo de vida da chave:
como ela é gerada, armazenada, acessada e destribuída. Através do ataque à
chave, e não ao algorítmo, é que se consegue quebrar um mecanismo de
criptografia.
Gerando Chave de Criptografia
Cada algorítmo de criptografia exige um tamanho específico de chave.

Idependentemente do algorítmo, as chaves de criptografia são geradas a
partir de uma semente. Essa semente pode ser um número aleatório, um
texto ou um segredo qualquer digitado pelo usuário. Em alguns casos, o
algorítmo define um mode de se obetter a chave a partir da semente,
enquanto em outros casos, pode-se obeter a chave de diversas formas, mas
sempre a partir da semente.
Qualquer que seja a situação, devemos ter um mente que se a chave foi
gerada a partir de um segredo ou senha, ela estará fatalmente comprometida
caso tal segredo seja revelado, já que o agente do ataque pode simplismente
gerar novamente a chave. Se for gerada a partir de número aleatório, temos
outro problema: as funções de geração de número são pseudoaleatórias. Na
maior parte das vezes esses números pseudoaleatórios são baseados na data
212
e na hora em que a semana foi gerada. Assim, pode ser relativamente

simples gerar novamente essas sementes e, por consequentimente, as
chaves. Mesmo que o atacante não saiba o segundo e o milissegundo
exatos, se ele souber que a chave foi gerar entre as 14:50 e as 15:00 horas
(um período de 10 minutos), terá, então, que tentar apenas 600.000 chaves
(imaginando que o gerador de números aleatórios considera até o
milissegundo), o que é bem pouco.
O ideal seria dispor de um gerador de números aleatórios independente, de

características tao simples quanto o tempo e outras características físicas da
máquina. Também nem sempre é desejável que o usuário entre com algum
segredo para servir de semente, pois este pode ficar com o poder de quebrar
a chave de criptografia. Uma alternativa muito usada é pedir que o usuário
mova o mouse diversas vezes sobre uma tela, de forma que algum
parâmetro (soma dos cossenos das retas formadas, por exemplo) seja nosso
número aleatório. O usuário dificilmente conseguiria reproduzir essa
geração aleatória mesmo que quisesse. Tampouco poderia o atacar.
Outra situação é aquela em que duas máquinas negociam uma chave de
criptografia para uma sessão. Nesse caso, geralmente é usado o algorítmo
de DiffieHellman para estabelecer um par de chaves assimétricas, as quais
são usadas para trocar uma chave simétrica. Nessa situação, a preocupação
com a possibilidade de quebra do número aleatório é menor, pois:
- As chaves são alteradas com muita frequência, o eu tornaria difícil

até mesmo um número pequeno de testes.
- As chaves são geradas a partir de dois números aleatórios em dois

computadores diferentes, o que multiplica a necessidade de testes, já que
dificilmente os computadores gerarão as sementes ao mesmo tempo.
Finalmente, os algorítmos de criptografia possuem algumas chaves que são

“chaves fracas”. Se uma dessas chaves for usada, o algorítmo pode ser
quebrado facilmente por criptoanálise. Assim, verifique se a chave gerada
213
não consta dessa “lista negra” de chaves do algoritmo escolhido antes de

usá-la.
Quando usar Criptografia de Dados ?
A criptografia pode ser usada em uma série de situações, para atingir um

grande número de objetivos de segurança.
Confidencialidade: quando é necessário garantir a confidencialidade de

uma informação, em um meio fora do controle do sistema, pode-se
criptografar a última. Para tal, pode-se recorrer a diversas bibliotecas de
algorítmos mais comuns de criptografia. O grande problema aqui é onde
guardar a chave. O sistema precisa manter a chave protegida, caso contrário
não há como garantir a confidencialidade. Se a chave ficar no código do
sistema, por exemplo, estará entao suscetível a ser obtida pela abertuda do
código. Existem duas outras possibilidades: manter a chave em um banco
de dados protegido todo o tempo pelo sistema ou delegar a tarefa de
manutenção da chave ao usuário.
No caso de uso do banco de dados, deve-se cuidar para que a chave não só
fique protegida no armazenamento, mas também durante seu uso para
criptografia e descriptografia.
Pode-se utilizar tanto criptografia simétrica quanto assimétrica nesse caso.

Geralmente, a criptografia assimétrica é mais segura, porém mais cara em
termos de processamento. Assim, quando se trata de grandes volumes de
dados, a opção preferencial é a criptografia simétrica.
Uma outra solução para manutenção da chave protegida é o uso de smart-
card com criptografia. Esses cartões contêm um processador com
capacidade de realizar a criptografia e descriptografia de dados. A chave,
porém, é armazenada em memória write-only, ou seja, pode ser alterada
214
mas não lida externamente (apenas o processador interno do cartão tem

acesso à chave). Esses cartões utilizam criptografia assimétrica.
Assinatura eletrônia (conhecida também como assinatura digital): como o

uso de criptografia assimétrica, é possível garantir a origem de um
documento. A idéia é gerar um par de chaves de criptografia assimétrica
para cada usuário. Uma dessas chaves será considerada pública, e a outra, a
chave privada desse usuário. A chave pública é mantida em um banco de
dados aberto, que pode ser consultado por todos os usuários do sitema. A
chave privada, por sua vez, é mantida em poder do usuário e com acesso
permitido apenas a este. Sempre que desejar enviar um dado com garantia
da origem, o usuário deve gerar um hash da mensagem e criptografá-lo com
sua chave privada. Ao receber a mensagem, o outro usuário pode
descriptografar o hash utilizando a chave pública do usuário que diz ser o
emissor da mensagem. Se for possível a obtenção do hash correto, tem-se a
garantir de que a mensagem foi gerada por aquele usuário, pois apenas ele
possui a chave privada a qual faz par com a chave pública armazenada.
Como saber, porém, que a chave pública pertence realmente àquele
usuário? Em um sistema simples, podemos até confiar em sua base de
dados. Em sistemas maiores ou com requisitos mais restritos de segurança,
é preciso fornecer uma garantia da origem da ligação da chave pública com
o usuário. Essa garantia é dada pela designação de uma entidade
certificadora, que assina um certificado e que contém a identificação do
usuário e sua chave pública, com uma chave privada certificadora. Se o
usuário confia na certificadora, ele usa uma chave pública desa para
garantir que a identidade confere com a da chave.
Repare ainda que pode haver certificadoras de certificadoras, as quais

garantem os certificados emitidos. Essa estrutura de certificação é
conhecida como PKI, ou public key infra-structure, cujo objetivo é garantir
a ligação do usuário, de forma que as estruturas de PKI também cuidem da
geração e distribuição das chaves privadas.
215
Não-repúdio de origem: o não-repúdio de envio é um mecanismo com o

objetivo de garantir que o receptor possa provar a origem de uma
mensagem. Por exemplo, um cliente faz um pedido de compra através de
um e-mail. Na hora de pagar, ele alega que não enviou nenhuma
mensagem. Assim, para garantir o bom funcionamento do sistema, é
necessário um mecanismo com o qual se possa provar que o pedido foi
feito. Fora do mundo eletrônico, isso é feito através da assinatura do pedido
de compra. Da mesma forma, isso pode ser facilmente implementado com
uma assinatura eletrônica e uma estrutura de PKI, aceita por ambas as
partes envolvidas.
Não-repúdio de recebimento: da mesma forma que o cliente pode negar a

realização do pedido, o coprador pode alegar que não o recebeu. Para
garantir o recebimento, a única maneira é através do envio da mesma
mensagem ou ao menos do hash desta, assinado eletronicamente pelo
receptor, de volta para o emitente original. Algo semelhante ao protocolo
de recebimento utilizado para documentos físicos.
Garantia de privacidade com responsabilização do usuário: o sistema pode

manter a trilha de auditoria criptografada com uma chave pública. A chave
privada é mantida sob controle da instância ou do sistema que tem o direito
de quebrar a privacidade dos usuários, com objetivo de responsabilização.
Garantia de integridade: embora existam formas mais simples de garantir a

integridade dos dados, a criptografia também pode fazer isso. Se for
necessário criptografar os dados para manter a privacidade, não é
necessário outro mecanismo para garantir a integridade das informações.
Criando a Classe de Criptografia
216
Agora estarei criando uma classe de criptografia, cujo, a mesma terá dois
métodos; um que criptografa dados e outro que descriptografa dados.
Criarei um serviço da web (WebService) que acessará essa classe de
criptografia passando os parâmetros e o mesmo retornará uma string
criptografada.
Não é muito difícil fazer esse WebService que criptografa dados, porém
irei começar a fazer pela classe de criptografia de dados.
Começando, crie uma classe dentro da pasta componentes chamada
clsCriptografia.cs. Como disse acima, essa classe terá dois métodos
chamados encryptografa e decryptografa.
Depois da classe criada, retirei o método construtor e no início da classe,

estou importando uma classe de criptografia, onde irei usa-la mais abaixo.
Veja o código de importação, logo abaixo:
using System.Security.Cryptography;
No começo da classe, estou declarando duas variáveis, uma é minha chave
fixa mesmo. As duas são uma array de bytes, não posso esquecer que
estarei utilizando as mesmas mais a frente. Veja o código abaixo:
217
//variaveis para criptografia

Byte[] IV = new byte[] {0x0012, 0x0034,0x0056, 0x0078, 0x0090,
0x00AB, 0x00CD, 0x00EF};
Byte[] key =System.Text.Encoding.UTF8.GetBytes("mauricio");
Continuando com a classe, estarei criando um método chamado

encryptografa passando como parâmetro um valor digitado. A única coisa
que o método irá fazer é:
- pegar o valor passado normalmente;
- criptografar o valor passado de acordo com a minha chave;
- converter para ToBase64;
- retornar a string criptografada para o método que o chamou;
/// <summary>
/// metodo que encriptografa os dados de acordo com a minha variavel
/// acima e os valores passos
/// ex.: encryptografa("valor")
/// </summary>
/// <param name="strValor"></param>
public string encryptografa(string strValor)
{
try
{
DESCryptoServiceProvider des = new
DESCryptoServiceProvider();
Byte[] inputByteArray =
System.Text.Encoding.UTF8.GetBytes(strValor);
System.IO.MemoryStream ms = new System.IO.MemoryStream();
CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(key, IV),
CryptoStreamMode.Write);
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
218
return Convert.ToBase64String(ms.ToArray());
}
catch (System.Exception ex)
{
return ex.Message;
}
}
No próximo método da classe de criptografia chamará decryptografa
passando um valor criptografado.
A única coisa que o método faz é o seguinte:
- pega o valor criptografado passado;
- verifica a chave fixa;
- converte o valor passado;
- retorna para o método que chamou o valor descriptografado.
Veja o método abaixo:
/// <summary>
/// metodo que descriptografa os dados de acordo com os valores passos
/// e as variaveis acima
/// ex.: decryptografa("valor_criptografado")
/// </summary>
public string decryptografa(string strValor)
{
Byte[] inputByteArray = new byte[strValor.Length];
try
{
inputByteArray = Convert.FromBase64String(strValor);
System.IO.MemoryStream ms = new
System.IO.MemoryStream();
219
CryptoStream cs = new CryptoStream(ms,

des.CreateDecryptor(key, IV), CryptoStreamMode.Write);
System.Text.Encoding encoding =
System.Text.Encoding.UTF8;
return encoding.GetString(ms.ToArray());
}
{
return ex.Message;
}
}
Estarei colocando a classe toda abaixo, para que você veja como ficou
todos os métodos da classe clsCriptografia.cs. Segue o código abaixo, logo
após a figura da classe:
using System;
namespace PrimeiroWebService.componentes
{
/// <summary>
/// Summary description for clsCriptografia.
/// </summary>
public class clsCriptografia
{

Byte[] IV = new byte[] {0x0012, 0x0034,0x0056, 0x0078,
0x0090, 0x00AB, 0x00CD, 0x00EF};
Byte[] key =
System.Text.Encoding.UTF8.GetBytes("mauricio");
220
/// <summary>
/// ex.: encryptografa("valor")
/// </summary>
public string encryptografa(string strValor)
{
try
{
des.CreateEncryptor(key, IV), CryptoStreamMode.Write);
cs.Write(inputByteArray, 0,
inputByteArray.Length);
return
Convert.ToBase64String(ms.ToArray());
}
{
return ex.Message;
}
}
/// <summary>
221

/// ex.: decryptografa("valor_criptografado")
/// </summary>
public string decryptografa(string strValor)
{
try
{
inputByteArray =
Convert.FromBase64String(strValor);
cs.Write(inputByteArray, 0,
inputByteArray.Length);
System.Text.Encoding encoding =
System.Text.Encoding.UTF8;
}
{
return ex.Message;
}
}
}
}
222
223
Criando WebService para Criptografar e Descriptografar Dados
Essa é a parte mais fácil do Serviço da Web, estarei apenas utilizando a

classe feita anteriormente, passando os parâmetros e mostrando o dado
retornado do método.
Estarei criando o serviço da web na classe Servico.asmx, junto com os
outros serviços criados anteriormente. Clique duas vezes no arquivo citado
acima e acrescente mais duas classes; uma chamada encrypt(string
valorDescriptografado) e o outra decrypt(string valorCriptografado).
Uma classe criptografa os dados e outra classe descriptografa.
Começando do método encrypt veja o código abaixo:
/// <summary>
/// Metodo que criptografa dados
/// </summary>
/// <param name="valorDescriptografado">string</param>
224
[WebMethod(Description="WebService que criptografa dados")]
public string encrypt(string valorDescriptografado)
{
PrimeiroWebService.componentes.clsCriptografia
sCript = new PrimeiroWebService.componentes.clsCriptografia();
return sCript.encryptografa(valorDescriptografado);
}
O método acima é bem simples e fácil de entender.
Primeiramente estou colocando para o mesmo receber um parâmetro
chamado valorDescriptografado, esse valor é o mesmo digitado ou passado
para o serviço da web.
Na linha abaixo, estou apenas instanciando a classe de criptografia de
dados, junto dessa instância, criei uma variável chamada sCript. Essa
variável que estarei usando para chamar o método encrytografa.
Na próxima linha, estou colocando a minha variável e chamando o método
passando o parâmetro que veio (valorDescriptografado). O return significa
que o mesmo retornará um XML para o programa que o chamou passando
o resultado da string. No começo do método, veja que está retornando
apenas uma String; public string.
Foi bem simples e fácil.
Passando para o método, não esqueça de que esse próximo método é para
descriptografar dados passados.
O mesmo não é tão diferente do anterior, porém usa outro método dentro da
classe de criptografia. Poderia estar fazendo até o mesmo WebService,
porém quis dividir para ficar mais fácil o entendimento.
/// <summary>
/// Metodo que descriptografa dados criptografados
/// </summary>
/// <param name="valorCriptografado">string</param>
225
[WebMethod(Description="WebService que descriptografa dados")]

public string decrypt(string valorCriptografado)
{
PrimeiroWebService.componentes.clsCriptografia
sCript = new PrimeiroWebService.componentes.clsCriptografia();
return sCript.decryptografa(valorCriptografado);
}
Coloquei uma descrição antes da assinatura do método, tentando explicar

pelo menos o que o método faz ou executa.
Analisando primeiramente a assinatura do método, veja o que mesmo
retorna um tipo de objeto chamado string, e que recebe um valor também
do tipo string.
Veja o nome do método agora: decrypt.
Na linha abaixo, estou instanciando a classe de criptografia que foi criada
anteriormente, criando uma variável chamada sCript.
Depois que instancio a classe, coloco o nome da minha variável mais (+) o
ponto, e o mesmo mostra todos os métodos disponíveis para o uso, porém o
que vamos usar agora é o decryptografa(valorCriptografado).
O return, serve apenas para retornar o valor passado da classe de
criptografia para o método que o chamou. Encapsulando o retorno para um
arquivo XML e retornando.
Viu que não foi tão difícil assim fazer um webservice que criptografa e
descriptografa dados, esse serviço pode ser usando por você na hora que
quiser, ou mesmo se colocar na internet pode ser usado para ajudar as
pessoas para criptografar dados. Essa é uma das poucas idéias que podem
ser criadas.
Executando Código Criado Anteriormente
226
Estarei agora mostrando o sistema de WebService funcionando

corretamente, não podendo esquecer que o mesmo pode ser disponibilizado
na internet, podendo assim ser utilizado em qualquer parte do mundo,
localmente ou não. Disponibilizei o mesmo serviço no endereço abaixo,
espero que ajude a muitas pessoas:
http://www.ascompras.com.br/webserviceCript/Servico.asmx
Primeiramente coloque a classe Servico.asmx como página principal do
projeto, cujo o mesmo inicializará quando clicar F5 no projeto do Visual
Studio.NET.
Clique F5 no projeto do Visual Studio.NET para inicializar o sistema que

acabei de criar com WebService. Veja que na figura abaixo, mostrará um
monte de serviços que criamos no mesmo WebService, com isso você pode
clicar em qualquer um para executar, porém que irei testar agora é o serviço
de criptografia. Veja a figura abaixo mostrando todos os serviços da Web
criados:
227
Clique na WebService de nome encrypt. Depois de clicado aparecerá um

campo e algumas observações importantes do serviço especificado, como:
o tipo de valor, o valor de entrada, um campo para que possa ser mandado
um valor e um botão Invoke para ser clicado.
228
Depois de visto o sistema de como irá ficar, irei digitar um nome ou frase
qualquer, clicando logo em seguida no botão Invoke. Depois disso o
sistema mandará o valor e retornará um XML mostrando um valor
criptografado.
Não esqueça de copiar esse mesmo valor e usar o outro método para
descriptografar; veja o passo a passo abaixo que dará tudo certo.
Estou mostrando na figura abaixo o valor que estarei colocando:
229
Na figura acima, digitei o valor a seguir: “testando o primeiro webservice

de criptografia”. Depois de digitado, estarei clicando no botão para a
criptografia de dados. Veja na figura abaixo o resultado que foi trazido para
a tela:
230
Não esqueça de copiar o código gerado e criptografado pelo WebService,

com isso posso colocar no outro método para descriptografar, testando
assim o sistema.
Copiei todo o código gerado, voltei para o serviço de WebService onde
estão todos os serviços disponíveis e cliquei agora no método decrypt.
Esse método apenas irá descriptografar o valor que copiei anteriormente
criptografado pelo método de criptografia de dados.
Na figura abaixo, estou mostrando como que estou copiando o valor
criptografado, veja:
231
Seguindo com o raciocínio, como disse anteriormente, agora estou no

método que descriptografa os dados ou string criptografada pelo mesmo
objeto.
Em seguida coloco a string que copiei anteriormente e clico no botão
Invoke. Esse mesmo WebService de descriptografia de dados possui
algumas informações sobre o método e tudo mais.
232
Nessa próxima figura abaixo, estou mostrando que colei o código que tinha
copiado e irei clicar no botão para descriptografar os dados.
Concorda comigo que, o mesmo deve trazer a frase que criptografei ?
233
Clicando no botão Invoke, feche os olhos e ore para o método trazer a

mesma frase que foi adicionada no método de criptografia, acho que
esqueci qual a frase que adicionei. A frase que foi adicionada para ser
criptografada é a seguinte: “testando o primeiro webservice de
criptografia”, esse método de descriptografia de dados deve trazer essa
string acima do mesmo jeito que foi, inclusive os espaços em branco e tudo
mais.
Estava brincando quando falei que para fechar os olhos e orar para trazer
tudo certo. O mesmo trazerá com certeza essa frase sem problemas e para
provar isso, veja a figura abaixo:
234
235
Mobilidade
A mobilidade vem crescendo muito para integrar com aplicações

corporativas existentes nas empresas e no mundo. Hoje em dia é possível
desenvolver aplicações para rodar em telefones celulares, Pocket PC,
Tablet PC, notebooks e demais dispositivos móveis existentes no mercado.
No entanto, com o Visual Studio.NET isso se tornou realidade bem
próxima, para não dizer do lado, de qualquer desenvolvedor que tenha no
mínimo de conhecimento da aplicação desenvolvidas no Visual
Studio.NET, principalmente ASP.NET.
Integrar aplicações corporativas torna-se uma necessidade de mercado e a

meta de diversas empresas. A própria estrutura de telefonia celular em
alguns estados do Brasil encontra-se com velocidade satisfatória para
executar aplicações desenvolvidas de integração, fato que a cada ano vem
ficando mais rápida e confiável. É fato que você e eu podemos ser
excelente programador, mas se a comunicação não tiver uma velocidade
suficiente para trazer resultados para sua empresa, sua aplicação não será
um sucesso. Por isso mesmo que temos que investir neste mercado de
telefonia.
O software Windows Móbile foi criado para ser facilmente adaptado a uma
grande variedade de dispositivos de hardware de diversos fabricantes,
operadores móveis e integradores. Para criar uma plataforma com um
conjunto consistente de recursos para uso pelos desenvolvedores, a
plataforma Windows Móbile fornece duas plataformas definidas: o Pocket
PC e o Smartphone baseados no Winodws Móbile. Nessas categorias, a
plataforma Windows Móbile permite a personalização por OEMs e
operadoras, os quais criam dispositivos exclusivos e atraentes para o
mercado. A meta na Microsoft é garantir uma base de conhecimento
consistente para os desenvolvedores de todos esses dispositivos, para que
os aplicativos construídos em um dispositivo e uma plataforma (Pocket PC
236
e Smartphone) funcionem em outro dispositivo com pouca ou nenhuma

modificação.
Existem variações ocasionais nos produtos e nas plataformas que podem

fazer com que os aplicativos tenham comportamentos diferentes entre
alguns dispositivos.
Interface
Quando é criado um menu Smartphone baseado no Windows Móbile 2003,

o sistema operacional adiciona automaticamente aceleradores numéricos ao
menu, como o sistema operacional faz isso automaticamente para você, o
Designed for Windows Móbile Software Application Handbook for
Smartphone especifica que não se deve adicionar números aos menus para
indicar o acelerador do teclado numérico. Essa alteração foi feita na
mudança do Smartphone 2002 para o Smartphone 2003, portanto, os
aplicativos que adicionam aceleradores manualmente obtêm duplicatas na
plataforma 2003.
Arquivos
O Smartphone tem um armazenamento persistente e volátil. O

armazenamento é reiniciado cada vez que é desligado o telefone. Os dados
que precisam ser mantidos quando o telefone é desligado são salvos no
armazenamento persistente. O armazenamento persistente é montado como
um diretório fora da raiz do software Windows Móbile 2003 para
Smartphone e do software Windows Móbile 2003 Segunda Edição para
Smartphone.
No Smartphone 2003, o local padrão é geralmente “Armazenamento”. Para
que o seu aplicativo possa sempre detectar o caminho do armazenamento
237
correto, você utiliza API SHGetSpecialFolderPath para determinar locais

comuns de armazenamento, como Meus Documentos.
O nome dos locais da placa de armazenamento nos dispositivos
Smartphone e Pocket PC pode variar entre os fabricantes. Como um
dispositivo pode ter varias placas de armazenamento com vários nomes, seu
aplicativo não pode pressupor a nomeação ou o caminho de uma placa
específica. Use as funções FindFirstFlashCard e FindNextFlashCard para
permitir a enumeração por programação das placas de armazenamento.
Instalação de alguns dispositivos Smartphone
Os Smartphones baseados no Windows Móbile possuem um modelo de

segurança de aplicativo que pode ser configurado pelo fabricandte do
dispositivo ou pela operadora móvel. Esse modelo de segurança é discutido
em detalhes em A Practical Guide to the Smartphone Application Security
and Code Signing Model for Developers (em inglês).
Além das configurações de segurança padrão recomendadas pelo
Microsoft, o modelo de segurança do Smartphone permite que uma
operador móvel ou um fabricante de dispositivos proteja seus bens
personalizando o dispositivo. Na maioria dos casos, é necessário apenas
verificar as configurações de segurança padrão de cada operadora para
compreender o nível de assinatura necessário para instalar e executar
aplicativos em seu dispositivo. Não se esqueça de que as tentativas de
modificar áreas protegidas do Registro ou dados do dispositivo durante a
instalação ou execução de aplicativos poderão ser negadas. Por causa da
natureza transacional da instalação do Smartphone, uma tentativa de
modificar uma chave do Registro protegida pode causar a falha da
instalação. Por exemplo, alguns telefones Samsung i600 inicialmente
protegiam a chave do Registro HKCR, o que causava algumas falhas de
instalação dos aplicativos que tentavam registrar uma associação de
238
arquivos sob a chave HKCR. A Samsung liberou um patch para expor essa
chave.
Problemas do dispositivo
O aplicativo é encerrado pelo Sistema
A plataforma Windows Móbile foi desenvolvida para ser executada em

dispositivos com pouca memória. No todo, é preciso garantir a alocação
bem-sucedida da memória antes de usá-las. Na solicitação, seja através de
malloc() ou do uso do operador new.
Se isso não for feito, poderá ocorrer uma tentativa de uso de memória que
não está alocada para você, o que causará uma violação de acesso.
Os dispositivos são fornecidos com configurações diferentes de memória

interna e disponível no primeiro uso. Quando o espaço de armazenamento
torna-se criticamente baixo, os aplicativos que gravam dados no
armazenamento e as novas instalações podem começar a falhar. Se o seu
aplicativo for afetado por uma dessas condições, não se esqueça de
verificar a memória e o armazenamento disponível no dispositivo de teste.
Se o aplicativo tiver requisitos de memória mais rigorosos, talvez seja
conveniente verificar a quantidade de memória disponível durante a
instalação e aconselho a desinstalar os softwares não utilizados.
Para verificar a memória e o armazenamento em dispositivos do Pocket PC,

toque em iniciar, configurações e memória.
Para verificar a memória e o armazenamento em dispositivos Smartphone,

toque em programas, configurações e sobre.
239
Outro fato que pode influenciar a memória disponível para os aplicativos é

o espaço de memória “endereçável”. O espaço de memória endereçável é o
mapeamento lógico de memória ao qual os processos, componentes
executáveis e a memória alocada devem se ajustar para serem executados.
O espaço de memória endereçável pode colaborar para vários problemas de
memória, pois pode haver uma grande quantidade de memória disponível
no sistema e, mesmo assim, a área de memória endereçável pode estar
esgotada.
O sistema operacional Windows CE, no qual é baseado o software

Windows Móbile, também compartilha áreas de memória endereçável
quando você carrega as DLLs para preservar memória entre os processos. É
importante entender primeiro a forma como o sistema operacional lida com
a memória.
Segurança
Uso de RAPI no Smartphone
O uso de APIs RAPI proporciona uma maneira conveniente de acessar

recursos de dispositivos a partir de um computador desktop. O modelo de
segurança do Smartphone pode ser configurado para proibir e restringir o
uso da RAPI. O Smartphone usa uma diretiva de segurança de RAPI (4097)
que pode ser configurada para permitir ou proibir a RAPI completamente
ou para permiti-la sob uma função restrita (SECROLE_USER_AUTH).
Se a RAPI for configurada para execução sob uma função restrita, você não
terá acesso a alguns tipos de chamados proibidos: CeMountDBVol e
CeRapiInvoke. Os dispositivos Smartphone podem ser configurados para
permitir todos os tipos de chamada de RAPI, mas cabe a operadora móvel,
ou ao fabricante do dispositivo definir essa diretiva ao construir o disposito.
240
Ao contrário do Smartphone, as plataformas de Pocket PC até a 2003

Second Edition não oferecem suporte à assinatura de executáveis. Se você
assinar um aplicativo para Pocket PC em alguma dessas plataformas, ela
relatará que o aplicativo está corrompido. Esse suporte será oferecido nas
futuras implementações da plataforma.
Hardware
Atualmente, a Microsoft exige dos fabricantes a implementação de um pad

direcional de cinco direções em dispositivos do sistema operacional
Windows Móbile. Alguns fabricantes superaram as exigências básicas
fornecendo pads de controles avançados.
Os pads direcionais de oito direções não são incomuns. É preciso lembrar
que, embora os dispositivos avançados ofereçam mais recursos aos
aplicativos, talvez nem todos os dispositivos disponíveis no mercado
ofereçam suporte a esses recursos.
Os aplicativos devem ser desenvolvidas para funcionar bem em relação às
especificações de hardware básicas, de forma a fornecer a melhor
experiência ao usuário e oferecer amplo suporte ao dispositivo.
Conexão com a Internet
Quando mudam a plataforma Windows Móbile 2002 para o Windows

Móbile 2003, as postagens HTTP superiores a 16 KB podem falhar. Após a
postagem de 16 KB de dados, as transações podem atingir o tempo limite e
relatar um erro. Para controlar esse problema, divida os dados em partes
pequenas, inferiores a 16 KB.
241
As paginas Web tem uma aparência diferente no dispositivo 2003 porque o

Microsoft Pocket Internet Explorer redimensiona automaticamente alguns
tipos de conteúdo da Web para melhorar a exibição dentro da área do
navegador. Esse recurso de redimensionamento é uma alteração feita em
relação à plataforma 2002. Se você aperfeiçoou seu conteúdo para
dispositivos moveis e deseja desativar o redimensionamento automático,
use a seguinte marca META:
<meta name = “MobileOptimized” content=”240”>
As imagens dos controles HTML do Pocket PC 2002 não eram exibidas

corretamente mas, no Pocket PC 2003 já foi arrumado.
No Pocket 2002, o arquivo apontado pela marca IMG SRC será transferido
em seu estado atual para o estado de manipulador de notificação
NM_INLINE_IMAGE.
Por exemplo:
“arquivo://\\Meus documentos\\logo.bmp” será transferido em seu estado
atual, se qualquer modificação, para o manipulado WM_NOTIFY.
No Pocket PC 2003, o controle altera a URL para “arquivo:///Meus

documentos/logo.bmp”. Se você estiver acostumado a lidar com a imagem
em seu aplicativo, a sequência de caracteres NM_HTMLVIEW::szTarget
deverá ser convertida corretamente para carregar a imagem.
Se você estiver usando MFC e quiser personalizar a manipulação das
imagens, no Pocket PC 2002, teria que retornar um valor diferente de zero
no manipulador NM_INLINE_IMAGE. A plataforma 2002 tambem ignora
o valor no terceiro parâmetro de OnNotify. Na plataforma 2003, defina o
parâmetro LRESULT de OnNotify como um valor diferente de zero para
informar ao controle que você mesmo já manipulou o evento. Observe que,
em ambas as plataformas, é preciso enviar DTM_SETIMAGE e também
retornar um valor diferente de zero do manipulador de notificação.
242
Depois de alguns conceitos e dúvidas, irei agora desenvolver o primeiro

aplicativo móbile para usar em qualquer dispositivo móvel sem precisar
instalar nada no dispositivo.
Estarei explicando mais a frente sobre o software, veja no próximo
capítulo.
243
Primeiro Aplicativo Móbile
Nesse primeiro aplicativo, estarei desenvolvendo um software para

qualquer dispositivo móvel. Não irá precisar instalar nada no dispositivo,
nem mesmo fazer sincronize. A única coisa que dispositivo terá que ter é
conexão com a internet, ou seja, qualquer aparelho que tiver conexão com a
internet poderá usar esse software que estarei mostrando e fazendo a vocês
logo abaixo.
Todo aplicativo estará na Internet ou será publicado na internet para o uso
de todos.
Requisitos para desenvolvimento do Sistema:
Instalação do Visual Studio.NET 2003;

FrameWork 1.1;
Linguagem de desenvolvimento C#.NET;
Banco de Dados MYSQL versão 4.016;
Tecnologia para desenvolvimento, ASP.NET.
Emulador:
Estou usando dois emuladores. Um chamado OpenWave SDK 6.2.2 e
outro da Microsoft chamado Microsoft Mobile Explorer 3.0.
Os dois emuladores podem ser pegos no site www.aspneti.com.br.
Antes de começar o desenvolvimento do mesmo, gostaria de informar que

esse software já se encontra disponível para uso seguinte endereço:
www.aspneti.com.br/todosartigos.aspx
Acesse e veja com o seu celular ou outro dispositivo todo sistema em

funcionamento.
244
Funcionalidade do Sistema:
Será um sistema de controle financeiro;

Terá dois tipos de módulos, cadastro e relatório;
Cadastro:
O sistema cadastra os usuários para acesso.
O sistema cadastra a despesa do usuário cadastrado.
Relatório:
O sistema gera relatório de acordo com os parâmetros informados pelo
usuário.
O sistema só mostra para o usuário os movimentos do próprio.
Vamos começar então a desenvolver o aplicativo.

A apostila estará mostrando a funcionalidade bem clara a você, leitor. O
mesmo será bem ilustrativo para que entenda tudo que estás a fazer.
Instalando o MYSQL
Para instalar o banco de dados MYSQL, primeiramente deve-se fazer

download no site www.mysql.org. Estou usando a versão 4.016 do
MYSQL. Depois que baixei o banco de dados, descompactei e irei clicar no
arquivo SETUP.EXE. Clicando no arquivo para instalação, apareceu uma
tela verde para avançar com a palavra NEXT. Na mesma tela existem
algumas informações do software, por favor, leia, nunca deixe de ler
nenhuma informação de qualquer software, ele pode sempre te ajudar.
245
Referência: 2-2
Na próxima tela existem apenas mais informações sobre o sistema e o

banco de dados MYSQL.
246
Referência: 2-3
Depois de clicar no botão NEXT, o sistema informa apenas o caminho onde

vai ser instalado todo o sistema. Esse diretório c:\mysql é padrão do
sistema. Não é bom, ou melhor, não mude o caminho do sistema, talvez o
banco de dados não funcione direito por causa do diretório.
247
Referência: 2-4
Na próxima tela, irei escolher o tipo de instalação irei querer instalar no

meu computador ou no servidor. Geralmente escolho a opção Typical, onde
é instalado tudo que preciso.
248
Referência: 2-5
Clicando no botão NEXT, o sistema será instalado com todos os arquivos e

executáveis, dentro do diretório escolhido anteriormente. A instalação do
banco de dados é bem simples e rápida.
249
Referência: 2-6
Agora sim, todo sistema foi instalado com sucesso e sem erro na hora da
instalação. Clique no botão FINISH, para terminar e fechar o setup. Foi
bem rápido e pratico instalar o MYSQL.
250
Referência: 2-7
Se está pensando que acabou, está correto, acabou de instalar o banco de

dados, porem o mesmo não possui um enterprise manager, ou seja, uma
ferramenta de gerenciamento do banco de dados. Para compreender melhor,
o banco de dados SQL SERVER possui um gerenciador já na instalação.
Agora irei instalar o programa para gerenciamento do MYSQL chamado
MYSQL-Front.
Irei mostrar passo a passo de como instalar.
Instalando o Gerenciador de Banco de Dados
Irei agora instalar o MYSQL Front para gerenciar o banco de dados

MYSQL. O mesmo pode ser baixado no site www.aspneti.com.br.
Depois de baixar o programa no site acima, clique no setup.exe, veja abaixo
a primeira tela:
251
Referência: 2-8
Na figura 2-9, mostra apenas a versão do gerenciador e informações do
software.
Referência: 2-9
A próxima figura, ou seja, de referência 2-10, como o nome diz, mostra

apenas a licença do produto, por favor, leia sobre o sistema e sua licença.
Tudo que se diz para computador é bom ler antes de clicar OK, ou
CANCEL ou SIM.
252
Referência: 2-10
A figura 2-11 mostra apenas o local onde irão ser instalados todos os
arquivos, pode ser mudado tranquilamente o diretório e não ocorrerá
nenhum problema em relação ao funcionamento do software. Existem
softwares que funciona apenas instalando no diretório default, nesse caso se
for mudado funcionará corretamente todo software.
253
Referência: 2-11
Referência: 2-12
254
Na figura 2-13, cria um ícone na tela principal do seu computador ou

servidor e associa todo o SQL Script do servidor ou do computador fazendo
abrir o mysql front.
Referência: 2-13
255
Referência: 2-14
A figura 2-15 mostra mais informações sobre todo o sistema. Por favor, leia
toda informação.
256
Referência: 2-15
Referência: 2-16
257
Clique no ícone que foi criado na sua tela. O sistema abrirá o software e
pedirá um usuário, senha e servidor. Use o servidor localhost, usuário root e
senha em branco mesmo, dessa forma estará logando no servidor local de
banco de dados MySQL. Veja a figura 2-17.
Referência: 2-17
Praticando
Irei começar a mostrar primeiramente a base de dados. Lembre-se, estou

fazendo com banco de dados MYSQL. Veja a figura abaixo depois veja a
especificação de cada tabela.
258
Referência 2-18
Essa tabela criada é para cadastrar os usuários. 2-18. Note que existem
campos e campos nessa tabela. Veja a especificação abaixo:
Banco de Dados: BD_MOBILE
Tabela: TB_USUARIO_CELULAR
Campos:
ch_usu (int) – chave do usuário (cria automaticamente)
no_usu (varchar 255) – nome do usuário que cadastrar
email_usu (varchar 255) – e-mail do usuário cadastrado
dt_usu (date) – data que o usuário cadastrou para controle
pw_usu (varchar 255) – senha do usuário criptografada, na figura veja que
a mesma está criptografada.
Segue abaixo figura de outra tabela do banco de dados do sistema.
259
Referência: 2-19
Essa tabela finanças é para cadastrar os tipos de despesas ou receitas de

cada usuário que usar o sistema. As especificações abaixo, é da figura ref.:
figuras finanças.
Banco de Dados: BD_MOBILE
Tabela: TB_FINANCAS
Campos:
ch_fin (int) – chave da tabela de finanças
tp_fin (int) – tipo de lançamento (1 – despesas, 2 – receita)
desc_fin (varchar 255) – descrição do lançamento
val_fin (decimal 10,0) – valor do lançamento
per_fin (varchar 255) – período de lançamento (ex.: 2005/04)
260
ch_usu (int) – chave do usuário para o relacionamento

dt_fin (date) – data do lançamento
Pronto, agora que o banco de dados foi criado junto com as suas respectivas
tabelas e campos, irei começar a programar.
Para lembra, estou usando o Visual Studio.NET 2003.
Referência: 2-20
Na figura 2-20, estou mostrando os passos para criar o projeto para o

dispositivo móvel.
Inicie o Visual Studio.NET 2003 e acesse: FILE / NEW / PROJECT ...
261
Referência: 2-21
Na figura 2-21, estou apenas escolhendo a tecnologia a ser usada, junto

com a linguagem. No Visual Studio.NET 2003, posso escolher apenas uma
linguagem por projeto, portanto se for escolher outra linguagem, é
necessário criar outro tipo de projeto ou outro projeto. Isso no Visual
Studio.NET 2005 Beta II já está diferente, agora pode ter dois ou mais tipo
de linguagens dentro de um mesmo projeto. Sinceramente, melhora muito
para o desenvolvedor.
Escolha o nome do projeto como na figura 2-21 com o nome:
MobileCelular.
Escolhi a linguagem do projeto como C#.NET. Essa questão de linguagem,

qual escolher? qual é a melhor ?, é melhor discutida no fórum da Microsoft
www.msdnbrasil.com.br, vejo essa questão de linguagem como gosto, e
gosto cada pessoa tem um diferente. Quando decidi trabalhar com .NET,
262
escolhi para estudar profundo mesmo, a linguagem C#.NET, por isso todas
as apostilas ou projetos criados por mim, será em C#.NET.
Voltando ao projeto MobileCelular, clique OK, para criar o projeto na sua

máquina e no servidor de aplicação, IIS automaticamente.
Depois do projeto criado, tire a página .ASPX que vem criada como default
no projeto. Deixe o projeto de acordo com a figura 2-22.
Referência: 2-22
Depois de tirado a formulário ou página padrão que vem no sistema, clique

com o botão direito em cima do nome do projeto, posicione o mouse na
opção ADD, logo após Add New Item .... Figura de ilustração: 2-23
263
Referência: 2-23
Escolha o item MobileWebForm e digite o nome default.aspx. O

MobileWebForum está na terceira opção do lado direito. Figura ilustrativa:
Referência 2-24
264
Referência: 2-24
O sistema que estarei criando, terá apenas uma página chamada

default.aspx. Criarei vários forms dentro de uma página só. Um pouco
diferente do ASP.NET, cujo tenho um formulário por página criada. O
objeto móbile aceita colocar vários forms dentro de uma página.
Abrir a página que acabei de criar, abri a barra de ferramentas chamada

toolbox, lá procurei o objeto form. Clico e arrasto paga a tela, tendo assim o
meu primeiro form.
Figura ilustrada de referência: 2-25
265
Referência: 2-25
O primeiro form que estarei criando, será de login, ou seja, o usuário

colocará o e-mail e senha para logar e entrar no sistema.
Veja a característica do form criado:
Configuração do form
Id = frmLogin
Title= Logar no Sistema
Font = Trebuchet MS
Dentro do form terá 7 objetos de tela. Todos os objetos estão na barra de

ferramentas, falada acima. Estarei mostrando cada objeto logo abaixo,
favor colocar os mesmos objetos dentro do form.
Todos os objetos da barra de ferramentas é só clicar e arrastar para dentro
do form.
266
Objetos do Form frmLogin

Label
Id = lblEmail
Text = E-mail:
TextBox
Id = txtEmail
Label
Id = lblSenha
Text = Senha:
TextBox
Id = txtSenha
Password = True
Command
Id = cmdLogar
Text = Logar
Format = Link
Label
Id = lblResultado
ForeColor= Red
Text = (em branco)
Command
Id = lnkCadastro
Text = Novo Usuário ?
Format = Link
267
Todos os objetos do form foram citados acima. Veja a figura de referência

2-26 e veja como deve ficar o que foi falado acima.
Referência: 2-26
Clicando uma vez dentro do form, você pode escrever qualquer coisa
dentro. O texto Sistema de Gerenciamento Financeiro, foi colocado apenas
clicando uma vez e digitando normalmente. Depois de digitar clicar
ENTER para deixar um espaço legal.
O meu próximo passo é fazer a conexão com o banco de dados e os

componentes para inserir e verificar usuário e senha. Estarei criando uma
pasta chamada componentes e estarei colocando todas as classes dentro.
Não esqueça, todas as classes tem apenas arquivos de extensão .cs. Veja a
figura de referência: 2-27.
Nessa figura abaixo, estou apenas ensinando como fazer uma pasta dentro
do projeto.
268
Referência: 2-27
269
Referência: 2-28
Na figura 2-28, mostro apenas a renomeação da pasta dentro do projeto,

bem simples mesmo.
Dentro desta pasta, terá todas as classes do sistema, podendo assim
centralizar todos os principais objetos e classes dentro de uma mesma
pasta.
Inserindo Classe para Conexão com o Banco de Dados
Neste mesmo capítulo mais acima, expliquei como instalar o banco de

dados MYSQL e todos os objetos para o funcionamento correto da
aplicação para conexão com o banco de dados. Passando do pressuposto
que está tudo correto, irei agora criar a primeira classe de conexão chamada
AcessoBanco.cs dentro da pasta componentes.
270
Clique com o botão direito em cima da pasta componentes, adicione uma

classe .cs para o banco de dados. Estarei escrevendo e explicando todo
código dentro dela. A figura 2-29 mostra ilustradamente como criar a
figura.
Referência: 2-29
Inserindo código da classe abaixo, se não entendeu, não tem problema

estou explicando todo o código mais abaixo.
public OdbcConnection sConn = new OdbcConnection("Driver={MySQL

ODBC 3.51
271
Driver};Server=BSB066666;DataBase=bd_mobile;uid=root;pwd=;option=
3");
/// <summary>
/// Metodo que conecta no banco de dados
/// </summary>
public void conecta()
{
try
{
if (sConn.State==0)
{
sConn.Open();
}
else
{
sConn.Close();
}
}
catch(Exception e)
{
throw new Exception("Banco fora do ar:"+
e.StackTrace.ToString());
}
}
/// <summary>
/// Metodo que desconecta no banco de dados
/// </summary>
public void desconecta()
{
try
{
272
if (sConn.State!=0)
{
sConn.Close();
}
else
{
sConn.Close();
}
}
catch(Exception e)
{
throw new Exception("Banco fora do ar :"+ e.StackTrace);
}
}
Não posso deixar de explicar que essa classe é apenas para acesso ao banco
de dados. Irei analisar linha por linha.
Essa linha de código using System.Data.Odbc; é apenas para importar a
classe de driver para a comunicação. No meu caso estou usando MYSQL
por isso estou usando a classe de ODBC, quando estiver usando outro
banco como o SQL SERVER, estarei usando outra classe para
comunicação.
public OdbcConnection sConn = new OdbcConnection("Driver={MySQL

ODBC 3.51
Driver};Server=BSB066666;DataBase=bd_mobile;uid=root;pwd=;option=
3");
O código acima apenas está definindo a string de conexão, passando o

banco de dados, servidor, usuário e senha. Veja que o servidor não é o
mesmo seu, mas o banco de dados bd_mobile, gostaria de que fosse o
mesmo, inclusive o usuário e senha. Portanto, mude apenas o servidor.
273
Tenho dois métodos dentro dessa classe chamados: conecta() e

desconecta(). Irei mostrar primeiro o método para conectar o banco de
dados.
Analisando o Método para Abrir o Banco de Dados
public void conecta()

{
try
{
if (sConn.State==0)
{
sConn.Open();
} ...
Voltando a algumas páginas atrás, veja que é um método que não retorna
valor, e também não recebe valor algum. É um método público e simples.
Perceba que o mesmo está dentro de um laço de try e catch, o que significa
isso? Significa que, se ocorrer algum erro na hora de abrir a conexão com o
banco de dados, o mesmo irá para o laço catch, mostrando assim o tipo de
erro e a descrição do erro calçado.
if (sConn.State==0)
{
sConn.Open();
}
Analisando o código acima, veja que pergunto primeiramente se o estado

da conexão é igual a (zero). Significa que se a conexão está fechada, então
posso abrir colocando o comando. Para abrir, coloco a variável que criei
chamada sConn, colocando ponto, logo aparecerá as opções do método e o
274
que irei usar é Open() para abrir o banco de dados. Viu que é bem simples
esse método?
catch(Exception e)
{
throw new Exception("Banco fora do ar :"+ e.StackTrace);
}
Essas próximas linhas de código acima, fazem apenas uma coisa. Se na

hora de abrir o banco e dados e der qualquer tipo de erro, o mesmo lança o
erro de código para cima, ou seja, para outra camada de dados, mandando a
mensagem Banco fora do ar + o tipo de erro que ocorreu. Nessa parte pode
ser feito um monte de coisas, como mandar e-mail avisando que o banco de
dados está fora do ar, mandar uma mensagem para o usuário ou
redirecionar para uma página de erro qualquer, existem várias
possibilidades e várias formas de falar que o banco de dados está fora do ar,
arrumando assim mais rápido possível o sistema.
O método para abrir um banco de dados é bem simples e fácil de fazer,
logo logo estarei utilizando a mesma.
Analisando Método para Fechar o Banco de Dados
public void desconecta()

{
try
{
if (sConn.State!=0)
{
sConn.Close();
}
275
As linhas de código acima são bem simples também de ser entendida.

Primeiramente, veja que criei um método do tipo público, que não retorna
valor algum, chamado desconectar, cujo não recebe parâmetro algum. Está
dentro de um laço do try e catch. Dentro do try existe uma condição, essa
condição pergunta apenas se a conexão está diferente de fechada, ou seja,
aberta, estando aberta coloco a variável que criei mais o método Close(),
que serve para fechar a conexão com o banco de dados.
Irá entrar no bloco catch, se der algum tipo de erro na hora de fechar o
banco de dados. Dessa forma, pode se gravar um log ou mandar um e-mail
informando que o erro foi ocorrido e muito mais. Não é diferente do
método para abrir. Não posso esquecer de falar que o erro é lançado para
uma camada acima.
Veja na figura 2-30 como ficou a classe dentro do Visual Studio.NET.
276
Referência: 2-30
Agora sim, com a classe de conexão do banco de dados criada, estarei

criando uma classe para inserir no banco de dados o usuário e senha. Dessa
forma, estarei criando também um form para inserir usuário e senha.
Adicionando Form para Inserir Usuário e Senha no Banco de Dados
Agora, saia da classe e entre na página default.aspx, estarei colocando mais

um form para inserir os dados do usuário. Esse cadastro será bem simples.
Veja na figura 2-31.
277
Referência: 2-31
Veja que na figura 2-31 possui apenas os campos Nome, E-mail e Senha.
Veja abaixo os objetos de tela, estarei detalhando cada um.
Primeiramente, clique no form da barra de ferramentas toolbox e arraste
para a tela. Como já dito antes, todos os objetos de tela estão dentro da
barra de ferramentas.
Label
Id = lblNome
Text = Nome
TextBox
Id = txtNomeCadastro
278
Label
Id = lblEmailUsuarioCadastro
Text = E-mail:
TextBox
Id = txtEmailCadastro
Label
Id = lblSenhaUsuarioCadastro
Text = Senha:
TextBox
Id = txtSenhaCadastro
Text = (em branco)
Password = True
Command
Id = cmdCadastrar
Text = Cadastrar
Format = Link
Label
Id = lblResultadoCadastro
ForeColor = Red
Command
Id = lnkLogar
Text = Logar no Sistema
Format = link
Todos os objetos de tela foram citados acima. O título que coloquei foi
apenas clicando uma vez dentro do form e digitando o texto normalmente.
279
Depois de fazer o form para cadastrar usuário, irei agora criar duas classes,
uma para criptografia de dados e outra para inserir o usuário cadastrado no
banco de dados. Estarei criando essa classe de criptografia para inserir a
senha do usuário criptografada. Nessa classe de criptografia terá apenas
dois métodos.
Criei da mesma forma a classe dentro da pasta de criptografia chamada
Criptografia.cs.
Abra a classe e use o importe abaixo:
Depois de importar a classe que serve para usar objetos de criptografia do

framework 1.1, insira os métodos dentro da classe.

Byte[] IV = new byte[] {0x0012, 0x0034, 0x0056, 0x0078,
0x0090, 0x00AB, 0x00CD, 0x00EF, 0x0013, 0x0045, 0x0099, 0x00AA,
0x0012, 0x0056, 0x0012, 0x0009};
Byte[] key =
System.Text.Encoding.UTF8.GetBytes("dot89000");
/// <summary>
/// ex.: encrypt("valor")
/// </summary>
public string encrypt(string strValor)
{
try
{
280

des.CreateEncryptor(key, IV), CryptoStreamMode.Write);
return Convert.ToBase64String(ms.ToArray());
}
{
return ex.Message;
}
}
/// <summary>
/// ex.: decrypt("valor_criptografado")
/// </summary>
public string decrypt(string strValor)
{
try
{
281
inputByteArray = Convert.FromBase64String(strValor);
System.Text.Encoding encoding = System.Text.Encoding.UTF8;
}
{
return ex.Message;
}
}
Antes de tudo, é colocada uma chave e será sempre usada para criptografar
os dados. Essa key é usada nos dois métodos. O nome que dei para
criptografar é dot89000.
O primeiro método chamado encrypt é passado um valor do tipo string e o
mesmo retornam um valor do tipo string, porém criptografada. Existe um
exemplo em total funcionamento na internet, segue o site:
www.aspneti.com.br, lá terá um link para o sistema que criptografa dados.
O segundo método chamado decrypt é usado toda vez que desejo
descriptografar qualquer dado que está criptografado no banco de dados. O
mesmo só deve ser usado se o método de criptografar dados tiver sido
usado primeiramente. O método para descriptografar dados é um método
do tipo público, que necessita de ser enviado um parâmetro do tipo string e
retorna outro parâmetro do tipo string. Na figura 2-32 mostra como ficará a
classe que acabamos de fazer.
282
Referência: 2-32
Estarei usando esta classe, na hora que for inserir um usuário no banco de
dados.
Criando Classe de Login
O próximo passo será criar uma classe para cadastrar o usuário e senha.
Essa chamará Login. Criei a mesma dentro da pasta padrão que defini
chamada componentes com nome Login.cs.
Depois de criado, primeiramente importei a classe para conectar o driver
com o banco de dados.
283
Esse importe estarei sempre usando quando a classe for comunicar com o
banco de dados. Logo depois, preciso usar as classes que criei
anteriormente. Estarei instanciando a classe de Banco e de Criptografia.
Veja abaixo como:
MobileCelular.componentes.AcessoBanco sBanco = new AcessoBanco();
MobileCelular.componentes.Criptografia sCript = new Criptografia();
Antes de criar método, instanciei as duas classes, criando uma variável para
cada uma das instâncias.
O método que irei criado agora é para cadastrar um usuário, por exemplo,
esse método terá três parâmetros de entrada como nome, senha e senha.
Será um método do tipo público e retornará um objeto do tipo Boolean.
Segue o código abaixo:
/// <summary>
/// Metodo para cadastrar o usuario no sistema
/// </summary>
/// <param name="nome">nome</param>
/// <param name="email">email</param>
/// <param name="senha">senha</param>
/// <returns>Boolean</returns>
public Boolean cadastraUsuario(string nome, string email, string senha)
{
try
{
///criptografando senha para gravar no banco de dados
senha = sCript.encrypt(senha);
///conecta no banco de dados

sBanco.conecta();
284
//monta o sql para inserir no banco

string sql = "insert into tb_usuario_celular (no_usu,
email_usu, pw_usu, dt_usu) values ";
sql += " ('" + nome + "', '" + email + "', '" +
senha + "', '" + DateTime.Now.ToString("yyyy-MM-dd") + "')";
OdbcCommand sqlc = new OdbcCommand(sql,

sBanco.sConn);
return true;
}
catch(Exception e)
{
///se ocorrer algum erro, encapsula e mostra o mesmo na classe de
cima
throw new Exception("erro na classe login :" +
e.StackTrace);
}
finally
{
///terminando a transacao, desconecta do banco de dados
sBanco.desconecta();
}
}
Explicando o método cadastraUsuário.
public Boolean cadastraUsuario(string nome, string email, string senha)
Método público que retorna um valor do tipo Boolean, ou seja, true ou

false, logo após vem o nome do método, passando como parâmetro do tipo
string o nome, email e senha.
285
try
{
///criptografando senha para gravar no banco de dados
senha = sCript.encrypt(senha);

sBanco.conecta();
Continuando o método, o mesmo está dentro de um bloco chamado try,

logo após pego a minha variável senha, atribuo ao nome da variável que
criei chamada sCript, onde está instanciando a classe de criptografia,
colocando (ponto) depois, aparecerá todos os métodos disponíveis da classe
e o que iremos usar será o encrypt. Como já foi dito antes, serve para
criptografar dados. O parâmetro que estou passando para o método de
criptografia é a variável passada no começo do método, ou seja, a variável
senha. Dessa forma, a senha que digitar no formulário, antes de ser inserida
no banco de dados, é primeiramente criptografada, e depois pode ser
inserida no banco de dados. Se quiseres depurar o sistema linha por linha,
verás que a variável será criptografada com grande facilidade, dificultado
assim a ação de Crackers ou invasores.
//monta o sql para inserir no banco

string sql = "insert into tb_usuario_celular (no_usu, email_usu, pw_usu,
dt_usu) values ";
sql += " ('" + nome + "', '" + email + "', '" + senha + "', '" +
DateTime.Now.ToString("yyyy-MM-dd") + "')";
Nas linhas de código acima, estou criando um SQL para inserir no banco de
dados. A tabela do banco que irei criar é a tabela de usuários chamada
tb_usuario_celular, colocando os nomes dos campos que existem na tabela,
passarei os valores que foram passados anteriormente. Veja que existe um
286
campo que não estou passando como parâmetro, mas estou inserindo o
mesmo no banco de dados, chamado dt_usu. Como valor, estou pegando a
data do sistema, ou seja, do servidor que está a aplicação.
OdbcCommand sqlc = new OdbcCommand(sql, sBanco.sConn);

return true;
Depois de criar o SQL para inserir no banco de dados, estarei executando a

mesma pelo objeto ODBCCommand do framework passando o SQL e a
variável do banco de dados criada.
Veja que crei uma variável para ser executada, chamada sqlc, digitando
esse nome e clicando (ponto), aparecerá o método ExecuteNonQuery() para
incluir efetivamente no banco de dados.
O sistema executando corretamente a instrução de inserção no banco de
dados retornará true.
catch(Exception e)
{
///se ocorrer algum erro, encapsula e mostra o mesmo na classe de cima
throw new Exception("erro na classe login :" + e.StackTrace);
}
finally
{
///terminando a transacao, desconecta do banco de dados
}
287
O sistema entrará no bloco catch se ocorrer algum erro na hora de executar

a instrução. O mesmo captura o erro gerado e lança para a camada acima,
informando que existe algum erro na classe de login concatenado com o
erro. O throw new que lança para cima o erro.
Seguindo com o código, o mesmo sempre entrará no bloco finally.

Significa que se o sistema ocorrer algum tipo de erro ou não, passará pelo
bloco finally. Como se fosse finalizando o método.
Veja a figura de ilustração abaixo:
Referência: 2-33
Depurando código criado
Primeiramente aperte F5 para depurar todo sistema.

Estarei depurando o sistema no emulador da Microsoft chamado Microsoft
Mobile Explorer 3.0. Veja a figura abaixo:
288
Referência: 2-34
Primeiramente coloquei o endereço do seu servidor no emulador e aperte

ENTER para acessar. http://localhost/mobilecelular.
Se estiver achando um pouco estranho, imagine que o seu emulador seja
um brownser, ou seja, um Internet Explorer, Mozilla ou FireFox. Agora sim
irei ver se o seu código ou meu código está funcionando corretamente.
Clique no botão novo dentro do emulador e cadastre-se normalmente. Veja
na figura 2-35.
289
Referência: 2-35
Depois que preenchi todos os campos, cliquei no botão cadastrar, veja o

resultado dentro do emulador na figura 2-36.
290
Referência: 2-36
Pronto, simples e fácil. O usuário foi cadastrado com sucesso no sistema

pelo celular. Estarei mostrando como ficou no banco de dados o cadastro,
veja na figura 2-37. Não esqueça que nos tópicos acima da apostila, ensinei
como instalar o MYSQL-front e o banco de dados MYSQL.
291
Referência: 2-37
292
Criando Método para Logar no Sistema
Depois de criar o método para cadastrar o usuário com senha criptografada

no banco de dados, agora tenho que criar um outro form para logar no
sistema e poder usar todas as funcionalidades do mesmo. Dentro da classe
Login.cs criada anteriormente, estarei criando outro método chamado logar
passando o usuário e senha como parâmetros.
Saiba que no banco de dados a senha foi grava criptografada, como

mostrado na figura de referência banco de dados cadastrado do capítulo
anterior. Portanto terei que, criptografar a senha antes mesmo de passar
para o banco de dados, comparando assim as strings criptografadas. Vamos
a luta agora.
Antes de tudo, para verificar se o usuário e senha são válidos, deve-se fazer
um select no banco de dados, dentro da tabela chamada tb_usuario_celular.
O método ser do tipo público, retornará um objeto DataSet e passará dois
tipos de parâmetros string.
public DataSet logar(string email, string senha)

{
try
{
sBanco.conecta();
//monta o sql para a selecao

string sql = "select ch_usu, no_usu,
email_usu, dt_usu from tb_usuario_celular ";
sql += " where email_usu = '" + email + "' and
pw_usu = '" + senha + "'";
293
///gera o dataset
///gera o dataadapter preenchendo o mesmo

OdbcDataAdapter dtAdapter = new
OdbcDataAdapter(sql,sBanco.sConn);
///preenche o dataset
///retorna o dataset
return dtSet;
}
catch(Exception e)
{
///se ocorrer algum erro, encapsula e mostra o
mesmo na classe de cima
throw new Exception("erro na classe login :"
+ e.StackTrace);
}
finally
{
///terminando a transacao, desconecta do
banco de dados
}
}
O código é bem simples e fácil de entender. Leia os comentários em cada

linha criados por mim. Estarei explicando mais abaixo sobre esse método,
antes de fazer o form para acessar pelo emulador.
294
Explicação do Método Logar
Sobre o método criado acima já tinha falando anteriormente, porém estarei

explicando novamente. É um método do tipo público, retorna um objeto
DataSet, e espera dois parâmetros do tipo string, um chamado email e outro
chamado senha. Lembre-se que antes de enviar o parâmetro senha, o
mesmo deve ser criptografado.
Estou colocando try e catch, se ocorrer algum erro dentro do sistema o
mesmo sabe para onde ir e lançar o erro. Dentro do bloco try, estou
primeiramente conectando ao banco de dados com o método conecta(), da
classe AcessoBanco.
Logo em seguida estou criei uma string chamada sql para montar a seleção
para ser enviada para o banco de dados.
string sql = "select ch_usu, no_usu, email_usu, dt_usu from

tb_usuario_celular ";
sql += " where email_usu = '" + email + "' and pw_usu = '" + senha + "'";
Esse select é montado e comparado com o campo email_usu e com o

campo pw_usu. Dentro da condição que é feito isso, na parte do sql where.
Logo após estou criando um objeto DataSet, mais abaixo um objeto
DataAdapter passando como parâmetros a string sql e o objeto do banco de
dados. Para preencher o DataSet faço a seguinte linha de código:
ObjetoDataAdapter.Fill(Passando o DataSet);
A forma que estou fazendo no meu é o seguinte:
Depois do DataSet preenchido posso retorná-lo com da seguinte forma:
return dtSet;
295
Não esqueça que é um objeto que está sendo retornada. Nele, existem
dados para preencher outro objeto de tela.
Depois da classe criada, estarei desenvolvendo a camada de apresentação,
ou seja, o form do projeto.
Dentro da mesma página default.aspx, estarei criando um outro form para
logar. Clique na barra de ferramentas e arraste para a página falada acima
com as seguintes características: Estarei colocando os objetos em ordem
que está a página, ou seja, coloque os componentes na ordem que estou
descrevendo.
Form
Id = frmLogin
Title= Logar no Sistema
Componentes do form:
Label
Id = lblEmail
Text = E-mail:
TextBox
Id= txtEmail
Label
Id = lblSenha
Text = Senha:
TextBox
Id=txtSenha
Password = True
Command
Id= cmdLogar
Text = Logar
296
Format = Link
Label
Id= lblResultado
ForeColor: red
Command
Id = lbkCadastro
Text = Novo Usuário ?
Format = Link
Veja a figura 2-38.
Referência: 2-38
297
Depois de montar o form para logar, cliquei duas vezes no cmdLogar,

(botão Logar). Isso significa que, quando o usuário ou cliente clicar no link
para logar, o mesmo estará executando as seguintes linhas de código:
private void cmdLogar_Click(object sender, System.EventArgs e)

{
MobileCelular.componentes.Login sLogin = new
MobileCelular.componentes.Login();
DataSet dtSetLogin = sLogin.logar(txtEmail.Text,
sCript.encrypt(txtSenha.Text));
if (dtSetLogin != null)
{
if (dtSetLogin.Tables[0].Rows.Count >0)
{
Session["NomeUsuario"] =
dtSetLogin.Tables[0].Rows[0][1].ToString();
Session["ChaveUsuario"] =
Session["EmailUsuario"] =
limpaCampos();
ActiveForm = frmMenu;
}
else
{
lblResultado.Text = "Email ou Senha
estão inválidos!";
}
}
else
298
{
lblResultado.Text = "Email ou Senha estão
inválidos!";
}
}
Explicando o Código para Logar
Essa parte é bem simples e fácil de entender.

Primeiramente estou instanciando a classe Login, cujo possui o método
logar. Estou instanciando o método Login com o new e criando uma
variável sLogin. Lembra que o método recebe como parâmetro E-mail e
Senha, porém lembre-se também que a senha está criptografada no banco
de dados, com isso, antes de passar tenho que criptografá-la e enviar
criptografada.
No começo da classe default.aspx.cs, instanciei a classe de criptografia para

ser usada em qualquer parte do código desta classe, veja a linha abaixo:
MobileCelular.componentes.Criptografia sCript = new

MobileCelular.componentes.Criptografia();
Depois da classe de criptografia ter sido instanciada, foi criado uma

variável sCript para ser usada mais abaixo, e estarei usando a mesma para
passar o parâmetro para o método logar. Parece que ficou complicado, mas
veja o código abaixo por gentileza.
DataSet dtSetLogin = sLogin.logar(txtEmail.Text,

sCript.encrypt(txtSenha.Text));
No código acima, estou declarando uma variável do tipo DataSet,

igualando a outra variável sLogin para pegar o método logar passando os
parâmetros txtEmail.Text (e-mail digitado) e a senha criptografada, veja
299
que estou chamando o método de criptografia passando a senha que foi

digitada, a volta desse método será uma string criptografada.
Depois de minha variável dtSetLogin ter sido criada, estarei perguntando se
a mesma é diferente de null logo após perguntando se é maior do que zero.
Veja nas linhas abaixo:
if (dtSetLogin != null)
{
if (dtSetLogin.Tables[0].Rows.Count >0)
}
Essa a condição acima for condizente, o sistema estará pegando os dados

do usuário que efetuou o login e gravar em Sessão internamente.
Nome do usuario
Session["NomeUsuario"] = dtSetLogin.Tables[0].Rows[0][1].ToString();
Chave do usuário
Session["ChaveUsuario"] = dtSetLogin.Tables[0].Rows[0][0].ToString();
E-mail do usuário
Session["EmailUsuario"] = dtSetLogin.Tables[0].Rows[0][2].ToString();
limpaCampos();
ActiveForm = frmMenu;
Veja que como pego algum dado do banco de dados:

minha variável dtSetLogin.Tables[0].Rows[0][posição do meu
select].ToString(). A posição do Select campos from tabelas é o número
que é colocado no dataSet. Logo depois estou chamando o método
limpaCampos() e chamando o form frmMenu. Lembre-se que ainda não fiz
esse form. Veja o código explicado acima na figura 2-39.
300
Referência: 2-39
Criando os Form’s Menu do Aplicativo e Cadastro de Finanças
Na mesma página default.aspx irei criar outro tipo de form chamado

frmMenu. Esse menu será para que depois que o usuário logar no sistema,
irá direto para a tela de menu para escolher qualquer opção e lançar os
dados. O menu terá três opções para ser escolhido:
1 – Sair do Sistema
2 – Cadastra Movimento
3 – Relatório Movimento
Esse form terá o visual bem simples e fácil, veja a especificação abaixo do
mesmo:
301
Form
Id = frmMenu
Title = Menu do Sistema
Font = Trebuchet MS
List
Id = listMenu
Decoration = Numbered
Items
Value = 1
Item Text = Sair do Sistema
Value = 2
Item Text = Cadastrar Movimento
Valeu = 3
Item Text = Relatório Movimento
Veja a figura 5-1 para associar os itens citados acima.
302
Referência: 5-1
Cliquei duas vezes no componente de tela chamado List e irei desenvolver

o seguinte código:
private void listMenu_ItemCommand(object sender,

System.Web.UI.MobileControls.ListCommandEventArgs e)
{
switch (Convert.ToInt16(e.ListItem.Value))
{
case 1:
ActiveForm = frmLogin;
break;
case 2:
ActiveForm = frmMovimento;
break;
case 3:
303
ActiveForm = frmRelatorio;
break;
}
}
Explicando o código do frmMenu.
Estou fazendo um switch pegando o valor passado do componente

e.ListItem.Value e verificando. Caso 1, chama o frmLogin, caso 2 chama o
form frmMovimento e caso 3 chama o form frmRelatorio. Bem simples de
entende e de fazer. Conforme o usuário clicar em qualquer opção, o sistema
executa o código mostrado acima.
A figura de ilustração 5-2 mostra como ficou o código dentro da classe:
Referência: 5-2
304
Antes de compilar sua aplicação ou projeto, tire o método limpaCampos()

porque não foi construído ainda, se deixar o build acusará que não existe
este método.
Antes de começar a testar o sistema e o menu que foi criado, crie os forms
que criamos acima, porque senão o mesmo dará um erro falando que o
form não existe.
Crie os forms com os nomes abaixo:

frmMovimento
frmRelatorio
Compile o código indo no Menu / Build / Build Móbile Celular e veja se

existe algum tipo de erro em todo código construído. Não esqueça de
iniciar o servidor de banco de dados MYSQL antes de tentar logar ou testar
o sistema.
Estarei usando o emulador para testar a aplicação. Lembre-se de uma coisa,
se no emulador acontecer algum erro, marque para depurar o código e teste
o mesmo no brownser mesmo, dessa forma verá onde está dando erro e em
qual linha.
305
Referência: 5-3
Depois de digitar o usuário e senha, o mesmo irá redirecionar para a pagina

ou form de menu’s. É mostrado todas as opções que criei no menu, lógico
que ainda não fiz os outros form, porém estarei desenvolvendo nos
capítulos mais a frente. Veja a figura 5-4.
306
Referência: 5-4
Cadastro de Despesas
307
Criarei mais um form para cadastrar as despesas de cada usuário logado.

Lembre-se que o sistema é por usuário logado, tudo que qualquer usuário
for alterar excluir ou cadastrar o sistema irá cadastrar o nome do mesmo no
banco de dados sendo assim identificado. Para cada código construído, terá
uma figura de ilustração para verificar como está sendo feito e testado.
Criei mais um form no arquivo default.aspx chamado frmMovimento.
Veja os atributos e objetos do form relacionados abaixo:

Todos os atributos estão no Toolbox ao lado esquerdo do Visual Studio
.NET.
Label
Id = lblTpMovimento
Text = Tipo Movimento
SelectionList
Id = cmbTpMovimento
SelectType = Radio
Rows = 3
Label
Id = lblDescMovimento
Text = Descrição:
TextBox
Id = txtDescricaoMovimento
Size = 30
Label
Id = lblValMovimento
Text = Valor:
308
TextBox
Id = txtValMovimento
EnableViewState = false
Numeric = true
Label
Id = lblPerMovimento
Text = Período:
TextBox
Id = txtPerMovimento
Size = 20
Command
Id = cmdGravar
Format = link
Text = Gravar
Label
Id = lblResultadoMovimento
StyleReference = error
Font = normal
Command
Id = lnkVoltarCadastro
Text = voltar
Format = link
Veja a figura 5-5 que mostra como ficou o form criado acima.
309
Referência: 5-5
Beleza, depois de criado, o formulário de cadastro de movimento terá todo

o funcionamento, com banco de dados e mais. Antes de tudo, desenvolverei
uma classe chamada Financas.cs , que terá um método chamado
insereFinancas.
Com o botão direito do mouse em cima da pasta componentes para criar a
classe acima. O funcionamento da classe será apenas para cadastrar no
banco de dados os dados informados pelo usuário que estiver operando pelo
celular.
Veja a figura 5-6 mostrando como ficou a classe dentro da pasta

componente.
310
Referência: 5-6
Lembrando do banco de dados, não esquecerei que existe uma tabela

chamada tb_financas. Mostrarei uma figura abaixo todos os atributos da
tabela de finanças. Veja a figura 5-7.
311
Referência: 5-7
Inserirei o método dentro da classe de finanças. Digite o código abaixo:
public Boolean insereFinancas(string tp_fin, string desc_fin,

string val_fin, string per_fin, string ch_usu)
{
try
{
sBanco.conecta();
string sql = "insert into tb_financas (tp_fin,

desc_fin, val_fin, per_fin, ch_usu, dt_fin) values (";
sql += "" + tp_fin + ", '" + desc_fin + "', '" +
val_fin + "', '" + per_fin + "', " + ch_usu + ", '" +
312

OdbcCommand(sql, sBanco.sConn);
return true;
}
catch(Exception e)
{
throw new Exception("erro na classe financas
"+ e.Message);
}
finally
{
}
}
Depois de inserir esse código coloquei as duas linhas a seguir no começo

do código. É para comunicação com o banco de dados.
Mais abaixo explicarei todo código do método criado.
//Drive de comunicação com o banco de dados

//instanciando classe de banco de dados

MobileCelular.componentes.AcessoBanco sBanco = new AcessoBanco();
Explicarei o Método “InsereFinancas” da Classe Financas
313
Primeiro de tudo, é uma classe de retorno Boolean, com cinco parâmetros

para ser enviados. Todos os parâmetros que estou passando é string. Veja a
explicação de cada parâmetro passado abaixo:
Tp_fin = Tipo de finanças, ou seja, pode ser despesa ou receita;
Desc_fin = Descrição de finanças, o usuário irá digitar toda a descrição
como pagamentos, CPMF e outros;
Val_fin = Valor de finanças, ou seja, o valor digitado pelo usuário da
despesa ou receita;
Per_fin = Período de finanças, por exemplo, ano e mês para buscar no
relatório depois, 2005/05;
Ch_usu = Chave do usuário que estará logado no sistema.
Veja a linha explicada acima com os respectivos parâmetros.
public Boolean insereFinancas(string tp_fin, string desc_fin,string val_fin,

string per_fin, string ch_usu)
Continuando a explicação, dentro do bloco try, coloquei tudo que pode dar
erro ou gerar um erro. Primeiramente chamo o método que abre o banco de
dados, depois crio uma string para inserção de valores dentro do banco de
dados. Para montar o sql, deve-se se entender um pouco da linha PLSQL.
Na linha abaixo do SQL, estou usando o ODBCCommand para executar o
próprio SQL, passando a variável de banco de dados sConn. Para executar
a instrução montada, coloco o nome de minha variável (ponto) o
ExecuteNowQuery(). Se ocorrer algum erro na aplicação ou na instrução, o
mesmo é redirecionado para o bloco catch. Se nenhum erro ocorrer, o
método retorna true para o método que o chamou com a linha de código
return true.
Veja como ficou o código dentro do bloco try:

try
{
sBanco.conecta();
314
string sql = "insert into tb_financas (tp_fin,

desc_fin, val_fin, per_fin, ch_usu, dt_fin) values (";
sql += "" + tp_fin + ", '" + desc_fin + "', '" +
val_fin + "', '" + per_fin + "', " + ch_usu + ", '" +

return true;
}
Dentro do bloco catch faço o seguinte:

Jogo para o método que chamou, ou seja, jogo para cima o erro gerado com
o código:
catch(Exception e)
{
throw new Exception("erro na classe financas "+ e.Message);
}
Não posso esquecer de falar do bloco finally.

Esse bloco, mesmo que ocorram erros ou não, coloquei para o meu banco
de dados sempre fechar o banco. Uso o método desconecta() da classe
Banco de dados para desconectar. Veja a linha de código que é colocada
abaixo:
finally
{
}
315
Prontinho, acesse de finanças está pronta para ser usada.

Agora terminarei de desenvolver o form frmMovimento criado
anteriormente dentro da página default.aspx.
Clique duas vezes no objeto cmdGravar e insira o código abaixo:
private void cmdGravar_Click(object sender, System.EventArgs e)

{
MobileCelular.componentes.Financas fin = new
MobileCelular.componentes.Financas();
Boolean bFin =
fin.insereFinancas(cmbTpMovimento.SelectedIndex.ToString(),
txtDescMovimento.Text, txtValMovimento.Text, txtPerMovimento.Text,
Session["ChaveUsuario"].ToString());
if (bFin)
{
lblResultadoMovimento.Text = "Movimento
cadastrado com Sucesso!";
limpaCampos();
}
else
{
lblResultadoMovimento.Text = "Erro ao
cadastrar movimento!";
}
}
Explicando o Código que Insere Finanças
316
Veja que primeiramente que instanciei a classe de finanças que está dentro
de componentes. Depois criei uma variável chamada fin para poder chamar
todos os métodos disponíveis dentro da classe Finanças. Na linha abaixo,
crio uma variável do tipo Boolean chamada bFin, que recebe como
parâmetro a variável criada anteriormente fin. Clico (ponto) e aparecem
todos os métodos disponíveis para uso.
O método que criei foi o insereFinancas, tenho que passar todos os
parâmetros digitados e escolhidos pelo usuário, não esquecendo que a
sessão do usuário deve ser passada também. Veja o código abaixo:

Boolean bFin =
fin.insereFinancas(cmbTpMovimento.SelectedIndex.ToString(),
txtDescMovimento.Text, txtValMovimento.Text, txtPerMovimento.Text,
Session["ChaveUsuario"].ToString());
Lembre-se que, todos os parâmetros do método têm que ser passado. Todos
os parâmetros se relacionam com os campos esperados pelo método. O
último parâmetro chamado Session[“ChaveUsuario”].ToString() é a sessão
do usuário criada quando o mesmo loga no sistema. Preste atenção de como
pego o valor de um objeto de tela radio button. Depois que é executado a
linha acima, apenas verifico se a variável bFin voltou verdadeiro ou falso
para gerar a mensagem para o usuário. Atribuo a mensagem para o label
criado, veja o código.
if (bFin)
{
lblResultadoMovimento.Text = "Movimento
cadastrado com Sucesso!";
limpaCampos();
}
317
else
{
lblResultadoMovimento.Text = "Erro ao
cadastrar movimento!";
}
Se não houver nenhum erro, mando a mensagem e limpo todos os campos

do formulário, pelo contrário não limpo o formulário, para que o usuário
veja os dados digitados.
Veja a figura 5-8.
Referência: 5-8
Coloque no form MENU referenciando o form frmMovimento quando o

usuário clicar em Cadastrar Movimento. Isso já foi mostrado anteriormente,
não esqueça.
318
Compile o código e veja se está tudo certo com o código. Estando tudo
certo, testarei o sistema com o emulador MME da Microsoft. Para compilar
o código use o Visual Studio.NET, menu Build e submenu Build Solution,
ou se preferir use a tecla de atalho CTRL + SHIFT + B. Quando for testar,
não esqueça de iniciar o servidor de banco de dados MYSQL. Depois que
logar, veja a figura 5-9.
Referência: 5-9
319
Clique na opção Cadastrar Movimento e veja a figura 5-10.
Referência: 5-10
Preencha os campos, corretamente e clique no botão Gravar.

Veja a figura 5-11 mostrando como foi gerada a mensagem na tela do
usuário.
320
Referência: 5-11
Não esqueça de verificar no banco de dados, se os dados foram gravados

com sucesso. Veja a figura 5-12.
321
Referência: 5-12
322
Gerando Relatórios de Movimentos
Depois de criar aos forms de login, cadastro e menu, agora irei criar um
form para gerar relatórios de acordo com o período ou descrição do
movimento. Tanto fazer se é receita ou despesa. Irei mostrar primeiramente
como é a tela, veja na figura 6-1.
Referência: 6-1
O form é bem simples e com postos componentes de tela.

Favor coloque o form de acordo com as especificações a seguir:
Form
Id = frmRelatorio
Title = Relatório do Sistema
Font = Trebuchet MS
323
Atenção: antes do text txtDescricaoRel existe apenas uma descrição normal

no form com a frase: Descrição:
TextBox
Id = txtDescricaoRel
Atenção: antes do text txtPeriodoRel existe apenas uma descrição normal

no form com a frase: Descrição:
TextBox
Id = txtPeriodoRel
TextView
Id = txtResultadoRel
Font = Trebuchet MS
Command
Id = cmdGerarRel
Text = Gerar Relatório
Format = Link
Command
Id = lnkVoltar
Text = voltar
Format = Link
Na figura 6-1 adicionei do toolbox, mais um componente cujo não tinha

usado ainda, chamado TextView. O mesmo serve para esse form apenas
para exibir o relatório do banco de dados depois de criado. Usarei um
objeto chamado DataReader para existe os dados no seu celular ou qualquer
dispositivo que acessou o sistema. Veja no próximo tópico.
324
Criando Método de Retorno DataReader
Dentro da classe criada anteriormente chamada Financas.cs, criarei outro

método chamado listaRelatorio, passando alguns parâmetros e retornando
um objeto DataReader. Veja o método abaixo:
public OdbcDataReader listaRelatorio(string descricao, string ch_usu,

string periodo)
{
try
{
sBanco.conecta();
string sql = "select tbf.tp_fin, tbf.desc_fin,

tbf.val_fin, tbf.per_fin ";
sql += " from tb_financas tbf,
tb_usuario_celular tbu ";
sql += " where tbf.ch_usu = tbu.ch_usu and
tbu.ch_usu = " + ch_usu + "";
if (descricao != "")
{
sql += " and tbf.desc_fin like '%" +
descricao + "%'";
}
if (periodo != "")
{
sql += " and tbf.per_fin = '" + periodo
+ "'";
}
325

OdbcDataReader dtReader =
sqlc.ExecuteReader();
return dtReader;
}
catch(Exception e)
{
throw new Exception("erro na classe financas
"+ e.Message);
}
}
Não é um código diferente do que já criei anteriormente. Existem poucas

diferenças e detalhes que se deva prestar um pouco mais de atenção. Os
detalhes importantes sobre esse método são:
A assinatura do método, ou seja, recebe três parâmetros e retorna uma

ODBCDataReader.
Uso o método para conectar no banco de dados e não uso o método para
desconectar. Não posso usá-lo, porque se me desconectar do banco de
dados, não poderei usar o objeto de retorno DataReader. O mesmo apenas
é retornado se a conexão com o banco de dados estiver aberta. Tente usar o
método para desconectar do banco de dados e retornar o objeto, o mesmo
retornará um erro para a tela.
Pelo fato de não estar usando o método para desconectar do banco de
dados, não posso usar o bloco de código finally.
326
Explicando Método ListaRelatorio
A assinatura do método:
public OdbcDataReader listaRelatorio(string descricao, string ch_usu,

string periodo)
Irei agora comparar os parâmetros recebidos com os do form criado na

figura 6-1.
txtDescricaoRel equivale ao parâmetro passado String descricao.
Session["ChaveUsuario"].ToString() equivale ao parâmetro passado
ch_usu.
txtPeriodoRel equivale ao parâmetro passado período do método.
É um método público e que retorna o objeto OdbcDataReader.
Bloco de código try:
try
{
sBanco.conecta();
string sql = "select tbf.tp_fin, tbf.desc_fin,

tbf.val_fin, tbf.per_fin ";
sql += " from tb_financas tbf,
tb_usuario_celular tbu ";
sql += " where tbf.ch_usu = tbu.ch_usu and
tbu.ch_usu = " + ch_usu + "";
{
sql += " and tbf.desc_fin like '%" +
descricao + "%'";
}
327
if (periodo != "")
{
sql += " and tbf.per_fin = '" + periodo
+ "'";
}

sqlc.ExecuteReader();
return dtReader;
}
Dentro do bloco try, conecto no banco de dados, com o método criado no

começo da apostila chamado conecta(). Logo após monto a string sql para
enviar a instrução para o banco de dados processar. Esse SQL montado é
bem simples. Faço apenas um select no banco de dados, dentro das tabelas
tb_financas e tb_usuario_celular, pego todos os campos das tabelas.
{
sql += " and tbf.desc_fin like '%" + descricao + "%'";
}
if (periodo != "")
{
sql += " and tbf.per_fin = '" + periodo + "'";
}
Nas condições (if) acima, apenas pergunto se o valor passado como

(descricao) é diferente de branco (“”), se o mesmo acontecer, ou seja, se for
328
preenchido, o sql é incrementado automaticamente. A mesma condição

faço com parâmetro período, se for preenchido incrementa o sql
automaticamente e manda para o banco de dados executar.
Envia Comandos para o Banco:
OdbcCommand sqlc = new OdbcCommand(sql, sBanco.sConn);

OdbcDataReader dtReader = sqlc.ExecuteReader();
return dtReader;
Instancio a classe OdbcCommand passando o sql criado, junto com o

objeto de conexão do banco de dados instanciado no começo da classe.
Crio uma variável dtReader e executo o sqlc criado anteriormente, usando o
método ExecuteReader(). Logo após executar, retorno o objeto criado
dtReader.
Bloco catch:
catch(Exception e)
{
throw new Exception("erro na classe financas "+ e.Message);
}
Dentro do bloco catch pego a mensagem de erro e lançando para a classe

acima, ou seja, a classe que a chamou. Não esqueça que transformo para
Exception e lanço-a. O sistema entrará nesse bloco, apenas se acontecer
algum erro dentro do bloco try.
Codificando Dentro da Classe default.aspx
329
Depois de criar o método para buscar relatórios, irei programar dentro da

classe default.aspx para chamar o método criado anteriormente. Clique
duas vezes em cima do command cmdGeralRel e insira o código abaixo:
private void cmdGerarRel_Click(object sender, System.EventArgs e)

{
txtResultadoRel.Text = "";

fin.listaRelatorio(txtDescricaoRel.Text,
Session["ChaveUsuario"].ToString(), txtPeriodoRel.Text);
Double valor = 0.0;
if (dtReader.Read())
{
do
{
txtResultadoRel.Text +=
"Descrição:" + dtReader["desc_fin"].ToString();
txtResultadoRel.Text += " 
Tipo:" + dtReader["tp_fin"].ToString();
Valor:" + dtReader["val_fin"].ToString();
Período:" + dtReader["per_fin"].ToString();
txtResultadoRel.Text += " ";
if (dtReader["tp_fin"].ToString() ==
"1")
{
330
valor +=
Convert.ToDouble(dtReader["val_fin"]);
}
else if (dtReader["tp_fin"].ToString()
== "2")
{
valor -=
Convert.ToDouble(dtReader["val_fin"]);
}
}
while (dtReader.Read());
txtResultadoRel.Text += "Total Geral:

R$" + valor.ToString();
MobileCelular.componentes.AcessoBanco
sBanco = new MobileCelular.componentes.AcessoBanco();
dtReader.Close();
}
else
{
txtResultadoRel.Text = "Nenhum movimento
encontrado !";
}
Instanciei o método pegando um objeto e passando todos os parâmetros

necessários para fazer a pesquisa no banco de dados. Logo apenas pergunto
se existem dados retornados e concateno com o meu objeto TextView
chamado txtResultadoRel.Text.
331
Faço um for para mostrar todos os valores disponíveis de retorno. No final

do código, instancio o método para acesso a dados e chamo o método para
desconectar do banco de dados.
Compile o código e acesse-o, não esqueça de iniciar o servidor de banco de
dados MYSQL. Veja a figura 6-2.
Referência: 6-2
Executarei a aplicação pelo MME da Microsoft, ou seja, o emulador da

Microsoft. Acesse o sistema e vá na opção Relatório Movimento. Não
digite nada e clique em pesquisar. Os resultados serão todos os seus
movimentos trazidos na tela. Veja a figura 6-3.
332
Referência: 6-3
Bem, o sistema móbile para web, cujo pode ser acessado de qualquer
dispositivo móvel está pronto. Os próximos capítulos, ensinarei como
desenvolver um aplicativo móvel localmente, ou seja, para um celular. O
sistema não poderá ser acessado por qualquer dispositivo via internet. Esse
tipo de aplicativo é chamado de “aplicativo windows form”.
333
Desenvolvendo Aplicativo para o Pocket Pc
Usando Banco de Dados
Irei utilizar o banco de dados SQL Server Windows CE da Microsoft, junto

do Visual Studio.NET 2003. No endereço abaixo pode ser feito o download
do SQS Server Windows CE, que é para um sistema operacional Windows
CE, isto é, para dispositivos móveis como: celular, pocket e outros...
http://www.microsoft.com/downloads/details.aspx?FamilyID=b9b12312-
fe57-4817-a4bc-69992802732d&DisplayLang=en
É um banco de dados igual ao SQL Server 2000 do sistema operacional

Windows 2000, 2003 Server. Funciona da mesma forma, porém com
algumas particularidades. Esse software deve ser instalado na sua máquina
de desenvolvimento para poder ser usado dentro do seu dispositivo móvel.
Não preocupe de como instalar o SQL Server CE no dispositivo móvel,
preocupe em instalar no computador ou pc, na hora de fazer o deploy o
mesmo será instalado com sucesso no seu dispositivo.
Criando Projeto do Tipo Smart Device Application
Criei um novo projeto no Visual Studio.NET 2003 dentro de uma pasta

SmartLivro, o projeto chama-se Sistema. Criando esse tipo de projeto, o
mesmo é designado para funcionar apenas em dispositivos móveis. Veja a
figura 7-1.
334
Referência: 7-1
Após criar o projeto, o Visual Studio.NET criará automaticamente um

formulário chamado Form1.cs. Lembre-se que o sistema é em C#.NET
(CSharp). Não apague o formulário e acrescente apenas alguns objetos. Os
mesmos estarão relacionados logo abaixo:
Form1.cs
Form
Name = Form1
Text = Cadastro
Label
Name = label1
Text = Cadastro
TextBox
335
Name = txtUsuario
Label
Name = label2
Text = E-mail:
TextBox
Name = txtEmail
Button
Text = Cadastrar
Name = cmdCadastrar
Label
Name = lblResultado
ForeColor = Red
Veja a figura 7-2.
336
Referência: 7-2
O sistema usando banco de dados SQL Server CE é bem simples e fácil de

desenvolver. Usarei OO no Visual Studio.NET, criei uma classe chamada
Banco.cs para conectar no banco de dados. Criei uma classe chamada
Insere.cs para inserir no banco de dados os valores passados, no caso nome
e e-mail.
Antes de criar a classe chamada Banco.cs, irei inserir uma referência ao

projeto. Essa referência é de banco de dados chamada
System.Data.SqlServerCe. Para inserir a mesma, basta clicar com o botão
direito em cima da pasta References e ir à opção Add Reference. Veja a
figura 7-3.
337
Referência: 7-3
Criando Classe para Conexão com Banco de Dados SQL Server Ce
Agora em diante irei criar uma classe para conexão com o banco de dados
SQL Server CE. Adicione uma classe chamada Banco.cs em seu projeto. A
mesma não está dentro de nenhuma pasta.
Criei dois métodos dentro da mesma, um chamado conectar() e outro
chamado desconectar().
Analisando o Primeiro Método conectar()
Analisando a assinatura do método, verificamos que o mesmo é público,

não retorna valor e não espera qualquer valor a ser passado.
338

{
sConn.Open();
}
O mesmo apenas abre o banco de dados normalmente, chamando o método

da classe Open().
Analisando o Segundo Método desconectar()
Nesse segundo método da classe Banco.cs, é bem simples também.

Analisando a assinatura do mesmo, vemos que é público, não retorna valor
(void), e não passa ou espera qualquer valor.

{
sConn.Close();
}
O desconectar() só usa o método da classe Sql chamado Close() para fechar

o banco de dados.
Veja a figura 7-4.
339
Referência: 7-4
Analisando o código de toda classe Banco.cs
Veja todo o código abaixo:
using System;
using System.Drawing;
using System.Data;
using System.Data.Common;
using System.Data.SqlServerCe;
using System.IO;
namespace Sistema
{
/// <summary>
/// Classe que conecta no banco de dados
340
/// </summary>
public class Banco
{
/// String de conexão do banco
public SqlCeConnection sConn = new
SqlCeConnection(@"Data Source=\My Documents\BD_Usuario.sdf");

{
sConn.Open();
}

{
sConn.Close();
}
}
}
Veja que primeiro importei algumas classe do framework 1.1 da Microsoft.

Não podendo esquecer desta classe: using System.Data.SqlServerCe; que é
responsável para conectar ao banco de dados dentro do pocket pc.
A string de conexão que vem logo em seguida é bem prática e simples de
entendimento.
public SqlCeConnection sConn = new SqlCeConnection(@"Data

Source=\My Documents\BD_Usuario.sdf");
Estou passando o local de onde estará o banco de dados dentro do

dispositivo móvel. O nome do banco de dados será BD_Usuario.sdf.
341
Dica C#.NET:
Para quem está usando C#.NET para desenvolver a aplicação, não esqueça
de usar o @ antes do Data Source da string de conexão. Sem usar o mesmo,
a string dará um erro. A mesma pode ser vista no fórum do site
www.aspneti.com.br/forum.
Compile o código e veja que não ocorreu nenhum erro na classe.
Criando Classe de Inserção de Valores
Criei uma classe chamada Insere.cs dentro de meu projeto. Ela será
responsável para inserir os valores digitados pelo cliente no banco de dados
do dispositivo móvel. Nesta classe, irei instanciar a classe Banco.cs criada
anteriormente. Na Insere.cs terás apenas um método chamado
cadastraUsuario(string usuario,string email).
public Boolean cadastraUsuario(string usuario, string email)
Analisando o método, vejamos que é público, retorna valor do tipo

Boolean, ou seja, true / false, e esperam valores como parâmetros do tipo
string. Veja a figura 7-5.
342
Referência: 7-5
Segue o código fonte de toda classe abaixo:
using System;
using System.Data.SqlServerCe;
using System.Data;
namespace Sistema
{
/// <summary>
/// Classe que insere valores no banco de dados
/// </summary>
public class Insere
{
Banco sBanco = new Banco();
343
public Boolean cadastraUsuario(string usuario, string email)

{
try
{
sBanco.conectar();

email_usu) values ('" + usuario + "', '" + email + "')";
SqlCeCommand sqlc = new
SqlCeCommand(sql,sBanco.sConn);
return true;
}
catch(Exception e)
{
throw new Exception("erro na insercao" +
e.Message);
//return false;
}
finally
{
}
}
}
}
Explicação do código acima:
Antes de tudo, veja que importei as classes responsáveis para utilizar o

banco de dados Sql Server CE. Lodo depois, dentro da classe, instancio a
classe de banco de dados da seguinte forma:
344
Banco sBanco = new Banco();
Colocando a linha acima dessa forma, deixo disponível para uso dentro de
toda classe a minha variável sBanco.
Estou usando os blocos para tratamento de erro try, catch e finally.
Dentro do bloco try estou colocando toda a operação do sistema, abrindo o
banco de dados para depois inserir.
try
{
sBanco.conectar();

email_usu) values ('" + usuario + "', '" + email + "')";
SqlCeCommand sqlc = new
SqlCeCommand(sql,sBanco.sConn);
return true;
}
Utilizo a variável sBanco chamando o método conectar() para abrir o banco

de dados. Monto o meu SQL e armazeno a instrução de insert passando os
valores necessários em minha variável sql.
Para instrução ser executada, inserindo valores no banco de dados é
necessário inserir as seguintes linhas de código:
SqlCeCommand sqlc = new SqlCeCommand(sql,sBanco.sConn);

345
Instancio o método da classe SqlServerCe importada no começo da classe,

chamada SqlCeCommand criando uma nova variável sqlc passando como
parâmetros a instrução criada junto com a variável de banco de dados.
Além disso, preciso executar a variável sqlc chamando o método
ExecuteNonQuery().
Se for tudo executado com sucesso, a classe retorna true com a linha de
código return true.
Dentro dos outros blocos é feito o seguinte:
catch(Exception e)
{
throw new Exception("erro na insercao" + e.Message);
//return false;
}
finally
{
}
No primeiro bloco (catch), o sistema só irá entrar se ocorrer algum tipo de

erro na operação. Com o código throw new Exception, estou apenas
jogando a mensagem de erro para a classe acima, ou seja, que a chamou.
No segundo bloco (finally), é bem interessante e legal de usar. Mesmo que

ocorra algum erro no sistema, ou não ocorra erro, o sistema sempre estará
passando por dentro desse bloco. Toda vez que o sistema passar por ele,
coloquei para desconectar do banco de dados, usando o método da classe
criado anteriormente.
346
Alterando Classe Form1.cs
Até agora, o que fizemos foi apenas criar classes no aplicativo para abrir o
banco de dados e outro para inserir dados. Não foi mexido na classe ou
formulário Form1.cs para enviar os valores para as mesmas. Estarei inserir
agora mesmo, logo abaixo.
Na prática faça o seguinte:

- Clique duas vezes no botão Cadastrar (cmdCadastrar) e insira o código a
seguir.
private void cmdCadastrar_Click(object sender, System.EventArgs e)

{
Insere inserir = new Insere();
Boolean bi = inserir.cadastraUsuario(txtUsuario.Text,
txtEmail.Text);
if (bi)
{
lblResultado.Text = "Cadastrado com sucesso";
}
else
{
lblResultado.Text = "Erro ao cadastrar";
}
}
Explicando código acima:
Primeiramente, instancio a classe insere criada anteriormente. Com ela, crio

uma variável chamada inserir.
347
Insere inserir = new Insere();
Atribuo a uma variável criada do tipo Boolean minha variável criada

(ponto) o nome do método da classe insere, passando os parâmetros
necessários, ou seja, os objetos de tela, chamados txtUsuario e txtEmail.
Boolean bi = inserir.cadastraUsuario(txtUsuario.Text, txtEmail.Text);
Logo depois, verifico a variável bi para enviar a mensagem ao usuário, veja

a linha de código abaixo:
if (bi)
{
lblResultado.Text = "Cadastrado com sucesso";
}
else
{
lblResultado.Text = "Erro ao cadastrar";
}
Apenas pergunto se a variável é verdadeira para lançar a mensagem ao

outro objeto chamado lblResultado a mensagem Cadastrado com sucesso,
se ocorrer algum tipo de erro, ou seja, voltar false, mostro a mensagem Erro
ao cadastrar. De fácil implementação e entendimento.
Veja que construí a aplicação OO (Orientada a Objetos), separando todas as

camadas, tornando assim todas elas independentes uma da outra. Depois da
aplicação toda criada, irei criar o banco de dados dentro do pocket pc. Veja
no próximo sub-tópico.
Criando Banco de Dados no Pocket Pc
348
Antes de tudo no capítulo acima, foi colocado um link para baixar o SQL
Server Ce para instalação no seu micro. Espero que tenha baixado e
instalado para que possa seguir neste capítulo da apostila.
Depois de instalar no micro, clique F5 para executar o Visual Studio.NET,

com isso o mesmo instalará automaticamente o banco de dados no Pocket
Pc.
Logo depois crie um banco dentro do mesmo com o nome BD_Sistema e
com os seguintes campos:
Banco:
BD_Sistema
Tabela:
Tb_usuario
Campos:
Ch_usu (int)
No_usu (nvarchar 100)
Email_usu (nvarchar 50)
Veja a figura 7-6 e compare com a descrição acima:
349
Referência: 7-6
Depois do banco de dados criado dentro do pocket pc, veja que não existem
dados cadastrados dentro dele. Na próxima figura 7-7 mostra os dados
dentro do banco.
Para verificar se existe apenas faça um select normalmente:
Select * from tb_usuario
350
Referência: 7-7
Execute o sistema e insira normalmente os dados no formulário criado

anteriormente. Na figura 7-8 apenas mostra o formulário criado dentro do
pocket pc em funcionamento.
351
Referência: 7-8
Digite os dados no formulário e clique no botão para Cadastrar.

Os dados digitados são mostrados na figura 7-9.
352
Referência: 7-9
Não estranhe com tantas figuras nesta parte da apostila, mostro apenas o
passo a passo mesmo do que foi executado. Na próxima figura mostra que
o sistema foi executado com sucesso e enviou a mensagem para o usuário.
Figura 7-10.
353
Referência: 7-10
Depois dos dados gravados no banco de dados, faça um select na tabela do

banco dentro do pocket pc para ver se foi gravado realmente os dados. A
figura 7-11 mostra como fazer dentro do SQL Server CE.
Select * from tb_usuario
354
Referência: 7-11
Execute o select e clique na aba de grid.

Veja a figura 7-12.
355
Referência: 7-12
356

Curso Prático de Visual

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

Curso Prático de Visual

Enviado por

Direitos autorais:

Formatos disponíveis

Curso Prático de Visual Studio.

Curso Prático de Visual

Autor: Mauricio Junior

Nota sobre direitos autorais:

Este e-book é de autoria de Mauricio Junior, sendo comercializado

Ao adquirir este ebook você tem o direito de lê-lo na tela do seu

Visite periodicamente o site www.juliobattisti.com.br para ficar por dentro

• Simulados gratuitos, em português, para os exames da Microsoft.

• ESTE E-BOOK NÃO PODE SER

• SE VOCÊ OBTEVE UMA CÓPIA DESTE E-

• USAR UMA CÓPIA NÃO AUTORIZADA É

• VOCÊ SÓ PODE USAR ESTE E-BOOK SE

PIRATARIA É CRIME, COM PENA DE CADEIA. EU

SE VOCÊ BAIXOU UMA CÓPIA DESTE ARQUIVO

ESTE ARQUIVO NÃO PODE SER DISTRIBUIDO

SE VOCÊ RECEBEU UMA CÓPIA ILEGAL DESTE

PELOS MEIOS DESCRITOS NO INÍCIO DA

Algumas palavras do autor:

Este curso foi criado com o objetivo de ajudá-lo a entender e a utilizar no

Em cada lição são apresentados conceitos teóricos, seguidos por exemplos

TRABALHANDO COM VISUAL STUDIO.NET .......................................33

PRIMEIRA PÁGINA PARA INICIAR FORMALMENTE ..............................34

ESTUDANDO O ID DOS OBJETOS .....................................................42

FIM DAS SUBS PROPRIEDADES DO FONT. .........................................48

USANDO COMPONENTES DINAMICAMENTE .......................................50

USANDO COMPONENTE DROPDOWNLIST ........................................56

USANDO VERDADEIRAMENTE ORIENTAÇÃO A OBJETOS .......................58

CLIQUE DUAS VEZES NO COMPONENTE CMBOPCOES ..........................61

INSERINDO MAIS UM COMPONENTE (CHEKBOX) ...............................67

INSERINDO MAIS UM COMPONENTE (BUTTON) ..................................70

USANDO O COMPONENTE LISTBOX .................................................77

VALIDANDO CAMPOS DO FORMULÁRIO ...........................................81

ADO.NET CONECTANDO COM MYSQL ...........................................89

VISÃO GERAL DO ADO.NET .........................................................89

CONNECTION: CONEXÃO COM O BANCO DE DADOS .............................90

CRIANDO CLASSE PARA INSERIR NO BANCO DE DADOS ........................97

INSERINDO NO BANCO DE DADOS ..................................................101

USANDO COMPONENTE DATAGRID PARA MOSTRAR DADOS ...............108

INTRODUÇÃO AO WEB SERVICES ..................................................129

ALGUMAS VANTAGENS DE UMA APLICAÇÃO DE WEB SERVICES ..........130

INTEGRAÇÃO DE APLICAÇÕES ......................................................131

COMPUTAÇÃO DISTRUIDA ...........................................................133

ARQUITETURA ORIENTADA A SERVIÇOS .........................................135

REQUISITOR DE SERVIÇO ............................................................135

REGISTRADOR DE SERVIÇO .........................................................135

PILHAS DE INTEROPERABILIDADE ................................................136

EXTENSIBLE MARKUP LANGUAGE (XML) .....................................136

ORIENTAÇÃO A DADOS ...............................................................137

ESTRUTURA DO DOCUMENTO XML ..............................................138

PRATICANDO WEB SERVICES.......................................................139

CODIFICANDO WEBSERVICE .......................................................146

ACESSANDO O WEBSERVICE ATRAVÉS DE OUTRO PROGRAMA ............152

INSTANCIANDO E CODIFICANDO O WEBSERVICE ............................156

CRIANDO BANCO DE DADOS SQL SERVER...................................162

CRIANDO TABELA DO BANCO DE DADOS .......................................165

CRIANDO STORE PROCEDURE PARA INSERIR NO BANCO DE DADOS ....167

ACESSO A BANCO DE DADOS .......................................................170

CRIANDO CLASSE PARA ACESSAR BANCO DE DADOS .......................170

CODIFICANDO CLASSE DE ACESSO A BANCO DE DADOS ...................174

CRIANDO MÉTODOS PARA CONEXÃO NO BANCO DE DADOS ..............177

CRIANDO O MÉTODO PARA FECHAR O BANCO DE DADOS ...................178

INSERINDO DADOS NO BANCO .....................................................181