Desenvolvimento de Website com ASP.NET e SQL Server – Parte 1

Olá caro leitor!

Estamos iniciando uma serie de artigos que tem como objetivo lhe mostrar o passo a passo da criação de um website utilizando ASP.NET e SQL Server.

Caso queira acessar as outras partes, veja os links abaixo:

Nessa primeira parte iremos criar nosso banco de dados, as tabelas, camada de conexão, camada de entidades e a camada de regras de negocio. Então vamos ao que interessa.

Inicialmente criaremos o nosso banco de dados então para isso abra o Microsoft SQL Manager e crie-o conforme imagem abaixo.

Agora criaremos nossa tabela. A principio será somente 1 (uma) tabela. Segue abaixo o script:


CREATE TABLE PAGINAS
(
	ID_PAGINA INT IDENTITY(1, 1) NOT NULL,
	TITULO_PAGINA VARCHAR(40) NOT NULL,
	TEXTO_PAGINA VARCHAR(MAX),
	DATACRIACAO_PAGINA DATETIME,
	ATIVO_PAGINA INT,
	PRIMARY KEY(ID_PAGINA)
) 

Vamos inserir alguns dados iniciais.


INSERT INTO PAGINAS(TITULO_PAGINA, TEXTO_PAGINA, DATACRIACAO_PAGINA, ATIVO_PAGINA)
VALUES('Empresa', 'Conteudo da página sobre a empresa', GETDATE(), 1)

INSERT INTO PAGINAS(TITULO_PAGINA, TEXTO_PAGINA, DATACRIACAO_PAGINA, ATIVO_PAGINA)
VALUES('Serviços', 'Conteudo da página de serviços', GETDATE(), 1)

O fato de termos somente uma tabela é que nela teremos todas as páginas e seus conteúdos cadastrados. Nosso website terá a flexibilidade de criar, alterar, excluir e ativas ou desativas as páginas.

Futuramente criaremos uma pagina que listará produtos e para isso criaremos uma segunda tabela. Mais isso veremos em um próximo artigo.

Agora abra o Visual Studio e crie uma nova Solution clicando no menu File > New > Project…

Para minha solution darei o nome de ProjetoWebSite.

Após isso, criaremos nosso primeiro. Esse projeto terá como objetivo a manipulação de dados utilizando o SQL Server.

Clique com o botão direito em cima da solution e clique na opção Add > New Project…

Feito isso, siga os passo conforme a imagem abaixo selecionando Windows > Class Library e defina um nome para o projeto. No meu caso escolhi WebSite.Data.

Com nosso projeto da camada de conexão criada, iremos implementar alguns métodos. Basicamente serão 4 (quatro) métodos e 1 (uma) propriedade. Os 4 (quatro) métodos serão para abrir e fechar conexão, retornar os dados e outro pra executar comando. Vamos ao código.


using System;
using System.Data;
using System.Data.SqlClient;

namespace WebSite.Data
{
    public class Connection
    {
        private SqlConnection Conexao;

        /// <summary>
        /// Dados de conexao para SqlServer
        /// </summary>
        public string ConnectionString { get; set; }

        public Connection() { }

        /// <summary>
        /// Construtor que recebe como parametro a ConnectionString
        /// </summary>
        /// <param name="ConnectionString"></param>
        public Connection(string ConnectionString)
        {
            this.ConnectionString = ConnectionString;
        }

        /// <summary>
        /// Abre conexao
        /// </summary>
        public void AbrirConexao()
        {
            if (string.IsNullOrEmpty(this.ConnectionString)) throw new Exception("Não foi informado a ConnectionString.");

            if (Conexao == null)
            {
                Conexao = new SqlConnection();
                Conexao.ConnectionString = this.ConnectionString;
            }

            Conexao.Open();
        }

        /// <summary>
        /// Fecha conexao
        /// </summary>
        public void FechaConexao()
        {
            if (Conexao != null &amp;amp;&amp;amp; Conexao.State == ConnectionState.Open)
            {
                Conexao.Close();
            }
        }

        /// <summary>
        /// Retorna os dados
        /// </summary>
        /// <param name="sql"></param>
        /// <returns>Retorna coleção de dados</returns>
        public IDataReader RetornaDados(string sql)
        {
            if (string.IsNullOrEmpty(sql)) throw new Exception("Não foi informado a query SQL.");
            if (Conexao == null || Conexao.State == ConnectionState.Closed) throw new Exception("A conexão fechada. Execute o comando AbrirConexao e não se esqueça de FecharConexao no final.");

            SqlCommand command = new SqlCommand();
            command.Connection = this.Conexao;
            command.CommandText = sql;
            IDataReader reader = command.ExecuteReader();

            return reader;
        }

