Acessando um banco SQL SERVER 2005 com ADO.NET e C# [Parte 1]

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (2)  (0)

Aprenda nesse primeiro artigo de uma série como conectar em um banco SQL SERVER 2005 com ADO.NET e C#.

1. Introdução

A intenção desta série é mostrar os conceitos "básicos" de C#. E o que me motivou a escrever sobre isso, foi a quantidade de pessoas que existem que ainda se perdem em alguns conceitos. Então, tentarei falar detalhadamente sobre cada assunto que formos vendo.
A minha intenção é criar um total de 4 artigos: 2 sobre conexão a banco de dados com ado.net e mais dois sobre uma asp.net (introdução).


2. Pré-Requisitos

Para acompanhar o artigo é aconselhável que:

-Você tenha um conhecimento prévio da linguagem C#.

-Visual Studio 2005 ou 2008

-Tenha o Sql Server instalado na máquina (existe uma versão express que pode ser baixada no seguinte link:  http://www.microsoft.com/downloads/details.aspx?familyid=220549b5-0b07-4448-8848-dcc397514b41&displaylang=pt-br )


3. E o que será tratado neste post?

Agora iremos dar inicio ao nosso primeiro artigo, onde iremos falar básicamente como acessar um banco Sql Server em C#.

Admito que nos primordio dos meus estudos em C# (Haaa bons tempos) eu me perdia nos objetos de dados na linguagem. Achava muito complexo, e me perguntava a necessidade de algumas classes do framework. Mas com o passar do tempo, com o estudo e a prática constante você vai adquirindo uma certa experiência e começa a notar o melhor local e situação para utilizar X ou Y.

Outro ponto importante deste post é que não iremos utilizar nenhum projeto de interface com o usuário, como windows form ou asp.net, mas sim tudo em Console. Pois deste modo iremos focar no problema e não em como se faz um textbox, umas label, ou sei la o que em asp.net.


4. Começando

4.1 Criando o banco de dados

Primeira coisa a se fazer (depois do projeto CONSOLE criado lógico) é criar o nosso banco de dados. Para fazer isso podemos utilizar básicamente três ferramentas:

-Linha de comando do próprio Sql Server (fora de cogitação no momento) ;

-Pelo próprio Visual Studio – nesta ferramente você não fica limitado a apenas escrever código C# ou VB.net. Nela você tem a capacidade de gerenciar e manipular todo o ambiente de desenvolvimento, como por exemplo o banco de dados que iremos trabalhar ;

- Sql Server Management Studio – é uma ferramente feita para manipular bancos de dados Sql Server. Particulamente, gosto e utilizo muito esta ferramenta. A sua versão express pode ser baixada no seguinte link: http://www.microsoft.com/downloadS/details.aspx?familyid=C243A5AE-4BD1-4E3D-94B8-5A0F62BF7796&displaylang=en .

Nesse exemplo iremos utilizar o Visual Studio para criar nosso banco (Caso você escolha o Sql Server Management Studio as operações serão bem parecidas).

- Localize a aba de server explorer no visual studio. Caso não ache, vá em VIEW –> SERVER EXPLORE.

ScreenShot001

- Aperte com o botão direito em “Data Connections” e selecione “Create New Sql Server Database”

ScreenShot002

- Uma tela irá se abrir, onde nela você irá colocar os dados do seu banco

ScreenShot003

  1. No server name coloque o nome do servidor onde o banco se encontra (caso esteja na máquina local: “.”, “localhost”, “.\SQLEXPRESS”).
    obs: Coloquei “.\SQL”, pois SQL é a instância do sql server que desejo me conectar. Isso acontece quando você tem mais de um SQL SERVER instalado em uma mesma máquina, sendo necessário dar nomes à cada intância (Para mais informações, procure sobre “instâncias nomeadas”).
  2. Em “log on to the server” coloque o tipo da autenticação, se vai ser por autenticação windows (utilizando usuário logado no windows, ou se vai ser via usuário e senha)
  3. Por ultimo coloque o nome do novo banco que deseja criar.
  4. Pressione “OK”.

- Agora seu novo banco deve estar aparecendo na TAB do server explorer, deste modo:

ScreenShot004

4.2 Criando a nossa primeira tabela

- Depois de ter o banco criado, precisamos criar suas tabelas. Para nosso exemplo, vamos criar uma tabela “Pessoa” que irá ter as colunas: id, nome, data de nascimento, sexo, email.

- Vá na pasta tables no banco que você acabou de criar. Pressione com o botão direito na pasta, e selecione “New Table”.

ScreenShot005

- Irá aparecer a seguinte aba no visual studio:

ScreenShot006

- Agorá o que tem a fazer é criar todas as colunas com os seus respectivos tipo. Preencha a tabela da seguinte maneira:

ScreenShot007

- Precisamos também dizer que a coluna ID vai ser uma chave primária. Para isso é necessário selecionar a coluna “id”, e em seguida pressionar na chave que se localiza na barra de ferramentas do Sql. Uma chave irá aparecer do lado da coluna.

ScreenShot008

- Precisamos informar, também que a coluna “id” será auto-increment. Para isso, siga os seguintes passos:

  1. Selecione, novamente, a coluna “id”.
  2. Vá em Column Properites.
  3. Procure a propriedade “Identity Specification”, Expanda a mesma.
  4. Marque a propriedade “Is Identity” para “Yes”.ScreenShot009

- Salve a tabela (CRTL + S). Irá aparecer uma janela para  você informa o nome da tabela. No nosso caso se chamará “Pessoa”.

- Pronto! Agora já temos nossa tabela criada, com todas as suas colunas devidamente identificadas. Para quem não conseguiu criar a tabela via modo design, segue o script para criar a tabela:

   1: CREATE TABLE [dbo].[Pessoa](
   2:     [id] [int] IDENTITY(1,1) NOT NULL,
   3:     [nome] [nvarchar](100) NULL,
   4:     [dataNascimento] [smalldatetime] NULL,
   5:     [sexo] [nchar](1) NULL,
   6:     [email] [nvarchar](50) NULL,
   7:  CONSTRAINT [PK_Pessoa] PRIMARY KEY CLUSTERED
   8: (
   9:     [id] ASC
  10: )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
  11: ) ON [PRIMARY]


5. Alguns conceitos importantes

Antes de darmos início à codificação, vamos falar sobre alguns conceitos que servirão de base para a compreensão do assunto. Vamos falar sobre string de cenexão, tipos de conexão em .NET.

5.1 Entendendo as Strings de Conexão

Todos concordam que para eu acessar um banco (seja ele Sql Server, MySql, PostGres, ou qualquer outro banco) eu preciso informa alguns dados sobre a conexão que irei realizar, como por exemplo:

- Onde o banco esta localizado?

- Qual o nome do banco que irei me conectar?

- Qual o tipo de autenticação que irei utilizar para acessar ao banco?

- Caso a autentição que for utilizar seja por usuário e senha, quais são elas?

E a string de conexão serve justamente para isso, para responder esse tipo de perguntas. É ela quem vai informar as configurções de uma determinada conexão com o banco.

A string de conexão é composta básicamente das seguintes propriedades:

  1. Data Source – que é o local onde o banco se encontra, no meu caso seria “.\SQL”.
  2. Initial Catalog – O nome do banco ao qual irei me conectar (ex: EstudoBlog)
  3. Integrated Security – Propriedade que informa se a autenticação será integrada ao windows ou não, ou seja, se quem será utilizado na autenticação será o usuário logado no windows no exato momento ou não.
  4. UID e PWD - Caso a autenticação não seja integrada, é necessário informar o usuário (UID) e a senha (PWD).

Obs: Para cada propriedade dessa pode haver um outro nome que tenha o mesmo significado (exemplo UID que pode ser também User ID).

Bancos de dados diferentes podem possuir formatos de strings de conexões diferentes. Existe um site bem interessante que trás strings de conexões de diversos bancos ( http://www.connectionstrings.com/ ).

Outro modo de verificar a sua string de conexão é através do Server Explorer. Click no banco que esta trabalhando (EstudoBlog). Selecione “properties”. Na aba que vai se abrir existe uma propriedade “Connection String” onde você pode ver a sua.

ScreenShot010

5.2 Modelo de conexão com o banco

Básicamente existem dois modelos: Modelo Conectado e o desconectado.

5.2.1 Modelo conectado

O nome é bastante sugestivo. Vamos trabalhar de maneira conectada ao banco, ou seja, para cada operação que formos fazer (insert, update, delete, select…)  teremos que abrir uma conexão com o banco e fecha-la apos seu uso.

A grande vantagem desse modelo é que temos certeza que os dados que estamos manipulando são os mais atuais no banco.

E a desvantegem é o constante acesso à rede, e como sabemos esse processo é lento. Se trabalharmos de maneira indevida, fazendo mais acessos do que o necessário, o desempenho da aplicação pode ser prejudicado.

Esse modelo é muito utilizado em aplicações que possuem uma certa dinamicidade, onde é necessário trabalhar com os dados mais atuais. Um exemplo disso são sistemas bancários, onde cada operação feita precisa ser atualizada no memso instante.

5.2.2 Modelo desconectado

Diferente do modelo conectado, este irá trabalhar de maneira desconectada ao banco, ou seja, iremos manipular os dados sem precisar estar se utilizando dos serviçoes de redes constantementes. “Ham? Como? Como vou manipular os dados do banco sem se conectar à ele?”

Bem meus caros leitores, utilizar modelo desconectado não quer dizer que nunca iremos nos conectar ao banco. O que esse modelo faz é: Pegar todos os dados que iremos necessitar em um dado tempo, e durtante esse tempo irá manipular esses dados em memória. Depois desse tempo, nos conectamos novamente ao banco e sincronizamos as informações (o que tinha em memória e o que tinha no banco).

A desvantagem desse modelo como já deu para notar é que ele ira trabalhar com dados antigos. Nem sempre o dado que iremos manipular, será o mais novo.

A vantagem é que diminuiremos bastante o número de acessos ao banco de dados.

Existe uma empresa perto de minha casa que se utiliza desse sistema. É uma concessionária onde todos os vendedores trabalham na rua com seus palms. Esses vendedores se conectam todo dia de manhã à base de dados da empresa e baixam para seus palms as pessoas que eles irão ter que visitar NO DIA. Esses dados passam o dia em memória, e os vendedores estão sempre atualizando os dados (vendeu o que para quem? o que vendeu? não vendeu? Quantidade de vendas?). Ao final do dia esses vendedores se conectam novamente à base de dados da empresa para a sincronização dos dados.

5.2.3 Modelo Conectado x Modelo Desconectado

Já escutei muita gente discutir qual o melhor modelo. Mas não existe isso!!! Gostaria que vocês entendessem que o que existe é: “O melhor modelo para uma determinada situação.”

Então antes de qualquer projeto estudem o melhor modelo, as vantagens e as desvantagens de cada um para aquele distema.

5.2.4 Objetos utilizados nos modelos
  1. String de Conexão
  2. SqlConnection
  3. SqlDataAdapter
  4. SqlCommand
  5. DataSet
  6. SqlDataReader

Logo no início (2 anos atrás), quando comecei a estudar C#, eu realmente não entendia a utilização desses objetos. Conseguia até fazer as coisas, apenas porque decorava. Então para não cometerem o mesmo erro que eu, vamos entender quando se utilizar cada objeto desse.

  1. String de Conexão – já foi muito discutido no tópico 5.1;
  2. SqlConnection – Objeto que de acordo com uma string de conexão irá se conectar com a base. Esta classe contem várias propriedades com informações e métodos para manipular a conexão com o banco;
  3. DataSet - É uma estrutura bastante complexa e parecida com nosso banco de dados, so que é manipulada em memória. O objeto contém tabelas (assim como o banco) com linhas e colunas. É muito utilizado em todo o framework .NET, mas uma das utilizações básicas é nos modelos desconectados.
  4. SqlDataAdapter – Utilizado no modelo desconectado. O DataSet por se só não consegue se conectar ao banco. Ele não sabe nada da nossa base de dados. Então o único modo de preenchermos nosso dataset com dados vindos do banco qual é?  Lógico, atráves de um objeto intermediário que vai ser uma ponte entre a conexão e o DataSet (por exemplo).
  5. SqlCommand – Utilizado no modelo conectado.  E serve básicamente para executar comandos no banco. Então para cada comando que vai ser realizado em cima do banco (INSERT, UPDATE, SELECT, DELETE) será necessário um objeto desta classe.
  6. SqlDataReader – Utilizado explicitamente no modelo conectado.Sabem os ponteiros para arquivos em C/C++?Pois é. Este objeto trabalha de maneira bem semelhante, sendo da mesma forma forward-only e read-only, ou seja esse “ponteiro” irá andar apenas para frente e será apenas  leitura.Ele irá apontar para resultados de um SqlCommand (que são sempre resultados em forma de tabelas, consequentemente [agora sem trema :D ], o datareader irá apontar sempre para uma linha desta tabela).


6. Acessando à base com C#

Finalmente chegamos na parte boa, depois de muito conceito vem a prática. Neste primeiro post iremos trabalhar com o modelo conectado.

6.1 Criando a nossa classe básica (Pessoa)

Vamos, primeiramente, criar nossa classe básica, a classe “Pessoa” que irá conter como propriedade todas as colunas de nossa tabela “Pessoa”. Essa classe será utilizada básicamente em todas as operações dos nossos exemplos.

   1: public class Pessoa
   2:    {
   3:        #region Atributos
   4:
   5:        private int _id;
   6:        private string _nome;
   7:        private string _email;
   8:        private DateTime _dataNascimento;
   9:        private char _sexo;
  10:
  11:        #endregion
  12:
  13:        #region Construtores
  14:
  15:        public Pessoa()
  16:        {
  17:
  18:        }
  19:
  20:        public Pessoa(string nome, string email, DateTime dataNascimento, char sexo)
  21:        {
  22:            this.Nome = nome;
  23:            this.Email = email;
  24:            this.DataNascimento = dataNascimento;
  25:            this.Sexo = sexo;
  26:        }
  27:
  28:        public Pessoa(int id, string nome, string email, DateTime dataNascimento, char sexo) : this(nome, email, dataNascimento, sexo)
  29:        {
  30:            this.ID = id;
  31:        }
  32:
  33:        #endregion
  34:
  35:        #region Propriedades
  36:
  37:        public char Sexo
  38:        {
  39:            get { return this._sexo; }
  40:            set { this._sexo = value; }
  41:        }
  42:
  43:        public DateTime DataNascimento
  44:        {
  45:            get { return this._dataNascimento; }
  46:            set { this._dataNascimento = value; }
  47:        }
  48:
  49:        public string Email
  50:        {
  51:            get { return this._email; }
  52:            set { this._email = value; }
  53:        }
  54:
  55:        public string Nome
  56:        {
  57:            get { return this._nome; }
  58:            set { this._nome = value; }
  59:        }
  60:
  61:        public int ID
  62:        {
  63:            get { return this._id; }
  64:            set { this._id = value; }
  65:        }
  66:
  67:        #endregion
  68:    }

6.2 Algoritmo Básicos do Modelo Conectado

Se conexão fechada

Abrir conexão

Cria comando que irá manipular o banco

Executa comando

Fecha Conexão com o banco

Como dá para ver é bem simples o fluxo das operações ao acessar o banco de dados.

Obs: Uma coisa muito importante que vocês não devem esquecer jamais é de fechar a conexão depois de já ter operado no banco. É como fala o meu chefe: “abra a conexão o mais tarde que poder, e feche o mais cedo possível.”

Isso se deve ao fato que ficar consumindo a conexão com o banco por muito tempo desnessariamente é prejudicial à aplicação.

6.3 Inserindo registros no banco

O nosso primeiro exemplo será de inserção. Então seguindo a linha de raciocínio do tópico à cima, temos o seguinte trecho de código:

   1: public class Program
   2: {
   3:     static Pessoa GetPessoa()
   4:     {
   5:         Pessoa pessoa = new Pessoa();
   6:         Console.WriteLine("Nome ");
   7:         pessoa.Nome = Console.ReadLine();
   8:         Console.WriteLine("Email ");
   9:         pessoa.Email = Console.ReadLine();
  10:         Console.WriteLine("Sexo (M ou F) ");
  11:         pessoa.Sexo = Convert.ToChar(Console.ReadLine());
  12:         Console.WriteLine("Data de Nascimento");
  13:         pessoa.DataNascimento = Convert.ToDateTime(Console.ReadLine());
  14:         return pessoa;
  15:     }
  16:
  17:     static void Main(string[] args)
  18:     {
  19:         //
  20:         //chama um método que irá preencher um objeto Pessoa de acordo com entradas do usuário
  21:         //
  22:         Pessoa newPessoa = GetPessoa();
  23:
  24:         //
  25:         //string de conexão que informa dados do banco que irei acessar
  26:         //
  27:         string connectionString = @"Data Source=.\SQL;Initial Catalog=EstudoBlog;Integrated Security=True;Pooling=False";
  28:
  29:         //
  30:         // Query TSQL com comando que irei realizar no banco.
  31:         //
  32:         string query = "INSERT INTO Pessoa (nome, dataNascimento, sexo, email) values (@nome, @dataNascimento, @sexo, @email)";
  33:
  34:         SqlConnection conn = null;
  35:         try
  36:         {
  37:             //
  38:             //instância da conexão
  39:             //
  40:             conn = new SqlConnection(connectionString);
  41:
  42:             //
  43:             //verifica se conexão está fechada, se tiver abre.
  44:             //
  45:             if (conn.State == ConnectionState.Closed)
  46:             {
  47:                 //
  48:                 //abre conexão
  49:                 //
  50:                 conn.Open();
  51:             }
  52:
  53:             //
  54:             // Criação do objeto comando, que recebe a query que será utilizada na operação e a conexão com o banco.
  55:             //
  56:             SqlCommand cmd = new SqlCommand(query, conn);
  57:
  58:             //
  59:             // Adiciona parametros ao comando
  60:             //
  61:             cmd.Parameters.Add(new SqlParameter("nome", newPessoa.Nome));
  62:             cmd.Parameters.Add(new SqlParameter("dataNascimento", newPessoa.DataNascimento));
  63:             cmd.Parameters.Add(new SqlParameter("sexo", newPessoa.Sexo));
  64:             cmd.Parameters.Add(new SqlParameter("email", newPessoa.Email));
  65:
  66:             //
  67:             // Executa comando
  68:             //
  69:             cmd.ExecuteNonQuery();
  70:
  71:             //
  72:             // Fecha conexão com o banco
  73:             //
  74:             conn.Close();
  75:
  76:             Console.WriteLine("Pessoa Cadastrada com sucesso!!!");
  77:         }
  78:         catch (Exception ex)
  79:         {
  80:             Console.WriteLine(ex.Message);
  81:         }
  82:         finally
  83:         {
  84:             //
  85:             // Garante que a conexão será fechada mesmo que ocorra algum erro.
  86:             // Não existe problema em fechar uma conexão duas vezes. 
  87:             // O problema esta em abrir uma conexão duas vezes.
  88:             //
  89:             if (conn != null)
  90:             {
  91:                 conn.Close();
  92:             }
  93:         }
  94:     }
  95: }

A seguinte linha pode causar uma certa dúvida em algumas cabeças:

   1: string query = "INSERT INTO Pessoa (nome, dataNascimento, sexo, email) values (@nome, @dataNascimento, @sexo, @email)";

Em cursos que ministro sempre alguem pergunta se pode fazer da seguinte maneira:

   1: string query = "INSERT INTO Pessoa (nome, dataNascimento, sexo, email) values ( ''" + newPessoa.Nome + "'', ''" + newPessoa.DataNascimento + "'', ''" + newPessoa.Sexo + "'', ''" + newPessoa.Sexo + "'')";

E minha resposta sempre é: “Lógico que pode fazer isso. Garanto que vai compilar e executar. Mas fazendo isso seu sistema irá ficar vuneravel à ataques de pessoas mal intensionadas.”

Aconselho que deem [sem acentuação agora :D ] uma olhada no que é SQL INJECTION.

(Quem não quiser saber mais sobre SQL INJECTION no momento e quiser partir para os próximos exemplos, vá para o próximo tópico)

Falando rapidamente, Sql Injection é  a capacidade de inserir código SQL dentro de uma Query Já existente. Ao invés de rodar o nosso código, rode o seguinte código que está sujeito à Sql Injection:

   1: public class Program
   2: {
   3:     static Pessoa GetPessoa()
   4:     {
   5:         Pessoa pessoa = new Pessoa();
   6:         Console.WriteLine("Nome ");
   7:         pessoa.Nome = Console.ReadLine();
   8:         Console.WriteLine("Email ");
   9:         pessoa.Email = Console.ReadLine();
  10:         Console.WriteLine("Sexo (M ou F) ");
  11:         pessoa.Sexo = Convert.ToChar(Console.ReadLine());
  12:         Console.WriteLine("Data de Nascimento");
  13:         pessoa.DataNascimento = Convert.ToDateTime(Console.ReadLine());
  14:         return pessoa;
  15:     }
  16:
  17:     static void Main(string[] args)
  18:     {
  19:         //
  20:         //chama um método que irá preencher um objeto Pessoa de acordo com entradas do usuário
  21:         //
  22:         Pessoa newPessoa = GetPessoa();
  23:
  24:         //
  25:         //string de conexão que informa dados do banco que irei acessar
  26:         //
  27:         string connectionString = @"Data Source=.\SQL;Initial Catalog=EstudoBlog;Integrated Security=True;Pooling=False";
  28:
  29:         //
  30:         // Query TSQL com comando que irei realizar no banco.
  31:         //
  32:         string query = "INSERT INTO Pessoa (nome, dataNascimento, sexo, email) values ( ''" + newPessoa.Nome + "'', ''" + newPessoa.DataNascimento + "'', ''" + newPessoa.Sexo + "'', ''" + newPessoa.Sexo + "'')";
  33:
  34:         SqlConnection conn = null;
  35:         try
  36:         {
  37:             //
  38:             //instância da conexão
  39:             //
  40:             conn = new SqlConnection(connectionString);
  41:
  42:             //
  43:             //verifica se conexão está fechada, se tiver abre.
  44:             //
  45:             if (conn.State == ConnectionState.Closed)
  46:             {
  47:                 //
  48:                 //abre conexão
  49:                 //
  50:                 conn.Open();
  51:             }
  52:
  53:             //
  54:             // Criação do objeto comando, que recebe a query que será utilizada na operação e a conexão com o banco.
  55:             //
  56:             SqlCommand cmd = new SqlCommand(query, conn);
  57:
  58:             //
  59:             // Executa comando
  60:             //
  61:             cmd.ExecuteNonQuery();
  62:
  63:             //
  64:             // Fecha conexão com o banco
  65:             //
  66:             conn.Close();
  67:
  68:             Console.WriteLine("Pessoa Cadastrada com sucesso!!!");
  69:         }
  70:         catch (Exception ex)
  71:         {
  72:             Console.WriteLine(ex.Message);
  73:         }
  74:         finally
  75:         {
  76:             //
  77:             // Garante que a conexão será fechada mesmo que ocorra algum erro.
  78:             // Não existe problema em fechar uma conexão duas vezes. 
  79:             // O problema esta em abrir uma conexão duas vezes.
  80:             //
  81:             if (conn != null)
  82:             {
  83:                 conn.Close();
  84:             }
  85:         }
  86:     }
  87: }

Na entrada do nome, digite o seguinte e veja o resultado:

felipe’, ‘02/01/1988’, ‘m’, ‘felipe@hotmail.com’); drop table pessoa —

ScreenShot012

Parabéns!!!! Você acabou de perder a tabela pessoa!!!

Para entender porque isso aconteceu, debug o código e veja o valor da string “query”.

ScreenShot013

Para evitar o uso de Sql Injection foi criado os Parameters, que tem a finalidade de tratar a string informado como um todo.

6.3 Recuperando registros do banco

O modo de recuperar dados do banco, é bastante parecido com o modo de inserir.

Uma coisa que muda e que vale chamar atenção são em três métodos da classe SqlCommand:

  1. ExecuteNonQuery: Executa qualquer comando que não tenha retorno, ou seja, esse método não retorna nada (INSERT, UPDATE)
  2. ExecuteReader: Executa comandos que retornem alguma coisa (SELECT)
  3. ExecuteScalar: Retorna a primeira linha e a primeira coluna do comando.

O nosso código ficará da seguinte maneira:

   1: public class Program
   2:     {
   3:         static void Main(string[] args)
   4:         {
   5:             //
   6:             //string de conexão que informa dados do banco que irei acessar
   7:             //
   8:             string connectionString = @"Data Source=.\SQL;Initial Catalog=EstudoBlog;Integrated Security=True;Pooling=False";
   9:
  10:             //
  11:             // Query TSQL com comando que irei realizar no banco.
  12:             //
  13:             string query = "SELECT * FROM Pessoa";
  14:
  15:             SqlDataReader reader = null;
  16:             SqlConnection conn = null;
  17:
  18:             try
  19:             {
  20:                 //
  21:                 //instância da conexão
  22:                 //
  23:                 conn = new SqlConnection(connectionString);
  24:
  25:                 //
  26:                 //verifica se conexão está fechada, se tiver abre.
  27:                 //
  28:                 if (conn.State == ConnectionState.Closed)
  29:                 {
  30:                     //
  31:                     //abre conexão
  32:                     //
  33:                     conn.Open();
  34:                 }
  35:
  36:                 //
  37:                 // Criação do objeto comando, que recebe a query que será utilizada na operação e a conexão com o banco.
  38:                 //
  39:                 SqlCommand cmd = new SqlCommand(query, conn);
  40:
  41:                 //
  42:                 // Executa comando
  43:                 //
  44:                 reader = cmd.ExecuteReader();
  45:
  46:                 //
  47:                 //interage com a tabela retornada
  48:                 //
  49:                 while (reader.Read())
  50:                 {
  51:                     Console.Write(reader["nome"].ToString() + " - ");
  52:                     Console.WriteLine(reader["email"].ToString());
  53:                 }
  54:
  55:                 //
  56:                 // Fecha conexão com o banco
  57:                 //
  58:                 conn.Close();
  59:             }
  60:             catch (Exception ex)
  61:             {
  62:                 Console.WriteLine(ex.Message);
  63:             }
  64:             finally
  65:             {
  66:                 //
  67:                 // Garante que a conexão será fechada mesmo que ocorra algum erro.
  68:                 // Não existe problema em fechar uma conexão duas vezes. 
  69:                 // O problema esta em abrir uma conexão duas vezes.
  70:                 //
  71:                 if (conn != null)
  72:                 {
  73:                     conn.Close();
  74:                 }
  75:             }
  76:         }
  77:     }

É bom ressaltar que o objeto reader, deve ser fechado assim como a conexão. Ele é fechado no finally, também, pois garante que ele seja fechado havendo ou não erro.

6.4 Outras operações

Bem… as próximas operações deixo para vocês como exercício. Garanto que não mudará muito em relação à essas.


7 Finalizando

Por enquanto ficamos por aqui. Daremos continuidade nos próximos posts.

para baixar o projeto do post, acesse o seguinte link:

http://cid-2d6d3503299ba131.skydrive.live.com/self.aspx/Artigos/AcessoBancoDados.rar


Abraços!


Este artigo encontra-se, também, em meu blog: http://fpimentel88.wordpress.com

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?