Construção Automática de Modelos de Classes A Partir de Especificações em Linguagem Natural

RICARDO BAPTISTA
CONSTRUÇÃO AUTOMÁTICA DE MODELOS DE CLASSES A PARTIR

DE ESPECIFICAÇÕES EM LINGUAGEM NATURAL
CEETEPS
Faculdade de Tecnologia de São Paulo
Departamento de Tecnologia da Informação
São Paulo
2013
i
RICARDO BAPTISTA
CONSTRUÇÃO AUTOMÁTICA DE MODELOS DE CLASSES A PARTIR

DE ESPECIFICAÇÕES EM LINGUAGEM NATURAL
Monografia apresentada à FATEC-SP,

como requisito parcial para a obtenção do
título de Especialista em Tecnologia de
Análise e Projeto de Sistemas.
Orientador: Prof. Dr. Silvio do Lago Pereira.
CEETEPS
Faculdade de Tecnologia de São Paulo
Departamento de Tecnologia da Informação
São Paulo
2013
ii
Baptista, Ricardo
B222c Construção automática de modelos de classes a partir
de especificações em linguagem natural / Ricardo Baptista.
-- São Paulo : Fatec-SP, 2013.
68 f. : il.
Orientador: Prof. Dr. Silvio do Lago Pereira.

Monografia (Especialização em Tecnologia de Análise
e Projeto de Sistemas) - Faculdade de Tecnologia de São
Paulo, 2013.
1. Engenharia de software. 2. Especificação de

requisitos. 3. Diagrama de classes. 4. UML. 5. POO. I.
Pereira, Silvio do Lago. II. Faculdade de Tecnologia de São
Paulo. III. Título.
iii
DEDICATÓRIA
A minha filha Mayara,
A minha mãe Isalina, minha

esposa, família e amigos.
Ricardo Baptista
iv
AGRADECIMENTOS
Foram muitos os que me ajudaram a concluir esse trabalho.
Os meus mais sinceros agradecimentos...
...a Deus, pois, sem sua ajuda, nada teria sido possível;
...à minha família pela confiança, paciência e apoio;
...aos meus amigos de graduação e pós-graduação, pelas conversas e troca de

experiência;
...ao Prof. Dr. Silvio Lago que aceitou orientar-me após meu outro orientador,
devido a problemas pessoais, ser forçado a não me orientar mais;
...aos meus amigos e colegas que participaram deste trabalho;
...aos orientadores que com paciência me ajudaram a concluir o trabalho.

v
SUMÁRIO
LISTA DE FIGURAS ............................................................................................ vii
LISTA DE SIGLAS ...............................................................................................viii
RESUMO .............................................................................................................. ix
ABSTRACT............................................................................................................ x
INTRODUÇÃO....................................................................................................... 1
1. MODELO DE CLASSES ............................................................................... 3
1.1. OBJETOS E CLASSES .......................................................................... 3
1.2. LIGAÇÕES E ASSOCIAÇÕES............................................................... 5
1.3. HERANÇA E POLIMORFISMO .............................................................. 6
2. LINGUAGEM DE MODELAGEM UNIFICADA (UML) ................................... 9
2.1. FUNDAMENTOS DA UML ..................................................................... 9
2.2. ESCOPO DA UML ............................................................................... 10
2.3. DIAGRAMA DE CLASSES ................................................................... 10
3. MÉTODO PARA CONSTRUÇÃO DO MODELO DE CLASSES ................. 12
3.1. FUNDAMENTOS .................................................................................. 12
3.2. MÉTODO DE INTERPRETAÇÃO ........................................................ 15
3.3. DEFINIÇÕES ....................................................................................... 15
3.4. FORMALIZANDO O MÉTODO ............................................................ 19
4. CONSTRUÇÃO AUTOMÁTICA DE MODELO DE CLASSES .................... 20
4.1. CM-BUILDER ....................................................................................... 21
4.2. NL-OOPS ............................................................................................. 22
4.3. UML – GENERATOR ........................................................................... 22
5. TEXTTOCLASS: A FERRAMENTA DESENVOLVIDA ............................... 23
5.1. ARQUITETURA.................................................................................... 24
5.2. ALGORITMO ........................................................................................ 24
5.3. RESULTADO DO TESTE LINHA A LINHA .......................................... 26

vi
5.4. RESULTADO DO TESTE FUNCIONAL ............................................... 26
CONCLUSÃO ...................................................................................................... 32
REFÊRENCIAS ................................................................................................... 33
APÊNDICE – CÓDIGO FONTE DO SISTEMA TEXTTOCLASS ......................... 34
Classe mdiPrincipal.......................................................................................... 34
Classe frmGerador ........................................................................................... 35
Classe frmPalavras .......................................................................................... 39
Classe FraseClasseDAL .................................................................................. 40
Classe MetodosDAL ........................................................................................ 44
Classe PalavraDAL .......................................................................................... 47
Classe ParametrosDAL .................................................................................... 51
Classe TipoPalavraDAL ................................................................................... 54
Classe FraseClasseDTO.................................................................................. 57
Classe MetodoDTO.......................................................................................... 58
Classe PalavraDTO ......................................................................................... 58
Classe ParametroDTO ..................................................................................... 58
Classe TipoPalavraDTO................................................................................... 59
Classe Banco_DAL .......................................................................................... 59
Classe ITextToClass ........................................................................................ 62
Classe WCFTextToClass ................................................................................. 64

vii
LISTA DE FIGURAS
Figura 1 – Representação diagramática de OMT para associações entre classes
(topo) e ligações entre objetos (abaixo) Fonte: Ricarte (2001).
Figura 2 – Representação diagramática de OMT para associações entre classes
com atributos Fonte: Ricarte (2001).
Figura 3 – Visualização de estrutura em UML Fonte: Lima (2011).
Figura 4 – Diagrama de Classes.
Figura 5 – Classe Galinha.
Figura 6 – Classe Carlos.
Figura 7 – Classe Gerente.
Figura 8 – Classe Carlos instanciando classe Gerente.
Figura 9 – Cadastro de Clientes.
Figura 10 – Classe X português.
Figura 11 – Polimorfismo.
Figura 12 – Encapsulamento.
Figura 13 – Diagrama de classes de um texto completo.
Figura 14 – Exemplo de Herança.
Figura 15 – Formalização do método.
Figura 16 – Árvore gramatical em bottom-up (Harmain, 2000).
Figura 17 – CM-Builder.
Figura 18 – TextToClass.
Figura 19 – Algoritmo usado no sistema TextToClass.
Figura 20 – Primeiro teste.
Figura 21 – Mensagem de erro alertando o usuário de que uma palavra não foi
localizada no banco de dados.
Figura 22 – Processo da frase "O cadastro de clientes cadastrará nome, telefone
e endereço." completo.
Figura 23 – Cadastro de palavras.
Figura 24 – Terceiro teste.
Figura 25 – MLD do banco de dados do sistema TextToClass.
viii
LISTA DE SIGLAS
Sigla/Abreviatura Significado
UML Linguagem de Modelagem Unificada.
POO Programação Orientada a Objetos.
OOP Object Oriented Programming.
Dll Dynamic Link Library.
OMT Object Modeling Technique.
RUP Processo Unificado Rational.
XML Linguagem de Marcação Extensiva.
XMI XML Metadata Interchange.
DTO Data Transfer Object.
WCF Windows Communication Foundation.
WinForms Interface Windows.
SGBD Sistema de Gerenciamento de Banco de Dados.
SQL Server Query Language.
C# Linguagem de programação da Microsoft.
IA Inteligência Artificial.
SOA Arquitetura Orientada a Serviços.
CRUD Uma sequência de comando que gerencia ações
de inclusão, alteração, leitura e exclusão de
dados em banco de dados relacional.
MLD Modelo Lógico de Dados.
IDE Plataforma de desenvolvimento de software.
ix
RESUMO
Esse trabalho tem como principal objetivo mostrar como um modelo de classes
pode ser construído, automaticamente, a partir da análise de requisitos especificados
em linguagem natural (português), fornecidos pelo usuário de um sistema a ser
desenvolvido. Para tanto, um protótipo de ferramenta para construção automática de
modelos de classes foi desenvolvido e resultados experimentais obtidos com essa
ferramenta foram relatados.
A construção automática é baseada principalmente na correspondência entre

substantivos e classes e entre verbos e métodos. Quando uma frase é fornecida à
ferramenta, ela a decompõe em palavras e identifica a classe gramatical de cada uma
delas (substantivo, verbo, preposição ou adjetivo). A partir daí, a ferramenta constrói o
modelo de classes correspondente, composto por classes, atributos, métodos e
parâmetros. Para verificar a funcionalidade dessa ferramenta, testes foram realizados
para com diversas frases digitadas pelo usuário. Os testes mostraram que a ferra-
menta consegue, de fato, identificar os elementos necessários para a construção do
modelo de classes correspondente às frases fornecidas.
Palavras-chave: Especificação de requisitos, engenharia de software, diagrama

de classes, UML, POO.
x
ABSTRACT
The main goal of this work is to show how a class model can be automatically
built from the analysis of requirements specified in natural language (Portuguese),
supplied by the user of a system to be developed. To this end, a prototype tool for
automatic construction of class models was developed and experimental results
obtained with this tool were reported.
The automatic construction is based mainly on the correspondence between

nouns and classes and between verbs and methods. When a phrase is supplied to the
tool, it breaks it down into words and identifies the grammatical class of each one of
them (noun, verb, preposition or adjective). Then, the tool builds the corresponding
class model, consisting of classes, attributes, methods and parameters. To verify the
functionality of this tool, tests were performed for a variety of phrases typed by the
user. The tests showed that the tool can, in fact, identify the information needed for the
construction of the class model corresponding to phrases provided.
Keywords: requirements specification, software engineering, class diagram,

UML, OOP.
1
INTRODUÇÃO
Ao se levantar especificações de requisitos com usuários, os mesmos
geralmente imaginam o sistema de uma forma diferente da forma que ele está
passando para o analista. Mas no decorrer do processo, os sistemas tomam a forma
que se espera ou muito aproximada. Isso requer muito tempo e esforço, o que
geralmente impacta muito no projeto.
MOTIVAÇÃO
O desenvolvimento de software é uma atividade complexa e de muitas etapas.

Uma delas é a etapa de especificação que é a primeira etapa do ciclo de vida de um
sistema.
Segundo Sommerville (2007) o nível de detalhamento a ser incluído em um

documento depende do tipo de sistema que está sendo desenvolvido e do processo
de desenvolvimento usado. Assim, muito provavelmente, será preciso construir um
modelo de classes. Esse modelo, além de ser peça chave de um sistema, também é
de suma importância para a produção do sistema.
Apesar da importância do modelo de classes, quase não há ferramentas

disponíveis para auxiliar na construção desse modelo. Uma ferramenta desse tipo,
além de acelerar o processo de desenvolvimento de sistemas, ainda poderia ser
usada como recurso didático em cursos de programação orientada a objetos.
OBJETIVO
Apesar de algumas empresas não reconhecerem, a fase de análise é crucial

para o desenvolvimento de sistemas (Sommerville, 2007). É nessa fase que são
gerados documentos importantes para o desenvolvimento e manutenção dos
sistemas. Quando o desenvolvimento é orientado a objetos, um desses documentos é
justamente o modelo de classes. Assim, o objetivo desse trabalho é desenvolver uma
ferramenta que possa automatizar a construção desse modelo, a ser usada durante a
fase de análise, e, dessa forma, facilitar a documentação do sistema.
A ferramenta a desenvolvida nesse trabalho deverá ser capaz de analisar uma

2
sentença dada pelo usuário, em língua portuguesa, e extrair elementos importantes

para a construção automática de um modelo de classes correspondente, a saber:
nome da classe, seus atributos e seus métodos e respectivos parâmetros.
HIPÓTESE
Esse trabalho assume, como hipótese, que é possível desenvolver uma ferra-
menta que, a partir da análise de documento textual de requisitos ou parte dele, pode
extrair automaticamente as classes referentes ao documento. Para isso, a ferramenta
deve ter acesso a um banco de dados representando um léxico em que as palavras
são categorizadas como substantivo, adjetivo, verbo e preposição.
METODOLOGIA
Esse trabalho de pesquisa é baseado no método hipotético-dedutivo. Na fase

indutiva, foi realizada uma pesquisa bibliográfica para coleta e análise de conceitos
sobre engenharia de software e análise de sistemas, que serviram de base para a
elaboração do método e da ferramenta descritos ao longo do trabalho. Na fase
dedutiva, foram realizados experimentos para validação da hipótese.
ORGANIZAÇÃO
A monografia está organizada da seguinte forma:

