Clique aqui para ler todos os artigos desta edição
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 http://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:
1. Atores:
a. Usuário;
b. Repositório de atividades;
c. Arquivo de configuração.
2. Casos de Uso:
a. Permitir que o Usuário (ator identificado) possa gerenciar suas atividades;
b. Permitir que o Usuário possa procurar suas atividades;
c. Permitir que o Usuário receba lembretes de suas atividades do sistema;
d. 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 http://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):
1. Faça o download do Web Site da Microsoft (http://www.microsoft.com/sql/msde/downloads/download.asp);
2. 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;
3. 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;
4. 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:
1. Na janela Solution Explorer, clique com o botão direito e selecione Add à New Project...
2. 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
3. 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);
4. Repita os passos 1 e 3 e nomeie o projeto como ActivityManagerData. Aqui teremos os objetos de acesso ao banco de dados;
5. 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:
1. 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.
2. Clique com o botão direito em Database Diagrams e selecione New Diagram.
3. Na área principal, clique com o botão direito e selecione New Table.
4. 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.
5. 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.
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.
7. 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:
1. Abra o nó da treeview referente à conexão criada na janela Server Explorer (Figura 3).
2. 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
3. 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.
4. 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.
5. 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).
6. 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.
7. 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
8. Para salvar a Stored Procedure, clique no botão Salvar.
9. Repita os passos de 2 a 7 para criar as seguintes Stored Procedures:
a. up_InsertAttachment;
b. up_UpdateActivity;
c. up_UpdateAttachment,;
d. up_DeleteActivity;
e. 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:
1. 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.
2. 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.
3. Clique na guia Options. Clique em Script database. Se você não estiver usando segurança integrada, selecione também as 3 caixas seguintes.
4. 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.
5. 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.
