apostila c# - módulo 2 - windows form com c#
TRANSCRIPT
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
CURSO DE
por
Carlos Vamberto
Módulo II
Aplicações Desktop
Curso C# Módulo II – Carlos Vamberto página 2
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
Dedicatória
À minha filha querida Karlla Oksana
Agradecimentos
Ao grupo de estudo do Abare.NET pelo incentivo de realizar este material.
Ao meu pai, Carlos Vamberto, pelo apoio didático e lógico deste material.
Prefácio
No Módulo I aprendemos toda a estrutura da linguagem C#. Neste Módulo usaremos a linguagem
C# para criar aplicações Windows conhecendo seus componentes visuais, geração de aplicações
com uso de banco de dados, trabalhar com arquivos XML, trabalhar com Web Services, entre
outros conhecimentos.
Curso C# Módulo II – Carlos Vamberto página 3
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
Sumário
Dedicatória ........................................................................................................................ 2 Agradecimentos ................................................................................................................. 2 Prefácio ............................................................................................................................. 2 Sumário ............................................................................................................................ 3 Capítulo 1 – Introdução ....................................................................................................... 4
Conhecendo a IDE do Visual Studio .NET 2005 .................................................................... 4 Capítulo 2 – Criando a primeira aplicação .............................................................................. 6 Capítulo 3 – Conhecendo as Ferramentas de Trabalho ............................................................. 8
Solution Explorer (Ctrl+W,S) ............................................................................................. 8 Properties (F4) ................................................................................................................ 8 Object Browser (Ctrl+W,J) ................................................................................................ 8 Toolbox (Ctrl+W,X) .......................................................................................................... 8 Class View (Ctrl+W,C) ...................................................................................................... 8 Server Explorer (Ctrl+W,L) ............................................................................................... 8
Capítulo 4 – Conhecendo alguns componentes com exemplos .................................................. 9 Capítulo 5 – Conhecendo as classes DateTime e TimeSpan .................................................... 10 Capítulo 6 – CheckListBox, ComboBox, RadioButton, MonthCalendar, ListBox e GroupBox ......... 11 Capítulo 7 – Trabalhando com as Caixas de Diálogo .............................................................. 13 Capítulo 8 – Trabalhando com formulários ........................................................................... 15 Capítulo 9 – Trabalhando com formulários MDI .................................................................... 16 Capítulo 10 – Trabalhando com Banco de Dados ................................................................... 19 Capítulo 11 – Fazendo conexões na mão ............................................................................. 26 Capítulo 12 – Trabalhando com Stored Procedures ............................................................... 27 Capítulo 13 – Banco de Dados em XML ................................................................................ 30 Capítulo 14 – Trabalhando com WebService ......................................................................... 33
O que é WebService? ..................................................................................................... 33
Curso C# Módulo II – Carlos Vamberto página 4
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
Capítulo 1 – Introdução
Conhecendo a IDE do Visual Studio .NET 2005
Iremos logo mais, conhecer o ambiente de desenvolvimento da Microsoft multilinguagem para
construção de aplicações usando a tecnologia .NET.
Ilustração 1 - Tela inicial do VS .NET 2005
A IDE do VS .NET contém tudo que é necessário para facilitar o dia-a-dia do programador.
O VS .NET é a ferramenta oficial de desenvolvimento de software da plataforma Microsoft .NET.
Ele contém um ambiente integrado para ser usado em todas as fases de desenvolvimento
contendo um editor de código-fonte, compiladores, depuradores e utilitários diversos. O VS .NET
também pode editar diversos tipos de documentos inclusive imagens em diversos formatos,
arquivos XML, schemas XSD, arquivos binários, e outros.
Ele contém diversos utilitários para visualizar servidores de banco de dados SQL Server, serviços
do Windows, eventos de sistemas, e muitos outros.
A primeira vista o ambiente do VS .NET é semelhante ao ambiente do Visual InterDev do VS 6.
Hospeda todas as linguagem da Microsoft suportadas na plataforma .NET (VB.NET, C#, C++, J# e
JScript). Ela também pode hospedar linguagens de outras empresas como o COBOL .NET e Perl.
Curso C# Módulo II – Carlos Vamberto página 5
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
O VS .NET pode ser estendido, por exemplo: gravar macro de operações rotineiras. A IDE
também pode ser estendida criando ferramentas para ela.
Vejamos a ilustração a seguir, algumas das ferramentas que encontramos nesta IDE.
Ilustração 2 - Janela de Projeto do VS .NET 2005
1 – Server Explorer - Visualiza os serviços da máquina atual, os servidores de banco de dados
SQL Server, entre outras funcionalidades.
2 – Toolbox – Caixa de ferramenta que contém os principais componentes do .NET Framework
3 – Form Editor – Área de trabalho para criação dos formulário que serão usados em uma
aplicação.
4 – Solution Explorer – Ferramenta que auxilia visualizar as referencias de bibliotecas de
classes como também, os formulários.
5 – Class View – Como o nome já diz, o Class View serve para visualizar todas as classes
instanciadas no formulário que está sendo visualizado.
6 – Properties – Ferramenta que altera as propriedades e constrói os métodos de um
componente.
7 – Dynamic Help – Janela que apresenta possíveis ajudas no que está sendo digitado ou
selecionado no momento. Ela só é funcional se o MSDN Library estiver instalado.
1
2 3
4
5
6
8
7
Curso C# Módulo II – Carlos Vamberto página 6
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
8 – Toolbar – Barra de ferramenta que facilita algumas operações como gravação, compilação,
depuração, exibição de janelas ocultas, entre outros.
O VS .NET permite criar diversos tipos de aplicativos em diversas linguagens como:
Windows Form (Janela)
Console (Prompt do DOS)
DLL (Bibliotecas de Classes)
Web Application (Aplicativos Web)
Web Services (Serviços de Web)
Windows Services (Serviços do Windows)
Projetos de Instalação
Móbile (Aplicação para dispositivos portáteis)
Capítulo 2 – Criando a primeira aplicação
O principal objetivo deste capítulo é mostrar como funciona a IDE do VS .NET criando uma
aplicação contendo alguns componentes como TextBox e Button.
Vamos agora criar um projeto seguido as seguintes instruções:
1. Clique no menu File e escolha a opção New Project ou simplesmente pressiona as
teclas de atalho Ctrl+Shift+N
2. Em Project Type selecione C#
3. Em Templates selecione Windows Application
4. Em Name Digite: PrimeirAplicacao
5. Observe onde será gravado em Location
Ilustração 3 - Janela de "New Project"
6. Clique no botão Ok.
Aparecerá a seguinte janela:
Curso C# Módulo II – Carlos Vamberto página 7
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
Ilustração 4 - VS.NET com um novo projeto Windows Form
Observe no lado esquerdo o ToolBox. Dentro de Windows Forms nós encontraremos vários
componentes.
7. Localize e clique e arraste até o formulário Form1 o componente TextBox que se
encontra na Toolbox
8. Faça o mesmo para o componente Button
9. Clique no TextBox1 inserido no Form1 para selecioná-lo
10. Na janela Properties do lado direito, você encontrará uma propriedade chamada Name.
Clique nela e mude seu valor para txtMensagem
11. Na propriedade Text retire com conteúdo deixando-a vazia
12. Clique no componente Button1 inserido no Form1
13. Troque a propriedade Name para btnOk, troque também a propriedade Text para Ok
14. Clique duas vezes sobre o botão Ok para abrir o método OnClick desde botão e digite o
seguinte código.
private void btnOk_Click(object sender, System.EventArgs e)
{
txtMensagem.Text = "Alo Mundo!!!";
}
15. Redimensione a janela para que fique igual a imagem abaixo:
Curso C# Módulo II – Carlos Vamberto página 8
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
16. Clique no Form1 e altere a propriedade Text para Primeira Aplicação
17. Pressione a tecla F5 para executar a aplicação e teste.
Com esta demonstração você percebe que não é complicado construir uma aplicação.
Capítulo 3 – Conhecendo as Ferramentas de Trabalho
Aqui conheceremos algumas ferramentas que auxiliam no desenvolvimento de aplicações bem
com suas respectivas formas de acessos.
Solution Explorer (Ctrl+W,S)
Na janela Solution Explorer encontramos todas as referencias que o projeto faz com DLLs, Web
Services, COM Componentes, ActiveX, entre outros. Nele também encontramos a lista de
Formulários e Classes que temos no projeto.
Properties (F4)
Na janela Properties encontramos todas as propriedades dos componentes utilizados no projeto
e também os eventos dos mesmos.
Object Browser (Ctrl+W,J)
O Object Browser é uma janela que abre na área de trabalho e serve para visualizar todos os
Namespaces (pacote) utilizados no projeto e suas respectivas classes.
Toolbox (Ctrl+W,X)
Caixa de Ferramenta que contém todos os componentes que podem ser usados em um projeto,
seja Web Application, Windows Application ou Mobile Application.
Class View (Ctrl+W,C)
Janela que contém classes com suas propriedades, métodos e eventos encontrados no código em
visualização no momento, esta aparência se apresenta em forma de árvore (treeview).
Server Explorer (Ctrl+W,L)
Aqui encontramos uma janela contendo informações sobre: Serviços do Windows, Logs de
Eventos, Lista de mensagens, Contador de Performance e Servidores de SqlServer.
Podemos adicionar no Server Explorer conexões com banco de dados (Data Connections)
mesmos aqueles que são diferentes do SQL Server mas que contenha seu drive ODBC. Exemplo:
MS Access; DBase; Oracle; InterBase; Excel; etc.
Curso C# Módulo II – Carlos Vamberto página 9
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
Capítulo 4 – Conhecendo alguns componentes com exemplos
Para um estudante de uma nova tecnologia, sua principal frustração é a ansiedade, desta forma,
irei aliviar esta frustração aos iniciantes.
Neste capítulo iremos construir uma pequena aplicação de geração de recibo para conhecer alguns
componentes como o TextBox e o ComboBox e suas propriedades comum.
1. Inicie um novo projeto C# do tipo Windows Application
2. Adicione os componentes (Panel, Label, TextBox, ComboBox, RichTextBox e Button) como
mostrado na figura a seguir
Ilustração 5 - Formulário com os componentes inseridos
3. Dê os seguintes nomes aos componentes inseridos:
txtPagador;
txtRecebedor;
txtValor;
txtExtenso;
cmbReferente;
btnGerar;
ricTexto;
4. Entre na propriedade Items do ComboBox e digite em cada linha:
- serviços prestados em treinamento
- suporte técnico
- serviços prestados no desenvolvimento de sistemas
5. Clique duas vezes no botão Gerar e digite o seguinte código:
// Variáveis
string linha;
const string branco = "\n";
int posicao;
Curso C# Módulo II – Carlos Vamberto página 10
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
// Limpando o RichText
ricTexto.Clear();
linha = "R E C I B O " + branco;
ricTexto.AppendText(linha);
ricTexto.AppendText(branco);
linha = "Eu " + txtRecebedor.Text + ", recebi a importância de "
+ txtValor.Text + "(" + txtExtenso.Text + "), referemte a(o) "
+ cmbReferente.Text + "." + branco;
ricTexto.AppendText(linha);
ricTexto.AppendText(branco);ricTexto.AppendText(branco);
ricTexto.AppendText("-------------------------" + branco);
ricTexto.AppendText(txtRecebedor.Text);
ricTexto.Focus();
ricTexto.Select(0,11);
ricTexto.SelectionFont = new Font(ricTexto.SelectionFont,FontStyle.Bold);
6. Execute o código pressionando a tecla F5, preencha os campos e clique no botão Gerar. Veja o resultado.
Neste capítulo passamos a conhecer um pouco dos componentes TextEdit, ComboBox e
Button.
Capítulo 5 – Conhecendo as classes DateTime e TimeSpan
Aqui conheceremos um novo componente, o DateTimePicker. Com ele poderemos trabalhar com
Datas e Horas.
Criaremos uma pequena aplicação para que você possa se familiarizar com este componente e
conhecer duas novas classes destinadas ao controle do Tempo que são a DateTime e
TimeSpan.
1. Inicie um novo projeto C# do tipo Windows Application.
2. Inclua os componentes DateTimePicker, Button e Label como mostra na ilustração
abaixo:
Ilustração 6 - Form exemplo
3. Altere a propriedade Name dos DateTimePicker1 e DateTimePicker2 para dtIni e
dtFim.
4. Altere a propriedade Text do Button1 para Diferenca.
5. Dê um duplo clique no botão Diferenca e digite o seguinte código:
private void btnDiferenca_Click(object sender, System.EventArgs e)
{
DateTime dtini;
dtini = dataIni.Value;
DateTime dtfim;
dtfim = dataFim.Value;
Curso C# Módulo II – Carlos Vamberto página 11
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
TimeSpan ts = dtfim - dtini;
label1.Text=ts.Days.ToString() + " dias de diferença";
}
6. Execute o programa pressionando a tecla F5 e teste.
Perceba que o dtini e o dtfim não estão instanciados em suas declarações, ou seja, não estão
usando o método construtor da classe DateTime. Elas só vão ser instanciadas quando for
atribuídas os valores iniciais.
A classe TimeSpan serve como intermediária para que possamos subtrair uma data da outra,
pois o DateTime de outras linguagens de programação é na verdade uma derivação do tipo
double.
Capítulo 6 – CheckListBox, ComboBox, RadioButton, MonthCalendar, ListBox e GroupBox
Como todo capítulo, aqui, conheceremos alguns novos componentes como: CheckListBox (uma
junção de dois componentes o CheckBox e o ListBox); ComboBox, RadioButton,
MonthCalenda,ListBox e o GroupBox.
1. Inicie um novo projeto C# do tipo Windows Application.
2. Insira um CheckListBox
3. Altere a propriedade Name para chlIdiomas
4. Clique na propriedade Items e adicione as seguintes linhas
Inglês
Francês
Espanhol
Alemão
Japonês
Outros
5. Insira um ComboBox no formulário
6. Altere a propriedade Name para cmbEscolaridade
7. Clique na propriedade Items e adicione as seguintes linhas
Não Formado
Tecnólogo
Bacharel
Latu Sensu
Mestrado
Doutorado
Pós Doutorado
8. Adicione um GroupBox no formulário
9. Dentro dele adicione dois RadioButton
10. Altere a propriedade Name deles para radMasculino e radFeminino
11. Altere também a propriedade Text deles para Masculino e Feminino
12. Adicione um componente MonthCalendar no formulário
13. Altere a propriedade Name para calNascimento
Curso C# Módulo II – Carlos Vamberto página 12
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
14. Insira no formulário um ListBox
15. Altere a propriedade Name para lstResumo
16. Insira os Labels e Buttons, organize-os como mostrado na ilustração que segue
Ilustração 7 - Form gerador de Currículo Resumido
17. Dê um duplo clique no botão Sair e digite o seguinte código
Application.Exit();
18. Dê um duplo clique no botão Gerar Resumo e digite o seguinte código
// Limpando o ListBox
lstResumo.Items.Clear();
// Declarando as variáveis
string linha;
int total = chlIdiomas.Items.Count;
int i;
// Trabalhando com CheckListBox
lstResumo.Items.Add("IDIOMAS");
lstResumo.Items.Add("------------------------");
for (i=0;i<total;i++)
{
if (chlIdiomas.GetItemCheckState(i) == CheckState.Checked)
{
linha = chlIdiomas.GetItemText(i) + " - " + chlIdiomas.Items[i].ToString();
lstResumo.Items.Add(linha);
}
}
// Trabalhando com ComboBox
lstResumo.Items.Add("");
lstResumo.Items.Add("ESCOLARIDADE");
lstResumo.Items.Add("------------------------");
linha = cmbEscolaridade.SelectedIndex.ToString() + " - " + cmbEscolaridade.Text;
lstResumo.Items.Add(linha);
// Trabalhando com RadioButton
lstResumo.Items.Add("");
lstResumo.Items.Add("GENERO");
Curso C# Módulo II – Carlos Vamberto página 13
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
lstResumo.Items.Add("------------------------");
if (radMasculino.Checked)
{
lstResumo.Items.Add("MASCULINO");
}
else
{
lstResumo.Items.Add("FEMININO");
}
// Trabalhando com MonthCalenda
lstResumo.Items.Add("");
lstResumo.Items.Add("DATA NASCIMENTO");
lstResumo.Items.Add("------------------------");
lstResumo.Items.Add(calNascimento.SelectionRange.Start.ToLongDateString());
Note que existe uma certa semelhança entre os componentes CheckListBox, ComboBox e
ListBox, todos eles tem a propriedade Items em comum.
No MonthCalenda veja que usamos a propriedade SelectionRange.Start para obter a data
selecionada. Lembrando que este componente também tem a propriedade SelectionRange.End
para definir.
Capítulo 7 – Trabalhando com as Caixas de Diálogo Neste capítulo conheceremos algumas das caixas de diálogo e como elas são invocadas em um
sistema, também perceberemos que a forma de trabalhar com elas são bem semelhantes.
Vamos localizar e adicionar os componentes:ToolStripContainer componente repositório de
componentes Strip, MenuStrip (uma derivação da classe MainMenu do framework 1.1) dentro do
ToolStripContainer inserido e troque sua propriedade GripStyle para Visible. Construa o
seguinte menu:
Ilustração 8 - Mine Editor
As opções do menu devem ter os seguintes nomes: mnuArquivo, mnuNovo, mnuAbrir,
mnuSalvar e mnuSair.
Insira um componente TextBox com a propriedade Multiline para True no centro do formulário,
troque sua propriedade Name para txtTexto, e a propriedade Dock para Fill.
Curso C# Módulo II – Carlos Vamberto página 14
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
Coloque o seguinte código no menu mnuSair:
private void mnuSair_Click(object sender, EventArgs e)
{
Application.Exit();
}
Coloque o seguinte código no menu mnuNovo:
private void mnuNovo_Click(object sender, EventArgs e)
{
txtTexto.Clear();
}
Adicione o componente OpenFileDialog no formulário, troque a propriedade name para
dlgAbrir. Na propriedade DefaultExt para txt, a propriedade Filter para “Arquivo Texto
(*.txt)|*.txt”, a propriedade InitialDirectory para “c:\”, na propriedade ScrollBars do
TextBox coloque Both.
Adicione SaveFileDialog e coloque o nome dlgSalvar.
Antes de você implementar o código para Abrir e Salvar coloque em uso o namespace de
entrada e saída System.IO.
using System.IO;
Coloque o seguinte código no menu mnuAbrir:
private void mnuAbrir_Click(object sender, EventArgs e)
{
if (dlgAbrir.ShowDialog() == DialogResult.OK)
{
StreamReader sr = new StreamReader(dlgAbrir.FileName);
string sb;
sb = sr.ReadToEnd();
txtTexto.Text = sb;
}
}
Coloque o seguinte código no menu mnuSalvar:
private void mnuSalvar_Click(object sender, EventArgs e)
{
if (dlgSalvar.ShowDialog() == DialogResult.OK)
{
StreamWriter sw = new StreamWriter(dlgSalvar.FileName);
sw.WriteLine(txtTexto.Text);
sw.Close();
}
}
Perceba que usamos instâncias das classes StreamReader e StreamWrite para ler e gravar o
arquivo texto. Estas classes fazem parte do namespace System.IO.
Curso C# Módulo II – Carlos Vamberto página 15
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
Capítulo 8 – Trabalhando com formulários
Uma das maiores expectativas de um programador que estar aprendendo uma nova linguagem é
trabalhar com formulários, pois eles farão parte de seus futuros sistemas. Para diminuir esta
expectativa e mostrar na prática, vamos fazer um simples sistema que abrirá formulários SDI.
1. Inicie um novo projeto.
2. Troque a propriedade name do formulário para frmPrincipal, e a propriedade Text
para Formulário Principal.
3. Adicione dois botões no formulário com as propriedades name para btnJanela e
btnModal.
4. Coloque na propriedade Text dos dois botões Abrir Janela e Abrir Modal.
5. Vá ao menu Project e escolha a opção Add Windows Form...
6. Digite o nome para o formulário frmJanela
Ilustração 9 - Janela de Adicionar Itens
7. Coloque na propriedade Text deste novo formulário para Formulário Janela.
8. Adicione um botão no centro com name para btnFechar e Text para Fechar
9. Clique duas vezes sobre o botão e digite o seguinte código
private void btnFechar_Click(object sender, EventArgs e)
{
Close();
}
10. Através do menu Project adicione outro formulário colocando o nome para frmModal.
11. Altere a propriedade Text para Formulário Modal
12. Adicione um botão no centro com name para btnFechar e Text para Fechar
13. Clique duas vezes sobre o botão e digite o seguinte código
private void btnFechar_Click(object sender, EventArgs e)
{
Close();
}
Curso C# Módulo II – Carlos Vamberto página 16
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
14. Através do Solution Explorer (Ctrl+W,S) retorne ao form1.
15. No botão Abrir Janela clique duas vezes e adicione o código
private void btnJanela_Click(object sender, EventArgs e)
{
frmJanela janela = new frmJanela();
janela.Show();
}
16. No botão Abrir Modal clique duas vezes e adicione o código
private void btnModal_Click(object sender, EventArgs e)
{
frmModal modal = new frmModal();
modal.ShowDialog();
}
17. Execute o programa pressionando F5 e observe o comportamentos dos formulários
criados
Capítulo 9 – Trabalhando com formulários MDI
Aqui aprenderemos a trabalhar com formulários MDI, formulários semelhantes aos documentos do
Word que você abre vários documentos dentro de sua aplicação.
A ideia é escrever uma aplicação que trabalha como se fosse editor de texto com a possibilidade
de trabalhar com vários textos abertos ao mesmo tempo.
Então vamos a luta:
1. Inicie um novo projeto Windows Form
2. Troque o valor da propriedade name do Form1 para frmPai
3. Altere a propriedade IsMdiContainer para True
4. Adicione o componente MenuStrip no formlário e coloque os seguintes menus e
adicione uma variável do tipo int e de nome numForm
Ilustração 10 - Janela do Formulário com o Menu em exposição
mnuArquivo
mnuNovo
mnuAbrir
mnuSalvar
mnuSair
Curso C# Módulo II – Carlos Vamberto página 17
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
5. Clique duas vezes no menu Sair e digite o seguinte código:
private void mnuSair_Click(object sender, EventArgs e)
{
Application.Exit();
}
6. Insira um novo formulário no projeto através do menu Project Add Windows Form
7. Coloque o nome do formulário para frmFilho
8. Procure o método construtor e adicione outro método construtror e as variáveis
arquivo e salvo com o seguinte código e adicione um TextBox no Form e coloque o
nome txtTexto propriedade Dock para Fill e Multline para True.
public partial class frmFilho : Form
{
string arquivo = "";
bool salvo = false;
public frmFilho()
{
InitializeComponent();
}
public frmFilho(string texto)
{
InitializeComponent();
txtTexto.Text = texto;
this.setArquivo(texto);
}
}
9. Adicione os seguintes métodos
public void setSalvo(bool set)
{
salvo = set;
}
public void setArquivo(string arq)
{
arquivo = arq;
}
public bool getSalvo()
{
return salvo;
}
public string getArquivo()
{
return arquivo;
}
private void txtTexto_TextChanged(object sender, EventArgs e)
{
setSalvo(false);
}
public string getTexto()
{
return txtTexto.Text;
}
public void setTitulo(string texto)
{
Text = texto;
Curso C# Módulo II – Carlos Vamberto página 18
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
}
10. Retorne ao formulário frmPai pressione F7 para abrir o código e adicione na primeira
linha using System.IO; e coloque no evento do click do menu mnuAbrir e digitar o
seguinte código: Adicionar OpenFileDialog (dlgAbrir) e SaveFileDialog (dlgSalvar).
private void mnuAbrir_Click(object sender, EventArgs e)
{
if (dlgAbrir.ShowDialog() == DialogResult.OK)
{
try
{
StreamReader sr = new StreamReader(dlgAbrir.FileName);
string sb;
sb = sr.ReadToEnd();
frmFilho doc = new frmFilho(sb);
doc.setArquivo(dlgAbrir.FileName);
doc.setSalvo(true);
doc.MdiParent = this;
doc.setTitulo(dlgAbrir.FileName);
doc.Show();
}
catch (Exception ex)
{
MessageBox.Show("Erro ao tentar abrir o arquivo:\n---------\n"
+ ex.ToString(),"Erro",MessageBoxButtons.OK,MessageBoxIcon.Error);
}
}
}
11. Faça o mesmo para o menu mnuSalvar com o seguinte código:
private void mnuSalvar_Click(object sender, EventArgs e)
{
frmFilho frm = (frmFilho)this.ActiveMdiChild;
string arq = frm.getArquivo();
string texto = frm.getTexto();
bool salvo = frm.getSalvo();
if ((arq.Length > 1) && (salvo == false))
{
StreamWriter sw = new StreamWriter(arq);
frm.setSalvo(true);
sw.WriteLine(texto);
sw.Close();
}
else if ((arq.Length <=0))
{
if (dlgSalvar.ShowDialog() == DialogResult.OK)
{
arq = dlgSalvar.FileName;
StreamWriter sw = new StreamWriter(arq);
sw.WriteLine(texto);
sw.Close();
frm.setArquivo(arq);
frm.setSalvo(true);
frm.setTitulo(dlgSalvar.FileName);
}
}
Curso C# Módulo II – Carlos Vamberto página 19
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
}
12. Faça o mesmo para o menu mnuNovo com o seguinte código
private void mnuNovo_Click(object sender, EventArgs e)
{
numForm++;
frmFilho doc = new frmFilho();
doc.MdiParent = this;
doc.Text = "Documento" + numForm.ToString("000");
doc.Show();
}
Capítulo 10 – Trabalhando com Banco de Dados
O ADO.NET é o nome da biblioteca de classes de acesso a dados desenvolvida pela Microsoft, e
como ela faz parte do Microsoft .NET Framework poderemos acessá-la a partir de qualquer
linguagem que faz suporte a plataforma .NET Framework. Suas classes estão definidas abaixo
do namespace System.Data.
No Módulo 1 já mencionamos as classes de acesso a dados, aqui iremos enfatizar o uso dessas
classes em componentes visuais e melhorar os conceitos para melhor entendimento.
As vantagens de se trabalhar com ADO.NET são: possibilidade de trabalhar com Banco de Dados
desconectados, usa o padrão XML como forma de armazenamento dos dados, DataSet tipados.
Podemos trabalhar com os dados usando o ADO.NET de forma conectada e desconectada. As
Data Classes são classes de objetos que representam dados em memória, um repositório de
dados. As classes do Data Classes são: DataSet, DataTable, DataRow, DataColumn,
DataRelation, etc.
Uma representação do acesso a estas classes
Também temos as classes de acesso a dados conectados que são chamados de Managed
Providers que fazem acesso direto ao bando de dados obtendo e gravando doados.
As classes do Managed Providers dependem diretamente do provider do bando de dados
desejado, exemplo: MS SQL, Oracle, Access, InterBase, PostgreeSQL, etc. Mas todos os providers
fazem implementação das interfaces IDbConnection, IDbCommand, IDataReader. No
ADO.NET existem quatro Managed Providers que são para SQL Server, Oracle, OLEDB e ODBC.
Curso C# Módulo II – Carlos Vamberto página 20
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
IDbConnection – Através de uma string de conexão com o Banco de Dados e com os métodos
Open() e Close(), o objeto realiza a conexão com um banco de dados físico fazendo controle de
transações e cachê de dados.
IDbCommand – Utilizando uma Connection realiza consultas ao banco de dados usando os
métodos ExecuteReader(dispara uma consulta retornando um objeto DataReader),
ExecuteNonQuery(dispara um comando de inserção, alteração ou exclusão no banco de dados
retornando apenas o numero de registros afetados) e ExecuteEscalar (executa uma consulta
mas só retorna uma informação simples e não um conjunto de dados).
IDbDataReader – Esta é uma interface de uma classe que faz acesso ao banco de dados
conectado utilizando um cursor com leitura somente para frente fazendo assim um acesso de alta
performance.
A partir de agora vamos fazer alguns exercícios na prática para melhorar até agora comentada, e
como vamos trabalhar com banco de dados vamos aproveitar que na instalação do Visual Studio
.NET que faz a instalação do SQL Server Express Edition (versão gratuita deste banco de dados da
Microsoft).
Primeiro vamos configura o Visual Studio para trabalhar com este banco de dados.
1. Abra o Visual Studio
2. Verifique se o Server Explorer está visível caso contrário, pressione Ctrl+W,L
3. Clique com o botão direito do mouse sobre o Data Connections e escolha a opção
Create New SQL Server Database
Ilustração 11 - Janela de Criação de Novo Banco de Dados
4. Coloque como nome do Banco de Dados Agenda
5. O padrão do SQL Server Express Edition a autenticação do usuário é baseado no
Sistema Operacional, então deixe a opção Use Windows Authentication ativada
6. E clique em OK
Curso C# Módulo II – Carlos Vamberto página 21
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
Ilustração 12 - Janela do Server Explorer com o Banco criado
7. Agora vamos criar as tabelas
8. Clique como botão direto do mouse sobre Tables e escolha a opção Add New Table
9. Construa a seguinte estrutura:
Curso C# Módulo II – Carlos Vamberto página 22
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
10. Perceba que o campo id tem a pripriedade da coluna Identity Spacification igual a
yes
11. Ao terminar, clique no botão Save da barra de ferramenta e coloque o nome da tabela
como Pessoa
12. Clique com o botão direito da tabela Pessoa criada que está sendo agora visualizada
dentro do Server Explorer e escolha a opção Show Table Data
13. Ao aparecer a tabela em forma de Grid, preencha com pelo menos 3 registros.
14. Após o cadastro desses registros, vamos a aplicação
15. Selecione o Form1
16. Adicione nele o componente DataGridView
17. No canto direito dele possui uma seta para direita clique nela e veja que possui
algumas propriedades padrões
Curso C# Módulo II – Carlos Vamberto página 23
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
18. Clique na caixa DropDown do Choose Data Source
19. Escolha a opção Add Project Data Source
20. Quando aparecer a janela Data Source Configuration Wizart escolha Database
21. Ao aparecer a janela abaixo clique em Next novamente
22. Nesta próxima janela você terá que definir o nome do Connection String a serado.
Curso C# Módulo II – Carlos Vamberto página 24
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
23. Selecione a tabela que será exibida no Grid
24. Veja o resultado final depois de ter clicado no botão Finish
Curso C# Módulo II – Carlos Vamberto página 25
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
Perceba que na parte inferior da janela tem 3 componentes não visuais inseridos, estes
componentes são: agendaDataSet (repositório dos dados desconectados),
pessoalBindingSource (encapsula o Data Source para o formulário), pessoaTableAdapter
(DataAfapter que preenche o DataSet).
Fácil!?, fizemos tudo isto e nem digitamos uma linha de código, pode rodar a aplicação para vê
como ficou.
Para melhorar ainda mais a aplicação, adicione um botão no formulário clique dias vezes nele e
adicione o seguinte código:
Curso C# Módulo II – Carlos Vamberto página 26
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
pessoaTableAdapter.Update(agendaDataSet);
Com este código, todos os registros trabalhados offline, ou seja, desconectados, vão ser
atualizados no Banco de Dados automaticamente independente de sua quantidade, a atualização
é feito por lote de dados. Ele
Veja como o ADO.NET do novo .NET Framework da Microsoft é ótimo de se trabalhar.
Capítulo 11 – Fazendo conexões na mão
Bem, a proposta agora é fazer a mesma aplicação não utilizando dos artifícios dos componentes,
iremos fazê-lo programavelmente linha a linha de código.
Para isto, siga os seguintes passos:
1. Inicie um novo Projeto do tipo Winforms
2. Agora inclua no formulário o componente DataGridView
3. Pressione F7 para entrar no código fonte
4. Adicione o seguinte código nos usings das classes e adicione os objetos
SqlConnections e DataSet como mostrado abaixo
namespace Capitulo11
{
public partial class Form1 : Form
{
public SqlConnection conn = new SqlConnection(
"Data Source=TI-09\\SQLEXPRESS;”
+”Initial Catalog=Agenda;Integrated Security=True;Pooling=False");
public DataSet dsAgenda = new DataSet();
5. Crie um método preencheCampos com o seguinte código
public void preencheCampos()
{
try
{
conn.Open();
SqlDataAdapter da = new SqlDataAdapter("select * from Pessoa", conn);
da.Fill(dsAgenda, "Pessoa");
dataGridView1.DataSource = dsAgenda;
dataGridView1.DataMember = "Pessoa";
conn.Close();
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
6. Estando o formulário selecionado procure o evento Load que se encontra na janela
Properties através do botão Events onde mostra a ilustração abaixo
Curso C# Módulo II – Carlos Vamberto página 27
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
7. Digite o seguinte código
private void Form1_Load(object sender, EventArgs e)
{
preencheCampos();
}
8. Adicione um botão no formulário e digite o seguinte código no seu evento OnClick
private void button1_Click(object sender, EventArgs e)
{
try
{
SqlDataAdapter da = new SqlDataAdapter("select id, nome, fone, obs from Pessoa",
conn);
SqlCommandBuilder builder = new SqlCommandBuilder();
builder.DataAdapter = da;
builder.ConflictOption = ConflictOption.OverwriteChanges;
da.Update(dsAgenda, "Pessoa");
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
9. A aplicação está pronta
Bem, esta pequena aplicação faz com o que se trabalhe com DataSet desconectados e depois de
todas as alterações, exclusões e inserções realizadas na memória, ele executa estas operações
fisicamente em forma de lote. Perceba que utilizamos um objeto da classe SqlCommandBuilder
para a construção das strings de insert, update e delete para realizar as alterações quando
forem necessários.
Capítulo 12 – Trabalhando com Stored Procedures
Nota - O propósito deste capítulo não é ensinar a construir uma Stored Procedure e sim
mostrar como funciona, mas é interessante para o programador, realizar um estudo mais
aprofundado sobre Stored Procedures.
Vamos primeiro fazer uma Store Procedure no banco de dados seguindo os seguinte passos:
1. Na janela do Server Explorere vá em Stored Procedured
2. Clique com o botão direito do mouse e escolha Add New Stored Procedure
3. Digite o seguinte código
-- =============================================
-- Author: <CARLOS VAMBERTO>
-- Create date: <02/10/2006>
Curso C# Módulo II – Carlos Vamberto página 28
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
-- Description: <INCLUSÃO DE DADOS EM PESSOA>
-- =============================================
CREATE PROCEDURE SP_PESSOA_INCLUIR
@NOME NVARCHAR(50),
@FONE NVARCHAR(20),
@OBS NVARCHAR(50),
@CHAVE INT OUTPUT
AS
BEGIN
INSERT INTO PESSOA (NOME, FONE, OBS) VALUES (@NOME, @FONE, @OBS);
SET @CHAVE = @@IDENTITY
RETURN @CHAVE
END
4. Depois clique em salvar
Pronto, a Stored Procedure está criada, perceba que além de inserir dados na tabela, a Stored
Procedure retorna o valor do campo ID que é autoincremental(identity) após a inclusão, agora
vamos fazer a aplicação que a usa esta Stored Procedure para inserir dados.
1. Inicie um novo projeto
2. Insira nele os componentes DataGridView, Button, Label e TextBox como mostrado
abaixo
3. Pressione F7 para abrir a janela de código do formulário e acrescente o uso ao
namespace System.Data.SqlClient e os seguintes objetos
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Data.SqlClient;
namespace Capitulo12
{
public partial class Form1 : Form
{
public SqlConnection conn = new SqlConnection(
Curso C# Módulo II – Carlos Vamberto página 29
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
"Data Source=TI-09\\SQLEXPRESS;Initial Catalog=Agenda;Integrated”+
"Security=True;Pooling=False");
public DataSet dsAgenda = new DataSet();
4. Acrescente o método preencheCampos como mostrado na código abaixo
public void preencheCampos()
{
dsAgenda.Clear();
try
{
conn.Close();
conn.Open();
SqlDataAdapter da = new SqlDataAdapter("select * from Pessoa", conn);
da.Fill(dsAgenda, "Pessoa");
grdPessoa.DataSource = dsAgenda;
grdPessoa.DataMember = "Pessoa";
conn.Close();
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
5. Os componentes podem estarem dispostos da seguinte forma: grdPessoa,
btnCarregar, btnIncluir, txtNome, txtFone e txtObs
6. Clique duas vezes sobre o botão btnCarregar e digite o seguinte código
private void Form1_Load(object sender, EventArgs e)
{
preencheCampos();
}
7. Clique duas vezes no botão btnIncluir e digite o seguinte código
private void btnIncluir_Click(object sender, EventArgs e)
{
try
{
SqlCommand command = new SqlCommand();
command.Connection = conn;
command.CommandText = "SP_PESSOA_INCLUIR";
command.CommandType = CommandType.StoredProcedure;
SqlParameter para1 = new SqlParameter();
para1.ParameterName = "@Nome";
para1.SqlDbType = SqlDbType.NVarChar;
para1.Direction = ParameterDirection.Input;
para1.Value = txtNome.Text;
SqlParameter para2 = new SqlParameter();
para2.ParameterName = "@FONE";
para2.SqlDbType = SqlDbType.NVarChar;
para2.Direction = ParameterDirection.Input;
para2.Value = txtFone.Text;
SqlParameter para3 = new SqlParameter();
Curso C# Módulo II – Carlos Vamberto página 30
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
para3.ParameterName = "@OBS";
para3.SqlDbType = SqlDbType.NVarChar;
para3.Direction = ParameterDirection.Input;
para3.Value = txtObs.Text;
SqlParameter para4 = new SqlParameter();
para4.Direction = ParameterDirection.Output;
para4.SqlDbType = SqlDbType.Int;
para4.ParameterName = "@CHAVE";
command.Parameters.Add(para1);
command.Parameters.Add(para2);
command.Parameters.Add(para3);
command.Parameters.Add(para4);
conn.Open();
command.Prepare();
command.ExecuteNonQuery();
string mensagem = command.Parameters["@CHAVE"].Value.ToString();
MessageBox.Show("ID = " + mensagem);
preencheCampos();
conn.Close();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
Capítulo 13 – Banco de Dados em XML
Uma forma de se trabalhar totalmente local e independente de Servidor de Banco de Dados é
trabalhar com arquivos, e por que não se trabalhar com arquivos do tipo XML?
XML (eXtensible Markup Language) é uma recomendação da W3C para gerar linguagens de
marcação para necessidades especiais.
XML é um subtipo de SGML (Standard Generalized Markup Language - Linguagem Padronizada de
Marcação Generica) capaz de descrever diversos tipos de dados. Seu propósito principal é a
facilidade de compartilhamento de informações através da Internet. Linguagens baseadas em
XML: XHTML, RDF, SMIL, MathML, NCL, XBRL, XSIL e SVG. O SVG por exemplo é um formato
gráfico vetorial (scalable vectorial ghapics).
Nós aqui iremos usar o XML como repositório de dados local e ao mesmo tempo iremos conhecer
e aprimorar o conhecimento com DataSet, DataTable e DataRow.
1. Inicie um novo projeto
2. Insira no formulário 4 (quatro) botões
3. Coloque os nomes btnGerar, btnCarregar, btnSalvar e btnVisualizar
4. Altere também as propriedades Text dos botões
5. Insira um DataGridView no formulário
Curso C# Módulo II – Carlos Vamberto página 31
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
6. Clique duas vezes no botão Gerar e digite o seguinte código
private void btnGerar_Click(object sender, EventArgs e)
{
// Cliando o DataSet
ds = new DataSet("MeuDataSet");
//Criando a Tabela
DataTable dt = new DataTable("Clientes");
//Criando as colunas da tabela
DataColumn dcCodigo = new DataColumn("Codigo");
dcCodigo.Caption = "Código";
dcCodigo.DataType = Type.GetType("System.Int32");
dcCodigo.AutoIncrementSeed = 1000;
dcCodigo.AutoIncrementStep = 1;
dcCodigo.AutoIncrement = true;
dcCodigo.AllowDBNull = false;
dcCodigo.Unique = true;
DataColumn dcNome = new DataColumn("Nome");
dcNome.Caption = "Nome";
dcNome.DataType = Type.GetType("System.String");
DataColumn dcAnoNasc = new DataColumn("AnoNasc");
dcAnoNasc.Caption = "Ano Nasc";
dcAnoNasc.DataType = Type.GetType("System.Int32");
DataColumn dcAnoAtual = new DataColumn("AnoAtual");
dcAnoAtual.Caption = "AnoAtual";
dcAnoAtual.DataType = Type.GetType("System.Int32");
dcAnoAtual.DefaultValue = 2006;
dcAnoAtual.ReadOnly = true;
DataColumn dcIdade = new DataColumn("Idade");
dcIdade.Caption = "Idade";
dcIdade.DataType = Type.GetType("System.Int32");
Curso C# Módulo II – Carlos Vamberto página 32
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
dcIdade.Expression = "AnoAtual - AnoNasc";
dcIdade.ReadOnly = true;
dt.Columns.Add(dcCodigo);
dt.Columns.Add(dcNome);
dt.Columns.Add(dcAnoNasc);
dt.Columns.Add(dcAnoAtual);
dt.Columns.Add(dcIdade);
//Adicionando registros
DataRow row;
row = dt.NewRow();
row["Codigo"] = 1;
row["Nome"] = "Carlos";
row["AnoNasc"] = 1973;
dt.Rows.Add(row);
row = dt.NewRow();
row["Codigo"] = 2;
row["Nome"] = "Islo";
row["AnoNasc"] = 1980;
dt.Rows.Add(row);
row = dt.NewRow();
row["Codigo"] = 3;
row["Nome"] = "André";
row["AnoNasc"] = 1994;
dt.Rows.Add(row);
row = dt.NewRow();
row["Codigo"] = 4;
row["Nome"] = "Bernardino";
row["AnoNasc"] = 1931;
dt.Rows.Add(row);
ds.Tables.Add(dt);
dataGridView1.DataSource = ds;
dataGridView1.DataMember = "Clientes";
}
7. Clique duas vezes sobre o botão Carregar e digite o código
private void btnCarregar_Click(object sender, EventArgs e)
{
DataSet ds = new DataSet("MeuDataSet");
ds.ReadXml("arquivo.xml");
ds.ReadXmlSchema("arquivo.xsl");
dataGridView1.DataSource = ds;
dataGridView1.DataMember = "ClienteS";
}
8. Clique duas vezes sobre o botão Salvar e digite o código
private void btnGravar_Click(object sender, EventArgs e)
{
ds.WriteXml("arquivo.xml");
ds.WriteXmlSchema("arquivo.xsl");
}
Curso C# Módulo II – Carlos Vamberto página 33
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
9. Clique duas vezes sobre o botão Visualizar e digite o código
private void btnVisualiza_Click(object sender, EventArgs e)
{
MessageBox.Show(ds.GetXml());
MessageBox.Show(ds.GetXmlSchema());
}
Execute o programa e teste-o.
Para esclarecimento, os arquivos XML e XSL serão armazenados dentro da mesma pasta onde se
encontra o executável. Para ser gravado em outro local deve se colocar o caminho inteiro de onde
ser armazenado.
Capítulo 14 – Trabalhando com WebService
O que é WebService?
Bem, nós já conhecemos o que são classes e seus métodos, então iremos imaginar agora estes
métodos sendo dispostos para acesso através da internet. Você conseguiu imaginar isto? O nome
disto que você imaginou se chama WebMethods. Sua forma de acesso é semelhante a uma
chamada de página web. O WebService se propaga sobre o protocolo SOAP.
Não pense que é difícil fazer um WebService usando o Visual Studio.NET 2005. Ele nos dá toda a
estrutura e Wizards para desenvolver este tipo de aplicação.
Vamos ver na prática.
1. Inicie um novo projeto usando o menu File New WebSite ASP.NET
WebService e no nome do WebService corra até o final, retire o nome WebSite1 e
troque para MeuWS
2. Observe que a classe Service contida no arquivo Service.asmx está no projeto e
aberto o documento
3. Perceba também que no código da classe existe um WebMethod chamado
HelloWorld() que é inserido automaticamente quando se cria um WebService
4. Vamos adicionar uma nova classe do tipo WebService no projeto
Curso C# Módulo II – Carlos Vamberto página 34
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
5. Clique com o botão direito sobre o projeto C:\...MeuWS\ e escolha a opção Add New
Item
6. Localize a opção WebService e renomeie o arquivo para Cidade.asmx
7. Adicione o seguinte código
[WebMethod(Description = "Retorna uma lista de cidades válidas do Amazonas")]
public DataSet GetCidadesAmazonas()
{
DataSet ds = new DataSet("MeusDados");
DataTable dt = new DataTable("Cidades");
DataColumn dc1 = new DataColumn("Codigo");
dt.Columns.Add(dc1);
DataColumn dc2 = new DataColumn("Cidade");
dt.Columns.Add(dc2);
DataRow dr;
dr = dt.NewRow();
dr["Codigo"] = "MAO";
dr["Cidade"] = "Manaus";
dt.Rows.Add(dr);
dr = dt.NewRow();
dr["Codigo"] = "PAR";
dr["Cidade"] = "Parintins";
dt.Rows.Add(dr);
dr = dt.NewRow();
dr["Codigo"] = "CDJ";
dr["Cidade"] = "Codajás";
dt.Rows.Add(dr);
ds.Tables.Add(dt);
return ds;
}
8. Pressione F5 para execultar o teste do WebService e perceba o endereço e porta para
onde foi colocado o serviço, no meu caso foi http://localhost:1722/MeuWS
Curso C# Módulo II – Carlos Vamberto página 35
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
9. Clique no link GetCidadesAmazonas
10. Clique no invoke para ver o retorno e este aparecerá em XML
Curso C# Módulo II – Carlos Vamberto página 36
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
Agora vamos criar uma aplicação para consumir este WebService e para isto, siga os passos
abaixo:
1. Abra outro Visual Studio 2005
2. Inicie um novo projeto Windows Form
3. Na janela Solution Explorer clique com o botão direito do mouse e escolha a opção
Add Web Reference
4. Ao abrir a janela, digite http://localhost:7122/MeuWS/Cidade.asmx
5. Adicione um Button no formulário e um DataGridView
6. Clique duas vezes no botão e digite o código
private void button1_Click(object sender, EventArgs e)
{
localhost.Cidade cidade = new Capitulo14.localhost.Cidade();
DataSet ds = new DataSet();
ds = cidade.GetCidadesAmazonas();
dataGridView1.DataSource = ds;
dataGridView1.DataMember = "Cidades";
}
Rode a aplicação e veja como ela se comporta.
OBS: Os WebServices são independente de plataforma, ou seja, o WebService pode ser feito no
.NET e ser consumido no Java e vice versa.
Curso C# Módulo II – Carlos Vamberto página 37
Copyright ® | Curso de C# Módulo II Windows Form – Prof. Carlos Vamberto
Curso de Programação em Visual Studio 2010 – Environment (Ambiente) 1ª Aula
Introduão a IDE do Visual Studio 2005 Criando Soluões e Projetos Trabalhando com Componentes
2ª Aula
Caixas de Diálogos Formulários SDI Formulários MDI
3ª Aula
Classe de Acesso a Dados (Providers) Trabalhando com Oracle (Oracle Client)
4ª Aula
Construindo Classes de Acesso a Dados Data Bindings
5ª Aula
Trabalhando com Banco de Dados desconectados Trabalhando com Store Procedure
6ª Aula
Banco de Dados em XML Criando WebService Consumindo WebService