Apostila C# - Módulo 2 - Windows Form Com C#

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


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.



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



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.



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



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:



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:



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.



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;



// 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;



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



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");


linha = cmbEscolaridade.SelectedIndex.ToString() + " - " + cmbEscolaridade.Text;

lstResumo.Items.Add(linha);

// Trabalhando com RadioButton


lstResumo.Items.Add("GENERO");




if (radMasculino.Checked)

{

lstResumo.Items.Add("MASCULINO");

}

else

{

lstResumo.Items.Add("FEMININO");

}

// Trabalhando com MonthCalenda


lstResumo.Items.Add("DATA NASCIMENTO");


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.



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.



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();

}



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



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;



}

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);

}

}



}

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.



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



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:



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



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.



23. Selecione a tabela que será exibida no Grid

24. Veja o resultado final depois de ter clicado no botão Finish



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:



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();

}


{

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



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");

}


{


}

}

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>



-- 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(



"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();

}


{


}

}

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;


para2.ParameterName = "@FONE";



para2.Value = txtFone.Text;




para3.ParameterName = "@OBS";



para3.Value = txtObs.Text;


para4.Direction = ParameterDirection.Output;

para4.SqlDbType = SqlDbType.Int;

para4.ParameterName = "@CHAVE";

command.Parameters.Add(para1);




conn.Open();

command.Prepare();

command.ExecuteNonQuery();

string mensagem = command.Parameters["@CHAVE"].Value.ToString();

MessageBox.Show("ID = " + mensagem);

preencheCampos();

conn.Close();

}


{

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



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");



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";


dt.Rows.Add(row);

row = dt.NewRow();

row["Codigo"] = 3;

row["Nome"] = "André";


dt.Rows.Add(row);

row = dt.NewRow();

row["Codigo"] = 4;

row["Nome"] = "Bernardino";


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.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");

}



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



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

http://localhost:1722/MeuWS



9. Clique no link GetCidadesAmazonas

10. Clique no invoke para ver o retorno e este aparecerá em XML



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.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.

http://localhost:7122/MeuWS/Cidade.asmx



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

Documents

Apostila C# - Módulo 2 - Windows Form Com C#