Aprendendo C# (Parte 1): Acessando um banco SQL SERVER 2005 com ADO.NET

1. Série de artigos ‘introdutórios’

Já pensou em namorar alguem da mesma área em que você atua? Já pensou como seria divertido? E as inumeras possibilidades?

Pois é, modestia a parte, mas eu tenho esta sorte. Namoro a pessoa mais linda e inteligente de toda a nossa área de informática. E para contribuir mais ainda, consegui leva-la para o mundo .NET (Só alegria :D)

Pensando nela e em todas as pessoas que estão começando .NET, decidi criar uma série de artigos para falar o básico de .NET (mas nem tão básico como OO e sintaxe em C#).

Vale ressaltar que o foco deste meu blog não é este (falar sobre coisas básicas). Como já falei em outros posts o foco aqui é falar sobre tecnologias novas, coisas mais avançadas, ou coisas que eu venho aprendendo no dia-a-dia. Então seremos breves em alguns pontos, e muitas vezes direi apenas o passo a passo do que se deve estudar e fica a seu criterio pesquisar no google sobre aquele assunto.

Nos artigos que estão por vir, iremos falar, básicamente, sobre conexão ao banco Sql Server, introdução à asp.net, controles de dados em asp.net.

2. Pré-Requisitos

Para acompanhar os nossos artigos com maiores tranquilidades é 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

Qualquer dúvida ou sugestão comentem. A continuidade dessa série vai depender do interesse dos leitores.
Anúncios

39 comentários sobre “Aprendendo C# (Parte 1): Acessando um banco SQL SERVER 2005 com ADO.NET

  1. Gustavo N. disse:

    Valew rapaz, esse seu tutorial ajudou muito!

    Funcionou direitinho integrando com o adobe Flex.

    Parabéns!

  2. Amanda disse:

    Eu estava há dias procurando na net um bom tutorial sobre como fazer um cadastro básico com boas explicações, mas não estava encontrando, até que encontrei o seu que é ótimo.

    Parabéns pela excelente colaboração aos futuros desenvolvedores.

  3. Claudio Stein Junior disse:

    Excelente artigo. Existe a possibilidade de fazer um artigo como por exemplo o cadastro de uma venda com várias tabelas, usando um n para n, ou mestre detalhe. Está dificil encontrar exemplos na net.

    Obrigado

    Claudio Stein Junior

  4. Diego disse:

    Artigo muito bom, prático e bem interesante, além de tudo ele é muito claro e nos ajuda muito com a linguagens em C#, qualquer atualizações e tutorial que você tiver pode enviar para o meu email, ficarei muito agradecido, pois C# é a linguagem que eu quero me especializar.

    Obrigado!

  5. Marcos disse:

    Arigo excelente, descritivo e, de forma simples, explica como fazer uma conexão. Continue assim, parábens por este!!!

  6. Tuga disse:

    achei dificil… kkk brincadeira, muito bom..

    alguem aqui pode me ajudar com uma coisa?

    eu criei por stream o seguinte:

    {
    WriteToFile();
    }
    }
    static void WriteToFile()
    {
    StreamWriter SW;
    SW = File.CreateText(@”D:\.txt”);

    SW.WriteLine(DateTime.Now);

    SW.Close();
    Console.WriteLine(“File Created SucacessFully”);
    }

    mas qui a data vai aparecer dentro do ficheiro txt.. eu queria que o ficheiro txt que criamos naquele momento tenha como nome a data sendo yyyyMMddHHmmss… alguem pode me ajudar? não precisa ser por stream pode ser Fileinfo ou qualquer outro

  7. michel disse:

    achei dificil… kkk brincadeira, muito bom..

    alguem aqui pode me ajudar com uma coisa?

    eu criei por stream o seguinte:

    {
    WriteToFile();
    }
    }
    static void WriteToFile()
    {
    StreamWriter SW;
    SW = File.CreateText(@”D:\.txt”);

    SW.WriteLine(DateTime.Now);

    SW.Close();
    Console.WriteLine(“File Created SucacessFully”);
    }

    mas qui a data vai aparecer dentro do ficheiro txt.. eu queria que o ficheiro txt que criamos naquele momento tenha como nome a data sendo yyyyMMddHHmmss… alguem pode me ajudar? não precisa ser por stream pode ser Fileinfo ou qualquer outro

    Faz o seguinte

    muda essa linha do codigo

    SW = File.CreateText(@”D:\” + system.datetime.now.tostring(“ddMMyyyymmss”) + “.txt”);

    Abraços

  8. Américo Pereira disse:

    Américo Pereira

    estou a fazer a transição do c para c# e este artigo ajudou-me bastante. Obrigado

  9. Robson disse:

    Robson Azuli

    Olá pessoal, parabens, com esse tutorial irei estudar.
    Sou estagiario, e estou aprendendo o visual studio 2010,
    mas não sei mexer nele.
    Alguem sabe algum tutorial que faça me ajudar , fazendo o mesmo que esse tutorial mas só que em 2010.

    Ficarei muito agradecido.
    Abraços.

  10. Olá, realmente está de parabéns, eu não havia entendido da boca do professor, mas agora vejo com mais clareza.
    Todavia, se for possível de se realizar um mesmo projeto, pode ser ate com os mesmos exemplos tabelas e campos, mas no modo visual com forms e Text box, eu ficaria muito grato. Estou usando o visual studio 2005 e estou enfrentando algumas complicações.
    Esta de parabéns, mais uma vez obrigado!!!

    Ferrari_skt@hotmail.com.

  11. Renata disse:

    Muito legal esse código, mais como consego rodar o programa.cs pela console, aparece website, alguem pode me ajudar.

  12. João Paulo disse:

    Muito bom, me ajudou muito, parabéns!
    Obs.: você escreve algumas coisas sem noção, engraçado…

  13. Bavosa disse:

    Meu codigo esta dando um erro nessa linha: if (conn.State == ConnectionState.Closed)

    erro Erro 1 O nome ‘ConnectionState’ não existe no contexto atual E:\ProjetosVisualStudio\ConsoleApplication1\ConsoleApplication1\Program.cs 63 33 ConsoleApplication1

  14. Parabéns… e obrigado !!! Sou iniciante na facul de Ciencia da Comput., suas informações foram de muita ajuda, explicam detalhadamente oq alguns professores deixam de ensinar.

  15. Lujon disse:

    Há um ano atrás aproximadamente estava começando a aprender C# e foi com esse artigo que consegui fazer minha primeira aplicação com banco de dados usando a linguagem. Depois desse tempo, retorno aqui e mais uma vez está sendo de grande ajuda. Gostei da forma que explicou, foi bem didático. Obrigado por compartilhar!

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s