No Capítulo 1 é introduzido o conceito de modelo de classes, dentro do
paradigma de orientação a objetos.
No Capítulo 2 é descrita a Linguagem de Modelagem Unificada (UML –
Unified Modeling Language).
No Capítulo 3 é apresentado um método para construção do modelo de
classes usando linguagem natural.
No Capítulo 4 são descritas ferramentas já existentes para a criação de
modelos de classes a partir de especificações em inglês.
No Capítulo 5 é descrita a ferramenta desenvolvida nesse trabalho para a
criação de modelos de classes a partir de especificações em português.
3
1. MODELO DE CLASSES
O paradigma de Orientação a Objetos baseia-se em uma organização de soft-

ware em termos de coleção de objetos discretos incorporando estrutura e compor-
tamento próprios (Lima, 2011). Esta abordagem de organização é essencialmente
diferente do desenvolvimento tradicional de software (Lima, 2011), em que estruturas
de dados e rotinas são desenvolvidas de forma apenas fracamente acopladas.
Neste capítulo, as primeiras noções de orientação a objetos serão introduzidas.

Esta breve visão geral do paradigma permitirá entender melhor os conceitos asso-
ciados à programação orientada a objetos.
1.1. OBJETOS E CLASSES
Segundo Lima (2011), objetos são coisas do mundo real como pessoas,
animais, etc., que se descobre estudando suas características. Objeto, segundo o
dicionário, é tudo aquilo que é compreendido, considerado exterior, física ou psico-
logicamente pelo observador. Sendo assim, do ponto de vista da programação, objeto
é uma abstração de algo do mundo real.
Em POO (Programação Orientada a Objetos), a objetificação das coisas se faz

necessária, pois somente assim pode-se ter acesso às qualidades e ações dos
objetos e definir como os objetos interagem entre si.
Embora os objetos sejam uma abstração de necessidades reais descritas em

levantamentos de requisitos, eles só são considerados grupos se forem similares em
termos de suas características (atributos) e comportamentos (métodos). Um grupo de
objetos similares é chamado de classe. As classes podem possuir vários atributos e
métodos e podem também compartilhar características, além de interagirem entre si.
Sejam A e B duas classes distintas tais que A compartilha características

herdadas de B. Nesse caso, A é denominada subclasse (ou classe filha) e B é
denominada superclasse (ou classe mãe). Toda classe, além de herdar propriedades
de outras classes, também pode possuir seus próprios atributos, métodos e
parâmetros.
4
1.1.1. Abstração
Abstração consiste em focalizar nos aspectos essenciais inerentes a uma

entidade. Em termos de desenvolvimento de sistemas, isto significa concentrar-se no
que um objeto é e faz, antes de se decidir como ele será utilizado. O uso de abstração
garante que, apenas quando houver um bom entendimento do problema tratado, a
solução será desenvolvida. Ou seja, abstração é a observação da realidade,
separação em objetos, definição das ações possíveis desses objetos e parâmetros
dessas ações e a definição dos atributos de cada objeto. A objetificação de uma
classe é denominada de instância de classe.
Muitas linguagens de programação modernas suportam o conceito de

abstração de dados; porém, o uso de abstração juntamente com polimorfismo e
herança, como suportado em orientação a objetos, é um mecanismo muito mais
poderoso.
O uso apropriado de abstração permite que um mesmo modelo conceitual

(orientação a objetos) seja utilizado para todas as fases de desenvolvimento de um
sistema, desde sua análise até sua documentação.
1.1.2. Encapsulamento
Encapsulamento (esconder informações) consiste em separar os aspectos

externos de um objeto, os quais são públicos a outros objetos, dos detalhes internos
de implementação do objeto, que permanecem escondidos dos outros objetos. O uso
de encapsulação evita que um programa torne-se tão acoplado que uma pequena
mudança gere grandes efeitos colaterais.
O uso de encapsulamento permite que o objeto possa ser modificado, sem

afetar as aplicações que usam este objeto. Motivos para modificar um objeto podem
ser, por exemplo, melhoria de desempenho, correção de erros e mudança de
plataforma de execução. O encapsulamento evita o acoplamento (um objeto
dependendo de outro objeto) na solução.
Assim como abstração, o conceito de encapsulamento não é exclusivo da

abordagem de orientação a objetos. Entretanto, a habilidade de se combinar estrutura
5
de dados e comportamento em uma única entidade torna o encapsulamento a mais

elegante e mais poderosa habilidade de linguagens orientadas a objetos.
1.2. LIGAÇÕES E ASSOCIAÇÕES
Segundo Lima (2011), ligações e associações são os mecanismos para

estabelecer relacionamentos entre objetos e classes. Uma ligação é uma conexão
física ou conceitual entre duas instâncias de objetos. Uma ligação é uma instância de
uma associação. Uma associação descreve um grupo de ligações com estrutura e
semântica comuns, por exemplo, uma pessoa X “trabalha para” uma companhia Y.
Uma associação descreve um conjunto de ligações potenciais da mesma forma que
uma classe descreve um conjunto de objetos potenciais.
Segundo Ricarte (2001), a notação de diagramas OMT (Object-Modeling

Technique) para associação é uma linha conectando duas classes. Uma ligação é
representada como uma linha conectando objetos. Nomes de associações são
usualmente apresentados em itálico. Se entre um par de classes só existe uma única
associação cujo sentido deva ser óbvio, então o nome da associação pode ser
omitido. A Figura 1 apresenta um exemplo de diagrama OMT com associações.
Figura 1 - Representação diagramática de OMT para associações entre

classes (topo) e ligações entre objetos (abaixo) Fonte: Ricarte (2001).
Ainda segundo Ricarte (2001), alguns atributos podem dizer respeito a

associações e não a classes. Para tais casos, OMT introduz o conceito de atributo de
ligação. Quando a associação tem ainda operações associadas, então ela pode ser
modelada como uma classe que está “conectada” à associação. Um exemplo deste
caso é apresentado na Figura 2.
6
Figura 2 - Representação diagramática de OMT para associações entre classes

com atributos Fonte: Ricarte (2001).
Segundo Ricarte (2001), a Figura 2 mostra a representação diagramática de

OMT para associações entre as classes com atributos. Neste caso, os atributos da
associação estão representados por meio de uma classe explícita, autorização. O
círculo preto, no final da linha da associação, indica que mais de um objeto de uma
classe pode estar associado a cada objeto da outra classe. Um círculo vazado indica
que possívelmente nenhum objeto está associado, ou seja, o conceito de associação
opcional.
Uma associação pode ser feita com uma instância de objeto, e a permissão de
modificação é representada pelo modo de acesso.
• Private (acesso privado): o objeto somente é acessado por objetos da

