monografia - sistema acadêmico em asp.net 2.0.pdf
TRANSCRIPT
CENTRO PAULA SOUZA
FACULDADE DE TECNOLOGIA DE TAQUARITINGA
TECNÓLOGO EM PROCESSAMENTO DE DADOS
SISTEMA ACADÊMICO EM ASP.NET 2.0
ERICK EDUARDO PETRUCELLI
ORIENTADOR: CLÁUDIO SHINJI MATSUMOTO
Taquaritinga
2007
SISTEMA ACADÊMICO EM ASP.NET 2.0
ERICK EDUARDO PETRUCELLI
Monografia apresentada à Faculdade de Tecnologia de
Taquaritinga, como parte dos requisitos para a obtenção do título
de Tecnólogo em Processamento de Dados.
Orientador: Cláudio Shinji Matsumoto
Taquaritinga
2007
Dedico,
Aos meus pais, namorada e irmã
que sempre me apoiaram,
e acreditaram em minha capacidade.
AGRADECIMENTOS
Em primeiro lugar a Deus, por me capacitar para a realização deste trabalho.
Ao Prof. Cláudio Shinji Matsumoto, pela orientação concedida.
Aos amigos e familiares, pelo excepcional apoio prestado.
Sistema Acadêmico em ASP.NET 2.0 - iv
SUMÁRIO
LISTA DE FIGURAS ................................................................................................................ v
LISTA DE ABREVIATURAS E SIGLAS ............................................................................... vi
RESUMO ................................................................................................................................. vii
ABSTRACT ............................................................................................................................ viii
INTRODUÇÃO ......................................................................................................................... ix
1. LEVANTAMENTO DE REQUISITOS .......................................................................... 10
1.1. Cenário Atual ............................................................................................................ 11
1.2. Escolhas Tecnológicas .............................................................................................. 13
2. PLATAFORMA .NET ..................................................................................................... 17
2.1. Framework .NET ...................................................................................................... 18
2.2. Linguagem C# .......................................................................................................... 20
2.3. ASP.NET .................................................................................................................. 24
3. CENTRAL DE GESTÃO ACADÊMICA ....................................................................... 28
3.1. Definição de Escopo ................................................................................................. 28
3.2. Desenvolvimento Iterativo e Incremental................................................................. 29
3.3. Modelo de Banco de Dados ...................................................................................... 30
3.4. Segurança de Acesso ................................................................................................ 33
3.5. Cadastros .................................................................................................................. 36
3.6. Matrícula ................................................................................................................... 38
3.7. Arquitetura ................................................................................................................ 42
CONCLUSÃO .......................................................................................................................... 44
REFERÊNCIAS BIBLIOGRÁFICAS ..................................................................................... 45
BIBLIOGRAFIA ...................................................................................................................... 46
Sistema Acadêmico em ASP.NET 2.0 - v
LISTA DE FIGURAS
FIGURA 1 - Evolução da utilização de sistemas. .................................................................... 10 FIGURA 2 - Primeira versão do CGA. .................................................................................... 12 FIGURA 3 - Segunda versão do CGA. .................................................................................... 12
FIGURA 4 - Performance na interpretação de documentos XML. .......................................... 14 FIGURA 5 - Integração do SQL Server 2005 com o Visual Studio 2005. .............................. 15 FIGURA 6 - Estatística de utilização de navegadores. ............................................................ 16 FIGURA 7 - Ambiente do Visual Studio 2005. ....................................................................... 17
FIGURA 8 - Componentes do .NET Framework. .................................................................... 19 FIGURA 9 - Evolução da linguagem C#.................................................................................. 22 FIGURA 10 - Geração 1: servidor de páginas sem processamento. ........................................ 24
FIGURA 11 - Geração 2: páginas passam por processamento prévio. .................................... 25 FIGURA 12 - Geração 3: os códigos são independentes da página e multiplataforma. .......... 26 FIGURA 13 - Processo iterativo incremental. ......................................................................... 29 FIGURA 14 - Modelo de dados: cadastro de pessoas. ............................................................. 30
FIGURA 15 - Modelo de dados: cadastro de disciplinas. ........................................................ 31 FIGURA 16 - Modelo de dados: cadastro de alunos. ............................................................... 31
FIGURA 17 - Modelo de dados: segurança do sistema. .......................................................... 32 FIGURA 18 - Modelo de dados: matrícula e histórico escolar. ............................................... 33 FIGURA 19 - Caso de uso: acesso ao sistema. ........................................................................ 34
FIGURA 20 - Tela de acesso ao sistema. ................................................................................. 35
FIGURA 21 - Tela principal para os alunos. ............................................................................ 36
FIGURA 22 - Caso de uso: telas de manutenção. .................................................................... 37 FIGURA 23 - Tela de gerenciamento dos dados do aluno. ...................................................... 37
FIGURA 24 - Caso de uso: matrícula inicial. .......................................................................... 38 FIGURA 25 - Tela de criação de novos alunos. ....................................................................... 39 FIGURA 26 - Caso de uso: matrícula presencial. .................................................................... 39
FIGURA 27 - Tela de matrícula presencial. ............................................................................. 40
FIGURA 28 - Caso de uso: matrícula virtual. .......................................................................... 40 FIGURA 29 - Tela de re-matrícula virtual dos alunos. ............................................................ 41 FIGURA 30 - Diagrama de componentes. ............................................................................... 42
Sistema Acadêmico em ASP.NET 2.0 - vi
LISTA DE ABREVIATURAS E SIGLAS
.NET Plataforma de Desenvolvimento da Microsoft
ADO Access Data Objects (Objetos de Acesso a Dados)
ASP Active Server Pages
CGA Cadastro Geral de Alunos ou Central de Gestão Acadêmica
CLR Common Language Runtime
CPU Central Processing Unit (Unidade Central de Processamento, ou Processador)
DLL Dynamically Linked Library
DOM Document Object Model
ECMA European Computer Manufacturers Association
GB Giga Byte
HTML Hyper Text Markup Language
HTTP Hyper Text Transfer Protocol
IE Internet Explorer
IIS Internet Information Services
ISO International Organization for Standardization
JSP Java Server Pages
JVM Java Virtual Machine
MB Mega Byte
MSIL Microsoft Intermediate Language
OOP Object Oriented Programming (Programação Orientada a Objetos)
PHP Hypertext Preprocessor
RA Registro Acadêmico
RAD Rapid Application Development (Desenvolvimento Rápido de Aplicações)
RSS Really Simple Syndication
SQL Structured Query Language
TI Tecnologia da Informação
W3C World Wide Web Consortium
WAP Wireless Application Protocol
XML Extensible Markup Language
Sistema Acadêmico em ASP.NET 2.0 - vii
RESUMO
Nesse trabalho é apresentado o planejamento e o processo de desenvolvimento de um
sistema acadêmico, com foco nas necessidades da Faculdade de Tecnologia de Taquaritinga,
apoiando-se nas principais técnicas de programação para Internet através da plataforma .NET
da Microsoft, com a linguagem C# em conjunto com as tecnologias oferecidas pelo ASP.NET
2.0. São discutidas todas as escolhas tecnológicas para a criação do sistema, apresentando de
forma sucinta com dados e gráficos o porquê de cada decisão, a fim de demonstrar a
viabilidade das propostas deste trabalho e como cada uma delas favorece a criação do sistema
e pode facilitar sua manutenção. Por fim, tornou-se possível constatar que a utilização da
Internet como base para sistemas de gestão – sejam eles acadêmicos ou não – pode ser um
grande atrativo, além de facilitar um dos maiores desafios de sistemas a serem acessados por
diferentes usuários em diferentes lugares, que é a distribuição do mesmo.
Palavras-Chaves: Sistema; Gestão; Acadêmico; CGA.
Sistema Acadêmico em ASP.NET 2.0 - viii
ABSTRACT
In this work is presented the planning and the development process of an academic
system, focused in the necessities of the “Faculdade de Tecnologia de Taquaritinga”, using
the main programming techniques for Internet through the Microsoft .NET platform, with the
C# language and the technologies offered by ASP.NET 2.0. The technological choices for the
system creation are evaluated, presenting in resumed data and graphs the reason of each
choice, in order to demonstrate the viability of this work proposals and as each one of them
allow the system creation and are able to turn its maintenance more easy. Finally, was became
possible to evidence that the use of the Internet as base for management systems – academics
systems or not – can be a great attractive, facilitating one of the biggest challenges of systems
to be had accessed for different users in different places, that is it distribution.
Keywords: System; Management; Academic; CGA.
INTRODUÇÃO
Desde os primórdios da humanidade, organizar as informações vem sendo um desafio.
E é este mesmo desafio que ainda hoje impulsiona os avanços na área de tecnologia da
informação.
Nas últimas décadas, o processo de informatização deixou de ser estritamente
científico, militar e acadêmico, para se tornar comercial. Desde então, a informatização
tornou-se um instrumento administrativo, mostrando-se uma ferramenta poderosa de gestão.
As principais vantagens agregadas pela tecnologia foram: capacidade de
manipular uma enorme quantidade de dados simultaneamente; precisão,
velocidade, menor desperdício e redução de custo (automação de tarefas) e, com
o advento da Internet, ampliou-se os mercados consumidores ao tamanho
atingido pela grande rede. Transformar toda a tecnologia que está disponível em
oportunidades é o grande desafio, assim como compreender exatamente para que
a informatização é desejada (Orlandini, 2005).
Sendo assim, a informatização pode oferecer inúmeras vantagens e oportunidades.
Além disso, com a proliferação da Internet, a criação de sistemas totalmente conectados e
disponíveis todo o tempo tornou-se simples e, o mais importante, barata.
Dadas estas oportunidades, este trabalho pretende apresentar a criação de um sistema
de gestão acadêmica online, facilitando as operações das três entidades principais envolvidas:
alunos, professores e funcionários administrativos.
1. LEVANTAMENTO DE REQUISITOS
O objetivo de construir um sistema acadêmico aproveitando-se das oportunidades
oferecidas por um ambiente de Internet vai de encontro à necessidade por este tipo de sistema
por parte da instituição para a qual este trabalho é elaborado, a Faculdade de Tecnologia de
Taquaritinga (doravante citada apenas como FATEC Taquaritinga).
Tal necessidade não se trata de um fato isolado, mas algo comum a diversas
instituições de ensino. Segundo Orlandini (2005), com a presença cada vez mais constante de
serviços de hospedagem de sistemas pela Internet, é provável que a informatização esteja tão
acessível e tão presente nas organizações quanto a energia elétrica. Um número cada vez
maior de empresas está aderindo a esse serviço, que possibilita acima de tudo uma redução
dramática nos custos inerentes à infra-estrutura de TI.
Esta evolução da Internet como base para sistemas de informação pode ser observada
no FIG. 1. Em um período de dez anos, sistemas publicados para Internet cresceram
aproximadamente 60%.
FIGURA 1 - Evolução da utilização de sistemas.
FONTES: Info Online (http://info.abril.com.br/) e IBGE (http://www.ibge.com.br).
Sistema Acadêmico em ASP.NET 2.0 - 11
As instituições de ensino superior, em especial as instituições públicas, parecem estar
no extremo oposto deste cenário. Mesmo instituições diretamente relacionadas a tecnologia,
como a FATEC Taquaritinga, muitas vezes não possuem ferramentas de ponta aproveitando-
se deste conhecimento.
Uma das preocupações deste trabalho, desde o início do levantamento de requisitos,
foi avaliar como elaborar o proposto sistema acadêmico de forma que se torne facilmente
manutenível e expansível, pela própria instituição, através de seus alunos e estagiários.
Também existe a preocupação com a continuidade do projeto, possibilitando que, com o
passar do tempo, o sistema se torne cada vez mais produtivo e, o mais importante, auxiliando
a faculdade a também se tornar mais produtiva.
1.1. Cenário Atual
O primeiro passo tomado no processo de modelagem foi o entendimento do cenário
atual da instituição em relação à automação acadêmica. Para uma melhor compreensão, pode-
se dividir este cenário em três fases principais.
A primeira fase está ligada ao início das atividades da faculdade. Este período é
marcado justamente pelo inverso à proposta deste trabalho, ou seja, pela inexistência de
qualquer tipo de sistema de apoio às atividades acadêmicas.
Paralelamente, a faculdade estava se formando e adquirindo seu formato de trabalho.
Nesta etapa inicial, surgem muitos costumes – os quais por diversas vezes vem a se tornar
regras – de como as tarefas devem ser realizadas na instituição.
O início da segunda fase deixa bem claro este ponto. Neste período, surge o primeiro
sistema acadêmico da instituição, moldado com o fim principal de substituir algumas
operações manuais, as mesmas operações consolidadas durante a primeira fase.
Esta abordagem de desenvolvimento, onde o sistema apenas informatiza determinadas
tarefas, não apresentando melhorias no processo da organização, era totalmente normal e
ainda hoje é muito freqüente.
De pouco adianta todo o potencial da informatização se os sistemas não estiverem
muito bem coordenados e analisados. Informatizar tarefas mal formuladas traz novos
problemas e nenhuma solução, além de nublar as possíveis causas dessas falhas. Essa situação
infelizmente é bastante comum, pois existe uma grande confusão sobre a análise de sistemas e
a programação dos mesmos (Orlandini, 2005).
Sistema Acadêmico em ASP.NET 2.0 - 12
Este primeiro sistema, desenvolvido em Clipper, ganhou o nome de Cadastro Geral de
Alunos (conhecido também pela sigla CGA), visto que seus objetivos eram estritamente os de
manter o cadastro dos dados pessoais dos alunos e automatizar a geração do RA (registro
acadêmico) para novos alunos.
A FIG. 2 demonstra a tela de cadastro básico dos alunos. Como pode ser observado, o
sistema recebeu atualizações até a versão 5.1, no ano 2000.
FIGURA 2 - Primeira versão do CGA.
FONTE: Sistema CGA versão 5.1 Y2K.
Por fim, a terceira fase é corresponde à criação da segunda versão do CGA (FIG. 3), o
que ocorreu no final de 2004. Tal versão pode ser descrita como uma adaptação do CGA
original com a inclusão de algumas novas ferramentas para automação de tarefas acadêmicas,
tais como matrícula de alunos, lançamento de notas e faltas e impressão de alguns relatórios.
FIGURA 3 - Segunda versão do CGA.
FONTE: Sistema CGA versão 2004.
Sistema Acadêmico em ASP.NET 2.0 - 13
Esta segunda versão do sistema foi desenvolvida em parceria com a empresa de
tecnologia Politec S/A, a qual havia acabado de abrir sua filial na cidade de Taquaritinga,
como uma forma prática de treinar alguns de seus funcionários e ao mesmo tempo retribuir o
apoio da faculdade durante o processo seletivo destes funcionários.
Tal sistema começou a ser desenvolvido sem uma fase elaborada de análise e com a
versão 1.1 da plataforma .NET da Microsoft, sendo migrado posteriormente para as versões
Beta 1, Beta 2 e Final da plataforma .NET 2.0. Este desenvolvimento sem planejamento
acabou deixando o sistema com alguns problemas, principalmente em relação à arquitetura e à
manutenção, segundo os próprios participantes do projeto.
1.2. Escolhas Tecnológicas
Verificados os problemas encontrados nos sistemas anteriores e delineados os
principais objetivos do novo sistema, algumas escolhas tecnológicas começaram a ser
tomadas.
O primeiro passo foi definir a metodologia a ser utilizada. Escolheu-se a Análise
Orientada a Objetos, por ser amplamente utilizada e de fácil compreensão. Além disso, visto
que o alvo do sistema é o ambiente de Internet, a orientação a objetos mostra-se um grande
atrativo, pois as duas maiores tecnologias de desenvolvimento para Internet atualmente
existentes são JSP, para desenvolvimento Java, e ASP.NET, para desenvolvimento .NET
(Johnson, 2007).
Além disso, uma das maiores vantagens da orientação a objetos é a reutilização do
código, possibilitada em sua maior parte graças ao recurso de herança de classes, onde classes
específicas podem se aproveitar de recursos de classes mais genéricas, evitando repetições
desnecessárias de código (Cardoso, 2006). Em um sistema projetado para se tornar facilmente
manutenível e expansível, este recurso representa um ganho considerável, tornando a escolha
da orientação a objetos um bom diferencial.
Já a escolha entre uma das duas maiores plataformas de desenvolvimento orientado a
objetos, Java ou .NET, nem sempre é fácil. Enquanto Java possui ao seu lado a força do
software livre, a plataforma .NET demonstra cada vez mais seu crescimento e ganha espaço
em relação à produtividade.
Sistema Acadêmico em ASP.NET 2.0 - 14
Além disso, a plataforma .NET vem se mostrando cada vez mais performática em
diversos fatores, como o tratamento de documentos DOM (Document Object Model) e XML
(Extensible Markup Language), padrões incrivelmente utilizados e disseminados. A FIG. 4
exibe um comparativo de desempenho na leitura e interpretação de documentos XML entre as
versões 1.1 e 2.0 do Framework .NET em relação ao Java 1.5.
FIGURA 4 - Desempenho na interpretação de documentos XML.
FONTE: Microsoft Developers Network (http://www.msdn.com).
Contudo, até pouco tempo, nenhum tipo de comparativo poderia ser decisivo na
escolha entre Java e .NET, visto que o primeiro era gratuito enquanto o segundo não. Esta
situação foi resolvida em 2005, com o lançamento das versões Express Edition de diversos
produtos de desenvolvimento da Microsoft, versões essas que possuem licença de utilização
livre, contanto que o produto final não seja comercializado, algo que não representa um
problema para o sistema acadêmico da faculdade.
Já a escolha entre as versões 1.1 ou 2.0 do .NET Framework não exige grandes
análises. Segundo Marques (2005), a quantidade de recursos e o aumento de produtividade no
desenvolvimento para a versão 2.0 é visível – conforme será discutido mais profundamente no
decorrer deste trabalho – o que facilita a escolha.
A escolha do banco de dados, o SQL Server 2005 Express Edition, está diretamente
relacionada às duas escolhas citadas acima. Sendo uma versão Express Edition, sua limitação
é quanto à comercialização e quanto ao tamanho limite do arquivo do banco de dados no
disco rígido (no máximo 4 GB). Tal limite não representa um problema, já que atualmente,
usando o SQL Server 2000, com 15 anos de dados da FATEC cadastrados, o banco de dados
não ultrapassou 25 MB. Além disso, o SQL Server 2005 foi desenhado para ser totalmente
Sistema Acadêmico em ASP.NET 2.0 - 15
integrado ao desenvolvimento .NET. O uso de SQL Server 2005 em conjunto com o .NET 2.0
representa mais um grande ganho de produtividade para o desenvolvimento (Ryan, 2006).
A FIG. 5 demonstra como todos os recursos de visualização e edição dos dados e da
própria estrutura das bases de dados estão totalmente integrados com o ambiente de
desenvolvimento do .NET 2.0, o que agiliza e facilita o desenvolvimento.
FIGURA 5 - Integração do SQL Server 2005 com o Visual Studio 2005.
FONTE: Microsoft Visual Studio 2005.
Escolhidas as tecnologias de desenvolvimento e armazenamento das informações, faz-
se necessário realizar definições sobre o ambiente esperado para os usuários do sistema, visto
que não é possível controlar a forma como cada usuário acessará a aplicação, sendo esta
publicada pela Internet.
Quando o foco é desenvolvimento Web, é essencial ter definido desde o início quais
navegadores serão adotados para navegar pelo sistema, visto que cada navegador possui suas
próprias peculiaridades em relação à interpretação dos padrões.
O órgão que regulamenta a padronização de desenvolvimento para Internet, chamado
W3C (World Wide Web Consortium), possui diversas recomendações de melhores práticas de
desenvolvimento e para quais navegadores são voltadas. Além disso, possui diversas
estatísticas que auxiliam a escolher os navegadores-alvos na hora da definição de escopo.
Sistema Acadêmico em ASP.NET 2.0 - 16
A FIG. 6 apresenta estatísticas de janeiro de 2002 a julho de 2007 quanto à utilização
de navegadores. É possível perceber que, segundo o W3C (2007), os únicos navegadores com
utilização maior que 10% são: Internet Explorer 6, Internet Explorer 7 e Firefox.
FIGURA 6 - Estatística de utilização de navegadores.
FONTE: W3 Schools (http://www.w3schools.com).
Outra preocupação importante está relacionada ao suporte a JavaScript pelos
navegadores escolhidos. Apesar de toda a evolução ocorrida nos servidores e plataformas de
desenvolvimento para Internet, no lado do usuário final o navegador ainda é capaz apenas de
executar instruções simples realizadas por scripts. Dentre as linguagens de script existentes
para Internet, a mais utilizada e suportada é o JavaScript.
Mesmo assim, sempre existem pessoas que desabilitam a execução de JavaScript em
seus navegadores. Contudo, a TAB. 1 mostra que atualmente existem poucos motivos para se
preocupar com isto, segundo o W3C (2007).
TABELA 1 - Percentual de usuários que habilitam JavaScript nos navegadores.
Ano JavaScript Habilitado JavaScript Desabilitado
2007 94% 6%
2006 92% 8%
2005 90% 10%
2004 90% 10%
2003 89% 11%
2002 88% 12%
FONTE: W3 Schools (http://www.w3schools.com).
2. PLATAFORMA .NET
Para o entendimento do sistema proposto, deve-se primeiro entender o funcionamento
geral da plataforma .NET e seu ambiente de desenvolvimento para Internet.
Denomina-se plataforma .NET o conjunto de componentes desenvolvidos pela
Microsoft, com alvo em sistemas Windows, desenhados para suportar aplicações e serviços de
última geração (Ryan, 2006).
Um grande destaque da plataforma .NET está na facilidade de desenvolvimento de
aplicações para os mais diversos tipos de dispositivos. Parte desta facilidade está nos vastos
recursos do Framework .NET, a ser detalhado a seguir, e do ambiente de desenvolvimento
produtivo, chamado Microsoft Visual Studio (FIG. 7).
FIGURA 7 - Ambiente do Visual Studio 2005.
FONTE: Microsoft Visual Studio 2005.
Sistema Acadêmico em ASP.NET 2.0 - 18
2.1. Framework .NET
O Framework .NET é a base da plataforma. Muitos especialistas realizam
comparações com a JVM (Java Virtual Machine).
De certa forma, o Framework .NET também é uma máquina virtual, pois representa
uma camada adicional entre o sistema operacional e código das aplicações desenvolvidas para
a plataforma. Porém, mais do que uma máquina virtual sobre o sistema operacional, o
Framework .NET possui um conjunto de bibliotecas de componentes completa,
automatizando diversas tarefas.
Além disso, assim como em Java, o código escrito não é compilado em linguagem de
máquina, mas sim e uma linguagem intermediária, chamada de MSIL (Microsoft Intermediate
Language), interpretada pelo Framework no momento da execução, de forma similar ao que
ocorre com o código intermediário de Java, chamado byte-code, interpretado pela JVM.
O Framework .NET abrange uma estrutura de objetos, classes e ferramentas que
se integram ao sistema operacional para fornecer suporte ao desenvolvimento.
Ao instalar o .NET Framework em uma máquina não é necessário fazer a
distribuição de outros componentes, uma vez que todos já estão instalados. Isto
facilita o desenvolvimento e a distribuição de aplicações (Sinsic, 2004).
A base do Framework .NET é o componente CLR (Common Language Runtime),
responsável pela comunicação direta com o sistema operacional, gerenciando o uso da
memória, requisitando a execução de instruções na CPU, etc. Também é responsabilidade do
CLR interpretar a MSIL gerada durante a compilação dos programas .NET, traduzindo em
linguagem de máquina. De forma a traçar um comparativo mais específico, pode-se dizer que
o CLR é a parte do Framework .NET que corresponde à Java Virtual Machine.
Isto garante que a portabilidade na plataforma não é responsabilidade do compilador
de cada linguagem e sim do CLR, ou seja, todos os hardwares e sistemas operacionais cuja
Microsoft desenvolve uma versão do Framework .NET são automaticamente capazes de
executar qualquer aplicação desenvolvida em qualquer uma das linguagens suportadas. Além
disso, existem projetos de migração, como o Mono, para sistemas não suportados pela
Microsoft, como Linux e Solaris, que garantem grande compatibilidade com o Framework
.NET original (Leitão, 2007).
Sistema Acadêmico em ASP.NET 2.0 - 19
Acima do Common Language Runtime, existe uma gama de bibliotecas especializadas
nas mais diversas tarefas e ambientes, como ADO.NET e ASP.NET, dentre outros (FIG. 8).
Os blocos em cinza representam os componentes existentes em todos os sistemas Windows,
independentes do .NET Framework.
FIGURA 8 - Componentes do .NET Framework. FONTE: Microsoft (http://www.microsoft.com).
Sobre o suporte a diversas linguagens, cabe citar que Visual Basic .NET, C#,
C++.NET, Perl.NET, J# e aproximadamente mais 35 outras linguagens podem ser utilizadas
no desenvolvimento. Qualquer linguagem que manipule objetos pode ser utilizada com o
Framework .NET. Até linguagens antigas como COBOL, Mumps e Python estão disponíveis
em versão atualizada e orientada a objetos para o Framework .NET.
Em teoria, como o Framework é um repositório de componentes e objetos e todas as
linguagens se transformam na mesma MSIL durante a compilação, as linguagens funcionam
apenas como script, instanciando os objetos que precisam, alimentam suas propriedades e
respondem aos eventos.
Dentre toda esta gama de linguagens, podemos dar maior ênfase ao C#, visto que,
segundo Petrucelli (2007), foi uma linguagem criada especificamente para a plataforma .NET
e é a mais utilizada.
Sistema Acadêmico em ASP.NET 2.0 - 20
2.2. Linguagem C#
O C# é uma linguagem de programação totalmente nova, inspirada no C++, orientada
a objetos e que foi lançada juntamente com a plataforma .NET, ou seja, tem como principal
foco o desenvolvimento para Web e dispositivos móveis.
Todo código em C#, assim como nas outras linguagens da plataforma .NET, é
compilado duas vezes antes de ser executado. A primeira compilação, pelo
compilador C#, gera um executável ou arquivo com extensão dll que contém o
código MSIL. Posteriormente, este será interpretado pelo compilador JIT (Just in
Time Compiler), componente do CLR (Common Language Runtime) que gera
código nativo para a CPU que está executando a aplicação (Ryan, 2006).
Este código é mantido na memória enquanto estiver sendo utilizado. Mas o
desempenho do restante do sistema operacional não é afetado drasticamente já que, caso essa
rotina não seja mais utilizada, existe outro item do CLR, chamado Garbage Collector,
literalmente um “coletor de lixo”, que limpa da memória os objetos não usados.
Segundo Leitão (2007), a linguagem C# é mais performática que outras linguagens
orientadas a objeto clássicas. Como exemplo, citemos o Smalltalk, onde tudo que está
instanciado na memória é tratado como um objeto. O custo de performance que isto implica é
demasiadamente alto. O extremo oposto, que é o Java, onde os tipos mais primitivos (como
números, textos, booleanos, etc.) não “funcionam” como objeto, atrapalha a codificação e
dificulta conversões entre tipos de dados.
O C# unifica os tipos sem alto custo em tempo de execução. Para isso, ele realiza a
divisão dos tipos por valor e por referência. Um tipo por valor só é convertido para tipo por
referência quando necessário, ou seja, certos valores são diretamente alocados na memória e
só se tornam objetos quando, e se, necessário (Leitão, 2007).
Além de ser uma linguagem robusta para gerenciar a memória automaticamente, o C#
possui outras vantagens como: mecanismo único de tratamento de erros, verificação de todas
as conversões entre tipos de dados, segurança contra overflow (estouro de tamanho de
variáveis, tabelas, arrays, etc.), pois sempre valida qualquer atribuição de valor,
impossibilidade de ambigüidade (não possui valores default) e facilidade de documentação do
código. Tudo isso evita falhas de codificação, execução e segurança, além de tornar o
desenvolvimento mais produtivo.
Sistema Acadêmico em ASP.NET 2.0 - 21
Outro atrativo da linguagem C# é sua sintaxe, incrivelmente parecida com Java, o que
facilita a codificação e quase tão flexível quanto C++, o que atrai os programadores mais
experientes.
A linguagem C# mostra-se a mais eficiente da plataforma .NET, por ter sido criada
especialmente para a mesma e por seguir todos os padrões ISO e ECMA (Ryan, 2006).
Uma declaração de classe, por exemplo, segue a sintaxe abaixo:
<visibilidade> <tipo> <nome>
public class Mensagens
Neste exemplo, a visibilidade define como esta classe poderá ser enxergada durante a
codificação, podendo assumir os valores private (invisível para outras partes do código),
protected (visível apenas para classes que herdarem desta), internal (visível para todas as
classes codificadas dentro do projeto desta) ou public (visível para todas as classes de todos os
projetos, assim como as classes do Framework).
Em seguida, o tipo class é obrigatório para criação de classes, mudando para outras
palavras da linguagem no caso de criação de outros tipos de estruturas, como structs, enums,
etc., os quais não serão tratados aqui.
E por fim o nome desejado para a classe pode utilizar letras e números, contanto que
não contenha espaços e pontuações.
As classes no Framework .NET são tipos customizados que podem conter
variáveis, constantes, métodos, atributos e propriedades. Para garantir a
consistência entre as classes, é possível se utilizar de herança (onde você deriva
uma nova classe de uma já existente, seja ela customizada ou nativa do próprio
Framework) ou uma interface (a qual especifica quais métodos e atributos são
obrigatórios para determinadas classes). Além disso, para que a aplicação esteja
apta a responder a determinadas ações do usuário ou de componentes externos,
você pode se utilizar de eventos em qualquer classe (Ryan, 2006).
Os tipos de dados em C# também são completos e flexíveis, adaptando-se facilmente a
outras tecnologias, como bancos de dados e Web Services (bibliotecas de componentes
acessíveis pela Internet, com o protocolo HTTP), e facilitando a interoperabilidade. Já que as
classes são tipos customizados, um atributo ou propriedade pode assumir qualquer tipo, sendo
este nativo do Framework ou customizado.
Sistema Acadêmico em ASP.NET 2.0 - 22
A TAB. 2 mostra os tipos de dados nativos mais comuns.
TABELA 2 - Tipos de dados em C#.
Tipo Descrição Exemplo de Utilização
string Texto extenso string Variável = “Erick”;
char Caractere único char Variável = ‘E’;
byte Inteiro de 8 bits byte Variável = 255;
short Inteiro de 16 bits short Variável = 15000;
int Inteiro de 32 bits int Variável = 810500;
long Inteiro de 64 bits long Variável = 1234567890;
bool Boolean bool Variável = true;
decimal Decimal (até 29 dígitos) decimal Variável = 159002.2551;
float Decimal (até 16 dígitos) float Variável = 650.5228;
double Decimal (até 7 dígitos) double Variável = 15.55;
DateTime Data e hora DateTime Variável = DateTime.Now;
FONTE: Microsoft Developers Network (http://www.msdn.com).
Com o lançamento da versão 2.0 do Framework .NET, a Microsoft buscou inovar a
linguagem com recursos existentes até então somente em linguagens experimentais e
acadêmicas, pouco aplicados a linguagens comerciais. Esta inovação faz parte dos objetivos
de evolução da linguagem C#, conforme pode ser observado na FIG. 9.
FIGURA 9 - Evolução da linguagem C#. FONTE: Microsoft (http://www.microsoft.com).
Sistema Acadêmico em ASP.NET 2.0 - 23
A seguir, temos um exemplo de classe simples em C#, com um método que realiza a
soma de dois números quaisquer recebidos como parâmetros do método:
01
02
03
04
05
06
07
08
09
10
Namespace NomeProjeto
{
public class ClasseTeste
{
private int SomarNumeros(int p_intN1, int p_intN2)
{
return p_intN1 + p_intN2;
}
}
}
Como única diferença visível na sintaxe do código em relação ao Java, temos a
palavra namespace. Serve para organizar logicamente as classes, sendo parecido com os
pacotes do Java.
No código a seguir, podemos observar a utilização dos recursos de herança e
polimorfismo da orientação a objetos aplicados no C#:
01
02
03
04
05
06
07
08
09
10
11
12
13
14
using System.Windows.Forms;
public class Janelinha : Form
{
public void MostrarMensagem()
{
MessageBox.Show("Mensagem Padrão");
}
public void MostrarMensagem(string p_strMensagem)
{
MessageBox.Show(strMensagem);
}
}
Na linha 03 observamos a herança: a classe trata-se de um uma janela que herda as
características de um formulário base do Windows (a classe Form, existente no próprio .NET
Framework). Em seguida, podemos notar o polimorfismo: os dois métodos MostrarMensagem
tem o mesmo objetivo (mostrar uma mensagem), porém trabalham de maneiras diferentes.
Dentre os recursos novos específicos do C# 2.0, podemos citar as listas genéricas,
conhecido pelo nome em inglês, Generics. Trata-se de uma melhoria que torna a linguagem
mais “tipada”. Isto quer dizer que, dada uma classe customizada, caso desejemos criar uma
coleção com várias destas classes (como uma lista ou uma pilha), não precisamos programar a
estrutura especialmente para esta classe, a estrutura se adapta automaticamente, mesmo que a
classe não seja nativa do Framework .NET.
Sistema Acadêmico em ASP.NET 2.0 - 24
Outro recurso novo são os tipos nulos, conhecidos pelo nome em inglês, Nullable
Types. Este recurso permite que estruturas que por padrão necessitam de algum valor, como
números inteiros ou datas, possam receber valores nulos. Isso facilita no mapeamento com
bancos de dados, que por padrão aceitam valores nulos para quaisquer tipos. Este tipo de
facilidade é um exemplo de coisas que aumentam a produtividade com o C# 2.0.
Por fim, o C# 2.0 é uma das linguagens mais adaptadas ao desenvolvimento para
Internet, através do ASP.NET. A única outra linguagem do .NET que possui tal adaptação é o
Visual Basic .NET (Petrucelli, 2007).
2.3. ASP.NET
Uma aplicação baseada em formulários Windows utiliza os recursos locais da máquina
do cliente, necessitando que se instale o .NET Framework e um poder de processamento
acima de Pentium II 300 e memória de 64 MB, além de exigir Windows 98 ou superior. Com
estas características limitamos em muito a distribuição e utilização fora do ambiente
corporativo (Sinsic, 2004).
Com os recursos presentes e adicionados nos navegadores Web e a aplicação de
servidores inteligentes, foi possível criar um ambiente de aplicações rico e funcional. Antes
disso, a área de aplicações para Internet passou por outras duas fases distintas.
Na primeira fase, os primeiros servidores para Internet eram somente transmissores de
texto em formato HTML (Hyper Text Markup Language, a linguagem de formatação de
documentos para Internet). Esta fase iniciou-se com o Windows NT 4.0 e o IIS 2.0, que fazia
apenas o transporte de dados, recebendo uma solicitação de página e retornando o texto sem
qualquer processamento prévio antes da resposta, conforme FIG. 10.
FIGURA 10 - Geração 1: servidor de páginas sem processamento.
FONTE: Sincic (2004).
Sistema Acadêmico em ASP.NET 2.0 - 25
Na segunda fase, os servidores passaram a ser “inteligentes” e a permitir o
processamento da página antes de retornar ao cliente. Segundo Petrucelli (2007), nesta época
os arquivos de processamento eram códigos script mesclados com o HTML. Em se tratando
de tecnologias Microsoft, a tecnologia utilizada era o ASP (Active Server Pages). A
codificação de uma página ASP simples pode ser conferida abaixo:
<HTML>
<P>Bem Vindo!</P>
<P>Agora são <% Request.Write(Time()) %></P>
</HTML>
As linhas delimitadas pelos sinais “<%” e “%>” eram as chamadas de diretivas, ou
seja, código que antes de retornar ao cliente era processado pelo servidor de aplicações Web
(podendo ser IIS 4.0 ou 5.0), e o que chegava ao navegador do usuário era algo como:
<HTML>
<P>Bem Vindo</P>
<P>Agora são 09:41:30</P>
</HTML>
O modelo gráfico pode ser representado com a FIG. 11:
FIGURA 11 - Geração 2: páginas passam por processamento prévio.
FONTE: Sincic (2004).
Este modelo era lento, pois o servidor era obrigado a ler a página e substituir os dados,
ou seja, trabalhava em modo interpretado, ocasionando erros de desenvolvimento. Além
disso, a verificação de sintaxe acabava sendo uma tarefa adicional aos programadores, por não
haver compilação prévia (Petrucelli, 2007).
Para ganhar performance eram criados componentes compilados do tipo Win32, em
linguagens como Visual Basic 6.0, C++ ou Delphi. Estes então eram chamados pelas diretivas
do código ASP.
Sistema Acadêmico em ASP.NET 2.0 - 26
Outra desvantagem do ASP era a necessidade de montar a página manualmente pela
codificação, uma vez que era necessário colocar a diretiva exatamente no local onde o
resultado deveria ser apresentado, impossibilitando a utilização de ferramentas de design para
facilitar o processo.
Estes problemas e dificuldades também eram marca de tecnologias semelhantes e
concorrentes, como PHP e ColdFusion.
No modelo atual de comunicação e processamento Web, iniciado com o ASP.NET 1.1
e continuado com o 2.0, as páginas não precisam ser processadas, uma vez que as diretivas
não precisam mais ser utilizadas e passamos a ter o conceito de Code Behind.
Neste modelo, a parte dos códigos é compilada e se transforma em um arquivo com
extensão dll e os blocos HTML permanecem em um arquivo separado, que será mesclado ao
resultado do processamento da DLL (Sinsic, 2004). Dessa forma, se ganha desempenho por
não mais interpretar o código página por página.
Além disso, a construção dos códigos é idêntica ao desenvolvimento comum.
Podemos, por exemplo, arrastar uma caixa de texto para a página e manipularmos seus
atributos, como feito em aplicações de formulários Windows.
Outra interessante inclusão é a capacidade do servidor adaptar a página e o HTML
retornado ao cliente conforme a versão do navegador e sistema operacional, incluindo
celulares WAP.
O modelo gráfico pode ser representado com a FIG. 12.
FIGURA 12 - Geração 3: os códigos são independentes da página e multiplataforma.
FONTE: Sincic (2004)
Sistema Acadêmico em ASP.NET 2.0 - 27
O modelo do ASP.NET traz diversas vantagens em relação às gerações anteriores.
Segundo Johnson (2007), podemos dar destaque a:
Modelo de Desenvolvimento de Aplicação Avançado: o ASP.NET é focado no
Desenvolvimento Rápido de Aplicações (RAD, na sigla em inglês) e criação de programas
Orientados a Objetos (OOP). Permite que você trabalhe com elementos HTML, tratando-os
como objetos.
Gerenciamento Nativo de Estado: para simplificar ainda mais o modelo de
programação, o ASP.NET mantém automaticamente o estado e os controles da página durante
o seu ciclo de vida, ou seja, todos os dados preenchidos pelo usuário são mantidos
automaticamente entre várias requisições do servidor. Por mais trivial que pareça, isso não
acontece por padrão para aplicações Web com outras tecnologias anteriores ao ASP.NET.
Suporte a uma Rica Biblioteca de Classes: em seu programa ASP.NET você tem
acesso a todas as classes do Framework .NET, o que torna incrivelmente semelhante o
desenvolvimento para várias plataformas, como Windows, Web e Mobile.
Desempenho: no ASP.NET todas as páginas são compiladas antes de serem
executadas, além de serem mantidas em cache na memória, fazendo com que normalmente
precisem ser processadas somente uma vez.
Escalabilidade: as aplicações ASP.NET podem rodar tanto em um único servidor
como em múltiplos servidores integrados.
Segurança: o ASP.NET tem várias formas automatizadas de autenticação para
aplicações Web, tornando a tarefa de desenvolver aplicações seguras muito mais simples.
Gerenciamento: os arquivos de configuração do ASP.NET são gravados como texto
simples, normalmente em formato XML, o que facilita o trabalho de administração das
aplicações.
Estensibilidade: você pode estender a funcionalidade do ASP.NET pela escrita de
seus componentes customizados, herdando funcionalidades do Framework e melhorando.
3. CENTRAL DE GESTÃO ACADÊMICA
Terminado todo o processo de levantamento de requisitos e realizadas as principais
escolhas tecnológicas, pode-se direcionar ao objeto do trabalho: o novo sistema acadêmico
para a FATEC Taquaritinga.
Conforme visto anteriormente, a sigla CGA foi consolidada para definir o sistema.
Contudo, como o escopo não é mais apenas o cadastro de alunos, o nome do mesmo foi
modificado para Central de Gestão Acadêmica, visto que o conjunto de todas as suas
funcionalidades prevê apoiar em todos os passos a gestão de assuntos acadêmicos.
3.1. Definição de Escopo
Para o novo sistema, ficaram definidos os seguintes pontos-chave:
Deve estar pronto para ser acessível pela Internet, cabendo à instituição apenas
definir um servidor de hospedagem pela Internet com suporte a ASP.NET 2.0 e
SQL Server 2005;
Deve diferenciar os usuários em Alunos, Professores e demais Funcionários,
apresentando conteúdo customizado a cada um destes grupos;
Deve conter todos os recursos existentes na versão anterior do CGA, que
esteve rodando desde 2004 na faculdade;
Deve implementar novas operações relativas à matricula, com destaque para a
possibilidade dos próprios alunos realizem sua matrícula pela Internet.
Deve ser bem elaborado e conter um código coeso e acoplável, de fácil
manutenção e expansão.
Deve conter código-fonte aberto, permitindo que a própria instituição seja
responsável pelas futuras manutenções.
Sistema Acadêmico em ASP.NET 2.0 - 29
3.2. Desenvolvimento Iterativo e Incremental
Outro ponto importante sobre o processo de desenvolvimento do sistema está na
abordagem de gerenciamento de projetos a ser utilizada, que é o processo de desenvolvimento
iterativo e incremental (FIG. 13).
FIGURA 13 - Processo iterativo incremental.
FONTE: Universidade Federal de Pernambuco (http://www.ufpe.br/).
Com isto, o ciclo de vida de análise e desenvolvimento do sistema torna-se
incrivelmente flexível. Desta forma, a base do sistema pode ser elaborada de forma simples e
rápida, conforme apresentado neste trabalho, e o objetivo da facilidade de manutenção pode
ser alcançado sem grandes esforços.
Após este primeiro ciclo de desenvolvimento, que está sendo concluído em conjunto
com este trabalho, a implantação da primeira iteração do sistema pode ser realizada com
facilidade na instituição, em um ambiente controlado de homologação. A partir daí, diversos
testes de performance, usabilidade e aderência podem ser realizados pelo próprio cliente, no
caso a FATEC Taquaritinga.
Estes testes podem ser realizados de forma controlada em um primeiro momento, com
dados fictícios e situações planejadas. Em seguida, dados replicados do ambiente de produção
atualmente funcional na faculdade podem ser utilizados de forma a simular situações reais e
tentar expor o sistema o máximo possível à realidade da instituição.
Sistema Acadêmico em ASP.NET 2.0 - 30
Conseqüentemente, torna-se fácil e rápida a obtenção de resultados, observando-se os
pontos críticos a serem solucionados e as sugestões de melhorias. Com isto, fica simples
elaborar a próxima iteração do processo de análise e desenvolvimento, voltados para estes
itens apontados. Dessa forma, o sistema fica auto-expansível e praticamente ilimitado, sempre
sendo possível criar um novo processo iterativo com novas funcionalidades e correções. Além
disso, quando tornar-se perceptível a possibilidade de utilizar integralmente o sistema, é
necessário somente migrá-lo para um ambiente de produção, podendo por fim abandonar
quaisquer versões anteriores e se aproveitar totalmente dos novos recursos.
3.3. Modelo de Banco de Dados
O modelo de banco de dados segue os preceitos de bancos objeto-relacionais, apesar
de ser criado com uma ferramenta relacional, o SQL Server 2005, conforme discutido
anteriormente. Tais preceitos ajudam a implementar, principalmente, o conceito de herança,
existente nas linguagens orientadas a objetos, em bancos relacionais.
A FIG. 14 demonstra as principais tabelas envolvidas com o cadastro de pessoas,
sejam alunos, professores ou funcionários, simulando a herança entre estas entidades.
FIGURA 14 - Modelo de dados: cadastro de pessoas.
FONTE: próprio autor.
Sistema Acadêmico em ASP.NET 2.0 - 31
As tabelas relacionadas a disciplinas, que se relacionam às tabelas de curso e de
matrícula podem ser observadas na FIG. 15.
FIGURA 15 - Modelo de dados: cadastro de disciplinas.
FONTE: próprio autor.
Vinculado à TPessoa temos o conjunto de tabelas destinado ao cadastro dos alunos e
outras informações relacionadas a estes (FIG. 16). De fato, a tabela de alunos se relaciona
com a maior parte do banco de dados, direta ou indiretamente, visto que é um dos objetivos
principal do sistema acadêmico.
FIGURA 16 - Modelo de dados: cadastro de alunos.
FONTE: próprio autor.
Sistema Acadêmico em ASP.NET 2.0 - 32
Também vinculada à tabela TPessoa está a tabela TUsuario, responsável por
armazenar os dados de todas as pessoas autorizadas a acessar o sistema. A FIG. 17 demonstra
as tabelas relacionadas à segurança de acesso do sistema.
FIGURA 17 - Modelo de dados: segurança do sistema.
FONTE: próprio autor.
De forma prática, a tabela TPessoa deve conter os dados de todas as pessoas
relacionadas diretamente com a instituição, ou seja, alunos, professores e funcionários.
Conseqüentemente, as tabelas filhas, TAluno e TProfessor, devem conter os dados
específicos de cada um destes dois perfis.
Independentemente, a tabela TUsuario também se relaciona com a tabela TPessoa,
representando os dados de acesso desta pessoa no sistema. Observa-se que a pessoa não
precisa ser obrigatoriamente professor ou aluno para acessar o sistema, visto que a relação
ocorre com a tabela mais genérica, que é a TPessoa.
Isto também evita dados desnecessários no banco de dados, pois é totalmente plausível
que existam diversos alunos e professores que não fazem mais parte da instituição e portanto
não devem possuir registros associados em TUsuario, ou seja, não possuem permissão para
acessar o sistema.
A integridade desta regra deve ser considerada quando os alunos estiverem se
formando ou os professores deixando a instituição, ou seja, o sistema deve automaticamente
remover os registros de TUsuario para estes usuários que deverão automaticamente deixar de
ter acesso ao sistema.
Sistema Acadêmico em ASP.NET 2.0 - 33
Por fim, outra questão importante é em relação ao histórico de notas e faltas de cada
aluno. Isto é obtido através de chaves contendo o ano e o semestre do registro, permitindo
diferenciarem-se facilmente dados do semestre atual em relação a dados anteriores.
A FIG. 18 demonstra estas tabelas, responsáveis pela matrícula e os dados de histórico
dos alunos, bem como as disciplinas e suas cargas horárias.
FIGURA 18 - Modelo de dados: matrícula e histórico escolar.
FONTE: próprio autor.
3.4. Segurança de Acesso
Conforme citado anteriormente, o sistema precisa estar acessível para diferentes
grupos de usuários, cada qual com determinadas permissões de acesso aos conteúdos. Isto é
possível graças às associações existentes entre as funcionalidades, os usuários e seus perfis de
acesso.
Sistema Acadêmico em ASP.NET 2.0 - 34
O diagrama de caso de uso (FIG. 19) demonstra resumidamente as operações de
validação e personalização do usuário.
FIGURA 19 - Caso de uso: acesso ao sistema.
FONTE: próprio autor.
Além de trabalhar com a permissão geral de cada um destes tipos de usuário (aluno,
funcionário e professor), o sistema deve possuir a possibilidade de configuração de grupos de
usuários específicos para acessar determinados recursos. Por exemplo, determinados
relatórios podem estar acessíveis somente a professores do curso de Processamento de Dados.
É possível então criar um perfil de acesso para professores deste curso, com acesso a tais
relatórios. Professores de outros cursos, apesar de também serem professores e terem
basicamente as mesmas permissões, não terão possibilidade de acessar estes conteúdos
específicos. Tais configurações podem ser realizadas de forma simples.
Além disso, também é possível configurar permissões personalizadas para cada
usuário. Sendo assim, é possível que um professor ou funcionário específico possua acesso
completo a outras áreas, como a manutenção do próprio sistema. Também é possível definir
professores coordenadores, que poderão acessar conteúdos específicos para eles.
Por fim, o sistema tem que estar preparado para bloquear usuários não autorizados,
como ex-alunos ou outras pessoas que não tenham vínculos com a faculdade. Este bloqueio
não deve ser realizado somente na primeira tentativa de acesso, mas sim constantemente,
verificando todas as tentativas posteriores e garantindo inclusive que as permissões do usuário
não se mantenham abertas por um longo tempo, o que permitiria que, por exemplo, outra
pessoa se utilizasse destas permissões caso utilize o mesmo computador num curto espaço de
tempo.
Sistema Acadêmico em ASP.NET 2.0 - 35
A FIG. 20 demonstra a tela de acesso ao sistema, a qual garante o acesso somente a
usuários autorizados – sejam eles alunos, professores ou funcionários.
FIGURA 20 - Tela de acesso ao sistema.
FONTE: próprio autor.
Aproveitando-se de recursos existentes no ASP.NET 2.0 para segurança de acesso, em
conjunto com outras boas práticas, é possível tornar o site até 95% seguro, visto não existem
meios de tornar um site 100% seguro em nenhuma hipótese (Johnson, 2007).
Tais recursos englobam: criptografia de dados, autenticação e autorização e podem ser
amplamente configurados com arquivos XML do próprio Framework .NET. Um exemplo é a
criptografia realizada com todas as senhas do sistema, que utiliza chaves de 128 bits,
teoricamente impossíveis de serem quebradas. Com tais técnicas, nem mesmo usuários
autorizados com acesso direto ao banco de dados conseguem entender e/ou decifrar as senhas
de nenhum usuário do sistema.
Os recursos de personalização também são flexíveis e extensíveis. A tela principal
para os três tipos de usuário pode ser configurada constantemente para condizer com a
situação da faculdade. É possível, por exemplo, que na época das matrículas a tela principal
dos alunos seja configurada para destacar de forma visível a possibilidade de realizada da
matrícula pela Internet. É possível associar um endereço ao alerta, que neste caso pode ser a
tela de re-matrícula que deve abrir para o aluno.
A tela também fornece suporte a conteúdo dinâmico, como exibição de notícias
diversas. Tais notícias podem ser alimentadas em forma de feeds RSS (Really Simple
Syndication, um conjunto de “dialetos” padronizados para distribuição de conteúdos
agregados, os quais vem se tornando populares principalmente para divulgação de notícias).
Sistema Acadêmico em ASP.NET 2.0 - 36
Com o tempo a instituição pode personalizar a tela principal de alunos, professores e
funcionários para enfocar as reais necessidades de cada um destes, aumentando
consideravelmente a produtividade dos mesmos para com o sistema.
A FIG. 21 demonstra um exemplo da tela principal para os alunos.
FIGURA 21 - Tela principal para os alunos.
FONTE: próprio autor.
No menu lateral, é possível observar dois itens fixos a todos os usuários, que são o
acesso aos dados pessoais e aos dados de acesso do sistema, como a senha do mesmo.
Em seguida, encontra-se uma lista com as telas abertas recentemente por este usuário
no sistema. Desta forma, as funcionalidades mais utilizadas pelo usuário sempre estão
disponíveis com apenas um clique.
Abaixo do título do sistema temos o menu principal, contendo a lista com todas as
funcionalidades disponíveis para este usuário específico, conforme explicado anteriormente
sobre os perfis de acesso.
3.5. Cadastros
O sistema também é composto por diversas telas de cadastro, de forma a garantir a
disponibilidade dos mais diversos dados, de apoio ou não. Dois exemplos de cadastros de
apoio são cidades e países. Outros cadastros essenciais ao sistema são, por exemplo: alunos,
disciplinas, professores, cursos, etc.
Sistema Acadêmico em ASP.NET 2.0 - 37
A FIG. 22 apresenta o caso de uso que generaliza o funcionamento de todas as telas de
manutenção do sistema. Segundo ele, podemos observar as operações de manutenção deve
iniciar por uma consulta ou uma inclusão. Após a consulta, existe a possibilidade de excluir
ou alterar os dados do registro consultado. Este padrão se repete por todas as telas de cadastro
do sistema.
FIGURA 22 - Caso de uso: telas de manutenção.
FONTE: próprio autor.
Uma das telas de cadastro mais importantes do sistema é a tela Gerenciar Alunos
(FIG. 23), responsável por permitir o acesso e edição dos dados de todos os alunos da
instituição, incluindo dados de endereço, paternidade, telefone, e-mail, foto, etc.
FIGURA 23 - Tela de gerenciamento dos dados do aluno.
FONTE: próprio autor.
Sistema Acadêmico em ASP.NET 2.0 - 38
3.6. Matrícula
Um dos requisitos mais importantes para o sistema trata-se da matrícula dos alunos.
Na verdade não é apenas um único requisito, pois existem basicamente três tipos de matrícula.
O primeiro tipo é a matrícula automática realizada quando o aluno ingressa na
faculdade. A FIG. 24 demonstra o funcionamento geral deste caso de uso.
FIGURA 24 - Caso de uso: matrícula inicial.
FONTE: próprio autor.
Neste caso de uso, é necessário somente selecionar o aluno ingressante de acordo com
uma lista de classificados, disponibilizada para todas as instituições dias antes da matrícula.
Tal lista contém todos os candidatos, ordenados pela classificação, de forma que seja possível
selecionar candidatos aprovados diretamente ou através de lista de suplentes.
Selecionado o novo aluno, é gerado automaticamente um número de registro
(conhecido como RA, ou registro acadêmico) para o mesmo. Este número será sua chave
única de identificação durante todo o curso. Em seguida, são gravados os dados básicos deste
novo aluno e criada automaticamente sua primeira matrícula, contendo todas as disciplinas do
primeiro semestre, já que o aluno provavelmente irá cursar exatamente estas disciplinas. Em
todo caso, deve ser possível editar esta matrícula posteriormente, para o caso do aluno realizar
dispensa de disciplinas ou cursar outras disciplinas em regime especial.
Sistema Acadêmico em ASP.NET 2.0 - 39
Por fim, este caso de uso prevê a impressão das declarações e comprovantes
necessários para a primeira matrícula.
A FIG. 25 apresenta o modelo da tela responsável por proceder com a geração do RA
dos novos alunos, bem como a criação de sua primeira matrícula.
FIGURA 25 - Tela de criação de novos alunos.
FONTE: próprio autor.
O segundo tipo de matrícula, descrito pelo caso de uso da FIG. 26, ocorre nos dias
predefinidos de re-matrícula que ocorrem no início de cada semestre, para os alunos veteranos
da faculdade. Tal matrícula é realizada por um funcionário com a presença física do aluno.
FIGURA 26 - Caso de uso: matrícula presencial.
FONTE: próprio autor.
Neste caso de uso, o funcionário informa o aluno que deseja realizar a re-matrícula.
Em seguida, são apresentadas todas as disciplinas já cursadas e as disciplinas disponíveis para
o aluno cursar em todos os dias da semana.
Sistema Acadêmico em ASP.NET 2.0 - 40
O processo consiste em selecionar as disciplinas que o aluno deve cursar no semestre
subseqüente. Alguns tipos de validações devem ser realizadas, como restringir a seleção de
várias disciplinas no mesmo dia e horário, a menos que uma delas seja para regime especial.
As únicas disciplinas que podem ser cursadas de forma concomitante são as disciplinas de
Monografia e de Estágio. A FIG. 27 demonstra um exemplo da tela de matrícula presencial.
FIGURA 27 - Tela de matrícula presencial.
FONTE: próprio autor.
O terceiro tipo de matrícula deve estar disponível para os próprios alunos realizarem
virtualmente, através da Internet, em datas predefinidas pela instituição. A FIG. 28 descreve o
comportamento deste caso de uso.
FIGURA 28 - Caso de uso: matrícula virtual.
FONTE: próprio autor.
Sistema Acadêmico em ASP.NET 2.0 - 41
O funcionamento deste caso de uso pode ser resumido como uma matrícula presencial
realizada de forma remota, através da Internet. A FIG. 29 demonstra o modelo geral da tela de
re-matrícula virtual dos alunos.
FIGURA 29 - Tela de re-matrícula virtual dos alunos.
FONTE: próprio autor.
Para tornar a iteração do aluno simples, esta tela se apóia em dois conceitos difundidos
de interface: navegação estilo wizard e interatividade estilo chat.
Quando o aluno acessa a tela, recebe boas vindas e um texto introdutório, informando
qual funcionário está disponível para lhe atender. Através de uma arquitetura de chat, o
funcionário estará, nos dias de matrícula virtual a serem definidos pela instituição, presente
virtualmente para atender o aluno, da mesma forma que ocorreria presencialmente.
O aluno é guiado por várias telas que simulam o processo real de matrícula, como a
confirmação de dados pessoais e a escolha de disciplinas a serem cursadas. Lembrando que
esta última só deve estar disponível caso o aluno possua disciplinas pendentes de outros
semestres, caso contrário não é necessário, pois todas as disciplinas do ciclo atual do aluno
podem ser automaticamente adicionadas em sua matrícula.
Sempre que o aluno precisar realizar alguma interação (como editar dados pessoais ou
escolher disciplinas), terá disponível um botão de envio. Neste momento, os dados aparecerão
na tela do funcionário que está lhe atendendo. O funcionário pode então aprovar ou reprovar
os dados recebidos do aluno.
Sistema Acadêmico em ASP.NET 2.0 - 42
Em caso de reprovação, pode digitar algum texto explicativo, para que o aluno
proceda da forma correta.
Quando todos os dados estiverem de acordo com o esperado pelo funcionário a
matrícula puder ser aceita, o funcionário precisa apenas acionar um botão de aceite e
automaticamente o aluno receberá em sua tela um comprovante de matrícula que poderá ser
impresso. Da mesma forma, o funcionário também recebe um comprovante, a fim de
assegurar a autenticidade da operação para ambas as partes.
Terminados estes passos, a matrícula está realizada sem que o aluno precise se
direcionar até a faculdade.
3.7. Arquitetura
Além da definição das principais funcionalidades e criação de protótipos das telas
abordadas pela primeira iteração do sistema, toda a arquitetura da aplicação deve ser
formulada. O diagrama de componentes da FIG. 30 resume esta arquitetura.
FIGURA 30 - Diagrama de componentes.
FONTE: próprio autor.
O primeiro componente, CGA.Web representa a interface da aplicação. Este
componente na prática é uma aplicação Web, ou seja, um site programado em ASP.NET e C#.
Sistema Acadêmico em ASP.NET 2.0 - 43
Tal aplicação necessita apenas de um servidor de hospedagem Windows Server com
.NET Framework 2.0 e SQL Server 2005 para estar disponível pela Internet. Dentro deste
componente as páginas do ASP.NET, os arquivos visuais, como imagens, temas e folhas de
estilo, e os scripts executados no navegador do usuário, conforme discutido anteriormente
neste trabalho.
Vinculado a este componente, está o CGA.Negocios. Esta camada representa a lógica
de negócio da aplicação. Além disso, encapsula as chamadas utilizando-se do padrão de
projeto Facade (Cardoso, 2006), a fim de fornecer um ponto de acesso único a todas as
aplicações de interface que tenham necessidade de acessar as informações oferecidas por este
sistema. Isto se torna simples não apenas pelo padrão do Facade, mas também por tal
componente ser um Web Service. Segundo Sincic (2004), um pacote de classes acessíveis de
forma remota através do protocolo de Internet, o HTTP.
A utilização de Web Services permite inclusive que outros sistemas da instituição
realizem operações providas pelo sistema CGA de forma simples e eficiente, inclusive
independente da tecnologia utilizada. É possível, por exemplo, que um sistema para controlar
a reserva de projetos pelos professores acesse operações do Web Service do CGA afim de
buscar os dados dos professores, evitando a existência de diversos bancos de dados com dados
replicados na faculdade.
A camada seguinte à de negócio é a CGA.Framework.Dados. Tal camada pequena,
tem a responsabilidade apenas de executar comandos no banco de dados. Para este sistema em
específico, adotou-se a utilização de Stored Procedures como forma de acesso padronizado ao
banco. Tais Stored Procedures encontram-se armazenadas no pacote denominado
SQLObjects. Sendo assim, a responsabilidade da camada de dados é simplesmente executar
determinada Stored Procedure retornando dados do banco de dados e transformando os
mesmos em objetos do .NET, para que a camada de negócio possa trabalhar de forma fácil.
O último componente da arquitetura é o CGA.Framework.WebControls. Tal
componente prevê a abstração e automatização de tarefas repetitivas no sistema,
principalmente voltadas à interface e às validações de dados.
Diversos controles customizados estão previstos neste componente, a fim de tornar os
códigos HTML mais limpos e o desenvolvimento o mais produtivo possível.
Com a utilização correta desta arquitetura, prevê-se que o tempo de desenvolvimento
de uma tela de complexidade média caia de 8 horas para apenas 3 horas de codificação.
CONCLUSÃO
Com a utilização de sistemas informatizados moldados visando a melhoria de
processos, em conjunto com o poder de distribuição e abrangência das aplicações para
Internet, é possível obter ganhos significativos em relação a produtividade e eficiência em
tarefas nas mais diversas áreas. Um sistema acadêmico voltado a três tipos diferentes de
público tem potencial para melhorar inúmeras atividades na instituição.
Esta monografia foi elaborada visando demonstrar as necessidades do proposto
sistema acadêmico para a FATEC Taquaritinga e as escolhas tomadas para possibilitar o
desenvolvimento do mesmo. Com base neste estudo, conclui-se que as escolhas tecnológicas
foram satisfatórias e a base do sistema pôde ser elaborada, podendo o mesmo ser expandido
futuramente de acordo com as necessidades da instituição.
REFERÊNCIAS BIBLIOGRÁFICAS
CARDOSO, C. Orientação a Objetos na Prática. Rio de Janeiro, RJ: Ciência Moderna, 2006.
JOHNSON, G; NORTHRUP, T. Microsoft .NET 2.0 Web-Based Client Development.
Redmond, Washington: Microsoft Press, 2007.
LEITÃO, B. Orientação a Objetos com C# 2.0. São Paulo, SP: Politec S/A, 2007.
MARQUES, P. Introdução ao C# 2.0. Microsoft Portugual, 2005. Disponível em:
<http://www.microsoft.com/portugal/techdays/2005/conteudostematicos/ferramdesenv.mspx>
Acesso em: 21/11/2007.
ORLANDINI, L. A Importância dos Sistemas de Informação. Portal Bonde, 2005. Disponível
em: <http://www.bonde.com.br/colunistas/colunistasd.php?id_artigo=1646>. Acesso em: 03
out. 2007.
ORLANDINI, L. Informatizar Para Que? Portal Bonde, 2005. Disponível em:
<http://www.bonde.com.br/colunistas/colunistasd.php?id_artigo=1742>. Acesso em: 03 out.
2007.
W3C. Browser Information. W3 Schools, 2007. Disponível em:
<http://www.w3schools.com/browsers/default.asp>. Acesso em: 21/11/2007.
PETRUCELLI, E. Desenvolvimento com ASP.NET 2.0. São Paulo, SP: Politec S/A, 2007.
RYAN, B; NORTHRUP, T; WILDERMUTH, T. Microsoft .NET 2.0 Application
Development Foundation. Redmond, Washington: Microsoft Press, 2006.
SINSIC, M. Orientação a Objetos com C#. São Paulo, SP: Politec S/A, 2004.
BIBLIOGRAFIA
CAMARA, F. Orientação a Objeto com .NET. Florianópolis, SC: Visual Books, 2006.
CEMBRANELLI, F. ASP. NET - Guia do Desenvolvedor. São Paulo, SP: Novatec, 2003.
CORREIA, C. H; TAFNER, M. A. Análise Orientada a Objetos. Florianópolis, SC: Visual
Books, 2006.
LIBERTY, J. Programando C#. Rio de Janeiro, RJ: Alta Books, 2006.
RICHTER, J. Programação Aplicada com Microsoft .NET Framework. Porto Alegre, RS:
Bookman, 2005.