C#  - Cadastro Básico com SQL Server Local (SDF) - I

Hoje vamos criar uma aplicação usando a linguagem C# para realizar o cadastro de Produtos usando o SQL Server Local ou SQL Server Compact (SQL CE).

Ele é um banco de dados enxuto e pequeno e fácil de distribuir que você pode usar para aplicações embarcadas, pequenas aplicações locais ou conectadas ocasionalmente.

O Microsoft SQL Server Compact (SQL CE) é um banco de dados relacional compacto produzido pela Microsoft para aplicativos que são executados em dispositivos móveis e desktops. Antes da introdução da plataforma desktop, ele era conhecido como SQL Server para Windows CE e SQL Server Mobile Edition.

A última versão é o SQL Server Compact 4.0 suportado na plataforma NET Framework 4.0. Ele inclui tanto o suporte a 32-bit como a 64-bit, sendo direcionado para aplicações embutidas e aplicativos com um banco de dados integrado. Ele é gratuito para baixar e redistribuir. Não existe um ODBC para SQL CE mas você pode usar o SQL CE via OLE DB.

Neste artigo vou mostrar como usar o SQL Server Local em uma aplicação onde iremos realizar as operações CRUD para um cadastro de Produtos.

Portanto neste artigo você vai aprender a:

Recursos Usados:

Criando um Cadastro de Produtos com SQL Server Local

Abra o Visual Studio 2012 Express for Windows desktop e clique em New Project;

Escolha a linguagem Visual C# -> Windows e a o template Windows Forms Application informando o nome BancodeDadosLocal;

No formulário padrão form1.cs inclua a partir da ToolBox os seguintes controles:

Disponha os controles no formulário conforme o leiaute abaixo:

Agora vamos criar um banco de dados chamado Vendas.sdf e uma tabela Produtos no SQL Server Local.

No menu PROJECT clique em Add New Item;

A seguir selecione a guia Data e clique no template Local DataBase, informe o nome Vendas.sdf e clique no botão Add;

Na próxima janela podemos escolher entre criar um DataSet ou um Entity Data Model. Podemos apenas clicar no botão Cancel para apenas criar o banco de dados. Clique no botão Cancel, pois vamos apenas criar o banco de dados neste momento.

Agora na janela DataBase Explorer exibindo a conexão e os objetos do banco de dados Vendas.sdf.

Para criar a tabela Produtos clique com o botão direito sobre o banco de dados e a seguir em Create Table:

Na janela New Table vamos definir a tabela Produtos com os campos : Id , Nome, Estoque, Custo e Descricao conforme mostra a figura abaixo:

Para concluir esta etapa vamos incluir alguns dados na tabela Produtos. Clique com o botão direito sobre a tabela e a seguir em Show Table Data.

A seguir digite alguns dados a partir da coluna Nome conforme mostrado abaixo. (A coluna Id será incrementada automaticamente)

Realizando as operações CRUD no SQL Server Local com ADO .NET

Vamos definir a string de conexão criada para o banco de dados Vendas.sdf no arquivo de configuração App.Config.

Para obter a string de conexão clique no banco de dados Vendas.sdf na janela DataBase Explorer e na janela de Properties obtenha o seu valor na propriedade Connection String. A seguir abra o arquivo App.Config e crie uma seção <connectionstrings> contendo os valores conforme mostrado abaixo:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup>
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
    </startup>
  <connectionStrings>
    <add name="ProdutosSDF" connectionString="Data Source=c:\users\mac\documents\visual studio 2012\Projects\BancodeDadosLocal\BancodeDadosLocal\Vendas.sdf"/>
  </connectionStrings>
</configuration>

Para podermos acessar o valor da string de conexão no arquivo app.config devemos incluir uma referência no projeto ao namespace System.Configuration.

No menu PROJECT clique em Add Reference e a seguir selecione o namespace System.Configuration conforme abaixo:

Neste momento você deve verificar se seu projeto possui a referência para a biblioteca System.Data.SqlServerCe.dll.

Se não possuir no menu PROJECT clique em Add Reference e a seguir selecione o local : 

C:\Program Files (x86)\Microsoft SQL Server Compact Edition\v4.0\Desktop e a seguir selecione  System.Data.SqlServerCe.dll.

Pronto agora já podemos partir para realizar as operações CRUD.

Separando as responsabilidades - Criando um classe para acesso aos dados

Neste momento poderíamos colocar o código ADO .NET diretamente nos eventos do botões de comando do formulário form1.cs que tudo funcionaria corretamente. Mas essa não é uma boa prática e por isso eu vou criar uma classe e colocar nela o código que acessa os dados e realiza a persistência dos mesmos realizando as operações de incluir, alterar e excluir dados da tabela Produtos.

No menu PROJECT clique em Add New Item e selecione o template Class e informe o nome DAL.cs. A seguir coloque o código abaixo nesta classe:

using System;
using System.Configuration;
using System.Data.SqlServerCe;
using System.Data;
namespace BancodeDadosLocal
{
    public class DAL
    {
        private static SqlCeConnection objSqlCeConnection = null; 
        private static DAL objSqlServerCeDAL     = null; 
        private static  string connString = null;
        public DAL()
        {
            string connString = ConfigurationManager.ConnectionStrings["ProdutosSDF"].ToString().Trim();  
            objSqlCeConnection = new SqlCeConnection(connString); 
        }

        public static DAL GetInstance(string connString)  
        {  
            if (objSqlServerCeDAL == null)  
            {  
                objSqlServerCeDAL = new DAL();  
            }  
            return objSqlServerCeDAL;  
        }  
        public void Open()  
        {  
            try  
            {  
                if (objSqlCeConnection.State == ConnectionState.Closed)
                {  
                    objSqlCeConnection.Open();  
                }  
            }  
            catch (Exception e)  
            {  
                throw e;  
            }  
        }  

        public void Dispose()  
        {  
            try  
            {  
                if (objSqlCeConnection.State != ConnectionState.Closed)  
                {  
                    objSqlCeConnection.Close();  
                    objSqlCeConnection.Dispose();  
                }  
            }  
            catch (Exception e)  
            {  
                throw e;  
            }  
        }
        public int Insert(Produto _produto, string sql)
        {
         DAL objSqlCeServerDAL = DAL.GetInstance(connString); 
            objSqlCeServerDAL.Open();
            SqlCeCommand dCmd = new SqlCeCommand(sql,objSqlCeConnection);
            dCmd.CommandType = CommandType.Text;
            try
            {
                dCmd.Parameters.AddWithValue("@nome", _produto.nome);
                dCmd.Parameters.AddWithValue("@estq", _produto.estoque);
                dCmd.Parameters.AddWithValue("@cust", _produto.custo);
                dCmd.Parameters.AddWithValue("@desc", _produto.descricao);
                return dCmd.ExecuteNonQuery();
            }
            catch
            {
                throw;
            }
            finally
            {
                dCmd.Dispose();
                objSqlCeServerDAL.Dispose();
            }
        }
        public int Update(Produto _produto, string sql )
        {
          DAL objSqlCeServerDAL = DAL.GetInstance(connString); 
            objSqlCeServerDAL.Open();
            SqlCeCommand dCmd = new SqlCeCommand(sql, objSqlCeConnection);
            dCmd.CommandType = CommandType.Text;
            try
            {
                dCmd.Parameters.AddWithValue("@nome", _produto.nome);
                dCmd.Parameters.AddWithValue("@estq", _produto.estoque);
                dCmd.Parameters.AddWithValue("@cust", _produto.custo);
                dCmd.Parameters.AddWithValue("@desc", _produto.descricao);
                return dCmd.ExecuteNonQuery();
            }
            catch
            {
                throw;
            }
            finally
            {
                dCmd.Dispose();
                objSqlCeServerDAL.Dispose();
            }
        }
        public DataTable Load(string sql)
        {
          DAL objSqlCeServerDAL = DAL.GetInstance(connString); 
            objSqlCeServerDAL.Open();
            SqlCeDataAdapter dAd = new SqlCeDataAdapter(sql, objSqlCeConnection);
            dAd.SelectCommand.CommandType = CommandType.Text;
            DataSet dSet = new DataSet();
            try
            {
                dAd.Fill(dSet, "Produtos");
                return dSet.Tables["Produtos"];
            }
            catch
            {
                throw;
            }
            finally
            {
                dSet.Dispose();
                dAd.Dispose();
                objSqlCeServerDAL.Dispose();
            }
        }
        public int Delete(int codigo,string sql)
        {
         DAL objSqlCeServerDAL = DAL.GetInstance(connString); 
            objSqlCeServerDAL.Open();
            SqlCeCommand dCmd = new SqlCeCommand(sql, objSqlCeConnection);
            dCmd.CommandType = CommandType.Text;
            try
            {
                dCmd.Parameters.AddWithValue("@codigo", codigo);
                return dCmd.ExecuteNonQuery();
            }
            catch
            {
                throw;
            }
            finally
            {
                dCmd.Dispose();
                objSqlCeServerDAL.Dispose();
            }
        }
    }
}

Nesta classe criamos os seguintes métodos:

Na segunda parte deste artigo vamos implementar as operações para incluir, alterar, excluir e exibir dados da tabela Produtos.

João 9:40 Alguns fariseus que ali estavam com ele, ouvindo isso, perguntaram-lhe: Porventura somos nós também cegos?

João 9:41 Respondeu-lhes Jesus: Se fosseis cegos, não teríeis pecado; mas como agora dizeis: Nós vemos, permanece o vosso pecado.

 

Referências:

José Carlos Macoratti