própria classe e é representado pelo sinal de subtração (-).
• Public (acesso público): o objeto é acessado por objetos de outras
classes, além de ser acessado pelos objetos da própria classe, e é
representado pelo sinal de adição (+).
• Protect (acesso protegido): o objeto somente é acessado pela própria
classe e suas subclasses e é representado pelo sinal de sustenido (#).
• Package (acesso de pacote): o objeto é acessado por todas as classes e
objetos do pacote (em algumas linguagens, “Package” tem outro nome;
em C#, chama-se “namespace”) e é representado pelo sinal de til (~).
1.3. HERANÇA E POLIMORFISMO

Na programação orientada a objetos, o polimorfismo permite que referências
de tipos de classes mais abstratas representem o comportamento das classes con-
cretas que referenciam. Assim, é possível tratar vários tipos de maneira homogênea
7
(por meio da interface do tipo mais abstrato). O termo polimorfismo é originário do

grego e significa "muitas formas" (poli = muitas, morphos = formas).
O polimorfismo é caracterizado quando duas ou mais classes distintas têm

métodos com o mesmo nome, de forma que uma função possa usar um objeto de
qualquer uma das classes polimórficas, sem necessidade de tratar de forma
diferenciada conforme a classe do objeto.
Polimorfismo pode ser implementado por meio de uma classe abstrata, cujos
métodos são declarados, mas não são definidos, que é especializada em classes
filhas que herdam seus métodos. Polimorfismo significa que a mesma operação pode
se comportar de forma diferente em classes diferentes. Por exemplo, a opera-
ção “move”, quando aplicada a uma janela de um sistema de interfaces, tem um
comportamento distinto daquele observado quando é aplicada a uma peça de um jogo
de xadrez.
Polimorfismo também implica que uma operação de uma mesma classe pode
ser implementada por mais de um método. O usuário não precisa saber quantas
implementações existem para uma operação, ou explicitar qual método deve ser
usado: a linguagem de programação deve ser capaz de selecionar o método correto,
a partir do nome da operação, classe do objeto e argumentos para a operação. Desta
forma, novas classes podem ser adicionadas sem a necessidade de modificar código
já existente; pois cada classe apenas define os seus métodos e atributos e isso
também evita o acoplamento, já que não há necessidade de se modificar as outras
classes que possuem o método com o mesmo nome.
Herança é o mecanismo do paradigma de orientação a objetos que permite

compartilhar atributos e operações entre classes, com base em um relacionamento
hierárquico. Uma classe pode ser definida de forma genérica e depois refinada,
sucessivamente, em termos de subclasses ou classes derivadas (cada classe
completa a classe mãe para uma determinada função). Cada subclasse incorpora
(herda) todas as propriedades de sua superclasse e adiciona suas propriedades
únicas e particulares. As propriedades da superclasse não precisam ser repetidas em
cada uma de suas subclasses (que herdam essas propriedades automaticamente).
Esta capacidade de agrupar as propriedades comuns de diversas classes em uma
8
superclasse pode reduzir dramaticamente a redundância de código em um projeto ou

programa, bem como aumentar o reaproveitamento de código já existente. Técnicas
de orientação a objetos promovem compartilhamento em diversos níveis distintos.
Herança de estruturas de dados e comportamento permite que estruturas comuns
sejam compartilhadas entre diversas classes derivadas similares, sem redundância. O
compartilhamento de código usando herança é uma das grandes vantagens da
orientação a objetos. Ainda mais importante que a economia de código, é a clareza
conceitual de reconhecer que operações diferentes são, na verdade, similares, o que
reduz o número de casos distintos que devem ser entendidos e analisados.
O desenvolvimento orientado a objetos não apenas permite que a informação

sobre um projeto seja compartilhada, como também possibilita reaproveitar projetos e
códigos em projetos futuros. As ferramentas para alcançar este compartilhamento,
tais como abstração, encapsulação e herança, estão presentes na metodologia e uma
estratégia de reuso entre projetos é a definição de bibliotecas de elementos reusáveis
(tais como: dlls, librarys, pakages e etc...). Entretanto, orientação a objetos não é uma
fórmula mágica para alcançar o reuso de classes. É preciso planejamento e disciplina
para pensar em termos genéricos, não voltados simplesmente para a aplicação
corrente.
No próximo capítulo será descrita a linguagem UML (Unified Modeling

Language), usada para modelagem de sistemas.
9
2. LINGUAGEM DE MODELAGEM UNIFICADA (UML)

No capítulo anterior foi descrita a POO e seus conceitos. Neste, será descrito o
que é e pra que serve a UML.
UML (Unified Modeling Language) é uma linguagem de modelagem de siste-

mas, ou um padrão de especificação de software, que usa representações gráficas
para diferentes visualizações de um mesmo sistema. Segundo Lima (2011), UML não
é um padrão de projetos, como o RUP (Rational Unified Process), e nem um padrão
de desenvolvimento de sistemas, mas sim um padrão de diagramação de sistemas.
2.1. FUNDAMENTOS DA UML
Segundo Lima (2011), UML é uma linguagem para especificação, construção,

visualização e documentação de um sistema de software intensivo. É uma linguagem
gráfica para análise, especificação e construção de sistemas para representar
projetos orientados a objetos utilizando uma notação comum.
Basicamente, a UML permite que desenvolvedores visualizem os produtos de

seus trabalhos em diagramas padronizados, sob diferentes pontos de vista. A UML
também especifica significados, isto é, semântica, é uma notação independente de
processos.
É importante distinguir entre um modelo UML e um diagrama (ou conjunto de

diagramas) de UML. O diagrama é uma representação gráfica da informação do
modelo, mas o modelo pode existir independentemente. O XMI (XML Metadata
Interchange), na sua versão corrente, disponibiliza troca de modelos, mas não de
diagramas.
10
2.2. ESCOPO DA UML

Figura 3 - Visualização de estrutura em UML Fonte: Lima (2011)
2.2.1. Tipos de diagrama
• De estrutura: Classe, Objetos, Interface, Componente, Colaboração, Nó.

• De comportamento: Casos de uso, Iteração, Máquina de estados.
• De agrupamento: Pacote, Modelo, Subsistema, Framework.
• De anotação: Notas.
2.2.2. Tipos de relacionamentos
• Agregação – a existência do Objeto-Parte faz sentido, mesmo não

existindo o Objeto-Todo.
• Associação (bidirecional ou unidirecional) – São relacionamentos
estruturais entre instâncias e especificam que objetos de uma classe
estão ligados a objetos de outras classes.
• Composição – Relacionamento entre um elemento.
• Generalização – Relacionamento entre um elemento mais geral e um
mais específico.
2.3. DIAGRAMA DE CLASSES
Nesta monografia, somente o diagrama de classes é descrito em detalhes, pois

é nele que se concentra o foco da pesquisa.
11
Segundo Lima (2011), o diagrama de classes tem como finalidade validar e

documentar a interação dos objetos envolvidos. A relação entre os objetos depende
de sua cardinalidade, referência e ou ainda dependência. Por exemplo, todo ser
humano fala; Carlos é um ser humano; portanto, Carlos fala (Figura 4).
Figura 4 - Diagrama de Classes
No próximo capítulo será apresentada a técnica de extração de classes usada

na ferramenta TextToClass, cujo protótipo foi desenvolvido nesse trabalho.
12
3. MÉTODO PARA CONSTRUÇÃO DO MODELO DE CLASSES

Nos capítulos anteriores, foram apresentados os fundamentos de orientação a
objetos e UML. Nesse capítulo, esses fundamentos serão usados como base para o
método de construção automática de modelos de classes, proposto nesse trabalho.
O método consiste na aplicação de regras gramaticais da língua portuguesa

para decomposição de frases e textos em elementos gramaticais (tais como
substantivos, verbos, adjetivos, etc), necessários para a construção de um modelo de
classes correspondente. Embora existam na literatura trabalhos correlatos para a lín-
gua inglesa, não foram encontradas ferramentas similares para a lígua portuguesa.
3.1. FUNDAMENTOS
Na frase “A galinha come milho”, “A galinha” é o sujeito e “come milho” é o
predicado. Como se sabe que a galinha é o sujeito? Porque o verbo relata uma ação
da galinha e o verbo se refere diretamente a ela. Portanto, pode-se inferir que
“galinha” refere-se a um objeto da classe “Galinha”, pois apenas objetos são capazes
de demonstrar comportamentos como, por exemplo, “comer”. Consequentemente,
pode-se também inferir que a palavra “comer” designa um método da classe
“Galinha”, pois refere-se a um comportamento esperado para os objetos dessa
classe. Em geral, substantivos representam classes, enquanto verbos representam
métodos. Com relação à frase “A galinha come milho”, ainda precisa-se saber se o
método “come” requer algum parâmetro ou devolve algo para quem o chama, mas
como saber isso? Nesse caso, a análise do contexto da frase deve levar à resposta;
pois é nesse contexto que se referencia o que a ação precisa para ocorrer. Como se
pode inferir pelo contexto, o método “comer” requer “milho” como parâmetro de
entrada. Por outro lado, como a frase não relata nenhum produto da ação “comer”, o
método “comer” não retorna nada (void). Assim, um modelo de classe correspondente
à frase “A galinha come milho” pode ser representado em UML conforme ilustrado na
Figura 5.
Figura 5 - Classe Galinha.

13
A frase “O Funcionário Carlos entrega relatório de vendas solicitado pelo

gerente” pode ser analisada de acordo com esse mesmo princípio. Nesta frase,
obtém-se o sujeito “Carlos”, como “Carlos” é um funcionário, pode-se dizer que
“Carlos” é uma instância da classe “Funcionário” e herda atributos e métodos dessa
classe. A classe “Gerente” também é um funcionário que herda atributos e métodos
da classe mãe “Funcionário”. Há dois verbos na frase “Entrega e Solicitado” que
podem ser métodos da instância “Carlos”. Então, precisa-se achar o predicado e
saber a quem o predicado se destina. Nesse caso, toda a frase se destina à entrega
do relatório, portanto quem entrega o relatório é “Carlos”, ou seja, “Carlos” é o sujeito
da frase e, mas como a frase especifica que “Carlos” é um funcionário então “Carlos”
não é uma classe e sim uma instância da classe “Funcionário”. Após encontrar a
classe volta-se à atenção para os métodos. Apesar de essa frase ter dois verbos,
somente um se qualifica para método, pois a ação contextualizada pela frase é
entregar. “Solicitado” é uma referência a quem solicitou, ou seja, o solicitante gerente.
Então o método é “Entrega”. Obtém-se a instância “Carlos” da classe “Funcionário” e
o método “Entrega”, conforme a contextualização da frase. É preciso referenciar o
solicitante e o que ele solicitou. Neste caso, solicitou um relatório de vendas e quem
solicitou foi o gerente; então o método “Entrega” necessita de dois parâmetros de
entrada “Relatório de vendas” e “Solicitante” (fig. 6).
Figura 6 - Classe Carlos
Ainda pode-se criar mais uma classe, porque segundo a frase, o gerente
também tem uma ação que é solicitar (fig. 7).
Figura 7 - Classe Gerente
Evidenciou-se a classe “Gerente” e a classe “Funcionário”, mas no contexto da

frase “Carlos” tem que entregar o relatório ao gerente e “Carlos” é a objetificação
14
(instância) da classe “Funcionário”. Então se pode dizer que Carlos deve chamar o
gerente e entregar o relatório (fig. 8).
Na POO, chamar a classe Gerente é chamado de instância da classe Gerente.

A figura 8 ilustra isso.
Figura 8 - Classe Carlos instanciando classe Gerente
No caso descrito na Figura 8, a classe “Funcionário” tem que receber uma

instância da classe “Gerente” e na classe “Funcionário” o atributo solicitante foi
trocado pelo atributo gerente do tipo “Gerente”.
Figura 9 - Cadastro de Clientes
Analisando-se o diagrama de classes na Figura 9, pode-se verificar que há

duas classes (“Clientes” e “CadastroCliente”) e uma flecha ligando as duas classes. A
flecha representa uma instância de “Clientes” contida em “CadastroCliente”. Então
pode-se textualizar o diagrama de classes.
15
“Cadastrar clientes com nome, telefone, CPF e endereço, retornar todos os

clientes, retornar um cliente por nome, telefone, CPF ou endereço, excluir clientes ou
alterar clientes”.
Pode-se ver que também há a possibilidade de gerar um texto a partir de um

diagrama de classes.
A Figura 10 mostra a correspondência de cada item de uma classe com a

língua portuguesa.
Figura 10 - Classe X português
3.2. MÉTODO DE INTERPRETAÇÃO

Como tem sido descrito ao longo desta monografia, pode-se notar um padrão
de composição. Para definir a classe, encontra-se o sujeito da frase. Para definir os
métodos, encontram-se as ações do sujeito e pode-se até encontrar situações de
herança (também obtém-se herança quando encontrada uma preposição na frase)
onde se podem extrair duas classes que atuam para um determinado fim. Consegue-
se também identificar os parâmetros dos métodos ou os substantivos que interagem
diretamente com as ações, também através dos artigos estimar quantidade e dos
gêneros estipular os gêneros dos sujeitos. Então, têm-se todos os ingredientes
necessários para poder escrever textos mais complexos até mesmo uma história.
3.3. DEFINIÇÕES
Neste item será definida, dentro do conceito, a orientação a objetos (POO).
3.3.1. Polimorfismo
O polimorfismo é caracterizado quando duas ou mais classes distintas têm
métodos de mesmo nome, sendo que uma função pode utilizar um objeto de qualquer
uma das classes abstratas, sem a necessidade de tratar de forma diferente conforme
a classe do objeto, como já foi discutido no capítulo sobre POO.
16
Uma frase com polimorfismo: “Todo animal fala, a galinha cacareja e o gato
mia”.
Figura 11 - Polimorfismo
3.3.2. Encapsulamento
Encapsulamento vem de encapsular, que em programação orientada a objetos
significa separar o programa em partes, o mais isolado possível. A ideia é tornar o
software menos dependente, fácil de modificar (com pouco ou nenhum acoplamento)
e de criar novas implementações.
Uma analogia ao encapsulamento é o ato de realizar um saque ou um depósito

em um caixa eletrônico. Os métodos sacar e depositar untilizam os mesmos produtos
para operar “cheque” ou “dinheiro” que estão encapsulados na classe “Produtos”.
Figura 12 - Encapsulamento
O encapsulamento é conhecido no Java por “JavaBeans” e no C# por “DTO”

(Data Transfer Object).
17
A seguir é visualizado um texto complexo e é definido o modelo de classes.
3.3.3. Polimorfismo e Herança

No texto:
“Tinha momentos em que deliciava-se com a ideia de que os livros podiam falar, ganhar vida e
autonomia.
Então compreendia o seu amor por aquelas estantes, graças às quais agora vivia e daqueles
livros dos quais obtivera ao longo dos anos uma felicidade diferente de todas as outras modalidades
possíveis de felicidade.
Ler era uma das coisas mais importantes da sua vida, da qual cada vez restavam menos
coisas importantes, e começou a contabilizá-las: a amizade, o café, o cigarro, o vinho, de vez em
quando fazer amor ora ao por ora ao nascer do sol (Amorinn, 2012)”.
Nesse texto são relatadas as ações de um sujeito oculto, mas pode-se definir o
sujeito por certos trechos do texto. O trecho “... Então compreendia o seu amor por
aquelas estantes, graças às quais agora vivia...” poder-se-ia dizer que o sujeito é um
bibliotecário, mas no trecho “Ler era uma das coisas mais importantes da sua vida”
pode-se definir com maior precisão que o sujeito é um “Leitor” acima de tudo como o
próprio texto o definiu. Pode-se agora listar as ações referentes ao sujeito
encontradas no texto: deliciava-se, tinha, compreendia, vivia, obtivera, ler, contabilizar
e fazer amor, pode-se também listar as propriedades encontradas: ideia, momentos,
amor pelas estantes, graças as estantes, longo dos anos, felicidade diferente das
outras, quantidade de coisas importantes, amizade, café, cigarro, vinho, ora por do sol
e ora nascer do sol.
Pode-se também identificar outra classe “Livros”, pois o autor relata duas
possíveis ações de livros, falar e ganhar com os seguintes atributos: vida e
autonomia.
Definindo as classes, métodos e parâmetros, o diagrama de classes (Figura

13) relata o texto descrito pelo autor.
18
Figura 13 - Diagrama de classes de um texto completo
Mas se o texto não define um sujeito então não se pode definir a classe? Na
verdade, todos os textos definem sujeitos mesmo que estejam ocultos. Ao longo do
texto, sempre se encontram menções ao sujeito; por exemplo: “Está chovendo.” o que
esta chovendo “Chuva” pode-se dizer então: “O Tempo está chovendo” o que chove
“O Tempo” então por definição “Tempo” é o sujeito da classe. Outro exemplo é, “Está
ensolarado” o que está ensolarado “O Tempo” então “O Tempo está ensolarado”.
Um exemplo de herança é na frase, “Todo o ser humano fala; Carlos é um ser

humano; portanto, Carlos fala”.
A classe “Carlos” herda o método “falar” da classe “Humano”, como mostra a

Figura 14.
19
Figura 14 - Exemplo de Herança
3.4. FORMALIZANDO O MÉTODO

Como pode ser visto durante o processo, há um padrão que foi notado: o sujei-
to é o nome da classe, os objetos são os parâmetros, os métodos são os verbos, os
atributos são os adjetivos e quando há uma herança temos uma ou mais prepo-
sições. A Figura 15 essa correspondência para a frase “A Galinha come milho”.
Figura 15 - Formalização do método
A seguir tratar-se-á sobre outras abordagens e ferramentas de extração de

classes usando linguagem natural.
20
4. CONSTRUÇÃO AUTOMÁTICA DE MODELO DE CLASSES

Segundo Harmain (2000), extração de classes a partir de um texto é um sonho
dos pesquisadores, desde o surgimento das primeiras linguagens; portanto, sempre
houve pesquisas em torno desse paradigma.
Algumas pesquisas estão bem avançadas, tanto que alguns pesquisadores
criaram softwares que cumprem esse papel. Alguns deles são chamados de análise
automática de requisitos, que são softwares que tentam automatizar o levantamento
de requisitos, transformando textos em modelos de classes. Um dos problemas que
os pesquisadores enfrentam é a semântica da linguagem, pois em uma linguagem
formal não é preciso que o conteúdo da frase faça sentido.
A maioria dos softwares de extração de classes automática é baseada em
técnicas de IA (Inteligência Artificial) como “Árvore gramatical”.
Os softwares NL-OOPS (Mich, 1996), CM-Builder (Harmain, 2000), UML –
Generator (Bajwa, 2003), transformam um texto em especificações de requisito e
diagramas UML. Esses softwares usam processos de IA baseados em regras. Uma
delas é bottom-up que é representada na Figura 16.
Figura 16 - Árvore gramatical em bottom-up (Harmain, 2000)
A Figura 16 representa uma árvore gramatical baseada em processo bottom-up

e simula o processo semântico de análise da fala (Fala – processo de comunicação
humana através de sons). Este é o processo que dá sentido às frases formadas pelos
seres humanos, pois para que se possa interpretar alguma frase, a mesma tem que
estar dentro de um contexto. Uma árvore gramatical, ou árvore sintática, é uma árvore
cujos nós são rotulados. Os nós internos são rotulados com símbolos não-terminais
da gramática (e.g., F, SV, SN1, SN, Subst Pr, LocAdj, Subst) e os nós externos, ou
folhas, são rotulados com símbolos terminais da gramática (e.g., Mário, imprimir, o, ε,
21
arquivo). Arestas na árvore sintática indicam passos de derivação permitidos pela

gramática considerada.
Nas próximas seções, são apresentados alguns softwares de análise
automática de requisitos.
4.1. CM-BUILDER
CM-Builder (Harmain, 2000) é um software desenvolvido para extração de
classes de textos em inglês. Essa ferramenta foi desenvolvida por Harmain para
demonstrar sua teoria. A Figura 17 mostra uma tela do sistema.
Figura 17 - CM-Builder
CM-Builder é uma ferramenta CASE de linguagem natural que visa apoiar a

fase de análise de desenvolvimento de software em uma estrutura orientada a
objetos. CM-Builder usa robustas técnicas de processamento de linguagem natural
para analisar textos de requisitos de software em inglês e construir um modelo
integrado de discurso do texto processado, representado em uma rede semântica.
Esta rede semântica é usada para construir automaticamente um modelo de classes
22
inicial UML, representando as classes de objetos mencionados no texto e as relações

entre eles. Segundo (Harmain, 2000), o modelo inicial pode ser diretamente adicio-
nado à ferramenta CASE para posterior aperfeiçoamento por um analista humano.
Segundo (Harmain, 2000), o CM-Builder foi quantitativamente avaliado em ensaios
cegos contra um conjunto de requisitos de software. Os resultados da avaliação foram
muito promissores e demonstram que ferramentas como CM-Builder têm potencial
para auxiliar o analista em um papel importante no processo de desenvolvimento de
software.
4.2. NL-OOPS
O NL-OOPS (Mich, 1996) é uma ferramenta CASE que suporta a análise de
requisitos, gerando modelos orientados a objetos a partir de documentos de requisitos
em inglês. A análise de linguagem natural no NL-OOPS é feita com base no núcleo
do sistema de processamento de linguagem natural LOLITA (Long & Garigliano,
1994), que usa uma rede semântica, denominada SemNet, para representação do
conhecimento. O módulo de análise orientada a objetos implementa um algoritmo
para a extração dos objetos e suas associações para uso na criação de modelos de
objetos.
4.3. UML-GENERATOR
O UML-Generator (Bajwa, 2003) permite que o sistema se adapte ao voca-
bulário do usuário e ao modo como analista modela sistemas de software. As técnicas
desenvolvidas podem ser usadas para várias aplicações, tais como sumarização de
documento, análise de software e modelagem, geração de consultas a banco de
dados, dentre outras. O UML-Generator analisa requisitos descritos por textos curtos
em inglês, fornecidos pelo usuário, extrai a informação associada e desenha vários
tipos de diagramas UML correspondentes aos textos analisados, tais como diagramas
de seqüência, diagramas de classe e diagramas de casos de usos. Ele ainda tem
capacidade para criar código automaticamente sem ambiente externo (sem IDE como
o Visual Studio). Em suma, o UML-Generator é uma ferramenta rápida e confiável
para gerar diagramas UML e respectivos códigos.
No próximo capítulo será descrita a ferramenta desenvolvida nesse trabalho.

23
5. TextToClass: A FERRAMENTA DESENVOLVIDA

No capítulo anterior foram apresentadas algumas ferramentas que utilizam
linguagem natural para processar texto, agora será descrita a ferramenta TextToClass
desenvolvida para este trabalho.
TextToClass é uma ferramenta CASE de produção de modelos de classes, a

partir de frases em português. TextToClass usa técnicas de processamento de
linguagem natural (método descrito no Capítulo 3) baseada em classificação de
palavras em categorias gramaticais, para ajudar o profissional no processo de
desenvolvimento do software, a partir de conhecimentos extraídos dos usuários (o
código-fonte completo da ferramenta desenvolvida é apresentado no Apêndice).
Deve-se ressaltar que nenhuma outra ferramenta similar àquela proposta

nesse trabalho foi encontrada na literatura da área.
TextToClass processa uma frase separando o nome da classe, parâmetros,

atributos e métodos referentes à classe. No Capítulo 3 foi apresentado o método
utilizado no desenvolvimento da ferramenta. A Figura 18 mostra a tela onde é inserida
a frase para a composição da classe.
Figura 18 - TextToClass
24
5.1. ARQUITETURA
O protótipo do software foi desenvolvido em C#, com a interface em Windows
Forms. Para o banco de dados, foi usado o SQL Server e, para a comunicação entre
a interface e o banco de dados, foi usado um Web Service em WCF.
WinForms é uma apresentação de interface que roda localmente na máquina,

sem a necessidade de acesso à internet.
WCF (Windows Communication Foundation) é uma aplicação distribuída

orientada a serviço (SOA).
SQL Server é um SGBD de propriedade da Microsoft e tem sua linguagem

baseada em SQL.
5.2. ALGORITMO
O algoritmo usado nesse projeto é baseado em identificação dos tipos das
palavras. Ao se inserir a frase no campo, o sistema decompõe a frase em palavras e
as compara com seu banco de dados. Assim que a palavra é identificada, e seu tipo é
determinado (verbo, substantivo, adjetivo ou outros), ela é colocada no campo
correspondente apresentado na tela do aplicativo.
No Capítulo 3 (método para a construção do modelo de classes) é apresentado

o método usado para avaliação das palavras, classificação e validação aplicadas em
cada uma das palavras de cada frase inserida no campo txtFrase. O método que é
apresentado no Capítulo 3 foi usado para a construção do algoritmo usado na
ferramenta. A Figura 19 descreve o algoritmo implementado pela ferramenta.
25
Figura 19 - Algoritmo usado no sistema TextToClass
A Figura 19 mostra o processo realizado pelo algoritmo, desde a inserção da

frase no campo de texto, decomposição da frase em palavras, avaliação do tipo de
palavras ao cadastramento das mesmas em seus devidos serviços.
Foram realizados dois tipos de teste, o teste linha a linha e o teste funcional
com o protótipo.
26
5.3. RESULTADO DO TESTE LINHA A LINHA

O teste linha a linha foi executado com a ferramenta Visual Studio 2010, e o
sistema comportou-se como se esperava. A frase inserida no campo “txtText” (campo
onde o usuário deve digitar a frase) é decomposta e as palavras da classe são
adicionadas a um objeto do tipo “List”, que em cada índice contém uma palavra. Os
índices do componente list são decompostos e cada palavra é enviada para o web
service (WCF) que a compara com as palavras do banco de dados, ao encontrá-la
verifica o tipo da palavra e a devolve em seu devido campo, cadastrando-a também
em uma tabela de seu tipo.
5.4. RESULTADO DO TESTE FUNCIONAL

No teste funcional foram escolhidas três frases, “A galinha come milho”, “A
classe cliente cadastra nome, telefone e endereço” e “O relatório devolve o resultado
de um cálculo”. Na Figura 20 é mostrado o resultado do primeiro teste.
Figura 20 - Primeiro teste
Na Figura 20 nota-se que os campos referentes ao tipo das palavras estão

preenchidos corretamente. Ao clicar na linha que corresponde à frase que foi
cadastrada, as listas de métodos e parâmetros são preenchidas automaticamente.
O segundo teste foi realizado e notou-se que o sistema não possuía algumas
palavras ou pontuações. Foi então adicionada uma tela de cadastro para as palavras.
A Figura 21 mostra o resultado do segundo teste com o erro.
27
Figura 21 - Mensagem de erro alertando o usuário de que uma palavra não foi
localizada no banco de dados.
Ao tentar cadastrar a frase “O cadastro de clientes cadastrará nome, telefone e

endereço”, o sistema reportou um erro; pois, não identificou uma das palavras ou
pontuação (nesse caso a vírgula). Então, foi feito um tratamento desse erro por meio
de uma mensagem apresentada ao usuário, notificando-o de que o sistema não
localizou a palavra no banco de dados, e também uma pergunta para saber se o
usuário deseja cadastrar essa palavra ou continuar o processo. Caso o usuário opte
por não cadastrar a palavra, a ferramenta continua analisando as outras palavras da
frase. Como é mostrado na Figura 22.
28
Figura 22 - Processo da frase "O cadastro de clientes cadastrará nome, telefone

e endereço." completo.
Assim, foi constatada a necessidade de se ter uma tela de cadastro de

palavras. Ao se clicar em “No” o sistema automaticamente direciona o usuário para a
tela de cadastro de palavras. A Figura 23 mostra a tela de cadastro de palavras com
um campo para a palavra e um combo para seleção do tipo de palavra.
Figura 23 - Cadastro de palavras

29
O sistema ainda não possui tabelas referentes ao flexionamento de verbos e,

consequentemente, não é capaz de perceber que diferentes conjugações de um
mesmo verbo reference a uma mesma ação ou método.
O processo de cadastramento de palavra se desenrola da seguinte forma:
O usuário preenche o campo “Palavra” com a palavra que deseja cadastrar. No

campo “Tipo”, que é do tipo “ComboBox”, o usuário seleciona o tipo de palavra. Caso
o usuário erre, basta clicar em “Limpar” para que os campos voltem a sua forma
original.
Após o preenchimento dos campos, o usuário clica em “Salvar” e a palavra é

enviada ao WebService. Então, usando o método “InserirPalavra” da classe
“PalavraDAL” (pág. 49), a palavra é enviada ao banco de dados.
No segundo teste (i.e., “O cadastro de cliente cadastrará nome, telefone e

endereço”), como foi mostrado na Figura 22, também se obteve o resultado esperado.
Os atributos referentes ao cliente estão na lista de atributos, os métodos referentes à
ação “cadastrará” está na lista de método.
A fase de teste funcional foi concluída com o terceiro e último teste, como mostra
a Figura 24.
Figura 24 - Terceiro teste

30
Com a conclusão da fase de testes funcionais, notou-se que o sistema

comportou-se de forma esperada, realizando as funções já previstas.
Ao clicar em “Cadastrar”, o botão aciona o evento de clique (cmdCadastrar_Click

pág. 38 do apêndice), que por sua vez cadastra a frase no banco, pois para cadastrar
os métodos, classes, parâmetros e atributos é necessário ter a identificação do
registro da classe (id_fraseclasse).
Após obter o número do registro da frase, tem início o processo de decom-

posição da frase.
Uma variável do tipo array de string (String[] frase) é populada com as palavras
da frase (i.e., cada posição desse vetor é preenchida com uma palavra da frase).
Então, com um laço de repetição (for) seleciona-se cada índice do referido array. No
decorrer do processo, para cada índice considerado, uma série de validações (if) são
feitas. Caso o item avaliado (objPalavraDTO._id_tipopalavra) passe por alguma das
validações, o item do array é cadastrado, através de um Web Service
(WCFTextToClass, pág. 66 do apêndice) no banco de dados, de acordo com seu tipo
identificado pelas validações. A Figura 25 mostra o Diagrama de Modelagem de
Dados (MLD) do banco de dados usado pelo sistema.
31
Figura 25 - MLD do banco de dados do sistema TextToClass.
O Web Service é descrito no apêndice, a partir da página 42, e o processo de

inclusão, exclusão, alteração e pesquisa de dados no banco é realizada por um
CRUD (Create, Reader, Update e Delete), que é responsável pelo gerenciamento de
cada objeto que o sistema trata.
No próximo capítulo são relatadas as conclusões desse este trabalho.

32
CONCLUSÃO
Esse trabalho descreve o paradigma de orientação a objetos (POO), a língua-
gem de modelagem de sistemas UML (Unified Modeling Language) e um método de
extração de modelos de classes a partir de especificações de requisitos em portu-
guês. Também descreve uma ferramenta desenvolvida para extração automática de
modelos classes a partir de especificações de requisitos em português, denominada
TextToClass, e relata resultados de testes realizados com essa ferramenta.
Ao longo do trabalho, constatou-se que é de suma importância que os analistas

e desenvolvedores de software possam contar com uma ferramenta para auxiliar na
documentação de sistemas, já que esta atividade consome grande parte do tempo de
desenvolvimento de um projeto. Além disso, o uso de tal ferramenta pode também
garantir um maior grau de confiabilidade no sistema desenvolvido.
Espera-se que a ferramenta TextToClass também possa auxiliar na área aca-

dêmica, contribuindo para uma melhor compreensão e entendimento dos conceitos de
POO por parte do aluno. Com essa ferramenta, ele poderá visualizar a construção
dos modelos de classes, comparar seus modelos com aqueles apresentados pela
ferramenta e assimilar mais facilmente os conceitos.
Um trabalho futuro de implementação da automatização do diagrama de caso

de uso, o diagrama de sequência, o diagrama de classes e o diagrama de atividades
poderá permitir uma avaliação mais eficaz do sistema. Serão criadas tabelas que
trataram o flexionamento de verbos. Será criada uma interface on-line para que as
pessoas que desejam usar o sistema possam ter acesso. Também será aprimorada a
precisão e confiabilidade do sistema juntando algoritmos de inteligência artificial com
lógica formal e até mesmo árvore gramatical.
33
REFÊRENCIAS
BAJWA, Imran S. 2003. UML-Generator: A Tool of Generating UML Diagrams

from NL Specification. http://www.thesisabstracts.com/ThesisAbstract_402_UML-
Generator-A-Tool-of-Generating-UML-Diagrams-from-NL-Specification.html Acessado
em: 24/09/2012.
HARMAIN, Gaizauskas M. Building Object-Oriented Conceptual Models Using

Natural Language Processing Techniques 2000 Disponível em:
www.cs.bham.ac.uk/~isb855/papers/LNBIP%202012.pdf. Acessado em: 08/09/2012.
LIMA, Adilson S. UML 2.3 do requisito à solução 1ª Edição; São Paulo: Érica,
2011.
LONG, Derek; GARIGLIANO, Roberto. 1993. The LOLITA Natural Language

Processing System. http://homepages.inf.ed.ac.uk/wadler/realworld/natlangproc.html.
Acessado em: 21/05/2012.
MICH, L. From natural language to object oriented requirements using the

natural language processing system LOLITA. 1996 Disponível em:
http://journals.cambridge.org/action/displayAbstract?fromPage=online&aid=48295
RICARTE, Ivan L. M. 2001. O modelo de objetos.

http://www.dca.fee.unicamp.br/cursos/POOCPP/node13.html. Acessado em:
15/05/2012.
SOMMERVILE, Ian Engenharia de Software 8ª edição; tradução Prof.ª Dra.

Selma Shin Shimizu Melnikoff, Prof. Dr. Reginaldo Arakaki e Prof. Dr. Edilson de
Andrade Barbosa; revisão técnica Kechi Hirama. São Paulo: Pearson Addison
Wesley, 2007.
AMORINN, http://www.recantodasletras.com.br/microcontos/3766599
34
APÊNDICE – CÓDIGO FONTE DO SISTEMA TEXTTOCLASS
Classe mdiPrincipal
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace TextToClass
{
public partial class mdiPrincipal : Form
{
private int childFormNumber = 0;
public mdiPrincipal()
{
InitializeComponent();
}
private void ShowNewForm(object sender, EventArgs e)

{
Form childForm = new Form();
childForm.MdiParent = this;
childForm.Text = "Window " + childFormNumber++;
childForm.Show();
}
private void OpenFile(object sender, EventArgs e)

{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
openFileDialog.Filter = "Text Files (*.txt)|*.txt|All Files (*.*)|*.*";
if (openFileDialog.ShowDialog(this) == DialogResult.OK)
{
string FileName = openFileDialog.FileName;
}
}
private void SaveAsToolStripMenuItem_Click(object sender, EventArgs e)

{
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
saveFileDialog.Filter = "Text Files (*.txt)|*.txt|All Files (*.*)|*.*";
if (saveFileDialog.ShowDialog(this) == DialogResult.OK)
{
string FileName = saveFileDialog.FileName;
}
}
private void ExitToolsStripMenuItem_Click(object sender, EventArgs e)

{
this.Close();
}
private void CutToolStripMenuItem_Click(object sender, EventArgs e)

{
}
35
private void CopyToolStripMenuItem_Click(object sender, EventArgs e)

{
}
private void PasteToolStripMenuItem_Click(object sender, EventArgs e)

{
}
private void CascadeToolStripMenuItem_Click(object sender, EventArgs e)

{
LayoutMdi(MdiLayout.Cascade);
}
private void TileVerticalToolStripMenuItem_Click(object sender, EventArgs e)

{
LayoutMdi(MdiLayout.TileVertical);
}
private void TileHorizontalToolStripMenuItem_Click(object sender, EventArgs e)

{
LayoutMdi(MdiLayout.TileHorizontal);
}
private void ArrangeIconsToolStripMenuItem_Click(object sender, EventArgs e)

{
LayoutMdi(MdiLayout.ArrangeIcons);
}
private void CloseAllToolStripMenuItem_Click(object sender, EventArgs e)

{
foreach (Form childForm in MdiChildren)
{
childForm.Close();
}
}
private void palavrasToolStripMenuItem_Click(object sender, EventArgs e)

{
frmPalavras palavra = new frmPalavras();
palavra.Show();
}
private void geradorToolStripMenuItem_Click(object sender, EventArgs e)

{
frmGerador gera = new frmGerador();
gera.Show();
}
}
}
Classe frmGerador
using System;
using System.Data;
using System.Linq;
using System.Text;
using TextToClass.WCFTextToClass;
36
{
public partial class frmGerador : Form
{
String[] frase = { };
TextToClassClient wcf = new TextToClassClient();
PalavraDTO objPalavraDTO = new PalavraDTO();
TipoPalavraDTO objTipoPalavraDTO = new TipoPalavraDTO();
FraseClasseDTO objFraseClasseDTO = new FraseClasseDTO();
MetodoDTO objMetodoDTO = new MetodoDTO();
List<String> lMetodo = new List<String>();
ParametroDTO objParametroDTO = new ParametroDTO();
List<String> lParametro = new List<String>();
int nomeClasse = 0;
public frmGerador()
{
carregaGrdClasse();
}
private void cmdIgnorar_Click(object sender, EventArgs e)

{
nomeClasse = 0;
txtMetodo.Text = "";
txtParametro.Text = "";
txtFrase.Text = "";
}
private void cmdCadastrar_Click(object sender, EventArgs e)

{
nomeClasse = 0;
txtMetodo.Text = "";
txtParametro.Text = "";
Int32 retornoFraseClasse = 0;
Int32 retornoMetodo = 0;
Int32 retornoParametro = 0;
#region Confecção da classe
if (txtFrase.Text != "")
{
frase = txtFrase.Text.Replace("classe", "").Replace("Classe", "").Replace(",",
"").Split(Convert.ToChar(" "));
if (frase.Count() != 0)
{
for (int i = 0; i < frase.Count(); i++)
{
objPalavraDTO = new PalavraDTO();
objPalavraDTO._nm_palavra = frase[i];
if (frase[i].Contains(".") && objPalavraDTO._nm_palavra != "")

{
string x = objPalavraDTO._nm_palavra.Replace(".", "");
objPalavraDTO._nm_palavra = x;
}
objPalavraDTO = wcf.retornaPalavraNm(objPalavraDTO);
if (objPalavraDTO._id_palavra != 0)
{
objTipoPalavraDTO = new TipoPalavraDTO();
37
objTipoPalavraDTO._id_tipopalavra = objPalavraDTO._id_tipopalavra;
if (wcf.retornaTipoPalavraID(objTipoPalavraDTO)._nm_tipopalavra != "")
{
if (nomeClasse == 0 && objPalavraDTO._id_tipopalavra == 7)
{
nomeClasse = 1;
string primeira = objPalavraDTO._nm_palavra;
char letraMaiuscula = char.ToUpper(primeira[0]);
objPalavraDTO._nm_palavra = letraMaiuscula + primeira.Substring(1);
groupBox2.Text = "Classe " + objPalavraDTO._nm_palavra;
objFraseClasseDTO = new FraseClasseDTO();

objFraseClasseDTO._id_palavra = objPalavraDTO._id_palavra;
objFraseClasseDTO._nm_frase = txtFrase.Text;
retornoFraseClasse = wcf.inserirFraseClasse(objFraseClasseDTO);
objFraseClasseDTO._id_fraseclasse = retornoFraseClasse;
}
else if (objPalavraDTO._id_tipopalavra == 4)
{
if (txtMetodo.Text != "")
{
txtMetodo.Text += "; " + objPalavraDTO._nm_palavra;
}
else
{
txtMetodo.Text = objPalavraDTO._nm_palavra;
}
objMetodoDTO = new MetodoDTO();

objMetodoDTO._id_fraseclasse = retornoFraseClasse;
objMetodoDTO._id_palavra = objPalavraDTO._id_palavra;
if (wcf.inserirMetodo(objMetodoDTO) != 0)
{
retornoMetodo = 1;
}
}
else if (objPalavraDTO._id_tipopalavra == 7)
{
if (txtParametro.Text != "")
{
txtParametro.Text += "; " + objPalavraDTO._nm_palavra;
}
else
{
txtParametro.Text = objPalavraDTO._nm_palavra;
}
objParametroDTO = new ParametroDTO();

objParametroDTO._id_fraseclasse = retornoFraseClasse;
objParametroDTO._id_palavra = objPalavraDTO._id_palavra;
if (wcf.inserirParametro(objParametroDTO) != 0)
{
retornoParametro = 1;
}
}
}
if(frase[i].Contains("."))
{
38
nomeClasse = 0;
if (retornoFraseClasse == 1 || retornoMetodo == 1 || retornoParametro == 1)

{
MessageBox.Show("A classe foi criada com sucesso !");
}
}
}
}
}
}
#endregion
carregaGrdClasse();
}
public void carregaGrdClasse()

{
grdClasses.DataSource = wcf.retornaTodosFraseClasse();
grdClasses.Columns[5].HeaderText = "Frase que gerou a classe";

grdClasses.Columns[5].Width = 800;
grdClasses.Columns[0].Visible = false;
}
private void grdClasses_RowHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e)

{
if (e.RowIndex != -1)
{
objFraseClasseDTO = (FraseClasseDTO)grdClasses.Rows[e.RowIndex].DataBoundItem;
if (objFraseClasseDTO._id_fraseclasse != 0)
{
objPalavraDTO._id_palavra = objFraseClasseDTO._id_palavra;
gboClasses.Text = "Classe: " + wcf.retornaPalavraID(objPalavraDTO)._nm_palavra;
lMetodo = new List<String>();

foreach (var item in wcf.retornaIdPalavraMetodoIDFrase(objFraseClasseDTO._id_fraseclasse))
{
objPalavraDTO._id_palavra = item;
lMetodo.Add(wcf.retornaPalavraID(objPalavraDTO)._nm_palavra);
}
lParametro = new List<String>();

foreach (var item in wcf.retornaIdPalavraParametroID(objFraseClasseDTO._id_fraseclasse))
{
objPalavraDTO._id_palavra = item;
lParametro.Add(wcf.retornaPalavraID(objPalavraDTO)._nm_palavra);
}
lstMetodos.DataSource = lMetodo;
lstParametros.DataSource = lParametro;
}
}
}
}
39
Classe frmPalavras
using System;
using System.Data;
using System.Linq;
using System.Text;
using TextToClass.WCFTextToClass;
{
public partial class frmPalavras : Form
{
TextToClassClient wcf = new TextToClassClient();
PalavraDTO palavra = new PalavraDTO();
TipoPalavraDTO tipoPalavra = new TipoPalavraDTO();
public frmPalavras()
{
//carregaGrdPalavras();
carregaCboTipoPalavra();
}
public void carregaGrdPalavras()

{
grdPalavras.DataSource = wcf.retornaPalavraTodos();
grdPalavras.Columns[0].Visible = false;
grdPalavras.Columns[1].HeaderText = "ID";
grdPalavras.Columns[2].HeaderText = "Tipo de palavra";
grdPalavras.Columns[4].HeaderText = "Palavra";
}
public void carregaCboTipoPalavra()

{
foreach (var item in wcf.retornaTipoPalavraTodos())
{
cboTipoPalavra.Items.Add(item._nm_tipopalavra);
}
cboTipoPalavra.Items[0] = "Selecione um tipo";

cboTipoPalavra.SelectedIndex = 0;
}
private void cmdSalvar_Click(object sender, EventArgs e)

{
if (txtPalavra.Text != "" & cboTipoPalavra.SelectedIndex != 0)
{
palavra = new PalavraDTO();
palavra._nm_palavra = txtPalavra.Text;
palavra._id_tipopalavra = cboTipoPalavra.SelectedIndex + 1;
if (wcf.retornaPalavraNm(palavra)._id_palavra == 0)
{
if (wcf.InserirPalavra(palavra) == 1)
40
{
MessageBox.Show("Registro inserido com sucesso !");
carregaGrdPalavras();
}
else
{
MessageBox.Show("Falha ao inserido com sucesso !");
}
}
else
{
MessageBox.Show("Registro já inserido !");
}
}
else
{
MessageBox.Show("Preencha todos os campos para inserir um registro");
}
}
private void cmdLimpar_Click(object sender, EventArgs e)

{
txtPalavra.Text = "";
cboTipoPalavra.SelectedIndex = 0;
}
private void cmdExcluir_Click(object sender, EventArgs e)

{
palavra = new PalavraDTO();
palavra._nm_palavra = txtPalavra.Text;
palavra = wcf.retornaPalavraNm(palavra);
if (palavra._id_palavra != 0)
{
if (wcf.ExcluirPalavra(palavra) == 1)
{
MessageBox.Show("Registro excluido com sucesso !");
}
else
{
MessageBox.Show("Falha ao excluir o registro !");
}
}
else
{
MessageBox.Show("Registro não encontrado !");
}
}
}
}
Classe FraseClasseDAL
using System;
using System.Linq;
using System.Web;
using WCFTextToClass.DTO;
using WCFTextToClass.Util;
using System.Data;
41
namespace WCFTextToClass.DAL
{
public class FraseClasseDAL
{
Banco_DAL objBancoDAL = new Banco_DAL();
List<FraseClasseDTO> lFraseClasse = new List<FraseClasseDTO>();
FraseClasseDTO objFraseClasse = new FraseClasseDTO();
DataTable objDT = new DataTable();
Int32 retorno = 0;
public Int32 inserirFraseClasse(FraseClasseDTO beFraseClasse)

{
try
{
if (objBancoDAL.ExecuteDR("Insert into tbFraseClasse (nm_frase, id_palavra, fl_status)" +
"values ('" + beFraseClasse._nm_frase + "'," +
beFraseClasse._id_palavra
+ ", 1)").RecordsAffected == 1)
{
objBancoDAL = new Banco_DAL();
beFraseClasse._id_fraseclasse = Convert.ToInt32(objBancoDAL.ExecuteDT("Select
MAX(id_fraseclasse) from tbFraseClasse").Rows[0].ItemArray[0]);
retorno = beFraseClasse._id_fraseclasse;
}
else
{
retorno = 0;
}
return retorno;
}
catch (Exception)
{
retorno = 0;
return retorno;
}
finally
{
retorno = new Int32();
}
}
public Int32 alterarFraseClasse(FraseClasseDTO beFraseClasse)

{
try
{
if (objBancoDAL.ExecuteDR("Update tbFraseClasse set nm_frase = " + beFraseClasse._nm_frase
+ ", id_palavra = " + beFraseClasse._id_palavra +
" where id_fraseclasse = " +
beFraseClasse._id_fraseclasse).RecordsAffected == 1)
{
retorno = 1;
}
else
{
retorno = 0;
}
return retorno;
}
catch (Exception)
{
retorno = 2;
return retorno;
42
}
finally
{
}
}
public Int32 excluirFraseClasse(FraseClasseDTO beFraseClasse)

{
try
{
if (objBancoDAL.ExecuteDR("Update tbFraseClasse set fl_status = false where id_fraseclasse = "
+ beFraseClasse._id_fraseclasse).RecordsAffected == 1)
{
retorno = 1;
}
else
{
retorno = 0;
}
return retorno;
}
catch (Exception)
{
retorno = 2;
return retorno;
}
finally
{
}
}
public List<FraseClasseDTO> retornaTodosFraseClasse()

{
try
{
objDT = objBancoDAL.ExecuteDT("Select * from tbFraseClasse where fl_status = 1");
if (objDT.Rows.Count > 0)
{
for (int i = 0; i < objDT.Rows.Count; i++)
{
objFraseClasse = new FraseClasseDTO();
objFraseClasse._id_fraseclasse = Convert.ToInt32(objDT.Rows[i]["id_fraseclasse"]);
objFraseClasse._id_palavra = Convert.ToInt32(objDT.Rows[i]["id_palavra"]);
objFraseClasse._nm_frase = objDT.Rows[i]["nm_frase"].ToString();
objFraseClasse._retorno = 1;
objFraseClasse._msg_retorno = "Registro encontrado !";
lFraseClasse.Add(objFraseClasse);
}
}
else
{
objFraseClasse._msg_retorno = "Registro não encontrado !";
}
return lFraseClasse;
}
43
catch (Exception e)
{
objFraseClasse._msg_retorno = "Falha ao localizar os registros, mensagem: " + e.Message + " !";
return lFraseClasse;
}
finally
{
lFraseClasse = new List<FraseClasseDTO>();
}
}
public FraseClasseDTO retornaFraseClasseID(FraseClasseDTO beFraseClasse)

{
try
{
objDT = objBancoDAL.ExecuteDT("Select * from tbFraseClasse where id_fraseclasse = " +
beFraseClasse._id_fraseclasse + " and fl_status = 1");
{
objFraseClasse._id_fraseclasse = Convert.ToInt32(objDT.Rows[0]["id_fraseclasse"]);
objFraseClasse._id_palavra = Convert.ToInt32(objDT.Rows[0]["id_palavra"]);
objFraseClasse._nm_frase = objDT.Rows[0]["nm_frase"].ToString();
}
else
{
}
return objFraseClasse;
}
catch (Exception e)
{
}
finally
{
}
}
public FraseClasseDTO retornaIDFraseClasse(FraseClasseDTO beFraseClasse)

{
try
{
objDT = objBancoDAL.ExecuteDT("Select * from tbFraseClasse where nm_frase = '" +
beFraseClasse._nm_frase + "' and fl_status = 1");
{
44

objFraseClasse._id_fraseclasse = Convert.ToInt32(objDT.Rows[0]["id_fraseclasse"]);
objFraseClasse._id_palavra = Convert.ToInt32(objDT.Rows[0]["id_palavra"]);
objFraseClasse._nm_frase = objDT.Rows[0]["nm_frase"].ToString();
}
else
{
}
}
catch (Exception e)
{
}
finally
{
}
}
}
}
Classe MetodosDAL
using System;
using System.Linq;
using System.Web;
using System.Data;
{
public class MetodosDAL
{
Banco_DAL objBanco = new Banco_DAL();
MetodoDTO objMetodo = new MetodoDTO();
List<MetodoDTO> lMetodo = new List<MetodoDTO>();
Int32 retorno = 0;
public Int32 inserirMetodo(MetodoDTO beMetodo)

{
try
{
if (objBanco.ExecuteDR("Insert into tbMetodo (id_palavra, id_fraseclasse, fl_status) values (" +
beMetodo._id_palavra + ", " + beMetodo._id_fraseclasse + ", 1)").RecordsAffected == 1)
{
objBanco = new Banco_DAL();
retorno = Convert.ToInt32(objBanco.ExecuteDT("Select MAX(id_metodo) from
tbMetodo").Rows[0].ItemArray[0]);
45
}
else
{
retorno = 0;
}
return retorno;
}
catch (Exception)
{
retorno = 0;
return retorno;
}
finally
{
}
}
public Int32 alterarMetodo(MetodoDTO beMetodo)

{
try
{
if (objBanco.ExecuteDR("Update tbMetodo set id_palavra = " + beMetodo._id_palavra + " where
id_metodo = " + beMetodo._id_metodo).RecordsAffected == 1)
{
retorno = 1;
}
else
{
retorno = 0;
}
return retorno;
}
catch (Exception)
{
retorno = 2;
return retorno;
}
finally
{
}
}
public Int32 excluirMetodo(MetodoDTO beMetodo)

{
try
{
if (objBanco.ExecuteDR("Update tbMetodo set fl_status = false where id_metodo = " +
beMetodo._id_metodo).RecordsAffected == 1)
{
retorno = 1;
}
else
{
retorno = 0;
}
return retorno;
}
catch (Exception)
{
46
retorno = 2;
return retorno;
}
finally
{
}
}
public List<MetodoDTO> retornaTodosMetodos()

{
try
{
objDT = objBanco.ExecuteDT("Select * from tbMetodo where fl_status = 1");
{
objMetodo = new MetodoDTO();
objMetodo._id_metodo = Convert.ToInt32(objDT.Rows[0]["id_metodo"]);
objMetodo._id_palavra = Convert.ToInt32(objDT.Rows[0]["id_palavra"]);
objMetodo._fl_status = Convert.ToBoolean(objDT.Rows[0]["fl_status"]);
objMetodo._retorno = 1;
objMetodo._msg_retorno = "Registro encontrado !";
lMetodo.Add(objMetodo);
}
else
{
objMetodo._msg_retorno = "Registro não encontrado !";
}
}
catch (Exception e)
{
objMetodo._msg_retorno = "Falha ao consultar registros, mensagem: " + e.Message + " !";
}
return lMetodo;
}
public MetodoDTO retornaMetodoID(MetodoDTO beMetodo)

{
try
{
objDT = objBanco.ExecuteDT("Select * from tbMetodo where fl_status = 1 and id_metodo = " +
beMetodo._id_metodo);
{
objMetodo._id_metodo = Convert.ToInt32(objDT.Rows[0]["id_metodo"]);
objMetodo._id_palavra = Convert.ToInt32(objDT.Rows[0]["id_palavra"]);
objMetodo._fl_status = Convert.ToBoolean(objDT.Rows[0]["fl_status"]);
objMetodo._msg_retorno = "Registro encontrado !";
}
else
{
objMetodo._msg_retorno = "Registro não encontrado !";
47
}
}
catch (Exception e)
{
}
return objMetodo;
}
public List<Int32> retornaIdPalavraMetodoIDFrase(Int32 id_fraseclasse)

{
List<Int32> lPalavras = new List<Int32>();
try
{
objDT = objBanco.ExecuteDT("Select * from tbMetodo where fl_status = 1 and id_fraseclasse = " +
id_fraseclasse);

{
lPalavras.Add(Convert.ToInt32(objDT.Rows[i]["id_palavra"]));
}
}
catch (Exception e)
{
}
return lPalavras;
}
}
}
Classe PalavraDAL
using System;
using System.Linq;
using System.Web;
using System.Data;
{
public class PalavraDAL
{
DataSet objDS = new DataSet();
PalavraDTO objPalavraDTO = new PalavraDTO();
List<PalavraDTO> lPalavra = new List<PalavraDTO>();
Int32 retorno = new Int32();
public Int32 InserirPalavra(PalavraDTO bePalavra)

{
48
try
{
if (objBancoDAL.ExecuteDR("Insert into tbDicionario(nm_palavra, id_tipopalavra, fl_status) values
('"
+ bePalavra._nm_palavra + "'," + bePalavra._id_tipopalavra +
",1)").RecordsAffected != 0)
{
retorno = 1;
}
else
{
retorno = 0;
}
}
catch (Exception e)
{
retorno = 2;
bePalavra._msg_retorno = "Falha ao inserir o registro " + e.Message;
}
return retorno;
}
public Int32 AlteraPalavra(PalavraDTO bePalavra)

{
try
{
if (objBancoDAL.ExecuteDR("Update tbDicionario set nm_palavra = " + bePalavra._nm_palavra
+ ", id_tipopalavra = " + bePalavra._id_tipopalavra + " where
id_palavra = " + bePalavra._id_palavra + "").RecordsAffected > 0)
{
retorno = 1;
}
else
{
retorno = 0;
}
}
catch (Exception e)
{
retorno = 2;
bePalavra._msg_retorno = "Falha ao alterar o registro " + e.Message;
}
return retorno;
}
public Int32 ExcluirPalavra(PalavraDTO bePalavra)

{
try
{
if (objBancoDAL.ExecuteDR("Update tbDicionario set fl_status = 0 where id_palavra = " +
bePalavra._id_palavra + "").RecordsAffected > 0)
{
retorno = 1;
}
else
{
retorno = 0;
}
49
}
catch (Exception e)
{
retorno = 2;
bePalavra._msg_retorno = "Falha ao excluir o registro " + e.Message;
}
return retorno;
}
public List<PalavraDTO> retornaPalavraTodas()

{
objDT = new DataTable();
lPalavra = new List<PalavraDTO>();
try
{
objDT = objBancoDAL.ExecuteDT("Select * from tbDicionario where fl_status = 1");
if (objDT.Rows.Count != 0)
{
{
objPalavraDTO._id_palavra = Convert.ToInt32(objDT.Rows[i]["id_palavra"].ToString());
objPalavraDTO._id_tipopalavra = Convert.ToInt32(objDT.Rows[i]["id_tipopalavra"].ToString());
objPalavraDTO._nm_palavra = objDT.Rows[i]["nm_palavra"].ToString();
lPalavra.Add(objPalavraDTO);
}
objPalavraDTO._retorno = 1;
}
else
{
}
}
catch (Exception e)
{
objPalavraDTO._nm_palavra = "Falha ao consultar o registro " + e.Message;
lPalavra.Add(objPalavraDTO);
}
return lPalavra;
}
public PalavraDTO retornaPalavraID(PalavraDTO bePalavra)

{
try
{
objDT = objBancoDAL.ExecuteDT("Select * from tbDicionario where id_palavra = " +
bePalavra._id_palavra);
{
{
50
objPalavraDTO._id_tipopalavra = Convert.ToInt32(objDT.Rows[i]["id_palavra"].ToString());
}
}
else
{
}
}
catch (Exception e)
{
}
return objPalavraDTO;
}
public PalavraDTO retornaPalavraNm(PalavraDTO bePalavra)

{
try
{
objDT = objBancoDAL.ExecuteDT("Select * from tbDicionario where nm_palavra = '" +
bePalavra._nm_palavra + "'");
{
{
objPalavraDTO._id_tipopalavra = Convert.ToInt32(objDT.Rows[i]["id_tipopalavra"].ToString());
objPalavraDTO._fl_status = Convert.ToBoolean(objDT.Rows[i]["fl_status"]);
}
}
else
{
}
}
catch (Exception e)
{
}
return objPalavraDTO;
}
}
}
51
Classe ParametrosDAL
using System;
using System.Linq;
using System.Web;
using System.Data;
{
public class ParametrosDAL
{
ParametroDTO objParametroDTO = new ParametroDTO();
List<ParametroDTO> lParametro = new List<ParametroDTO>();
Int32 retorno = 0;
public Int32 inserirParametros(ParametroDTO beParametroDTO)

{
try
{
if (objBancoDAL.ExecuteDR("insert into tbParametro (id_palavra, id_fraseclasse, fl_status) " +
"values (" + beParametroDTO._id_palavra + ", " + beParametroDTO._id_fraseclasse
+ ", 1)").RecordsAffected == 1)
{
objBancoDAL = new Banco_DAL();
return retorno = Convert.ToInt32(objBancoDAL.ExecuteDT("Select MAX(id_parametro) from
tbParametro").Rows[0].ItemArray[0]);
}
else
{
return retorno = 0;
}
}
catch (Exception)
{
return retorno = 0;
}
finally
{
retorno = 0;
}
}
public Int32 alterarParametros(ParametroDTO beParametro)

{
try
{
if (objBancoDAL.ExecuteDR("Update tbParametro set id_palavra =" + beParametro._id_palavra +
", id_fraseclasse = " + beParametro._id_fraseclasse + " where id_parametro = " +
beParametro._id_parametro + ")").RecordsAffected == 1)
{
return retorno = 1;
}
else
{
return retorno = 0;
}
}
catch (Exception)
52
{
return retorno = 2;
}
finally
{
retorno = 0;
}
}
public Int32 excluirParametros(ParametroDTO beParametro)

{
try
{
if (objBancoDAL.ExecuteDR("Update tbParametro (fl_status) values (0) where id_parametro = " +
beParametro._id_parametro).RecordsAffected == 1)
{
return retorno = 1;
}
else
{
return retorno = 0;
}
}
catch (Exception)
{
return retorno = 2;
}
finally
{
retorno = 0;
}
}
public List<ParametroDTO> retornaTodosParametro()

{
try
{
objDT = objBancoDAL.ExecuteDT("Select * from tbParametro where fl_status = 1");
{
objParametroDTO._id_parametro = Convert.ToInt32(objDT.Rows[0]["id_parametro"]);
objParametroDTO._id_palavra = Convert.ToInt32(objDT.Rows[0]["id_palavra"]);
objParametroDTO._retorno = 1;
objParametroDTO._msg_retorno = "Registro encontrado !";
lParametro.Add(objParametroDTO);
}
else
{
objParametroDTO._msg_retorno = "Registro não encontrado !";
}
return lParametro;
}
catch (Exception e)
{
53
objParametroDTO._msg_retorno = "Falha ao localizar os registros, mensagem: " + e.Message +

"!";
return lParametro;
}
finally
{
lParametro = new List<ParametroDTO>();
}
}
public ParametroDTO retornaParametroID(ParametroDTO beParametro)

{
try
{
objDT = objBancoDAL.ExecuteDT("Select * from tbParametro where id_parametro = " +
beParametro._id_parametro + " and fl_status = 1");
{
objParametroDTO._id_parametro = Convert.ToInt32(objDT.Rows[0]["id_parametro"]);
objParametroDTO._id_palavra = Convert.ToInt32(objDT.Rows[0]["id_palavra"]);
objParametroDTO._msg_retorno = "Registro encontrado !";
}
else
{
objParametroDTO._msg_retorno = "Registro não encontrado !";
}
return objParametroDTO;
}
catch (Exception e)
{
"!";
return objParametroDTO;
}
finally
{
}
}
public List<Int32> retornaIdPalavraParametroID(Int32 id_fraseclasse)

{
List<Int32> lPalavras = new List<Int32>();
try
{
objDT = objBancoDAL.ExecuteDT("Select * from tbParametro where id_fraseclasse = " +
id_fraseclasse);

{
54

lPalavras.Add(Convert.ToInt32(objDT.Rows[i]["id_palavra"]));
}
return lPalavras;
}
catch (Exception e)
{
"!";
return lPalavras;
}
finally
{
}
}
}
}
Classe TipoPalavraDAL
using System;
using System.Linq;
using System.Web;
using System.Data;
{
public class TipoPalavraDAL
{
TipoPalavraDTO objTipoPalavraDTO = new TipoPalavraDTO();
DataSet objDS = new DataSet();
List<TipoPalavraDTO> lTipoPalavra = new List<TipoPalavraDTO>();
Int32 retorno = new Int32();
public Int32 InserirTipoPalavra(TipoPalavraDTO beTipoPalavraDTO)

{
try
{
if (objBancoDAL.ExecuteDR("insert into tbTipoPalavra(_nm_tipopalavra) values ("
+beTipoPalavraDTO._nm_tipopalavra+")").RecordsAffected > 0)
{
retorno = 1;
}
else
{
retorno = 0;
}
}
catch (Exception e)
55
{
retorno = 2;
objTipoPalavraDTO._msg_retorno = "Falha ao inserir registro " + e.Message;
}
return retorno;
}
public Int32 AlterarTipoPalavra(TipoPalavraDTO beTipoPalavra)

{
try
{
if (objBancoDAL.ExecuteDR("Update tbTipoPalavra set nm_tipopalavra = " +
beTipoPalavra._nm_tipopalavra
+ " where id_tipopalavra = " +
beTipoPalavra._id_tipopalavra).RecordsAffected > 0)
{
retorno = 1;
}
else
{
retorno = 0;
}
}
catch (Exception e)
{
retorno = 2;
objTipoPalavraDTO._msg_retorno = "Falha ao alterar o registro " + e.Message;
throw;
}
return retorno;
}
public Int32 ExcluirTipoPalavra(TipoPalavraDTO beTipoPalavra)

{
try
{
if (objBancoDAL.ExecuteDR("Update tbTipoPalavra set fl_status = false "
+ " where id_tipopalavra = " +
beTipoPalavra._id_tipopalavra).RecordsAffected > 0)
{
retorno = 1;
}
else
{
retorno = 0;
}
}
catch (Exception e)
{
retorno = 2;
objTipoPalavraDTO._msg_retorno = "Falha ao excluir o registro " + e.Message;
throw;
}
return retorno;
}
56
public List<TipoPalavraDTO> retornaTipoPalavraTodos()

{
lTipoPalavra = new List<TipoPalavraDTO>();
try
{
objDT = objBancoDAL.ExecuteDT("Select * from tbTipoPalavra");
{
{
objTipoPalavraDTO._id_tipopalavra = Convert.ToInt32(objDT.Rows[i]["id_tipopalavra"]);
objTipoPalavraDTO._nm_tipopalavra = objDT.Rows[i]["nm_tipopalavra"].ToString();
objTipoPalavraDTO._fl_status = Convert.ToBoolean(objDT.Rows[i]["fl_status"]);
lTipoPalavra.Add(objTipoPalavraDTO);
}
}
}
catch (Exception e)
{
objTipoPalavraDTO._retorno = 2;
objTipoPalavraDTO._msg_retorno = "Falha ao consultar registro " + e.Message;
}
return lTipoPalavra;
}
public TipoPalavraDTO retornaTipoPalavraID(TipoPalavraDTO beTipoPalavra)

{
try
{
objDT = objBancoDAL.ExecuteDT("Select * from tbTipoPalavra where id_tipopalavra = " +
beTipoPalavra._id_tipopalavra);
{
{
}
}
}
catch (Exception e)
{
}
57
return objTipoPalavraDTO;
}
public TipoPalavraDTO retornaTipoPalavraNm(TipoPalavraDTO beTipoPalavra)

{
try
{
objDT = objBancoDAL.ExecuteDT("Select * from tbTipoPalavra where nm_tipopalavra = " +
beTipoPalavra._nm_tipopalavra);
{
{
}
}
}
catch (Exception e)
{
}
return objTipoPalavraDTO;
}
}
}
Classe FraseClasseDTO
using System;
using System.Linq;
using System.Web;
namespace WCFTextToClass.DTO
{
public class FraseClasseDTO
{
public Int32 _id_fraseclasse { get; set; }
public String _nm_frase { get; set; }
public Int32 _id_palavra { get; set; }
public Int32 _id_metodo { get; set; }
public Int32 _id_parametro { get; set; }
public String _msg_retorno { get; set; }

public Int32 _retorno { get; set; }
}
}
58
Classe MetodoDTO
using System;
using System.Linq;
using System.Web;
{
public class MetodoDTO
{
public Int32 _id_metodo { get; set; }
public Boolean _fl_status { get; set; }

}
}
Classe PalavraDTO
using System;
using System.Linq;
using System.Text;
{
public class PalavraDTO
{
#region Propriedades

public String _nm_palavra { get; set; }
public Int32 _id_tipopalavra { get; set; }

#endregion
}
}
Classe ParametroDTO
using System;
using System.Linq;
using System.Web;
{
public class ParametroDTO
{
public Int32 _id_parametro { get; set; }
59

}
}
Classe TipoPalavraDTO
using System;
using System.Linq;
using System.Web;
{
public class TipoPalavraDTO
{
#region Propriedades
public Int32 _id_tipopalavra { get; set; }

public String _nm_tipopalavra { get; set; }

#endregion
}
}
Classe Banco_DAL
using System;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
namespace WCFTextToClass.Util
{
public class Banco_DAL
{
SqlConnection mSqlConexao;
//String mSqlServerHost = String.Empty;
SqlCommand cmd = new SqlCommand();
String mSqlServerHost = @"CESIO126-PC\SQLEXPRESS\";

String mSqlDataBase = "TextToClass";
String mSqlLogin = "sa";
String mSqlSenha = "220979";
public Banco_DAL()
{
mSqlConexao = new SqlConnection();
}
60
public String Login

{
get { return mSqlLogin; }
set { mSqlLogin = value; }
}
public String Senha

{
get { return mSqlSenha; }
set { mSqlSenha = value; }
}
public String DataBase

{
get { return mSqlDataBase; }
set { mSqlDataBase = value; }
}
public String HostName

{
get { return mSqlServerHost; }
set { mSqlServerHost = value; }
}
public void OpenConnection()

{
string strConnString = ConfigurationManager.ConnectionStrings["TextToClass"].ConnectionString;
if (mSqlConexao == null || mSqlConexao.State == ConnectionState.Broken || mSqlConexao.State ==

ConnectionState.Closed)
{
mSqlConexao = new SqlConnection();
mSqlConexao.ConnectionString = strConnString;
mSqlConexao.Open();
}
}
public void CloseConnection()

{
if (mSqlConexao.State == ConnectionState.Open)
{
mSqlConexao.Close();
mSqlConexao.Dispose();
mSqlConexao = null;
}
}
public DataSet ExecuteDS(String sql)

{
DataSet ds = new DataSet();
SqlDataAdapter da = new SqlDataAdapter();
try
{
this.OpenConnection();
cmd.CommandType = CommandType.Text;
cmd.CommandText = sql;
cmd.Connection = mSqlConexao;
da.SelectCommand = cmd;
da.Fill(ds);
da.Dispose();
}
catch (Exception e)
{
61
MessageBox.Show(e.Message);
}
this.CloseConnection();
return ds;
}
public DataTable ExecuteDT(String sql)

{
SqlDataAdapter da = new SqlDataAdapter();
DataTable myDataTable = new DataTable();
try
{
da.SelectCommand = cmd;
da.Fill(myDataTable);
da.Dispose();
return myDataTable;
}
catch (Exception e)
{
}
return myDataTable;
}
public SqlDataReader ExecuteDR(String sql)

{
SqlDataReader dr = null;
try
{
dr = cmd.ExecuteReader();
cmd.Dispose();
return dr;
}
catch (Exception e)
{
}
return dr;
public SqlDataReader ExecuteDA(String sql)

{
try
{
cmd.CommandType = CommandType.StoredProcedure;
62
return dr;
}
catch (Exception e)
{
}
return dr;
}
public String ExecuteES(String comandoSQL)

{
String retorno = null;
try
{
cmd.CommandText = comandoSQL;
retorno = cmd.ExecuteScalar().ToString();
}
catch (Exception e)
{
throw (e);
}
return retorno;
}
public SqlDataReader ExecuteDRr(String sql)

{
try
{
cmd.Dispose();
}
catch (Exception e)
{
throw (e);
}
return dr;
}
}
}
Classe ITextToClass
using System;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
63
using System.Text;
using WCFTextToClass.DAL;
using System.Data;
namespace WCFTextToClass
{
// NOTE: You can use the "Rename" command on the "Refactor" menu to change the interface name
"IService1" in both code and config file together.
[ServiceContract]
public interface ITextToClass
{
#region Palavra
[OperationContract]
Int32 InserirPalavra(PalavraDTO bePalavra);
[OperationContract]
Int32 AlteraPalavra(PalavraDTO bePalavra);
[OperationContract]
Int32 ExcluirPalavra(PalavraDTO bePalavra);
[OperationContract]
List<PalavraDTO> retornaPalavraTodos();
[OperationContract]
PalavraDTO retornaPalavraID(PalavraDTO bePalavra);
[OperationContract]
PalavraDTO retornaPalavraNm(PalavraDTO bePalavra);
#endregion
#region TipoPalavra
[OperationContract]
Int32 InserirTipoPalavra(TipoPalavraDTO beTipoPalavraDTO);
[OperationContract]
Int32 AlterarTipoPalavra(TipoPalavraDTO beTipoPalavraDTO);
[OperationContract]
Int32 ExcluirTipoPalavra(TipoPalavraDTO beTipoPalavraDTO);
[OperationContract]
List<TipoPalavraDTO> retornaTipoPalavraTodos();
[OperationContract]
TipoPalavraDTO retornaTipoPalavraID(TipoPalavraDTO beTipoPalavraDTO);
[OperationContract]
TipoPalavraDTO retornaTipoPalavraNm(TipoPalavraDTO beTipoPalavraDTO);
#endregion
#region FraseClasse
[OperationContract]
Int32 inserirFraseClasse(FraseClasseDTO beFraseClasseDTO);
[OperationContract]
Int32 alterarFraseClasse(FraseClasseDTO beFraseClasseDTO);
64
[OperationContract]
Int32 excluirFraseClasse(FraseClasseDTO beFraseClasseDTO);
[OperationContract]
List<FraseClasseDTO> retornaTodosFraseClasse();
[OperationContract]
FraseClasseDTO retornaFraseClasseID(FraseClasseDTO beFraseClasseDTO);
[OperationContract]
FraseClasseDTO retornaIDFraseClasse(FraseClasseDTO beFraseClasseDTO);
#endregion
#region Metodo
[OperationContract]
Int32 inserirMetodo(MetodoDTO beMetodoDTO);
[OperationContract]
Int32 alterarMetodo(MetodoDTO beMetodoDTO);
[OperationContract]
Int32 excluirMetodo(MetodoDTO beMetodoDTO);
[OperationContract]
List<MetodoDTO> retornaTodosMetodo();
[OperationContract]
MetodoDTO retornaMetodoID(MetodoDTO beMetodoDTO);
[OperationContract]
List<Int32> retornaIdPalavraMetodoIDFrase(Int32 id_fraseclasse);
#endregion
#region Parametro
[OperationContract]
Int32 inserirParametro(ParametroDTO beParametroDTO);
[OperationContract]
Int32 alterarParametro(ParametroDTO beParametroDTO);
[OperationContract]
Int32 excluirParametro(ParametroDTO beParametroDTO);
[OperationContract]
List<ParametroDTO> retornaTodosParametro();
[OperationContract]
ParametroDTO retornaParametroID(ParametroDTO beParametroDTO);
[OperationContract]
List<Int32> retornaIdPalavraParametroID(Int32 id_fraseclasse);
#endregion
}
}
Classe WCFTextToClass
using System;
65
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;
using WCFTextToClass.DAL;
using System.Data;
namespace WCFTextToClass
{
// NOTE: You can use the "Rename" command on the "Refactor" menu to change the class name
"Service1" in code, svc and config file together.
public class WCFTextToClass : ITextToClass
{
PalavraDAL objPalavraDAL = new PalavraDAL();
TipoPalavraDAL objTipoPalavraDAL = new TipoPalavraDAL();
FraseClasseDAL objFraseClasseDAL = new FraseClasseDAL();
MetodosDAL objMetodosDAL = new MetodosDAL();
ParametrosDAL objParametroDAL = new ParametrosDAL();
GenericoDAL objGenericoDAL = new GenericoDAL();
#region Palavras
public Int32 InserirPalavra(DTO.PalavraDTO bePalavra)

{
return objPalavraDAL.InserirPalavra(bePalavra);
}
public int AlteraPalavra(DTO.PalavraDTO bePalavra)

{
return objPalavraDAL.AlteraPalavra(bePalavra);
}
public int ExcluirPalavra(DTO.PalavraDTO bePalavra)

{
return objPalavraDAL.ExcluirPalavra(bePalavra);
}
public List<PalavraDTO> retornaPalavraTodos()

{
return objPalavraDAL.retornaPalavraTodas();
}
public DTO.PalavraDTO retornaPalavraID(DTO.PalavraDTO bePalavra)

{
return objPalavraDAL.retornaPalavraID(bePalavra);
}
public DTO.PalavraDTO retornaPalavraNm(DTO.PalavraDTO bePalavra)

{
return objPalavraDAL.retornaPalavraNm(bePalavra);
}
#endregion
#region TipoPalavra
public Int32 InserirTipoPalavra(TipoPalavraDTO beTipoPalavraDTO)

{
return objTipoPalavraDAL.InserirTipoPalavra(beTipoPalavraDTO);
}
66
public Int32 AlterarTipoPalavra(TipoPalavraDTO beTipoPalavraDTO)

{
return objTipoPalavraDAL.AlterarTipoPalavra(beTipoPalavraDTO);
}
public Int32 ExcluirTipoPalavra(TipoPalavraDTO beTipoPalavraDTO)

{
return objTipoPalavraDAL.ExcluirTipoPalavra(beTipoPalavraDTO);
}
public List<TipoPalavraDTO> retornaTipoPalavraTodos()

{
return objTipoPalavraDAL.retornaTipoPalavraTodos();
}
public TipoPalavraDTO retornaTipoPalavraID(TipoPalavraDTO beTipoPalavraDTO)

{
return objTipoPalavraDAL.retornaTipoPalavraID(beTipoPalavraDTO);
}
public TipoPalavraDTO retornaTipoPalavraNm(TipoPalavraDTO beTipoPalavraDTO)

{
return objTipoPalavraDAL.retornaTipoPalavraNm(beTipoPalavraDTO);
}
#endregion
#region FraseClasse
public Int32 inserirFraseClasse(FraseClasseDTO beFraseClasseDTO)

{
return objFraseClasseDAL.inserirFraseClasse(beFraseClasseDTO);
}
public Int32 alterarFraseClasse(FraseClasseDTO beFraseClasseDTO)

{
return objFraseClasseDAL.alterarFraseClasse(beFraseClasseDTO);
}
public Int32 excluirFraseClasse(FraseClasseDTO beFraseClasseDTO)

{
return objFraseClasseDAL.excluirFraseClasse(beFraseClasseDTO);
}
public List<FraseClasseDTO> retornaTodosFraseClasse()

{
return objFraseClasseDAL.retornaTodosFraseClasse();
}
public FraseClasseDTO retornaFraseClasseID(FraseClasseDTO beFraseClasseDTO)

{
return objFraseClasseDAL.retornaFraseClasseID(beFraseClasseDTO);
}
public FraseClasseDTO retornaIDFraseClasse(FraseClasseDTO beFraseClasseDTO)

{
return objFraseClasseDAL.retornaIDFraseClasse(beFraseClasseDTO);
}
#endregion
#region Metodo
public Int32 inserirMetodo(MetodoDTO beMetodoDTO)

67
{
return objMetodosDAL.inserirMetodo(beMetodoDTO);
}
public Int32 alterarMetodo(MetodoDTO beMetodoDTO)

{
return objMetodosDAL.alterarMetodo(beMetodoDTO);
}
public Int32 excluirMetodo(MetodoDTO beMetodoDTO)

{
return objMetodosDAL.excluirMetodo(beMetodoDTO);
}
public List<MetodoDTO> retornaTodosMetodo()

{
return objMetodosDAL.retornaTodosMetodos();
}
public MetodoDTO retornaMetodoID(MetodoDTO beMetodoDTO)

{
return objMetodosDAL.retornaMetodoID(beMetodoDTO);
}
public List<Int32> retornaIdPalavraMetodoIDFrase(Int32 id_fraseclasse)

{
return objMetodosDAL.retornaIdPalavraMetodoIDFrase(id_fraseclasse);
}
#endregion
#region Parametro
public Int32 inserirParametro(ParametroDTO beParametroDTO)

{
return objParametroDAL.inserirParametros(beParametroDTO);
}
public Int32 alterarParametro(ParametroDTO beParametroDTO)

{
return objParametroDAL.alterarParametros(beParametroDTO);
}
public Int32 excluirParametro(ParametroDTO beParametroDTO)

{
return objParametroDAL.excluirParametros(beParametroDTO);
}
public List<ParametroDTO> retornaTodosParametro()

{
return objParametroDAL.retornaTodosParametro();
}
public ParametroDTO retornaParametroID(ParametroDTO beParametroDTO)

{
return objParametroDAL.retornaParametroID(beParametroDTO);
}
public List<Int32> retornaIdPalavraParametroID(Int32 id_fraseclasse)

{
return objParametroDAL.retornaIdPalavraParametroID(id_fraseclasse);
}
#endregion
68
}
}

Construção Automática de Modelos de Classes A Partir de Especificações em Linguagem Natural

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Construção Automática de Modelos de Classes A Partir de Especificações em Linguagem Natural

Enviado por

Direitos autorais:

Formatos disponíveis

RICARDO BAPTISTA

CONSTRUÇÃO AUTOMÁTICA DE MODELOS DE CLASSES A PARTIR

CONSTRUÇÃO AUTOMÁTICA DE MODELOS DE CLASSES A PARTIR

Monografia apresentada à FATEC-SP,

Orientador: Prof. Dr. Silvio do Lago Pereira.

1. Engenharia de software. 2. Especificação de

A minha filha Mayara,

A minha mãe Isalina, minha

Foram muitos os que me ajudaram a concluir esse trabalho.

Os meus mais sinceros agradecimentos...

...à minha família pela confiança, paciência e apoio;

...aos meus amigos de graduação e pós-graduação, pelas conversas e troca de

...aos meus amigos e colegas que participaram deste trabalho;

...aos orientadores que com paciência me ajudaram a concluir o trabalho.

LISTA DE SIGLAS ...............................................................................................viii

1. MODELO DE CLASSES ............................................................................... 3

1.1. OBJETOS E CLASSES .......................................................................... 3

1.2. LIGAÇÕES E ASSOCIAÇÕES............................................................... 5

1.3. HERANÇA E POLIMORFISMO .............................................................. 6

2. LINGUAGEM DE MODELAGEM UNIFICADA (UML) ................................... 9

2.1. FUNDAMENTOS DA UML ..................................................................... 9

2.2. ESCOPO DA UML ............................................................................... 10

2.3. DIAGRAMA DE CLASSES ................................................................... 10

3. MÉTODO PARA CONSTRUÇÃO DO MODELO DE CLASSES ................. 12

3.1. FUNDAMENTOS .................................................................................. 12

3.2. MÉTODO DE INTERPRETAÇÃO ........................................................ 15

3.3. DEFINIÇÕES ....................................................................................... 15

3.4. FORMALIZANDO O MÉTODO ............................................................ 19

4. CONSTRUÇÃO AUTOMÁTICA DE MODELO DE CLASSES .................... 20

4.1. CM-BUILDER ....................................................................................... 21

4.2. NL-OOPS ............................................................................................. 22

4.3. UML – GENERATOR ........................................................................... 22

5. TEXTTOCLASS: A FERRAMENTA DESENVOLVIDA ............................... 23

5.2. ALGORITMO ........................................................................................ 24

5.3. RESULTADO DO TESTE LINHA A LINHA .......................................... 26

5.4. RESULTADO DO TESTE FUNCIONAL ............................................... 26

APÊNDICE – CÓDIGO FONTE DO SISTEMA TEXTTOCLASS ......................... 34

Classe frmGerador ........................................................................................... 35

Classe frmPalavras .......................................................................................... 39

Classe FraseClasseDAL .................................................................................. 40

Classe MetodosDAL ........................................................................................ 44

Classe PalavraDAL .......................................................................................... 47

Classe ParametrosDAL .................................................................................... 51

Classe TipoPalavraDAL ................................................................................... 54

Classe PalavraDTO ......................................................................................... 58

Classe ParametroDTO ..................................................................................... 58

Classe Banco_DAL .......................................................................................... 59

Classe ITextToClass ........................................................................................ 62

Classe WCFTextToClass ................................................................................. 64

A construção automática é baseada principalmente na correspondência entre

Palavras-chave: Especificação de requisitos, engenharia de software, diagrama

The automatic construction is based mainly on the correspondence between

Keywords: requirements specification, software engineering, class diagram,

O desenvolvimento de software é uma atividade complexa e de muitas etapas.

Segundo Sommerville (2007) o nível de detalhamento a ser incluído em um

Apesar da importância do modelo de classes, quase não há ferramentas

Apesar de algumas empresas não reconhecerem, a fase de análise é crucial

A ferramenta a desenvolvida nesse trabalho deverá ser capaz de analisar uma

sentença dada pelo usuário, em língua portuguesa, e extrair elementos importantes

Esse trabalho de pesquisa é baseado no método hipotético-dedutivo. Na fase

A monografia está organizada da seguinte forma:

O paradigma de Orientação a Objetos baseia-se em uma organização de soft-

Neste capítulo, as primeiras noções de orientação a objetos serão introduzidas.