        /// <summary>
        /// Executa comando
        /// </summary>
        /// <param name="sql"></param>
        /// <returns>Retorna o total de linhas afetadas</returns>
        public int ExecutaComando(string sql)
        {
            if (string.IsNullOrEmpty(sql)) throw new Exception("Não foi informado a query SQL.");
            if (Conexao == null || Conexao.State == ConnectionState.Closed) throw new Exception("A conexão fechada. Execute o comando AbrirConexao e não se esqueça de FecharConexao no final.");

            SqlCommand command = new SqlCommand();
            command.Connection = this.Conexao;
            command.CommandText = sql;
            int result = command.ExecuteNonQuery();

            return result;
        }
    }
}

Para utilização da classe, será necessário instancia-la, executar o método para abrir conexão, executar os métodos para retornar os dados ou executar comando SQL e em seguida encerrar conexão.

Essa camada de conexão é simples, de fácil entendimento e pode ser utilizado em qualquer projeto.

Com nossa camada de conexão criada, vamos à camada de entidades onde teremos todas as entidades envolvidas no projeto e que é um espelho de nossas tabelas. Inicialmente teremos somente 1 (uma) entidade. Vamos criar um novo projeto.

Clique com o botão direito em cima da solution e clique na opção Add > New Project…

Feito isso, siga os passo conforme a imagem abaixo selecionando Windows > Class Library e defina um nome para o projeto. No meu caso escolhi WebSite.Entities.

Agora vamos criar nossa entidade. Renomeie o arquivo Class1.cs para Paginas.cs que será um espelho da nossa tabela Paginas. Segue código abaixo.


using System;

namespace WebSite.Entities
{
    public class Paginas
    {
        public int Id { get; set; }
        public string Titulo { get; set; }
        public string Texto { get; set; }
        public DateTime DataCriacao { get; set; }
        public bool Ativo { get; set; }

        public Paginas()
        {

        }

        public Paginas(int Id)
        {
            this.Id = Id;
        }

        public Paginas(int Id, string Titulo, string Texto, DateTime DataCriacao, bool Ativo)
        {
            this.Id = Id;
            this.Titulo = Titulo;
            this.Texto = Texto;
            this.DataCriacao = DataCriacao;
            this.Ativo = Ativo;
        }
    }
}

Com nossa camada de entidades criada, iremos cria camada de regra de negócios. Siga os passos abaixo.

Clique com o botão direito em cima da solution e clique na opção Add > New Project…

Feito isso, siga os passo conforme a imagem abaixo selecionando Windows > Class Library e defina um nome para o projeto. No meu caso escolhi WebSite.Business.

Agora vamos criar as regras de negocio. Renomeie o arquivo Class1.cs para Paginas.cs que conterá todas as operações necessárias para manipularmos nossa tabela Paginas.

Antes de implementar os códigos, precisaremos adicionar como referencia ao nosso projeto as bibliotecas criadas anteriormente. Adicione a biblioteca WebSite.Data e WebSite.Entities clicando com botão direito em References > Add References > Projects. Na janela que segue selecione as 2 (duas) bibliotecas criadas.

Na classe Paginas, vamos adicionar as referencias.


using System.Configuration;
using System.Data;

Agora implementaremos a nossas regras conforme o código abaixo.


using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;
using System.Data;

namespace WebSite.Business
{
    public class Paginas
    {
        private string ConnectionString = ConfigurationManager.ConnectionStrings["DBConnection"].ConnectionString;

        public Paginas() { }

        public Entities.Paginas[] ListaPaginas()
        {
            return ListaPaginas(null);
        }

        public Entities.Paginas[] ListaPaginas(Entities.Paginas pagina)
        {
            List<Entities.Paginas> lstPaginas = new List<Entities.Paginas>();

            Data.Connection connection = new Data.Connection(this.ConnectionString);
            connection.AbrirConexao();

            StringBuilder sqlString = new StringBuilder();
            sqlString.AppendLine("select * from paginas");

            if (pagina != null)
            {
                sqlString.AppendLine("where 1 = 1");

                if (pagina.Id > 0)
                {
                    sqlString.AppendLine("and id_pagina = " + pagina.Id + "");
                }

                if (!string.IsNullOrEmpty(pagina.Titulo) &amp;amp;&amp;amp; pagina.Titulo.Length > 0)
                {
                    sqlString.AppendLine("and titulo_pagina like '" + pagina.Titulo.Replace("'", "''") + "'");
                }

                if (!string.IsNullOrEmpty(pagina.Texto) &amp;amp;&amp;amp; pagina.Texto.Length > 0)
                {
                    sqlString.AppendLine("and texto_pagina like '" + pagina.Texto + "'");
                }
            }

            IDataReader reader = connection.RetornaDados(sqlString.ToString());

            int idxId = reader.GetOrdinal("ID_PAGINA");
            int idxTitulo = reader.GetOrdinal("TITULO_PAGINA");
            int idxTexto = reader.GetOrdinal("TEXTO_PAGINA");
            int idxDataCriacao = reader.GetOrdinal("DATACRIACAO_PAGINA");
            int idxAtivo = reader.GetOrdinal("ATIVO_PAGINA");

            while (reader.Read())
            {
                Entities.Paginas _pagina = new Entities.Paginas();
                _pagina.Id = reader.GetInt32(idxId);
                _pagina.Titulo = reader.GetString(idxTitulo);
                _pagina.Texto = reader.GetString(idxTexto);
                _pagina.DataCriacao = reader.GetDateTime(idxDataCriacao);
                _pagina.Ativo = reader.GetInt32(idxAtivo) == 1;

                lstPaginas.Add(_pagina);
            }

            connection.FechaConexao();

            return lstPaginas.ToArray();
        }

