Desenvolvendo Aplicações Conectadas - Parte I – Planejando a aplicação e criando o banco de dados

por Wallace Cézar Sales dos Santos

O objetivo deste treinamento é demonstrar como desenvolver aplicações conectadas a bases de dados ou outros repositórios de informação utilizando os recursos existentes no Visual Studio .Net.

Veja a seguir as ferramentas necessárias para este treinamento:

• Visual Studio .Net 2003 ou superior;

• Microsoft SQL Server 2000 (MSDE – versão gratuita do MS SQL Server 2000 – disponível para download no endereço https://www.microsoft.com/sql/msde/);

• Microsoft Visio 2003 for Enterprise Architects (opcional).

Introdução

O Visual Studio .Net traz inúmeros recursos próprios ao desenvolvimento de aplicações conectadas a diversas fontes de informações: bancos de dados, arquivos XML, arquivos de inicialização, Registry, etc.

Tais recursos não estão restritos apenas ao acesso e manipulação dos dados. Temos grandes recursos para o design e desenvolvimento de bancos de dados, os quais têm evoluído cada vez mais e tornado o trabalho do desenvolvedor mais produtivo e integrado.

Sendo assim, vamos desenvolver uma aplicação desktop: o Gerenciador de Atividades (Activity Manager). Faremos o acompanhamento de todo o ciclo de desenvolvimento do software e analisaremos os conceitos mais recentes do desenvolvimento, desde sua especificação até o deployment, com foco nos recursos do Visual Studio.

Definindo a aplicação

Diferentemente dos conceitos mais antigos, nos quais o desenvolvimento de um sistema começava com a criação dos diagramas ER (Entidade-Relacionamento), nosso sistema será planejado com foco nos conceitos da MDA (Model Driven Architecture – Arquitetura Dirigida ao Modelo) e com base na UML (Unified Modeling Language – Linguagem Unificada de Modelagem). Já foi suficientemente provado que a UML é mais eficiente no planejamento de sistemas de software que a simples diagramação ER, pois esta não possui mecanismos suficientes para contemplar todas as necessidades inerentes a esse tipo de projeto. No que se refere à MDA, seu uso se justifica por um simples motivo: planejamento. Primeiro definimos o modelo, a arquitetura do sistema; em seguida, fazemos a implementação. Todas as alterações subsequentes são realizadas no modelo. O software em si nada mais é que a exata implementação do modelo. Neste modelo, utilizamos o Microsoft Visio for Enterprise Architects, pois este acompanha o Visual Studio .Net (versão Architect) e possui integração com ele, atendendo perfeitamente a nossas necessidades.

Todo software tem um único objetivo: atender às necessidades de um ou mais usuários. Dentro da UML, a identificação das necessidades dos usuários é realizada através do diagrama de Use Cases, demonstrado na Figura 1. No diagrama em questão, primeiramente identificamos os atores (meios externos que interagem com nosso sistema: usuários, outros sistemas, banco de dados) e, de uma forma bastante simples, “perguntamos” a eles o que desejam do sistema. A partir das respostas, extraímos os casos de uso. É claro que esse processo demanda ciclos e refinamentos, sobre os quais nos aprofundaremos aqui.

Figura 1: Diagrama de Use Case

Através do diagrama identificamos os seguintes atores e casos de usos:

• Atores:

  • Usuário;

  • Repositório de atividades;

  • Arquivo de configuração.

• Casos de Uso:

  • Permitir que o Usuário (ator identificado) possa gerenciar suas atividades;

  • Permitir que o Usuário possa procurar suas atividades;

  • Permitir que o Usuário receba lembretes de suas atividades do sistema;

  • Permitir que o Usuário configure o sistema.

Dentre os requisitos identificados, um merece atenção imediata: armazenar as atividades. Precisamos definir qual será o repositório: um banco de dados relacional, um arquivo XML ou mesmo um arquivo texto seqüencial. Nossa opção é o banco de dados, mais precisamente o Microsoft SQL Server 2000 na versão MSDE (Microsoft Desktop Engine), que é a versão gratuita deste sistema gerenciador de banco de dados e a qual atende perfeitamente às nossas necessidades. Ele pode ser executado nas versões a partir do Windows 98 (tem algumas limitações) e possui capacidades e performance semelhantes à versão completa do SQL Server. Os requisitos de sistema para execução do MSDE podem ser consultados no endereço https://www.microsoft.com/sql/msde/productinfo/sysreqs.asp. O maior senão do MSDE é o fato de ele não possuir uma interface com o usuário amigável, o que dificulta sua instalação e o gerenciamento das atividades administrativas, mas como poderemos ver mais adiante, o Visual Studio .NET poderá ajuda-lo nessa tarefa.

Uma vez definida a forma de armazenamento dos dados da aplicação, precisamos endereçar os demais requisitos identificados para ela. Assim, passamos a trabalhar nos outros diagramas que compõem nossa documentação com o intuito de identificar as classes (Diagrama de Classes – Figura 2) e os comportamentos e de representar os diversos diagramas de interação (Diagramas de Seqüência e Colaboração), os estados (Diagramas de Estado e Atividade) e como a aplicação será implementada (Diagramas de Componente e Implantação). Como se vê, contemplamos todo o ciclo de desenvolvimento de nosso sistema, abordando desde o requisito até o software final instalado.

Figura 2: Diagrama de Classes (visão parcial)

Como resultado, definimos um sistema que será implementado desta maneira:

• ActivityManager.exe – terá as interfaces com o usuário, independentemente de qualquer regra de negócio;

• ActivityManager.dll – terá as regras de negócio do sistema, abstraindo da User Interface e permitindo gerenciamento e manutenção mais detalhados e eficientes da aplicação;

• ActivityData.dll – fará a conexão e o gerenciamento dos acessos ao banco de dados, permitindo assim que a aplicação seja totalmente abstraída do repositório de informações.

Uma vez a par do que será produzido, vamos realizar a última parte do planejamento de nosso sistema: a geração de código. Note que até este momento não nos preocupamos com a linguagem que será utilizada para implementar o modelo, justamente porque este independe dessa informação. O MS Visio nos auxilia nessa tarefa e gera, a partir de nossos diagramas de classe, os “esqueletos” do nosso sistema (esqueletos de código são as estruturas dos tipos com apenas as declarações dos atributos e operações, sem as respectivas implementações). O código gerado será posteriormente adicionado ao nosso projeto no Visual Studio .Net.

Instalando o Microsoft Desktop Engine (MSDE):

• Faça o download do Web Site da Microsoft (https://www.microsoft.com/sql/msde/downloads/download.asp);

• Feito o download, acesse o arquivo MSDE2000A.exe e dê um duplo clique nele (esse arquivo é um pacote com todos os arquivos necessários para a instalação do MSDE). Com isso, tem início o processo de descompactação e extração dos arquivos. Para prosseguir, aceite os termos de licenciamento;

• Uma vez extraídos os arquivos, vá até o diretório no qual foi realizada a extração e localize o arquivo ReadMeMSDE2000A.htm, onde você encontrará os pré-requisitos e as instruções detalhadas para instalação e uso do MSDE. Leia-o antes de prosseguir;

• No mesmo diretório acima citado, localize o arquivo Desktop Engine Setup.exe. Dê um duplo clique nele para iniciar o processo de instalação do banco de dados. Leia as informações em cada tela do assistente e realize a instalação.

Criando os projetos no Visual Studio

Hora de materializar o projeto. Abra o Visual Studio .Net e crie uma solução (sem incluir qualquer projeto). Clique no menu File à New à Project. Dentre os tipos de projetos existentes (Project Types), selecione a opção Visual Studio Solutions e, em List Templates, Blank Solution. Defina o nome da solução como ActivityManager, defina a localização onde o projeto será criado e clique em OK.

Em seguida, crie o banco de dados. Na janela Server Explorer, clique com o botão direito em “Data Connections” e selecione o menu “Create New SQL Server Database...” (veja a Figura 3).

Figura 3: Criando um novo banco de dados

No campo Server da janela Create Database, digite (local) para indicar que o servidor SQL Server local será utilizado para a criação do banco de dados e, no campo New Database Name, digite ActivityManager para definir o nome do banco de dados a ser criado (veja a Figura 4). Caso deseje fazer uso da segurança integrada ao sistema operacional, deixe a opção Use Windows NT Integrated Security assinalada. Do contrário, defina um usuário e a senha para acesso, indicando os respectivos valores nos campos Login Name e Password. Clique no botão OK para criar o banco de dados. Para confirmar a criação do banco de dados, verifique a janela Server Explorer, expandindo os nós da treeview existente em Servers à (Nome do seu computador) à SQL Servers. O banco de dados ActivityManager deverá constar entre os banco de dados existentes no SQL Server.

Figura 4: Definindo o novo banco de dados

O banco de dados ainda não possui nenhum objeto relacionado ao sistema: tabelas, views, stored procedures e índices. Portanto, precisamos criar nosso diagrama de banco de dados, onde faremos o mapeamento das classes definidas nos diagramas de classes para o relacional. Na janela Server Explorer, clique com o botão direito na opção Data Connections (veja na Figura 3) e selecione Add Connection. Será exibida a janela Data Link Properties (Figura 5). Clique na guia Provider e verifique se a opção selecionada é Microsoft OLE DB Provider for SQL Server. Caso não seja, selecione essa opção. Clique na guia Connection. No campo 1, selecione o nome do servidor onde está localizada a instância de SQL Server na qual foi criado o banco ActiveManager – dica: simplesmente digite (local). No campo 2, selecione a opção Use Windows NT Integrated Security (se você estiver usando segurança integrada). No campo 3, selecione o banco de dados ActivityManager e clique no botão Test Connection. Caso a conexão seja realizada com sucesso, clique no botão OK. A conexão criada deverá aparecer abaixo da opção Data Connections da janela Server Explorer (Figura 3). Expanda o nó da treeview dessa conexão e verifique as opções existentes: Database Diagrams, Tables, Views, Stored Procedures e Functions. Se você tentar expandir qualquer um dos nós, perceberá que todos se encontram vazios.

Após criar a conexão e o banco de dados, vamos aos projetos necessários à implementação de nossa solução. Para isso, siga estes passos:

• Na janela Solution Explorer, clique com o botão direito e selecione Add à New Project...

• Selecione um projeto do tipo Windows Application e nomeie-o como ActivityManagerUI, pois este será o projeto relativo à nossa user interface.

Figura 5: Janela Data Link Properties

• Repita novamente o passo 1, selecione um projeto do tipo Class Library e nomeie-o como ActivityManagerBO. Aqui serão definidos os objetos de negócio (Business Objects);

• Repita os passos 1 e 3 e nomeie o projeto como ActivityManagerData. Aqui teremos os objetos de acesso ao banco de dados;

• Repita o passo 1, selecione Others Projects à Database Projects, selecione um projeto do tipo Database Project e nomeie-o como ActivityManagerDB. Na janela Add Database Reference aberta, selecione a conexão criada anteriormente e clique em OK. Esse projeto servirá para criar todos os scripts necessários às futuras implementações do banco de dados.

Criando os objetos no banco de dados

O próximo passo consiste em criar a base de dados. O Visual Studio .Net faz juz ao “I” de IDE (Integrated Development Environment – Ambiente de Desenvolvimento Integrado), principalmente porque o MSDE não possui o Enterprise Manager, ambiente de gerenciamento visual do SQL Server que permite realizar todas as tarefas relativas à criação e manutenção dos objetos existentes no banco de dados.

Para criar as tabelas do banco de dados, siga estes passos:

• Na janela Server Explorer (Figura 3), clique no nó da treeview da conexão criada anteriormente com o banco de dados ActivityManager para expandi-lo.

• Clique com o botão direito em Database Diagrams e selecione New Diagram.

• Na área principal, clique com o botão direito e selecione New Table.

• Na janela Choose Name, defina o nome da tabela no campo correspondente. Durante a criação de um banco de dados e suas tabelas, o principal desafio consiste em traduzir o modelo definido no diagrama de classes. Não podemos nos esquecer em nenhum momento de que o banco de dados é a persistência dos objetos. Para este mapeamento, utilize a seguinte técnica: cada classe representa uma tabela, e os relacionamentos entre as classes são traduzidos nas chaves estrangeiras necessárias. Essa regra não cobre 100% dos casos, mas ajuda a ter uma visão clara e rápida do banco. Cada campo a ser adicionado na tabela é representado pelos atributos existentes na classe. Neste momento, as operações das classes poderão ser ignoradas, pois elas não serão representadas no modelo ER do banco de dados.

• Repita os passos 3 e 4 para criar cada nova tabela necessária. Crie as tabelas Activity e Attachment de acordo com a Figura 6.

• Adicione um relacionamento entre as tabelas Activity e Attachment. Para isso, clique no campo Id da tabela Activity e arraste-o sobre o campo IdActivity da tabela Attachment.

• Salve o diagrama, definindo seu nome como ActivityManagerDiagram.

Depois que você criar as tabelas, o banco de dados deverá estar igual ao apresentado na Figura 6:

Figura 6: Banco de Dados ActivityManager

Se você comparar o diagrama do banco de dados com o diagrama de classes criado anteriormente, perceberá que existe mais classes que tabelas. Isso acontece porque algumas classes criadas são coleções (traduzidas no diagrama de banco de dados pelo relacionamento “1 – n” entre as tabelas). Existe o modelo enumerações, (que traduz o banco de dados como as chamadas “tabelas auxiliares”), as quais poderiam ser usadas, por exemplo, para melhorar a apresentação de informações em relatórios. Como o sistema é relativamente simples e não tem requisitos de criação de relatórios, optamos por não incluir essas tabelas no banco de dados.

O próximo passo na criação de objetos do banco de dados é definir as stored procedures necessárias para a inclusão, alteração, exclusão e busca dos dados nas tabelas criadas. Para essa tarefa, execute os seguintes passos:

• Abra o nó da treeview referente à conexão criada na janela Server Explorer (Figura 3).

• Clique com o botão direito na opção Stored Procedure e selecione New Stored Procedure. Na janela de documento, aparecerá um script com as definições parciais de criação da stored procedure, conforme o seguinte código:

CREATE PROCEDURE dbo.StoredProcedure1
/*
	(
		@parameter1 datatype = default value,
		@parameter2 datatype OUTPUT
	)
*/
AS
	/* SET NOCOUNT ON */
	RETURN

• Defina o nome da stored procedure como up_InsertActivity. O prefixo “up_” significa “user procedure” e deve ser inserido à frente de todas as procedures que nós criarmos, a fim de facilitar sua identificação; Insert serve para definir a operação a ser executada e, por fim, o nome da tabela que será afetada pela operação.

• Vamos utilizar o assistente para criar as consultas SQL. Clique com o botão direito na janela de documento e selecione Insert SQL. A janela Add Table apresentará as tabelas disponíveis no banco de dados para a criação de uma sentença SQL. Selecione Activity e clique no botão Add. Clique em Close para fechar a janela. A tela estará dividida em 4 painéis: Diagram Pane, Grid Pane, SQL Pane e Result Pane, respectivamente, de cima para baixo.

• No Diagram Pane, clique com o botão direito e selecione Change Type à Insert Values. Como o padrão de desenvolvimento é configurado para a criação de consultas, com esta operação você altera o assistente para as outras sentenças SQL disponíveis (neste caso, para a criação de Inserts).

• Selecione os campos da tabela para a sentença SQL. Selecione todos exceto Id. À medida que você seleciona uma coluna, esta é disponibilizada no Grid Pane. Na coluna New Value, repita o nome de cada coluna, acrescentando “@” ao início de cada palavra. Por exemplo: Column: assunto; New Value: @assunto. Salve a sentença SQL e feche o assistente.

• De volta ao script da Stored Procedure, adicione os parâmetros necessários para que ela seja executada na parte comentada do script. A Listagem 1 apresenta a Stored Procedure up_InsertActivity.

Listagem 1. Script de criação de Stored Procedures

CREATE PROCEDURE dbo.up_InsertActivity
	@assunto nvarchar(200),
	@dataInicio smalldatetime,
	@dataTerminoPrevista smalldatetime = NULL,
	@dataTermino smalldatetime = NULL,
	@lembrete smalldatetime = NULL,
	@descricao ntext = NULL,
	@trabalhoTotal int = NULL,
	@trabalhoTotalPrevisto int = NULL,
	@status smallint,
	@activityColor smallint,
	@priority  smallint,
	@returnValue int OUTPUT
AS
	INSERT INTO Activity (assunto, dataInicio, dataTerminoPrevista, dataTermino, lembrete,
		descricao, trabalhoTotal, trabalhoTotalPrevisto, status, activityColor, priority)
	VALUES (@assunto, @dataInicio, @dataTerminoPrevista, @dataTermino, @lembrete,
		@descricao, @trabalhoTotal, @trabalhoTotalPrevisto, 
		@status, @activityColor, @priority)
	
	SELECT @returnValue = @@identity

• Para salvar a Stored Procedure, clique no botão Salvar.

• Repita os passos de 2 a 7 para criar as seguintes Stored Procedures:

  • up_InsertAttachment;

  • up_UpdateActivity;

  • up_UpdateAttachment,;

  • up_DeleteActivity;

  • up_DeleteAttachment.

Além dessas, que seguem o padrão de nomenclatura explicado anteriormente, criaremos: up_LoadActivity, up_LoadAttachment, cuja finalidade é recuperar um objeto Activity ou Attachment do banco de dados; up_LoadActivities, cuja finalidade é recuperar todos os objetos Activity do banco de dados, e up_LoadAttachmentFromActivity, que retornará todos os anexos (id e nome apenas) de uma atividade informada. Não criaremos Stored Procedures para a realização de buscas, pois elas serão criadas dinamicamente na aplicação.

Uma vez criados os objetos de banco de dados necessários para a aplicação, é preciso criar os scripts que irão gerar o banco de dados dinamicamente quando você fizer o deployment da aplicação. Para isso, execute os seguintes passos:

• Na janela Server Explorer (Figura 3), clique com o botão direito na conexão criada com o banco de dados e selecione Generate Create Script. Esta janela (Figura 7) informará quais scripts poderemos criar.

• Na guia General, selecione a caixa Script All Objets. Todos os objetos do banco de dados criados anteriormente serão adicionados ao textbox Objects to be scripted, do qual serão gerados scripts de criação.

• Clique na guia Options. Clique em Script database. Se você não estiver usando segurança integrada, selecione também as 3 caixas seguintes.

• Clique no botão OK. Será exibida a janela Browser for Folder, com o folder Create Scripts relativo ao projeto ActivityManagerDB selecionado. Note que o script está sendo automaticamente adicionado ao projeto. Clique novamente em OK.

• Observe o folder Create Scripts do projeto citado no passo anterior. Todos os scripts necessários para a criação dos objetos, inclusive o banco de dados, estarão dentro dele.

Figura 7: Janela Generate Create Scripts

No próximo artigo, desenvolveremos os objetos definidos e implementaremos o acesso ao banco de dados, sempre observando as boas práticas da programação. Aprenderemos também a utilizar as propriedades de conectividade existentes nos objetos de User Interface e a utilizar o ADO.Net dentro de uma arquitetura de “n” camadas.

Conclusão

De modo geral, este projeto é bastante simples. Certamente você já deve ter imaginado muitos outros requisitos, e a idéia é justamente esta: permitir que você possa exercitar os conhecimentos aqui iniciados e aprimorar o sistema. Não se esqueça, porém, que você deve sempre partir do modelo, planejando, avaliando impactos e, aí sim, escrever o código.

Nesta primeira parte, pudemos ter uma noção de como desenvolver software de maneira profissional e ver também que esse procedimento pode ser aplicado a qualquer nível de software, mesmo sendo extremamente simples o desenvolvimento. Desenhamos o sistema, geramos os esqueletos de código e criamos a estrutura principal do projeto. Por fim, utilizamos os recursos do Visual Studio para criar o projeto de banco de dados com as ferramentas de que ele dispõe, o que nos permitiu diagramar e criar os objetos necessários para uso do sistema, bem como gerar os scripts para posterior deployment do repositório.

Wallace Cézar Sales dos Santos (wallace_cezar@hotmail.com) é Arquiteto de Software da Datasul S.A., responsável pelos sistemas que utilizam a tecnologia Microsoft .NET. Profissional certificado como MCSD, MCP e MVP (Microsoft Most Valuable Professional), colabora com diversas comunidades de desenvolvedores nacionais que utilizam a tecnologia .Net. É também co-autor do livro Desenvolvendo com C#, lançado pela editora Bookman, e atualmente trabalha em um livro sobre Visual Basic .Net.