        public bool SalvaPagina(Entities.Paginas pagina)
        {
            bool salvou = false;

            if (pagina != null)
            {
                Data.Connection connection = new Data.Connection(this.ConnectionString);
                connection.AbrirConexao();

                StringBuilder sqlString = new StringBuilder();

                if (pagina.Id > 0)
                {
                    sqlString.AppendLine("update paginas set");
                    sqlString.AppendLine("titulo_pagina = '" + pagina.Titulo.Replace("'", "''") + "',");
                    sqlString.AppendLine("texto_pagina = '" + pagina.Texto.Replace("'", "''") + "',");
                    sqlString.AppendLine("ativo_pagina = " + (pagina.Ativo ? 1 : 0)  + " ");
                    sqlString.AppendLine("where id_pagina = " + pagina.Id + "");
                }
                else
                {
                    sqlString.AppendLine("insert into paginas(titulo_pagina, texto_pagina, datacriacao_pagina, ativo_pagina)");
                    sqlString.AppendLine("values('" + pagina.Titulo.Replace("'", "''") + "', '" + pagina.Texto.Replace("'", "''") + "', GETDATE(), " + (pagina.Ativo ? 1 : 0) + ")");
                }

                int i = connection.ExecutaComando(sqlString.ToString());
                salvou = i > 0;

                connection.FechaConexao();
            }

            return salvou;
        }

        public bool SalvaPagina(int Id, string Titulo, string Texto, DateTime DataCriacao, bool Ativo)
        {
            return SalvaPagina(new Entities.Paginas(Id, Titulo, Texto, DataCriacao, Ativo));
        }

        public bool ExcluiPagina(Entities.Paginas pagina)
        {
            bool salvou = false;

            if (pagina != null &amp;amp;&amp;amp; pagina.Id > 0)
            {
                Data.Connection connection = new Data.Connection(this.ConnectionString);
                connection.AbrirConexao();

                StringBuilder sqlString = new StringBuilder();
                sqlString.AppendLine("delete from paginas");
                sqlString.AppendLine("where id_pagina = " + pagina.Id + "");

                int i = connection.ExecutaComando(sqlString.ToString());

                connection.FechaConexao();
            }

            return salvou;
        }

        public bool ExcluiPagina(int Id)
        {
            return ExcluiPagina(new Entities.Paginas(Id));
        }
    }
}

Como pode ver, até aqui somente criamos as classes que iremos utilizar em nosso Website. Até momento nosso projeto ficou da seguinte forma.

  • WebSite.Data: Camada responsável por abrir conexão, executar comandos SQL, retornar dados e encerrar conexão.
  • WebSite.Entities: Camada responsável por manter nossas entidades que serão utilizadas em todo o projeto.
  • WebSite.Business: Camada responsável em conter todas as operações possíveis, ou seja, ela conterá no mínimo as quatro operações básicas: Criar (Create), Ler (Read), Atualizar (Update) e Excluir (Delete).

Com o que já criamos, é possível também reutiliza-lo em um projeto do tipo WinForm (Windows Form), porem nosso foco será o desenvolvimento de um website.

Vale lembrar também que a camada de conexão de dados pode ser reutilizada e modificada para a utilização de outros bancos de dados. Modificando você poderá usar os seguintes:

  • System.Data.OleDb
  • System.Data.OracleClient
  • MySql.Data.MySqlClient
  • System.Data.SQLite
  • FirebirdSql.Data.FirebirdClient

Espero que com esse primeiro artigo da serie, você possa ter uma visão melhor sobre o desenvolvimento de projetos N-Camadas e com ele ter base para iniciar outros projetos com maior facilidade e com uma visão mais ampla do todo.

No próximo artigo iniciaremos a criação de nosso website.

Fonte do projeto: Github

Não deixe de participar do fórum. Siga o C# Brasil no Twitter e Facebook.

Até o próximo artigo e bons estudos!