You are on page 1of 116

UNIVERSIDADE DO CONTESTADO

CURSO DE SISTEMAS DE INFORMAÇÃO

DANIEL SCHROEDER

CONFRONTO TECNOLOGICO ENTRE MONO(.NET FRAMEWORK) E JAVA

CANOINHAS
2009
DANIEL SCHROEDER

CONFRONTO TECNOLOGICO ENTRE MONO(.NET FRAMEWORK) E JAVA

Monografia apresentada como exigência para a


obtenção do título de Bacharel do curso de Sistemas
de Informação, ministrado pela Universidade do
Contestado – UnC Campus Marcílio Dias, sob
orientação do professor Saulo José Benvenutti.

CANOINHAS
2009
CONFRONTO TECNOLOGICO ENTRE MONO(.NET FRAMEWORK) E JAVA

DANIEL SCHROEDER

Este(a) (Trabalho de Conclusão de Curso, Monografia, Dissertação, Tese) foi


submetido(a) ao processo de avaliação pela Banca Examinadora como requisito parcial
para a obtenção do Título (Grau) de:

Licenciado(a) ou Bacharel em Sistemas de Informação.

E aprovado(a) na sua versão final em 10/11/2009, atendendo às normas da legislação


vigente da Universidade do Contestado – UnC e Coordenação do Curso de Sistemas de
Informação.

________________________________
Otto Robert Lessing

BANCA EXAMINADORA:

___________________________
Otto Robert Lessing

___________________________
Saulo José Benvenutti

___________________________
Danhylo Almeida Ramos
RESUMO

Este trabalho foi baseado em duas plataformas de desenvolvimento de aplicações, de


diferentes empresas, a Novell e sua plataforma Mono .NET Framework, e a Sun
Microsystems com sua plataforma Java. Em sua primeira parte foi apresentado a origem
do Java, seus conceitos e características, a ideia de um ambiente multiplataforma,
características da maquina virtual e os conceitos do gerenciamento de memória. É
descrito em sua segunda parte as características quanto a capacidade de interconexão
TCP/IP no desenvolvimento sob aplicações distribuídas e comunicação entre objetos
através de componentes; mostrando o processo de evolução até o surgimento do .NET
Framework, interoperabilidade entre objetos localmente ou remotamente, WebServices e
protocolo SOAP. Na terceira parte é abordado as arquiteturas .NET Framework, quanto a
sua normalização até a estrutura Mono, outras plataformas derivadas da especificação
.NET, como o Rotor e DotGNU, e a arquitetura Java com base na sua estrutura geral, seja
no modo de compilação e funcionamento. Quanto a Quarta parte deste trabalho descreve
de uma maneira geral os conceitos de orientação a objetos que esta fixado sob as
tecnologias estudas (Java e Mono), as linguagens suportada por cada plataforma, os
principais ambientes de desenvolvimento destacados para cada plataforma e seus modos
de conexão a banco de dados. No processo de finalização na quinta parte inicia o
processo de comparação das tecnologias Java e Mono .NET Framework, analisando e
demonstrando alguns de seus pontos críticos como desempenho em relação ao sistema
operacional seja Windows ou Linux aqui comparado. Em uma analise breve comentando
sobre as linguagens Java e C# as quais foram utilizadas no processo de comparação, os
ambientes de desenvolvimento trabalhados e a maneira utilizada na conexão com o
banco de dados. São mostrados a este capítulo tabelas e gráficos focando a analise
quantitativa afim de melhor demonstrar o comparativo executado nestas plataformas. As
considerações finais levantadas para este trabalho, nota as várias semelhanças contida
na estrutura Java e Mono .NET, no entanto cada uma possui suas vantagens e
desvantagens, mais seguem a mesma tendencia de mercado.

Palavras chave: Tecnologia; Plataforma; Mono; JAVA; Desenvolvimento; Linguagem;


Maquina Virtual.
ABSTRACT

This work was based on two platforms, application development, from different companies,
Novell and the Mono .NET Framework platform, and Sun Microsystems with its Java
platform. In the first part was made the source of Java, its concepts and features, the idea
of a multiplatform environment, characteristics of the virtual machine and the concepts of
memory management. It is described in the second part features as the ability to
interconnect TCP/IP development in distributed applications and communication between
objects across components, showing the process of evolution until the appearance .NET
Framework, interoperability between objects locally or remotely, WebServices and SOAP
protocol. The third part deals with the .NET Framework architecture, and its
standardization by the structure Mono, other platforms derived from the specification .NET,
as the rotor and DotGNU, and Java architecture based on its overall structure, perhaps in
the way of compiling and operation. In the fourth part of this work describes in general the
concepts of object orientation that is settled in the studied technologies (Java and Mono),
the supported languages by each platform, the main development environments assigned
to each platform and its modes of connection to the database. In the process of finalizing
the fifth part begins the process of comparing Java and Mono .NET Framework
technologies, analyzing and demonstrating some of its critical points such a performance
relative to the operating system is Windows or Linux here compared. In a brief review
commenting on the Java and C# which were used in the comparison, the development
environment worked and the way used to connect to the database. Are shown in this
chapter charts and tables focusing on quantitative analysis in order to better demonstrate
the comparative run on these platforms. The final considerations raised for this work
demonstrates several similarities between the structure of Java and Mono .NET, the
advantages and disadvantages of each platform has, but following the same trend. Final
considerations raised in this study, note the many similarities contained in the structure
Java and Mono .NET, but each one has its advantages and disadvantages, most follow the
same trend of the market.

Keywords: Technology; Platform; Mono; Java; Development; Language; Virtual Machine.


LISTA DE FIGURAS
Figura 1: Segmentação da maquina virtual Java. O Autor(2009).......................................24
Figura 2: Funcionamento inicial do Garbage collector - GC através do heap. MSDN(2008).
.............................................................................................................................................25
Figura 3: Diagrama demonstrando o processo de gerenciamento de memória. Simmons
(2004)...................................................................................................................................26
Figura 4: Estrutura do Mono. NANTZ (2004).......................................................................39
Figura 5: Cycle compiler .NET. Ciclo de execução do código fonte .NET. BAGNALL (2002)
.............................................................................................................................................44
Figura 6: Plataforma Java Standard Edition v 1.4. Sun Microsystems, Inc. (2009)............48
Figura 7: Java code cycle. Ciclo de execução do código fonte Java. BAGNALL (2002)....49
Figura 8: Estrutura base do JDBC. O desenvolvedor trabalha com objetos simples em
Java. O DriverManager em conjunto com o driver especifico, fornece o acesso ao banco
de dados. BRILL(2001)........................................................................................................59
Figura 9: Arquitetura ADO.NET. MSDN (2009)....................................................................60
Figura 10: Principio básico de acesso a base de dados PostgreSQL, utilizando o NpgSQL.
Autor(2009)..........................................................................................................................61
Figura 11: Especificação dos softwares utilizados no processo de comparação das
tecnologias Java e Mono .NET. Autor(2009).......................................................................62
Figura 12: Topologia Cliente-Servidor, aplicada nos teste entre as plataformas Java e
Mono. Autor (2009)..............................................................................................................63
Figura 13: Resultados obtidos no processo de gravação de dados em arquivo, executados
sob o sistema operacional Linux, através do gnome-terminal. Autor (2009)......................67
Figura 14: Script SQL da tabela, utilizado no comparativo. Autor (2009)...........................87
Figura 15: Dados inseridos no banco. Autor (2009)............................................................87
Figura 16: Tela Principal. Netbeans 6.7 (Win32), sob outro sistema operacional sua
interface é a mesma. Autor (2009)......................................................................................89
Figura 17: Splash NetBeans 6.7.1. Autor (2009).................................................................89
Figura 18: Tela Principal. SharpDevelop 3.1 (Win32). Autor (2009)....................................90
Figura 19: Splash SharpDevelop 3.1. Autor (2009).............................................................90
Figura 20: Tela Principal. MonoDevelop 2.0, Linux. Autor (2009).......................................91
Figura 21: Splash MonoDevelop 2.0. Autor (2009).............................................................91
Figura 22: Logomarca: Java. Sun (2009)............................................................................92
Figura 23: Logomarca: Mono. Mono (2009)........................................................................92
Figura 24: Aplicativo Java, sendo executado sobre o Console do Windows (MS-DOS). No
Linux foi executado sob o console gnome-terminal. Os resultados quanto ao tempo eram
gravados para um arquivo de texto. Autor (2009)...............................................................93
Figura 25: Aplicativo Mono .NET, sendo executado sobre o Console do Windows (MS-
DOS). No Linux foi executado sob o console gnome-terminal. Os resultados quanto ao
tempo eram gravados para um arquivo de texto. Autor(2009)............................................93
LISTA DE GRÁFICOS
Gráfico 1: Resultados obtidos no processo de gravação de dados em arquivo, executados
sob o sistema operacional Windows, através do console DOS. Autor (2009)....................67
Gráfico 2: Gráfico demonstrando e comparando o desempenho no processo de inserção
em uma bateria de 10 testes, a cada teste 10000 inseridos um a um. Teste efetuado sob o
sistema operacional Windows. Autor(2009)........................................................................68
Gráfico 3: Gráfico demonstrando e comparando o desempenho no processo de listagem,
também entendido como localização em uma bateria de 10 testes, a cada teste 10000
listados. Teste efetuado sob o sistema operacional Windows. Autor(2009).......................68
Gráfico 4: Gráfico demonstrando e comparando o desempenho no processo de alteração
em uma bateria de 10 testes, a cada teste 10000 alterados um a um. Teste efetuado sob o
sistema operacional Windows. Autor(2009)........................................................................69
Gráfico 5: Gráfico demonstrando e comparando o desempenho no processo de remoção
em uma bateria de 10 testes, a cada teste 10000 removidos um a um. Teste efetuado sob
o sistema operacional Windows. Autor(2009).....................................................................69
Gráfico 6: Gráfico demonstrando e comparando o desempenho no processo de inserção
em uma bateria de 10 testes, a cada teste 10000 inseridos um a um. Teste efetuado sob o
sistema operacional Linux. Autor(2009)..............................................................................70
Gráfico 7: Gráfico demonstrando e comparando o desempenho no processo de listagem
ou também considerado com uma localização em uma bateria de 10 testes, a cada teste
10000 registros foram listados em modo console. Teste efetuado sob o sistema
operacional Linux. Autor(2009)............................................................................................70
Gráfico 8: Gráfico demonstrando e comparando o desempenho no processo de alteração
em uma bateria de 10 testes, a cada teste 10000 registros alterados um a um. Teste
efetuado sob o sistema operacional Linux. Autor(2009).....................................................71
Gráfico 9: Gráfico demonstrando e comparando o desempenho no processo de remoção
em uma bateria de 10 testes, a cada teste 10000 registros removidos um a um. Teste
efetuado sob o sistema operacional Linux. Autor(2009).....................................................71
LISTA DE TABELAS
Tabela 1: Equivalência entre alguns tipos de dados das linguagens Java e C#. MOK
(2003, adaptado)..................................................................................................................74
Tabela 2: Analise comparativa das IDE's. Plataforma (S.O. suportado) e Licença. Autor
(2009)...................................................................................................................................74
Tabela 3: Aspectos gerais que demonstram algumas similaridades e diferenças, para o
Java e o Mono .NET. Autor (2009).......................................................................................75
Tabela 4: Analise comparativa das licenças utilizadas por cada tecnologia. OSI (2009,
adaptado).............................................................................................................................76
LISTA DE ABREVIATURAS E SIGLAS

Active Data Objects ADO


Abstract Window Toolkit AWT
Active Server Pages ASP
Application Foundation Classes AFC
Application Programming Interface API
Base Class Library BCL
Common Development and Distribution License CDDL
Common Gateway Interface CGI
Common Infraestruture Language CLI
Common Intermediate Language CIL
Common Language Especification CLS
Common Language Runtime CLR
Common Object Request Broker Architecture CORBA
Common Type System CTS
Compact Framework CF
Component Object Model COM
Corporation for National Research Initiatives CNRI
Distributed Architecture Internetwork DNA
Distributed Component Object Model DCOM
Distributed Computing Environment DCE
Dynamic Data Exchange DDE
Dynamic Link library DLL
Enterprise Java Beans EJB
European Computer Manufacturers Association ECMA
Executive Committee CE
Enterprise Resource Planning ERP
eXtensible Markup Language XML
eXtensible Stylesheet Language Transformations XSLT
Framework Class Library FCL
Global Assembly Cache GAC
GNU Public License GPL
Graphical User Interfaces GUI
Hypertext Transfer Protocol HTTP
Interface Definition Language IDL
Intermediate Language IL
International Standards Organization ISO
Internet Foundation Classes IFC
Internet Information Service IIS
Java Class Library JCL
Java Community Process JCP
Java Data Objects JDO
Java Database Connectivity JDBC
Java Development Kit JDK
Java Naming and Directory Interface JNDI
Java Runtime Environment JRE
Java Specification Requests JSR
Java Virtual Machine JVM
Just in Time JIT
Library GNU Public License LGPL
Matz Ruby Implementation IRM
Massachusetts Institute of Technology MIT
Microsoft MS
Microsoft Intermediate Language MSIL
Mozilla Public License MPL
Microsoft Transaction Server MTS
Network File System NFS
Object Linking and Embedding OLE
Object Management Group OMG
Object Oriented OO
Object Oriented Programming OOP
Objective CAML Ocaml
Open Database Connectivity ODBC
Open Graphics Library OpenGL
Open Software Foundation OSF
Open Source Initiative OSI
Portable Execute PE
Publicly Available Specification PAS
Remote Method Invocation RMI
Remote Procedure Call RPC
Remote Procedure Calls RPC
Server Message Block SMB
Shared Source CLI SSCLI
Simple Object Access Protocol SOAP
Software Development Kit SDK
Structured Query Language SQL
Universal Description, Discovery and Integration UDDI
Unified Modeling Language UML
Virtual Execution System VES
Virtual Machine VM
Visual Basic VB
Visual Studio VS
Web Service Definition Language WSDL
World Wide Web WWW
SUMÁRIO
1 INTRODUÇÃO.................................................................................................................13
1.1 TEMA........................................................................................................................13
1.2 APRESENTAÇÃO ....................................................................................................13
1.3 PROBLEMA..............................................................................................................14
1.4 JUSTIFICATIVA........................................................................................................15
1.5 OBJETIVOS..............................................................................................................16
1.5.1 Objetivo Geral....................................................................................................16
1.5.2 Objetivos específicos........................................................................................16
1.6 PROCEDIMENTO METODOLOGICO.....................................................................17
1.7 PLANO DE METAS..................................................................................................18
CAPITULO I.........................................................................................................................19
2 ORIGEM DO JAVA E O CONCEITO MULTIPLATAFORMA..........................................19
2.1 FUNDAMENTOS DO JAVA......................................................................................19
2.1.1 Ideia Multiplataforma.........................................................................................21
2.2 CARACTERISTICAS DO JAVA................................................................................21
2.3 MAQUINA VIRTUAL.................................................................................................23
2.3.1 JVM (Java Virtual Machine)..............................................................................23
2.4 GARBAGE COLLECTOR (GERENCIADOR DE RECURSOS DA MEMÓRIA).......24
2.4.1 Funcionamento do gerenciador de memória....................................................25
CAPITULO II........................................................................................................................27
3 APLICAÇÕES DISTRIBUÍDAS E O SURGIMENTO DO .NET FRAMEWORK.............27
3.1 TECNOLOGIAS DISTRIBUÍDAS.............................................................................27
3.1.1 CORBA..............................................................................................................27
3.1.2 Java RMI...........................................................................................................28
3.1.3 Interface Definition Language (IDL)..................................................................28
3.1.4 Java EJB...........................................................................................................28
3.2 A MICROSOFT E A COMPUTAÇÃO DISTRIBUÍDA................................................29
3.2.1 DCE/RPC..........................................................................................................30
3.2.2 OS PIONEIROS COM, MTS, DCOM................................................................30
3.2.3 COM+................................................................................................................32
3.2.4 .NET REMOTING..............................................................................................32
3.3 WEBSERVICES........................................................................................................33
3.3.1 Protocolo SOAP................................................................................................33
3.4 A EVOLUÇÃO ATÉ O SURGIMENTO DO .NET FRAMEWORK.............................33
3.4.1 Fatos ocorridos sob o surgimento do .NET Framework...................................34
CAPITULO III.......................................................................................................................36
4 ARQUITETURAS MONO .NET FRAMEWORK E JAVA................................................36
4.1 ARQUITETURA .NET FRAMEWORK......................................................................36
4.1.1 NORMALIZAÇÃO..............................................................................................36
4.1.2 SSCLI/Rotor......................................................................................................37
4.1.3 Portable .NET....................................................................................................37
4.1.4 Compact Framework.........................................................................................37
4.1.5 Mono (.NET Framework)...................................................................................38
4.1.6 Licenças usadas no Mono.................................................................................39
4.1.7 Common Type System (CTS)...........................................................................40
4.1.8 Common Language Specification.....................................................................40
4.1.9 Conceito Multilinguagem...................................................................................40
4.1.10 Linguagem Intermediária.................................................................................41
4.1.11 ASSEMBLY......................................................................................................41
4.1.11.1 PE (Portable Executable).........................................................................42
4.1.12 Common Language Runtime..........................................................................42
4.1.13 Just in Time Compiler......................................................................................43
4.1.14 Framework Class Library................................................................................43
4.1.15 Ciclo de execução do .NET.............................................................................44
4.1.16 Compilando Código Fonte em código nativo..................................................45
4.2 ARQUITETURA JAVA...............................................................................................46
4.2.1 Normalização do Java.......................................................................................46
4.2.2 Java Community Process..................................................................................46
4.2.3 Java Foundation Classes..................................................................................47
4.2.4 ByteCode...........................................................................................................47
4.2.5 JIT Compiler......................................................................................................47
4.2.6 Class Loader.....................................................................................................47
4.2.7 Distribuições da Plataforma Java......................................................................48
4.2.8 Ciclo de execução do JAVA..............................................................................49
4.2.9 Licença..............................................................................................................49
CAPITULO IV......................................................................................................................50
5 LINGUAGENS DE PROGRAMAÇÃO, IDE's E MODOS DE ACESSO A DADOS.......50
5.1 Conceitos de Orientação a Objetos..........................................................................50
5.2 Linguagens de programação suportas pela plataforma JAVA.................................50
5.2.1 Java...................................................................................................................50
5.2.2 Groovy...............................................................................................................51
5.2.3 JRuby................................................................................................................51
5.2.4 Jython................................................................................................................51
5.3 Linguagens de programação suportas pela plataforma Mono (.NET Framework)..51
5.3.1 C#......................................................................................................................51
5.3.2 VB.NET..............................................................................................................52
5.3.3 Object Pascal....................................................................................................52
5.3.4 J# (JSharp)........................................................................................................52
5.3.5 F# (FSharp).......................................................................................................53
5.3.6 IronRuby............................................................................................................53
5.3.7 IronPython.........................................................................................................53
5.3.8 Boo....................................................................................................................53
5.3.9 C++....................................................................................................................54
5.3.10 C# Versus Visual Basic .NET.........................................................................54
5.3.11 C# versus Java................................................................................................54
5.4 Ambientes de desenvolvimento destacados às plataformas Java e Mono (.NET
Framework)......................................................................................................................55
5.4.1 Camadas principais de uma IDE.......................................................................55
5.4.2 MonoDevelop....................................................................................................56
5.4.3 Sharp Develop...................................................................................................56
5.4.4 Visual Studio......................................................................................................57
5.4.4.1 DelphiPrism................................................................................................57
5.4.5 Eclipse...............................................................................................................57
5.4.6 Netbeans...........................................................................................................58
5.5 COMPONENTES DE ACESSO A DADOS...............................................................58
5.5.1 JDBC.................................................................................................................58
5.5.2 ADO.NET...........................................................................................................59
5.5.3 Outros modos de acesso a dados com o .NET...............................................60
5.5.4 Open DataBase Connectivity (ODBC)..............................................................60
5.5.4.1 NPGSQL....................................................................................................60
5.5.4.2 PgSqlNET Free Express............................................................................61
CAPITULO V.......................................................................................................................62
6 COMPARATIVOS DAS TECNOLOGIAS JAVA E MONO .NET FRAMEWORK...........62
6.1 PROCESSO DE DESENVOLVIMENTO PRÁTICO ................................................62
6.2 ANALISE DO APLICATIVO COMPARADO..............................................................63
6.2.1 Analise do processo de desenvolvimento prático.............................................64
6.2.1.1 Das linguagens de programação Java e C#..............................................64
6.2.1.2 Da maneira de conexão com o banco de dados.......................................64
6.3 BANCO DE DADOS UTILIZADO.............................................................................64
6.3.1 PostgreSQL.......................................................................................................64
6.3.2 Analise no processo de teste quanto ao banco de dados................................64
6.3.2.1 Do desempenho no acesso a dados.........................................................65
6.4 ANALISE DOS AMBIENTES DE DESENVOLVIMENTO UTILIZADOS...................65
6.4.1 Quanto a produtividade e desempenho nas plataformas Java e Mono .NET. .66
6.5 RESULTADOS OBTIDOS NOS TESTES.................................................................66
6.5.1 Resultados obtidos no processo de gravação em arquivo texto......................67
6.5.2 Comparativo: CRUD. Testes efetuados no Sistema Operacional Windows.....68
6.5.3 Comparativo: CRUD. Testes efetuados no Sistema Operacional LINUX.........70
6.6 DOS APLICATIVOS COMPARADOS.......................................................................72
6.7 DOS SISTEMAS OPERACIONAIS USADOS NOS TESTES..................................72
6.8 COMPARATIVO GERAL ENTRE AS PLATAFORMAS JAVA E MONO .NET
FRAMEWORK.................................................................................................................73
6.8.1 Analise dos tipos de dados das linguagens Java e C#.....................................73
6.8.2 Analise dos ambientes de desenvolvimento.....................................................74
6.8.3 Aspectos gerais das plataformas estudadas....................................................75
6.8.4 Analise conceitual das licenças utilizadas........................................................76
CAPITULO VI......................................................................................................................77
7 CONCLUSÃO..................................................................................................................77
7.1 SUGESTÃO PARA TRABALHOS FUTUROS..........................................................80
REFERENCIAS...................................................................................................................81
APÊNDICE A.......................................................................................................................84
Algoritmo exemplo C#.....................................................................................................84
Algoritmo exemplo Java..................................................................................................84
Algoritmo JAVA demonstrando um laço de repetição e gravação em arquivo...............85
Algoritmo C# demonstrando um laço de repetição e gravação em arquivo...................86
APÊNDICE B – Código fonte do aplicativo utilizando um CRUD no acesso a dados87
Código fonte da tabela utilizada no comparativo............................................................87
Dados inseridos na tabela...........................................................................................87
Código fonte: Projeto. CRUD-Java-Java-JDBC – JAVA.................................................87
Código fonte: Projeto. CRUD-Mono-CSharp-NpgSQL – Mono .NET Framework .........87
APÊNDICE C - Disponibilidade da Documentação, Plataforma, IDE's e o Banco de
Dados utilizado...................................................................................................................88
Plataformas.................................................................................................................88
IDE's............................................................................................................................88
Banco de Dados..........................................................................................................88
APÊNDICE D – Ambientes de Desenvolvimento utilizados na Implementação dos
Aplicativos, Logomarca das plataformas comparada e Tela das aplicações.............89
13

1 INTRODUÇÃO

1.1 TEMA

CONFRONTO TECNOLOGICO ENTRE MONO(.NET FRAMEWORK) E JAVA

1.2 APRESENTAÇÃO

Tanto o Mono .NET Framework e o JAVA, são uma plataforma de desenvolvimento


de software. Quando desenvolvemos um software, de uma forma geral, estamos
desenvolvendo para um sistema operacional e hardware específico, assim tornando
dependentes dos mesmos. A proposta .NET e JAVA é desenvolver não mais para um
sistema operacional ou hardware, mas sim para sua plataforma, onde o software
funcionará onde quer que o framework ou maquina virtual estiver disponível: de
computadores a celulares.
14

1.3 PROBLEMA

A linha existente de programadores no mercado atual, cada um evangeliza sua


plataforma de desenvolvimento. Mesmo havendo hipótese de que uma plataforma não
atenda seus requisitos, a empresa detentora de sua tecnologia procura não deixar
totalmente visível a sua comunidade seus defeitos, porém, por se tratar de dois ambientes
open source, os bugs a cada dia que passa são corrigidos e novas versões são
disponibilizadas.

Até hoje não existe uma linha comparativa que possa confrontar as tecnologias
Java e Mono .NET afim de demonstrar seu desempenho e viabilidade. A questão é: a
relação entre Java e Mono .NET, é mais um caso de religião do que tecnologia, ou, uma
questão cultural de organização que influencia na adoção de uma plataforma de
desenvolvimento, seja pelo que ela oferece e por influenciar no próprio mercado.

Os aplicativos desenvolvidos sob estas tecnologias rodam sob maquinas virtuais,


que é um fator de desvantagem no desempenho para ambas, em relação há softwares
executados nativamente sob um determinado sistema operacional. No entanto esta
questão já esta se tornando um mito, e devido a maquina virtual contida no Java e Mono,
estas oferecem suporte multiplataforma nas suas aplicações.
15

1.4 JUSTIFICATIVA

As vantagens de plataformas de desenvolvimento, que rodam sobre um framework


ou maquina virtual oferece grandes benefícios, quando se trata de portabilidade, não tem
a necessidade de recompilar um código só por apenas executar um aplicativo sob outro
sistema operacional, basta apenas ter a plataforma que rode este.

A pesquisa nos proporcionará uma visão melhor sobre o paradigma de


programação Orientado a Objetos que esta focada tanto em Java como Mono .NET, pois
esta permite maior facilidade para reutilização de código, possibilitando o desenvolvedor
trabalhar em um nível mais elevado e abstrato, como também a utilização de um único
padrão conceitual durante todo o processo de criação de um determinado software.

Por se tratar de tecnologias ascendentes, cada plataforma possui suas


particularidades, ou seja, pode ser vantagem para uma linha de desenvolvedores e
desvantagem a outra. Pois cada organização tem seu modo de pensamento; e quando
uma equipe já se tem o domínio sob uma linguagem de programação, se torna algo
inviável modificar este ambiente.
16

1.5 OBJETIVOS

1.5.1 Objetivo Geral

• Confrontar tecnologias JAVA e Mono .NET, afim de avaliar seu desempenho e


mostrar alguns dos recursos, que cada plataforma oferece.

1.5.2 Objetivos específicos

• Estudar os conceitos gerais do Java e do Mono (.NET Framework), identificando


suas evoluções.

• Identificar vantagens e desvantagens das plataformas JAVA e Mono .NET


explorando algumas de suas características em cada plataforma.

• Identificar as linguagens de programação que são suportadas por cada plataforma


e quais as principais formas de conexão com o banco de dados.

• Desenvolver uma aplicação em modo Console, para cada plataforma com intuito
de analise de código, aplicação, e desempenho.

• Analisar o desempenho de cada tecnologia, em 2 sistemas operacionais distintos


(Windows e Linux).
17

1.6 PROCEDIMENTO METODOLOGICO

Pretende-se realizar o trabalho utilizando-se os métodos descritos a seguir:

• Fazer um levantamento bibliográfico, na internet, em livros, em revistas, artigos


científicos clássicos e atuais relacionados ao tema. Este levantamento continuará
ao longo de todo o desenvolvimento do trabalho;

• Construir o histórico da plataforma Java, evoluindo até o surgimento do Mono .NET


Framework.

• Descrever as principais características de cada tecnologia, linguagens de


programação que cada uma suporta, conectividade com o banco de dados.

• Após a elaboração teórica do trabalho, será desenvolvido como estudo de caso um


aplicativo sob cada plataforma, visando a conclusão dos objetivos práticos, e
analisando seu desempenho quanto ao desenvolvimento e execução do aplicativo
nos sistemas operacionais Windows e Linux.

A característica do projeto, é um estudo comparativo o qual tem como objetivo


comparar o desempenho das tecnologias Java e Mono .NET Framework.
18

1.7 PLANO DE METAS

• Capítulo 01: Origem do Java; A ideia de um ambiente multiplataforma; Maquinas


Virtuais; Gerenciamento de memória (Garbage Colletor);

• Capítulo 02: Conceito de Aplicações distribuídas; Servidores de Componentes;


Evolução do COM ao .NET; Outros relevantes fatos quanto o surgimento do .NET;

• Capítulo 03: Arquitetura Java; Arquitetura .NET Framework; Fundamentos do Mono


(.NET Framework); Conceito Multilinguagem;

• Capítulo 04: Linguagens de programação; Conceito de Orientação a Objetos; IDE:


Principais ambientes de desenvolvimento disponível em cada tecnologia; Modo de
conexão ao banco de dados.

• Capítulo 05: Comparativo prático/teórico: Gráficos analisando o desempenho de


carregamento de dados de cada aplicativo implementado; Tabela comparando
alguns dos principais pontos importantes de cada plataforma; Comparativo teórico:
Linguagens de programação usadas na implementação; Conexão a banco de
dados; Sistemas Operacionais que foram testados;

• Capítulo 06: Conclusão;


19

CAPITULO I

2 ORIGEM DO JAVA E O CONCEITO MULTIPLATAFORMA

Este primeiro capítulo será apresentado a origem do Java, seus conceitos e


características, a ideia de um ambiente multiplataforma, características da máquina
virtual, gerenciamento de memória.

2.1 FUNDAMENTOS DO JAVA

De acordo com DEITEL (2003), o Java iniciou a partir de 1991, foi projetado por um
grupo de engenheiros da Sun Microsystems, a qual criou uma filial denominada First
Person Inc., afim de gerenciar este projeto. Seu intuito era o desenvolvimento de
tecnologias de software para dispositivos eletrônicos como aparelhos domésticos e depois
também a televisão interativa.

Conforme PARGA (2005), a Sun necessitava de uma linguagem de programação


que fosse flexível e robusta, se tratando no que seria implantado, ou seja, para estes tipos
de equipamento era necessário gerar um código pequeno e deveria possui interfaces
mais intuitivas do que as existentes naquela época. Como também viu se que não poderia
ficar amarrado em uma só arquitetura específica, seja nos diferentes tipos hardwares e
sistemas operacionais.

Considerando facilidade de desenvolvimento e confiabilidade do código, James


Gosling, membro da equipe com mais experiência em linguagens de programação,
concluiu que as vantagens que contribuíam para a eficiência do C++ não compensavam o
alto custo dos testes de depurações.

Segundo Gosling(1996) as linguagens em uso, C ou C++, devem ser compiladas


para um chip, e se há mudanças no chip, todo o software deve ser compilado novamente.
Isso encarece muito o desenvolvimento e o problema é essencialmente apontado no
campo da eletrônica de consumo.

Os engenheiros da Sun se basearam na linguagem C++ a qual era orientada a


20

objetos, analisando o que ela oferecia de melhor e corrigindo suas falhas. Implementou se
melhorias no gerenciamento oferecendo robustez e interoperabilidade, assim construíram
a linguagem Oak.

A Sun Microsystems financiou uma pesquisa corporativa interna com o codinome


Green em 1991. 0 projeto resultou no desenvolvimento de uma linguagem
baseada em C e C++ que seu criador, James Gosling, chamou de Oak (carvalho)
em homenagem a uma árvore que dava para a janela do seu escritório na Sun.
Descobriu-se mais tarde que já havia uma linguagem de computador chamada
Oak. Quando uma equipe da Sun visitou uma cafeteria local, o nome Java (cidade
de origem de um tipo de café importado) foi sugerido e pegou. (Deitel, et al., 2003
p. 59)

O primeiro projeto que aplicou a linguagem Bytecode recebeu o nome de projeto


Green, este consistia em um sistema de controle completo de aparelhos eletrônicos de
uma casa. Para ele se construiu um ordenador experimental denominado *7 (Star Seven).
O sistema apresentava uma interface baseada na representação da casa de forma
animada e o controle era apresentado por meio de uma tela sensível ao tato.
Posteriormente, se aplicou a outro projeto denominado Video ON Demand (VOD)
no qual foi empregado como uma interface para televisão interativa. Nenhum destes
projetos transformou o em um sistema comercial, porém foram desenvolvidos
inteiramente em um Java primitivo.
De acordo com PARGA (2005), a First Person foi fechada em 1994 e já quando
tudo parecia ter sido definitivamente esquecido, Bill Joy, cofundador da Sun, julgou que a
Internet poderia chegar a ser um campo adequado para disputar mercado e viu na Oak o
instrumento ideal para enfim realizar seus planos. Após trocar o nome e modificações de
projeto, a linguagem Java foi apresentada à sociedade em agosto de 1995.
De acordo com GOSLING (2005), a linguagem de programação Java, foi
originalmente chamado Oak, sua utilização era em aplicações incorporadas ao
consumidor final, por James Gosling. Após vários anos de experiência com a linguagem, e
contribuições significativas por Ed Frank, Patrick Naughton, Jonathan Payne, e Chris
Warth foi reformulada à Internet. Com o avanço da World Wide Web desde 1993, visando
grande interesse para a Sun, e trazendo a partir de 1995 o suporte java em um dos
primeiros navegadores de internet através de interface chamado Mosaic. A forma final da
linguagem foi definida por James Gosling, Bill Joy, Guy Steele, Richard Tuck, Frank Yellin,
e Arthur van Hoff, com a ajuda de Graham Hamilton, Tim Lindholm, e muitos outros
envolvidos no projeto.

A enorme popularidade da World Wide Web ocorrida a partir de 1993, com o


21

surgimento dos browsers levou à reformulação do Java como uma linguagem para
incorporação em programas baseados em aplicações Web. Conforme Vernners (1997), a
Internet é uma rede mundial, e na WWW é a parte da rede que fornece acesso multimédia
a uma vasta gama de informações. Java tornou se uma das mais importantes linguagens
da web.

2.1.1 Ideia Multiplataforma

Desde quando a Sun iniciou o projeto green, que visava o desenvolvimento de


tecnologias de software para equipamentos domésticos, pensava em não ficar
dependente de um só ambiente operacional ainda mais produtos desta linha aos quais
possuía "n", tipos e modelos.

Necessitou um projeto detalhado para que, se desenvolvesse este modelo de


software. Mesmo o fracasso ocorrido no mercado escolhido, não desistiu se da ideia, pois
esta foi uma solução de grande importância para os aplicativos Web, das suas primeiras
aplicações por seu nome Applets, que poderia ser executado em qualquer plataforma sem
haver uma compilação especifica a cada hardware. Um passo tecnológico no mercado de
software, a qual a Sun Microsystems elencou sob o Java.

2.2 CARACTERISTICAS DO JAVA

A tecnologia Java é adequada para ajudá lo a enfrentar os desafios e aproveitar as


oportunidades apresentadas no mercado de desenvolvimento emergente. Conforme
Venners (1997), o seu papel original destina como uma linguagem de programação para
microprocessadores incorporados em aparelhos consumidores, porém o Java foi
projetado com uma série de outras características interessantes.

Robustez; o que significa que os erros dos programas em Java não causam falhas
no sistema tão frequentemente como erros nas outras linguagens de programação.
Alguns aspectos da linguagem é permitir que muitos erros potenciais possam ser
detectados antes que um programa é executado.
22

É uma plataforma independente. Uma plataforma, neste contexto, é apenas um


determinado tipo de sistema de computador, tais como um sistema Windows, MacOS,
Linux, etc. Java tem como sua marca registrada: "Escreva uma vez, execute em qualquer
lugar.". Isto significa que um programa Java pode ser executado sem modificações em
diferentes tipos de computadores. Isto não é verdadeiro para outras linguagens de
programação de alto nível. Uma razão para o Java é ser bem adequado para aplicações
WWW.

Suporte à comunicação em redes de computadores. A sua aptidão para ambientes


em rede é inerente a sua arquitetura, o que permite ser seguro, robusto e independente
de plataforma assim programas distribuídos através da internet pode ser executado em
uma grande variedade de computadores.

Linguagem distribuída; o que significa que seus programas podem funcionar em


redes de computador. Conforme PARGA (2005), além da própria linguagem, o Java vem
com uma extensa coleção de bibliotecas de código que tenha sido concebido para ser
utilizado diretamente para tipos específicos de aplicações para torná-lo muito fácil de
construir sistemas de software para desktop e Internet. Esta é uma das razões pelas
quais o Java é tão bem adaptado para apoiar aplicações em redes corporativas.

Segurança, quanto ao uso em redes, Java contém funcionalidades que protegem


contra códigos não confiáveis que possa introduzir um vírus ou corromper o sistema de
alguma forma. Por exemplo, quando é executado algo no navegador web, programas
Java são impedidos de leitura e escrita a partir de informações e para o seu computador
desktop.

Característica, orientado a objeto. Linguagens orientadas a objetos permitem dividir


programas em módulos separados, chamados objetos, que sintetizam o programa de
dados e operações. Assim Programação Orientada para Objetos (OOP) e Projeto
Orientado a Objetos (OOD) referem-se a uma forma particular de organizar programas,
um que está rapidamente emergindo como a melhor abordagem para a construção de
complexos sistemas de software. Ao contrário da linguagem C++, em que possui
características orientadas a objetos enxertado sob a linguagem C, Java foi concebido a
partir do zero como uma linguagem orientada para objeto.
23

2.3 MAQUINA VIRTUAL

Marketing pessoal na Sun Microsystems para o Java: “Write Once, Run Anywhere”;
escreva uma vez e rode em qualquer lugar, este foi o resultado que a equipe de
desenvolvimento atingiu, e desta trouxe grandes facilidades para o ambiente de
desenvolvimento.
Máquina virtual é uma abstração de uma máquina real onde o software simula um
computador executando vários aplicativos. É um ambiente operacional independente da
máquina ou dispositivo em que está hospedada e sendo executada. Dessa forma, ela
constitui uma plataforma, onde o sistema operacional, a memória, o processador e seus
demais recursos, são virtuais. Conforme Engel (1999), máquina virtual é o nome definido
a um ambiente, como um sistema operacional que não existe fisicamente, porém é
executado sob outro ambiente.
Segundo Wesley (2004), uma maquina virtual realiza a interpretação do código
intermediário, este é gerado como resultado da tradução de uma linguagem de alto nível.
Assim é garantida a portabilidade do código do programa. Isso porque, como o código
está numa linguagem intermediária, ou seja, independente da arquitetura de um
computador real, só é necessário que a máquina virtual esteja instalada no computador
onde o aplicativo será executado. A máquina virtual será a responsável pela interpretação
do código para a linguagem de máquina do computador em execução.
Dentre as vantagens principais proporcionadas pela máquina virtual pode citar se o
fato dos programas intermediários serem compactos e poderem ser executados em
qualquer plataforma na qual a máquina virtual esteja presente.

2.3.1 JVM (Java Virtual Machine)

Segundo BURD (2005), quando se iniciou a tecnologia Java em 1995, se tornou


quase que imediatamente popular. Isto aconteceu por causa da máquina virtual Java. A
JVM é um interpretador de linguagem, que transforma Java bytecode em código nativo
para que um determinado computador compreenda. Com a JVM, um bytecode opera em
máquinas Windows, Unix, Macs, entre outros.
Isso é chamado de portabilidade, que hoje em dia uma é inovação no mercado
computacional. Pense em todas as pessoas que utilizam computadores para navegar na
24

Internet. Destas pessoas, nem todas rodam o Microsoft Windows, ou outro sistema
operacional específico, mas cada pessoa do computador pode ter o seu próprio
interpretador de bytecodes, ou seja, a sua máquina virtual Java.
De acordo com Venners(1997), cada aplicação Java é executado dentro de sua
própria máquina virtual. Sendo responsável pela interpretação do código intermediário,
chamados também bytecodes, a JVM faz uma validação se estes se adéquam as
especificações não violando a integridade do sistema. A JVM também é responsável por
carregar o programa de forma segura.

Figura 1: Segmentação da maquina


virtual Java. O Autor(2009).

2.4 GARBAGE COLLECTOR (GERENCIADOR DE RECURSOS DA MEMÓRIA)

Conforme Rodrigues (2005), gerenciar recursos alocados por aplicativos é algo


vital para o funcionamento eficiente e prolongado de qualquer sistema. O mecanismo
automatizado do GC garante o gerenciamento de recursos alocados, todavia, em algumas
circunstancias a serem abordadas, é tarefa de o desenvolvedor envolver-se diretamente
nesta prática, elaborando o código necessário explicitamente.
Cada objeto consome parte da memória, de que existe uma quantidade limitada.
Eventualmente, a memória alocada para estes objetos devem ser liberadas quando não
são mais utilizadas. A máquina virtual Java, recupera esses objetos automaticamente
25

através de um processo chamado garbage collector. Segundo Engel (1999), o garbage


collector é o processo de coleta automática de lixo da memória, liberando objetos que não
são mais referenciados pelo programa.

O mecanismo automatizado do GC garante o gerenciamento de recursos alocados,


todavia, em algumas circunstancias a serem abordadas, é tarefa de o desenvolvedor
envolver-se diretamente nesta prática, elaborando o código necessário explicitamente.

2.4.1 Funcionamento do gerenciador de memória

De maneira simplificada, GC implementa um mecanismo de liberação de recursos


de memória no heap de objetos.

A ilustração 02 demonstra a ação do garbage collector sobre os objetos alocados


por uma aplicação. Estes objetos são referenciados em tabelas internas criadas pelo
compilador JIT quando da inicialização do GC. Estas referências, são denominadas raiz
pois correspondem à primeira fase de ação do GC no monitoramento de objetos alocados
pela aplicação, ainda referenciados pela mesma, que o GC não pode liberar. Diante deste
fato, o GC constrói suas próprias estruturas correspondentes aos objetos no heap.

Figura 2: Funcionamento inicial


do Garbage collector - GC
através do heap. MSDN(2008).
26

Simmons (2004), descreve o procedimento de gerenciamento de memória da


seguinte forma:

Figura 3: Diagrama demonstrando o processo de gerenciamento de memória.


Simmons (2004).

Este diagrama mostra todos os passos que são tomadas quando uma referência a
um objeto é removido da máquina virtual. Isso acontece sempre que o usuário define
explicitamente uma variável para null, sobrescreve uma variável do ponto de referência
para outro objeto, ou provoca a classe que detém a variável de referência para sair do
campo de aplicação. Para cada referência que tenha a máquina virtual, esta executa este
processo de recolha de lixo durante o seu ciclo.

Primeiro, a máquina virtual tenta traçar um caminho a partir da raiz definido para o
objeto. Se encontrar um caminho, não ocorre coleta. Se não encontrar um caminho, a
máquina virtual elimina a referência do objeto da memória. Em seguida, a máquina virtual
determina se ira apontar para os objetos de referencia retirados de referencia. Se houver
objetos de referencia, a máquina virtual determina se a memória sob a pilha é baixa. Se
assim for, ele faz uma verificação de memória. Se a verificação indicar que não há
memória livre ou a referência a um objeto já não for referida com quaisquer referências ou
as referências aos dados já foi o lixo coletado, a referencia na referencia é definido como
nulo. Finalmente, a referencia dos objetos são adicionado à fila.
27

CAPITULO II

3 APLICAÇÕES DISTRIBUÍDAS E O SURGIMENTO DO .NET FRAMEWORK

A tecnologia Java em uma de suas características é a capacidade de interconexão


TCP/IP, o que significa o desenvolvimento sob aplicações distribuídas. Descreve se neste
capítulo o conceito da arquitetura distribuída, comunicação entre objetos através de
componentes; mostrando o processo de evolução até o surgimento do .NET Framework,
interoperabilidade entre objetos localmente ou remotamente, WebServices e protocolo
SOAP.

3.1 TECNOLOGIAS DISTRIBUÍDAS

3.1.1 CORBA

Construída pela Object Management Group (OMG), um consórcio internacional de


cerca de 800 empresas, CORBA tem como objetivo ser o middleware de escolha dos
sistemas heterogêneos. OMG's CORBA, o que corresponde ao Common Object Request
Broker Architecture, é apenas uma coleção de normas, para execução de objetos (ORBs)
que é feito por várias solicitações de terceiros. Partes do padrão são opcionais, então os
vendedores (empresas fornecedoras de software) podem incluir funcionalidades
adicionais nos ORBs que não estão disponíveis. Como resultado, um aplicativo
desenvolvido para fazer uso de um fornecedor de recursos não poderiam ser facilmente
transferidos para outro ORB. Quando você compra um programa baseado em CORBA,
você apenas pode integrar com suas aplicações se forem compatíveis ou terem sido
desenvolvido pelo mesmo fornecedor.

No entanto, quando se tem implementando sua própria CORBA, você será capaz
de integrar uma grande quantidade de linguagens e plataformas. Há integração para
camadas COM ou EJB, e além disso suporte ao protocolo SOAP, "CORBA é o único a ser
multiplataforma, ambiente multiprogramming language para aplicações distribuídas"
(Rammer, 2002).
28

3.1.2 Java RMI

Tradicional método de invocação remota do java (Java RMI) utiliza um proxy


manual/compilação de ciclo. Em contraste com DCE/RPC e DCOM, as interfaces não são
escritas em uma IDL, mas em Java. Isto é possível devido a ser a única linguagem
interoperando entre a implementação Java.

3.1.3 Interface Definition Language (IDL)

Segundo McLean (2002), esta linguagem fornece uma forma padrão de descrever
a chamada sintaxe e tipos de dados remotamente exigível, procedimentos independentes
de qualquer linguagem de programação. IDL, não é necessária para algumas Java RMI
porque esta tecnologia de aplicação distribuída suporta apenas uma linguagem: Java.

3.1.4 Java EJB

Enterprise Java Beans (EJB), foi a resposta da Sun para com a Microsoft COM+.
Ao contrário do CORBA, que é apenas uma norma, EJB vem com uma implementação de
referência. Isto permite que os desenvolvedores a fim de verificar se os seus produtos são
executados em qualquer norma conformes a implementação EJB. EJB tem sido
amplamente aceitos pela indústria, e existem várias implementações bases variando de
fontes livres ou comerciais.

Um problema com EJB é que apesar de existir uma aplicação de referência, a


maioria das empresas vendedoras de software adicionam elementos à suas aplicações
sob servidores. Quando um programador escreve um componente que usa uma dessas
características, o aplicativo não será executado em um outro EJB cujo fornecedor não
implementou estas novas regras de funcionalidade.
29

3.2 A MICROSOFT E A COMPUTAÇÃO DISTRIBUÍDA

Conforme BARNABY (2002), a Microsoft foi a pioneira em software para PC e


ferramentas de desenvolvimento, a empresa foi rápida para promover os benefícios de
desenvolvimento cliente/servidor. Foi durante este período, que o sistema operacional
Windows, atingiu uma posição dominante no mercado. O Visual Basic é um exemplo de
como foi fácil em desenvolver uma interface de usuário do Windows e interagir com um
RDMS como Oracle ou SQL Server.

A Microsoft implementou a tecnologia Dynamic Data Exchange (DDE), à procura de


formas mais flexíveis para partilhar dados entre aplicações, em especial entre as
aplicações no seu Office. Fora deste trabalho veio Object Linking and Embedding (OLE),
uma tecnologia, que há tempo estava inutilizada, mas ainda continuava a sobreviver.
Através do OLE a Microsoft logo percebeu que os problemas que resolve transcender
planilhas e processadores de texto, poderiam ser usadas como a base para um novo
estilo de programação chamado COM Component Object Model, ou Componente Base
para Objetos. Isso a leva para uma nova geração no desenvolvimento de sistemas.

Segundo BARNABY (2002), dado que a Microsoft foi o principal fornecedor de


software para PC, segue se que a empresa também desempenhou um papel importante
na computação cliente/servidor. Inicialmente as ferramentas e tecnologias da Microsoft
foram centradas em níveis de cliente, incluindo Visual Basic, Access e FoxPro. Com o
lançamento do Windows NT, no entanto, a Microsoft voltou a sua atenção para o lado do
servidor, proporcionando diversas tecnologias que facilitam o desenvolvimento em n
camadas sob os aplicativos.

Depois do marketing da Microsoft definindo como arquitetura distribuída entre


redes DNA (Distributed Architecture Internetwork). DNA é implantado junto com o
Windows 2000 como o servidor de backend do sistema operacional Microsoft e trabalha
em conjunto com outros servidores, o SNA Server (ou o Host Integration Server 2000), e
outros. Além disso enfatiza a arquitetura “n” camadas (separação de apresentação, lógica
empresarial, e serviços de dados), o DNA também viu a concentração do COM e MTS em
que é conhecido como COM+.
30

3.2.1 DCE/RPC

Distributed Computing Environment (DCE), projetado pela Open Software


Foundation (OSF), durante o início da década de 1990, foi criado para fornecer um
conjunto de ferramentas e serviços que permitam facilitar o desenvolvimento e a
administração de aplicações distribuídas. O DCE fornece várias bases de serviços, tais
como Remote Procedure Calls (DCE/RPC), Serviços de Segurança, Serviços de Tempo, e
assim por diante.

Em uma aplicação DCE as interfaces devem ser especificadas na Interface


Definition Language (IDL) e compilados em C, seus cabeçalhos, processos cliente e
servidor por um compilador IDL. Ao executar o servidor, tem um link para um binário com
DCE/Pass, que estão disponíveis para C/C++. A utilização de linguagens de programação
é um pouco diferente, este devido à dependência dos serviços subjacentes, como o
DCE/Threads, o que levou a que um tem de viver com um único servidor se abstendo de
usar C/C+ +.

DCE/RPC, no entanto, é o alicerce para muitos dos atuais protocolos de nível


superior, incluindo DCOM e COM+. Vários protocolos de nível de aplicação, tais como MS
SQL Server, Exchange Server, Server Message Block (SMB), que é usado para
compartilhar arquivos e impressoras, Network File System (NFS) também são baseadas
em DCE/RPC.

3.2.2 OS PIONEIROS COM, MTS, DCOM

Conforme Mok (2003), duas importantes invenções da Microsoft para dominar o


mercado de software foram as tecnologias Microsoft Transaction Server (MTS) e
Component Object Model (COM) em meados dos anos 90.

COM pode ser tratado como um módulo ou parte de um software que tenha sido
escrito para que seja auto suficiente, ou seja, devidamente encapsulado, e pode ser
usado por outras classes sem elas saberem a forma como o objeto COM é implementado
internamente. Um objeto COM da Microsoft é a versão do Java Beans. Eles são
31

componentes de software que pode ser comprado e integrado em suas próprias


aplicações. "Fale sobre COM, e você poderá ouvir frases como "através reutilização de
interface" e "desenvolvimento baseado em componentes"(Mok, 2003).

(Tradução nossa) "Em teoria, não importa qual linguagem é usada para escrever
componentes COM; pois interfaces COM são usados para comunicação. Não
confunda com "interfaces", como utilizado em Java ou C #, interfaces COM são
mais como arquivos similares a IDL CORBA. Descreve os métodos públicos de
um componente COM, para que códigos externos serem capazes de invocar-
los."(Mok, 2003)

O MTS é uma camada intermediária, ou seja, um servidor que cuida de questões


como transações e segurança. MTS é uma camada construída em cima de COM e
DCOM, fornecendo serviços da mesma forma que o Enterprise Java Beans fornece.

Como o Enterprise Beans, componentes COM estão sob o MTS, que também lhe
fornece serviços como a operação, a ligação entre agrupamentos, a segurança, a pooling
de agrupamento, sincronização, e uma interface de usuário administrativa.

Quando a Microsoft foi "empurrada" para o mercado de servidores, foi necessário a


criação do Distributed COM (DCOM). DCOM fornece a infra-estrutura necessária para
interoperar com componentes COM através de uma rede como se estivessem na mesma
máquina.

No DCOM, os objetos COM por padrão são empacotados através de referência.


Isto significa que um cliente solicita o método deve passar através da rede para o objeto
COM. É decididamente não trivial para aplicar um valor pelo qual um regime de
empacotamento personalizado o objeto COM é copiado a partir de uma aplicação para
outra, permitindo assim que o cliente possa chamar métodos sobre a cópia local.

DCOM é um protocolo de comunicação remota da Microsoft. Os problemas


enfrentados pelo DCOM é ser limitado a plataforma Windows.

Conforme Rammer (2002), DCOM permite a distribuição dos componentes entre os


diferentes computadores. Escalabilidade, gestão, e sua utilização em WANs colocam
várias questões que precisam ser abordadas. DCOM utiliza um processo de ping para
gerir o objeto, todos os clientes que usam um determinado objeto irá enviar mensagens
após um determinado intervalo. Quando o servidor receber estas mensagens sabe que o
cliente ainda está ativo, senão ela irá destruir o objeto.
32

3.2.3 COM+

COM+ é o melhoramento do COM e MTS através de novas funcionalidades, tais


como uma base de segurança (por métodos de níveis), objeto de agrupamento (em
oposição a conjugação de pooling MTS), componentes enfileirados (para trabalhar com
MSMQ) e eventos COM. Segundo Mok (2003), eventos COM são os serviços que
fornecem um mecanismo para componentes COM para publicar ou assinar eventos.

3.2.4 .NET REMOTING

Conforme Rammer (2002), .NET Remoting é para Serviços Web ASP, que tem sido
a programação CGI, ou seja, a tecnologia de gerar paginas dinâmicas. Ela cuida de um
monte de problemas para você: ao contrário do Web Services, por exemplo, o .NET
Remoting permite que você trabalhe com stateful objetos. Este único fato permite que seja
a base de aplicações distribuídas. Para além da gestão dos objetos stateful, .NET
Remoting dá lhe um quadro flexível e extensível que permite a diferentes mecanismos de
transferência (HTTP e TCP são suportados por padrão), encodings (SOAP binário), e as
definições de segurança (a segurança do IIS Internet Information Service e SSL).

.NET Remoting da apoio para padrões abertos, como XML e Simple Object Access
Protocol (SOAP) tornando possível a comunicação entre diferentes plataformas em
ambientes abertos, uma vez que estas normas são adaptadas por outros vendedores de
software.

Arquitetura Extensível

O .NET Remoting oferece ao administrador e o desenvolvedor uma vasta escolha


de protocolos e formatos, do que qualquer mecanismo antigo de acesso remoto. Sempre
que um aplicativo cliente detém uma referência a um objeto remoto, ele será representado
por um objeto proxy transparente, que será mascarado como um objeto de destino. Isto
permitirá que todos os objetos mestres instanciem métodos para ser chamado a ela.
33

Sempre que um método chamado é colocado para o proxy, ele será convertido em uma
mensagem, e a mensagem irá passar por várias camadas.

3.3 WEBSERVICES

Web Services fornecem a capacidade de comunicação entre aplicações, ou seja, o


processo de conexão também entre redes, assim oferecendo interoperabilidade entre
plataformas e linguagens. Web Services tecnicamente são chamadas para componentes
remotos via HTTP POST, por codificação em formato XML, por exemplo: SOAP.

3.3.1 Protocolo SOAP

De acordo com RAMMER (2002), SOAP, ou Simple Object Access Protocol, define
um conjunto de serviços, a especificação não abrange apenas chamadas a
procedimentos remotos, mas também a Web Services Description Language (WSDL) e
Universal Description, Discovery, and Integration (UDDI). WSDL é SOAP, por definição de
interface e linguagem. UDDI funciona como um serviço de diretório para a descoberta de
Web Services. Estes protocolos complementares e as especificações estão também
baseado em XML, que permite que todas as características SOAP possam ser
implementadas em várias plataformas.

3.4 A EVOLUÇÃO ATÉ O SURGIMENTO DO .NET FRAMEWORK

De acordo com Mok (2003), originalmente chamado COM+ 2.0, o .NET nasceu do
COM e COM+, porém é um paradigma novo, ou seja, novas linguagens de programação,
bibliotecas de código, e novas ideias foram implementadas. Embora ainda seja possível
para o .NET se comunicar com os componentes COM e vice-versa, parece que
tecnologias como COM, DCOM e COM+ serão marcados como "herança" num futuro
34

próximo.

Ao longo da última década, COM foi o alicerce para quase todas as tecnologias da
Microsoft .NET, no entanto, substitui completamente COM e, portanto, uma radical partida
para a empresa aos milhões de desenvolvedores que utilizam as suas ferramentas. Ainda
assim, é instrutivo para olhar para trás com a linhagem que procria a atual tecnologia
.NET.

.NET trata componentes COM como pedaços de código. Ainda se pode utilizar
componentes COM no. NET, usando um wrapper (empacotador). Componentes COM
também podem comunicar com códigos .NET através de um wrapper. A inter operação
COM foi descontinuada, devido ao fato do surgimento do .NET Framework.

Conforme BARNABY (2003), duas importantes mudanças ocorreram até a chegada


do .NET, primeiro, houve a passagem para componente à base de programação. Esta
filosofia encaixou se naturalmente no mundo das aplicações distribuídas; construída com
base sob "n" camadas e princípios orientado a objetos. A segunda foi o surgimento da
internet e o desenvolvimento do activeX com base na tecnologia COM, o qual englobava:
controles ActiveX, Documentos ActiveX, Active Server Pages (ASP) e Active Data Objects
(ADO).

Os benefícios do COM, refere se a Microsoft .NET como uma evolução. Tanto o


COM e o .NET partilham os mesmos objetivos, .NET só faz melhor.

3.4.1 Fatos ocorridos sob o surgimento do .NET Framework

Logo que surgiu por volta de 1990 o Java já estava no imaginário dos
programadores, que sonhavam com a promessa da Sun, da célebre frase: "Escreva uma
vez, rode em qualquer lugar". Poucos anos depois Java já tomava uma grande fatia do
mercado e a Microsoft não ficaria de fora, investindo pesado na nova tecnologia criando
até uma otimização da plataforma para seu sistema operacional. Contudo os planos da
rival não agradaram a Sun que entrou na justiça alegando que o produto da Microsoft não
era compatível com o Java, ferindo os copyrights de sua detentora.

A Microsoft usava o Java sob seus produtos, tendo também como uma modificação
35

da plataforma otimizada para seu ambiente Windows chamado Microsoft Java Virtual
Machine. Esta maquina virtual java era bastante eficiente sob os sistemas operacionais
Microsoft devido ha interação entre suas APIs, porém anos depois, a sua descontinuação
trouxe o Java apenas como um plugin adicional ao ambiente Windows.

Nessa mesma época de 90 Steven Lucco e a sua organização, a Colusa, alheios à


disputa pelo Java, produziam um produto que poderia ser o substituto para o Java, o
Omniware Runtime Environment. O produto da Colusa vinha com uma Virtual Machine
(VM) e uma extensa Application Programming Interface (API) assim como seu rival, só
que ao invés de suportar uma só linguagem, o OmniVM, como era conhecido, suportava a
linguagem Visual Basic e C/C++ e prometia ser o sucessor para o Java.

A Microsoft amputada nas derrotas judiciais para a Sun, acabou sem poder usar a
plataforma Java. Enxergando uma oportunidade para contornar a situação, a Microsoft
comprou a Colusa em 1996. Entretanto nos próximos anos só haveria especulações
sobre a tecnologia do OmniVM, até que em 11 de julho de 2000 a Microsoft finalmente
lançou o pré-beta de um framework para concorrer com o Java, o Microsoft .NET
Framework. No entanto sua versão oficial, 1.0, chegou em 15 de janeiro de 2002.
36

CAPITULO III

4 ARQUITETURAS MONO .NET FRAMEWORK E JAVA

Neste terceiro capítulo será abordado as arquiteturas .NET Framework, quanto a


sua normalização até a estrutura Mono, outras plataformas derivadas da especificação
.NET, como o Rotor e DotGNU, e a arquitetura Java com base na sua estrutura geral,
seja no modo de compilação e funcionamento.

4.1 ARQUITETURA .NET FRAMEWORK

4.1.1 NORMALIZAÇÃO

Logo após o lançamento oficial do .NET Framework, houve a padronização do C#


(Linguagem padrão do .NET) e da Common Language Runtime. Deste modo
programadores podem desenvolver e utilizar projetos de código fonte aberto que são
baseadas em uma linguagem que é uma norma internacional, bem como a ser
compatíveis com diversas plataformas.

A Microsoft inicialmente apresentou o CLI e a linguagem de programação C# para


o European Computer Manufacturers Association (ECMA) para a normalização em
setembro de 2000. Em dezembro de 2002, a segunda edição do ECMA-335 Common
Language Infrastructure (CLI) se tornou uma norma. A linguagem de programação C#
tornou ECMA-334 simultaneamente.

Segundo NANTZ (2004), devido à estreita relação entre a ECMA e a International


Standards Organization (ISO), C# e o CLI teria descontinuado esta padronização em abril
de 2003. O CLI é agora ISO/IEC 23271:2006, e C# se tornou norma ISO/IEC 23270:2006.
37

4.1.2 SSCLI/Rotor

A Microsoft e a Corel, uniram se para criar a Shared Source CLI (SSCLI), também
conhecido pelos seu codinome Rotor. SSCLI é destinado ao estudo acadêmico como
também a implementação de instruções independentes de plataforma. Embora úteis para
o estudo, Rotor não possui qualidade comercial.

4.1.3 Portable .NET

O Open Source Portable .NET também chamado dotGNU pertencente ao projeto


GNU, liderado por Rhys Weatherley. Esta centrada principalmente nas normas do CLI,
semelhantes ao SSCLI, mas contendo algumas funcionalidades adicionais como TCL/TK
para UIS e utilizando algumas implementações do próprio Mono. Atualmente o
Portable.NET roda nas plataformas Linux, Windows, Solaris, e Mac OS X. O
Portable.NET possui um menor nível de bibliotecas, e a execução e o compilador são
escritos em C.

Segundo NANTZ (2004), a equipe da Portable.NET usa uma abordagem um pouco


estranho, na medida em que desenvolveu um intérprete primeiro. Algumas
implementações não tem sequer um intérprete, apenas um compilador JIT. Esta
abordagem interessante pode revelar se uma muito rápida implementação de um
compilador JIT. Esta implementação é definitivamente o mais pequeno e portátil, visto que
quase todos os processadores e o sistema operacional tem um compilador C, tornando o
um bom candidato para a incorporação. Portable.NET está sob a licença Gnu GPL Open
Source license.

4.1.4 Compact Framework

Depois de liberado o .NET Framework em 2002, a Microsoft começou a testar a


versão beta do Compact Framework (CF). Cerca de um ano depois o Compact
Framework foi liberado. Este é destinado a dispositivos portáteis como Mobile e Pocket
38

PC, sendo embarcado ao Windows CE. O CF é apenas um subconjunto da estrutura


Microsoft .NET Framework, e traz facilidades ao desenvolvimento móvel. Pois de fato a
base de programação é semelhante no desenvolvimento Desktop, pois se trabalha nos
mesmos ambientes de desenvolvimento.

4.1.5 Mono (.NET Framework)

Lançado em meados de 2001 pela Ximian cujo seu cofundador Miguel de Icaza,
Mono é uma iniciativa open source que traz a tecnologia .NET para sistemas operacionais
diferentes da Microsoft. O projeto Mono .NET em sua distribuição esta disponível para os
sistemas operacionais Linux, Windows, Mac OS, Berkeley Software Distribution (BSD),
Solaris. Ele também inclui suporte para ambientes x86 (32bit e 64bit) e PowerPC (PPC).

De acordo com MAMONE (2006), Icaza começou o projeto GNU Object Model
Environment (GNOME) em agosto de 1997 com um amigo, Federico Mena. Embora o
projeto foi bem sucedido, Icaza foi tornando se frustrado com a complexidade do
desenvolvimento de soluções baseadas em componentes, através disso achou
interessante a Microsoft .NET, a qual achou um caminho a ser explorado. Ele também
pretendia promover os conceitos introduzidos como parte do projeto Bonobo, que era
baseado em componentes COM, mas sobre o modelo .NET. Assim, nasceu o projeto
Mono.

Icaza agora é o Vice Presidente de desenvolvimento na Novell. A Novell adquiriu o


grupo Ximian em 2003, de modo agora o Mono é uma parte fundamental da estratégia da
Novell, com um número de suas principais aplicações e serviços, que se baseia no
ambiente de desenvolvimento Mono.

Mono é uma fonte open source, multiplataforma e possui grandes incorporações


contribuindo para sua melhoria. O ambiente Mono é classificado como um "Core Mono"
ou núcleo, e seus componentes adicionais que oferecem suas funcionalidades, que na
maioria das vezes é criado partir do núcleo do ambiente Mono.
39

Figura 4: Estrutura do Mono. NANTZ (2004)

O Mono vai além da estrutura .NET da Microsoft, pois conta com a integração de
biblioteca de terceiros, as quais são: API de depuração, integração a plataforma Gnome
(acessibilidade, renderização com o Pango, Gdk/Gtk, Glade, GnomeUI), Mozila, OpenGL,
suporte extensivo a banco de dados. Enquanto a Microsoft suporta uns poucos padrões
em sua instalação padrão, o Mono suporta mais de 11 padrões diferentes. As bibliotecas
de integração POSIX e a API embarcada usada para adicionar suporte a scripts em
aplicações, usando o CLI.

4.1.6 Licenças usadas no Mono

De acordo com LIMA (2006), o Compilador C# e as ferramentas usam a licença


GNU General Public License (GPL). As bibliotecas de runtime estão sob a licença GNU
Library GPL 2.0 (LGPL). As bibliotecas de classe usam a licença MIT X11.
40

4.1.7 Common Type System (CTS)

De acordo com MAMONE (2006), o CTS oferece uma série de princípios


orientadores para permitir o .NET Framework suportar múltiplas linguagens
interoperáveis.

CTS fornece um conjunto de regras que uma determinada linguagem deve seguir a
fim de interagir com outras linguagens, que incluem a forma de lidar com tipos (tanto de
referência e valor) e como para fornecer um modelo de orientado a objeto. Esta é uma
característica fundamental do .NET Framework e significa que você pode escrever sua
aplicação utilizando uma ou mais linguagens suportadas.

4.1.8 Common Language Specification

O Common Language Specification (CLS) define um conjunto de regras para a


interoperabilidade entre os componentes em diferentes linguagens. Conforme PUVVALA
(2003), os componentes escritos em outras linguagens que aderem a este conjunto de
regras são a ser "CLS-compliant" e são acessíveis a partir de outras linguagens "CLS-
compliant". O CLS define regras em um subconjunto do CTS.

4.1.9 Conceito Multilinguagem

Uma das características do .NET é o suporte à várias linguagens de programação.


Porém além de suportar diversas linguagens, é poder estar integradas em conjunto.
Segundo Mok (2003), você pode escrever uma sub classe VB.NET em uma classe C#, e
este bloco será interpretado pela CLR gerando um arquivo IL. Numa visão teórica agora é
muito mais fácil de implementar partes de sua aplicação usando a linguagem melhor te
dispõe.

Linguagens de programação já suportadas pelo .NET Framework: APL, Mondrian,


C#, Oberon, COBOL, Oz, Object Pascal, Boo, Perl, Eiffel, Python, Forth, RPG, Fortran,
Scheme, Haskell, Smalltalk, Java (J#), Standard ML, JScript, Visual Basic, Mercury, Visual
41

C++, RUBY.

A interoperabilidade de código oferece muitas vantagens para companhias de


software. Por exemplo, programadores C#, Visual Basic e Java pode trabalhar lado a lado
no mesmo projeto, sem ter de aprender uma outra linguagem de programação.

O .NET Framework Class Library (FCL) pode ser usado por qualquer linguagem
.NET. A FCL contém uma variedade de componentes reutilizáveis, poupando
programadores o problema da criação de novos componentes.

4.1.10 Linguagem Intermediária

Após ter sido escrito um determinado bloco de código, sob uma determinada
linguagem de programação suportada pelo .NET, este é compilado (usando o compilador
JIT) em uma linguagem intermediária conhecida como IL. A CLR, em seguida, executa a
IL. Esta linguagem é independente de plataforma embora a sua definição é um formato
de arquivo padrão que uma implementação do CLR pode compreender. É este formato de
arquivo que oferece a possibilidade para que você possa executar qualquer código .NET
em qualquer plataforma, desde que tenha uma implementação do CLR acessível. O
Microsoft Intermediate Language (MSIL) é o equivalente de Java bytecode o qual é
gerado na plataforma Java.

De acordo com LIBERTY (2005), o CTS prevê a interoperabilidade das linguagens


e aplicações, IL oferece uma plataforma que permite interoperabilidade e uma compilação
nativa em sistemas e finalmente, o sistema de metadados e da completa biblioteca
classes (BCL), as funcionalidades necessárias para desenvolvimento baseado em
componentes.

4.1.11 ASSEMBLY

Quando uma linguagem .NET gera seu arquivo de saída, é gerado um PE (portable
execute), em formato binário usado para armazenar programas Win32 que envolve um
conjunto de códigos IL, dados com a descrição de tipo e tamanho, além de métodos e
42

seus parâmetros de entrada e saída e a definição de outros componentes externos


necessários para a execução.

Um assembly pode ser privado ou compartilhado, seu conteúdo é chamado


Managed Code, ou seja, seu conteúdo é gerenciado pelo framework.

De acordo com PUVVALA (2003), assemblies compartilhados são armazenados


em um repositório mantido pelo .NET e conhecido como Global Assembly Cache (GAC).
O assembly privado é visível apenas para uma aplicação em geral armazenado no próprio
local do arquivo a executar.

Toda aplicação .NET, quando compilada, é armazenada fisicamente numa unidade


de código denominada assembly. Uma aplicação pode ser composta de um ou mais
assemblies, os quais são representados no sistema de arquivos do sistema operacional
host na forma de arquivos executáveis, de extensão .EXE, ou de uma biblioteca de
ligação dinâmica melhor conhecida como DLL, e obviamente

de extensão .DLL.

4.1.11.1 PE (Portable Executable)

Quando um aplicativo é compilado, são geradas instruções IL. METADADOS com


informações da aplicação também são gerados, e obviamente armazenados na forma de
uma DLL ou de um arquivo executável.

4.1.12 Common Language Runtime

O Common Language Runtime (CLR), é a maquina virtual do .NET Framework; é


através dela que são executados todos e qualquer executável .NET. O código
intermediário contido em um arquivo IL é interpretado por esta maquina através do JIT
compiler gerando o código nativo a ser executado na maquina física.

Segundo PUVVALA (2003), a CLR fornece serviços de infraestruturas de apoio à


execução de código gerido. Estes serviços incluem gerenciamento de memória
43

automática, segurança, gestão de processos, e versionamento.

4.1.13 Just in Time Compiler

Compiladores JIT, usam metadados para compilar o código Intermediate Language


(IL). Metadados são uma descrição de dados que o .NET Framework usa para fornecer
informações sobre componentes e os seus recursos. IL é uma representação
intermediária, que contribui significativamente para a integração entre linguagens de
programação, que deve ser interpretado. A função do JIT é compilar o código IL em
código nativo antes da sua execução.

Segundo Soares (2005), a compilação da IL em código binário é feito durante a


execução do aplicativo. Existem três modalidades possíveis de compilação, através do
JIT:

PRÉ-JIT: todo código da aplicação é compilado e armazenado. A desvantagem


desta modalidade é que o overhead (tempo de dedicação do processador a um dado
processador) se dá uma só vez, o que dependendo da aplicação pode demorar algum
tempo. Porém depois de compilado, esta é executada sem a necessidade de
recompilação.

Econo-JIT: o código é compilado sob demanda. Quando não é mais necessário é


descartado liberando memória. Se novamente for demandado, uma nova compilação
acontecerá. Essa modalidade é aconselhável em dispositivos com poucos recursos de
memória, como os hand-helds e celulares;

Normal-JIT: o código também é compilado sob demanda, no entanto não é mais


descartado sendo reaproveitado no futuro.

4.1.14 Framework Class Library

A visão geral do .NET Framework Class Library (FCL), tal como a API Java, é
poder ajudá lo a executar muitas tarefas, como o acesso aos bancos de dados, criação de
gráficos, processamento XML, comunicação de redes, troca de mensagens, segurança e
44

serviços de diretório.

Conforme SOARES (2005), FCL ou também conhecido por Base Class Library
(BCL) é a biblioteca de classes do .NET. Aqui se encontra as principais classes para a
implementação da GUI (Graphic User Interface), entrada e saída de dados,
gerenciamento de memória, etc. A BCL é organizada em uma estrutura conhecida como
namespace. Esta estrutura conhecida organiza classes prevenindo ambiguidades e
simplificando bastante o trabalho com grandes grupos de objetos. Um exemplo de
namespase é o System.Windows.Forms que implementa todos os controles de interface
gráfica como labels, listboxes, buttons entres outros. "Os tipos definidos na FCL são todos
controlados pelo framework através do GC, já que todos aderem ao Common Type
System (CTS)."

4.1.15 Ciclo de execução do .NET

Este diagrama demonstra o processo em que o .NET é compilado e executado no


sistema operacional.

Figura 5: Cycle compiler .NET. Ciclo de execução do código fonte .NET.


BAGNALL (2002)
45

4.1.16 Compilando Código Fonte em código nativo

Conforme LENZ (2003), através do código IL, pode ser permitido que o compilador
JIT otimize-o para a plataforma a qual será executada. Por exemplo, a otimização em
termos da quantidade de memória instalada, o número de processadores, e assim por
diante. O compilador pode também tirar o máximo proveito do conjunto de instruções do
processador. O código compilado nativamente deve se averiguar qual plataforma à
otimizar antes da distribuição da aplicação.
46

4.2 ARQUITETURA JAVA

4.2.1 Normalização do Java

O Java esta sob a publicly available specification (PAS), ou melhor dizendo uma
especificação disponível publicamente, normatizada pela ISO.

A referência à execução da plataforma Java é o Java Development Kit (JDK), um


conjunto de software livre fornecido pela Sun, afim de fornecer um conjunto de
ferramentas ao desenvolvedor.

Várias versões do Java vem sendo lançadas deste sua origem. A primeira foi a
versão 1.0; posteriormente foram introduzidas alterações sob a plataforma, chegando ao
JDK 1.1. Este incorporou uma nova maneira de lidar com gráficos e algumas pequenas
mudanças para a linguagem Java, juntamente com uma série de novas APIs e
ampliações das existentes. A versão mais atual no presente escrito é o Java 6, o qual
possui várias melhorias desde sua primeira versão, porém não modificado sua estrutura
base.

Segundo ENGEL (1999), embora as novas versões da plataforma Java raramente


afeta a JVM anterior, isto nem sempre significa que você pode utilizar suas
implementações nas JVM existentes seguidas das novas funcionalidades.

4.2.2 Java Community Process

A JCP foi fundada em 8 de dezembro de 1998 e vem passando por diversas


melhorias. O trabalho do JCP consiste em garantir na tecnologia Java a estabilidade e
compatibilidade multiplataforma. Em conjunto com a JCP, esta e a Java Specification
Process (JSR), a qual cuida no processo de requisição de melhorias para o ambiente
java.
47

4.2.3 Java Foundation Classes

O Java Foundation Classes (JCF), é uma coleção de ferramentas contendo a


interface do utilizador e as classes Java Beans, que permitem a construção Visual de um
determinado programa. De acordo com ENGEL (1999), JCF foi escrito inteiramente em
Java e funciona em qualquer ambiente JVM.

4.2.4 ByteCode

De modo geral o ByteCode é um arquivo .class, a qual é gerado pelo compilador


Java, este arquivo é independente de plataforma, o que significa que este pode ser
interpretado e executado por uma JVM em qualquer plataforma. O bytecode esta entre o
código fonte, seja alguma linguagem suportada pelo java (o próprio Java, Groovy, JRuby,
Jython) e o código nativo.

4.2.5 JIT Compiler

Em conjunto com a JVM o compilador JIT interpreta os bytecodes, transformando o


em código de maquina para a execução no sistema operacional.

4.2.6 Class Loader

O Class Loader é responsável pelo carregamento de classes da JVM. O processo


ocorre através da localização e identificação dos bytecodes necessários a ser carregados,
criando também uma instancia do java.lang.Class que é um pacote contendo as classes
base do Java. Classes referenciadas por classes já carregadas serão resgatadas só
quando houver necessidade.
48

4.2.7 Distribuições da Plataforma Java

Sun Microsystems reorganizou a plataforma Java em três categorias, principais:

Java SE: A plataforma Java Standard Edition visam máquinas desktop.

Java ME: A plataforma Java Standard Edition ou Mobile Edition orientados para
dispositivos portáteis.

Java EE: A plataforma Java Enterprise Edition utilizado no desenvolvimento de


aplicações empresarias em longa escala, relaciona aplicativos baseado em componentes
e multi camadas.

O nome da plataforma Java foi simplificada. Anteriormente, era conhecida como


Plataforma Java 2 Enterprise Edition (J2EE), e suas versões específicas era constituídas
por "pontos" e "números", tais como J2EE 1.4. O "2" foi retirado do nome, bem como o
"ponto" e "número". Então a última versão da plataforma Java é Java Enterprise Edition
6(Java EE 6).

Para PUVVALA (2003), embora se trate de uma simplificação feita pela Sun, você
pode pensar em Java ME como um subconjunto do Java SE e deste pense como um
subconjunto de Java EE. Java EE é uma tecnologia de base construída para o Java, Java
SE e Java EE prevê o desenvolvimento e a execução de ferramentas utilizadas por
desenvolvedores para criar aplicativos empresariais.

Figura 6: Plataforma Java Standard Edition v 1.4. Sun


Microsystems, Inc. (2009)
49

4.2.8 Ciclo de execução do JAVA

Figura 7: Java code cycle. Ciclo de execução do código fonte Java. BAGNALL
(2002)

Este diagrama demonstra o processo em que o Java é compilado e executado no


sistema operacional.

4.2.9 Licença

O Java atualmente (2009), possui um duplo licenciamento, ou seja, é constituído


pela GPLv2 e Common Development and Distribution License (CDDL), esta criada pela
própria Sun, a qual não deixa de ser open source, porém leva em consideração o
proposito comercial. Quanto ao usuário, pode opta-lo pela qual melhor se adequá.
50

CAPITULO IV

5 LINGUAGENS DE PROGRAMAÇÃO, IDE's E MODOS DE ACESSO A DADOS

O quarto capitulo deste trabalho descreve de uma maneira geral os conceitos de


orientação a objetos que esta fixado sob as tecnologias estudas (Java e Mono), as
linguagens de programação suportas por cada plataforma, os principais ambientes de
desenvolvimento destacados para cada plataforma e seus modos de conexão a banco de
dados.

5.1 Conceitos de Orientação a Objetos

Conforme SIMMONS (2004), o conceito orientação a objetos inicia em meados dos


anos 70, abrangendo um grande número de programadores e organizações, através das
linguagens Smalltalk e Eiffel que eram puramente orientada a objetos. Logo mais com o
advento do C++, o qual era um C melhorado como o apoio em desenvolvimento orientado
a objetos.

Com o surgimento da linguagem Java, este conceito (Orientado a Objeto) se


popularizou de vez no ambiente de desenvolvimento, devido as suas facilidades em
questão de manutenção e reutilização de código. Das diversas linguagens suportadas
pela plataforma Java e Mono .NET Framework, todas aderem ao estilo orientação a
objetos.

5.2 Linguagens de programação suportas pela plataforma JAVA

5.2.1 Java

O Java além de ser uma plataforma é também uma linguagem de programação a


qual é interpretada pela JVM. Java é a linguagem de programação mais conhecida
popularmente a ser programado sob o ambiente Java, pois é ela que é fornecida por
51

padrão. É uma linguagem Orientada a Objetos, e derivada do C/C++.

5.2.2 Groovy

Groovy é uma linguagem dinâmica, a qual possui diversas características das


linguagens python e ruby, com similaridade na sintaxe do java.

5.2.3 JRuby

Ruby foi criado em 1993 pelo YUKIHIRO Matsumoto sendo liberada ao público em
1995. A aplicação principal é um intérprete escrito em C, geralmente chamado Matz Ruby
Implementation (IRM), quando há uma necessidade de distinguir entre a linguagem Ruby
e o Ruby Implementation. O JRuby é a implementação da linguagem Ruby disponível
para plataforma Java.

5.2.4 Jython

Conforme BILL (2001), a história do Jython começa com Jim Hugunin, um colega
de Guido van Rossum (fundador da Linguagem Python) na Corporation for National
Research Initiatives (CNRI), que reconheceu a necessidade de uma aplicação Java sob a
linguagem de programação Python e aplicaram na sob o nome original Jython.

5.3 Linguagens de programação suportas pela plataforma Mono (.NET Framework)

5.3.1 C#

Quando foi desenvolvido a plataforma .NET, necessitou se uma linguagem de


programação para que fosse interpretada pela CLR. A Microsoft projetou então o C# a
qual se identifica como uma moderna linguagem orientada a objetos, que permite aos
programadores construir rapidamente componentes .NET de alto nível. Esses
52

componentes podem ser facilmente convertidos em serviços Web para ser utilizado
através da Internet.

C# é baseado na sintaxe C e C++ e utiliza alguns conceitos de diversas outras


linguagens, como o Java e Visual Basic. Ele combina a rápida produtividade do Visual
Basic com o poder do C++.

5.3.2 VB.NET

Ao longo do tempo a Visual Basic se tornou a linguagem mais popular no


desenvolvimento de aplicativos para Windows, no entanto havia a necessidade de
modernizar a linguagem em si, tornando a mais robusta e adaptada para uma nova
realidade de mercado.

A linguagem VB.NET é derivado do Visual Basic, porém com um perfil totalmente


remodelado para a plataforma .NET Framework, em 2002.

5.3.3 Object Pascal

A linguagem object pascal é derivado do pascal. É uma linguagem orientada a


objetos, a qual tem suporte sob as plataformas .NET, tanto Microsoft quanto Mono.

5.3.4 J# (JSharp)

Anunciado no final de 2001, J# é o sucessor oficial do Visual J++, o qual era um


ambiente de desenvolvimento pra Java criado pela Microsoft. Como J++, J# segue a
linguagem Java das sintaxes as regras. Mas ao contrário de Java, aplicações escritas
usando J# pode ser executado apenas na CLR, e não em uma JVM.

A vantagem para os desenvolvedores Java quanto a linguagem J# é poder de


usufruir, das competências existentes em Java para escrever códigos J# na plataforma
.NET, até uma migração possível ao C#.
53

5.3.5 F# (FSharp)

F# é uma linguagem de programação funcional, ou seja, porque programas são


formados exclusivamente por funções. Segundo SYME (2007), o desenvolvimento de um
sistema através do paradigma funcional, consiste na escolha de funções matemáticas que
expressem o problema de forma declarativa.

O F# é baseado nas linguagens Haskell e Ocaml, seu desenvolvimento inicio se


em 2002 por Dom Syme e outros mais desenvolvedores da Microsoft, seu pré lançamento
ocorreu em 2005. A programação em F# tende a ser mais orientada a objeto, do que em
outras linguagens funcionais.

5.3.6 IronRuby

O IronRuby é um um projeto open source baseado na linguagem Ruby, para


implementação através da plataforma .NET. Ruby em sua linguagem é bem conhecida
devido a sua simplicidade de código e orientada a objetos.

5.3.7 IronPython

IronPython é uma implementação do Python para a plataforma .NET, esta como


outras linguagens comentadas é Orientada a Objetos, dinâmica e permite a integração
com outras linguagens como C#.

5.3.8 Boo

Boo é uma linguagem baseada na sintaxe do python, para implementações sob a


plataforma Mono e Microsoft .NET. O significado de Boo vem do nome de seu fundador
Rodrigo Banboo.
54

5.3.9 C++

Diferente dos problemas enfrentados pelo C++ anteriormente, principalmente na


questão de gerenciamento de memória. A linguagem C++ esta disponível para a
plataforma .NET, agora também em modo gerenciado, podendo ser trabalhada neste
modo ou não (ou seja, nativamente, neste trata se como uma exceção ao
desenvolvimento sob ambiente .NET).

5.3.10 C# Versus Visual Basic .NET

De acordo com LIBERTY (2005), a premissa do .NET Framework é que todas as


linguagens são iguais. Parafraseando George Orwell, no entanto, algumas linguagens são
mais semelhantes do que outras. C# é uma excelente linguagem para o desenvolvimento
em .NET como também é a na maioria das vezes a mais comentada em estudos.

É possível que muitos programadores do antigo Visual Basic 6 iram escolher C#


para aprender em vez de melhorar as suas habilidades para VB.NET. A transição do VB 6
para VB.NET é provavelmente quase tão difícil como partir de VB 6 para C# e, se é justa
ou não, historicamente, a família de programadores C tiveram maior ganho potencial que
programadores VB. Programadores VB nunca obtiveram o respeito que merecem, e o C#
oferece uma maravilhosa oportunidade de fazer uma transição potencialmente lucrativa.

5.3.11 C# versus Java

Em suma LIBERTY (2002) afirma, programadores Java podem olhar em C# uma


mistura de ansiedade, alegria, e ressentimento. Tem sido sugerido que C# é de alguma
forma um "rip-off" de Java. Através do C# certamente entende se sobre Java. Assim
através de Java aprende se muita coisa de C++, que deriva a sua sintaxe de C, o que, por
sua vez, foi construído sob outras linguagens.

C# oferece uma transição fácil para programadores Java; a sintaxe e a semântica é


muito semelhante por isso estão familiarizados e confortáveis. Programadores Java
55

provavelmente iram querer focar as diferenças entre Java e C# para usar com eficacia no
seu desenvolvimento.

5.4 Ambientes de desenvolvimento destacados às plataformas Java e Mono (.NET


Framework)

Um ambiente de desenvolvimento integrado (IDE) consiste em uma coleção de


programas colaborativos que facilitam o desenvolvimento de software. Os serviços e
componentes disponíveis sob este ambiente estão literalmente integrados formando um
ambiente de trabalho pratico no processo de desenvolvimento.

5.4.1 Camadas principais de uma IDE

Editor: É onde você estará escrevendo seu código. Com o próprio "bloco de notas"
do Windows, ou Gedit no Gnome (Linux), ou seja, com qualquer editor de texto por mais
simples que ele seja, já poderá desenvolver algum programa. Porém qual é a importância
de uma IDE, quais são as vantagens? Sua principal vantagem esta na interatividade com
o desenvolvedor, seja então auxiliando e facilitando o processo de codificação de um
determinado software para computador.

Plataforma: A maneira de entendimento de como uma IDE atua como uma


plataforma, e da forma de como ela integra todos os componentes oferecidos pela
tecnologia trabalhada, seja Java, .NET ou qualquer outra plataforma.

Processo de desenvolvimento - (Utilizando qualquer editor de texto)

Compilando e executando um programa no Java (utilizando a linguagem Java)

meu_programa.java (Apendice 01 – Algoritmo exemplo Java)


Compilando
javac meu_programa.java
Executando
java meu_programa.class
56

Compilando e executando um programa no Mono .NET (utilizando a linguagem C#)

meu_programa.cs (ANEXO 01 – Algoritmo exemplo C#)


Compilando
mcs meu_programa.cs
Executando
Mono meu_programa.exe

Notem que isto é extremamente simples, servindo apenas como exemplo, porém
quando estivermos desenvolvendo algum projeto, sendo orientado para Desktop, Web ou
Mobile, devido a sua complexidade, necessitaremos de algo mais produtivo, assim o
poder contido no ambiente de desenvolvimento influenciará tanto na qualidade e o tempo
de término de um determinado software.

5.4.2 MonoDevelop

MonoDevelop é uma IDE Gnome destinada ao desenvolvimento Mono .NET


Framework. Principalmente suportando a linguagem C#, e logo mais, também outras
linguagens como VB.NET, Boo, etc. É um software open source e multiplataforma, sendo
mantido pela empresa Novell.

5.4.3 Sharp Develop

SharpDevelop é um ambiente de desenvolvimento integrado de código aberto para


aplicativos .NET Framework. Suporta o desenvolvimento de aplicações escritas em C#,
VB.NET, Boo, IronPython e F#. Ele fornece características de uma moderna IDE, porém
suporta somente o sistema Windows, possui uma boa compatibilidade com o Visual
Studio devido a utilizar uma mesma estrutura de projeto e formatos de arquivo. Além disso
tem o suporte ao desenvolvimento para aplicativo GTK para Mono .NET.
57

5.4.4 Visual Studio

O Visual Studio é a ferramenta oficial para o desenvolvimento de software da


plataforma Microsoft .NET, ele contem um ambiente integrado para ser utilizado em todas
as fases de desenvolvimento. Inclui o editor de código fonte, compiladores, depuradores e
utilitários diversos aos quais se torna mais pratico o desenvolvimento de aplicativos em
modo designer. Conforme a MSDN (2008), o Visual Studio possui uma versão Express
destinado para estudantes e a versão professional para empresas. O VS é um ambiente
proprietário funcionando apenas no sistema operacional Windows, cujo sua detentora é a
Microsoft, porém softwares desenvolvidos neste RAD, podem ser executados sob a
plataforma Mono .NET.

5.4.4.1 DelphiPrism

Delphi Prism é um novo ambiente de desenvolvimento Delphi para a plataforma


Microsoft .NET e Mono. Não possui uma IDE própria, mas é integrada ao ambiente Visual
Studio, ou seja, o Delphi Prism e o VS trabalham em conjunto quanto ao desenvolvimento
utilizando a linguagem Object pascal. A atual (2009) detentora do Delphi Prism é a
empresa Embarcadero.

5.4.5 Eclipse

Conforme GAMMA (2003), o Eclipse pode servir como uma IDE para diversas
linguagens de programação. A IDE pode ser integrada a linguagens como C/C++, Java e
até mesmo C#, como também outros componentes para o desenvolvimento de software
através de Plugins disponíveis pelo próprio Eclipse ou por terceiros. A sua grande
popularidade é como uma IDE para a plataforma Java. O eclipse é um ambiente open
source e multiplataforma, mantido pela própria Comunidade Eclipse.
58

5.4.6 Netbeans

O ambiente de desenvolvimento Netbeans, segue os mesmos princípios do


Eclipse. Ele possui um completo ambiente de desenvolvimento, oferecendo suporte para
programação Desktop, Web, Mobile, podendo ter integração total com UML. O Netbeans
esta sob uma licença dupla: a GPLv2 e a CDDL, sua detentora é a Sun Microsystems. É
multiplataforma e destinado principalmente ao desenvolvimento Java, além de suportar a
integração com Ruby, C/C++, PHP, entre outras linguagens dependendo dos plugins
instalados na IDE.

5.5 COMPONENTES DE ACESSO A DADOS

5.5.1 JDBC

Conforme ZUKOWSKI (2006), a API JDBC foi adicionada a partir do JDK 1.1, e tem
oferecido apoio para conectar o Java a diferentes tipos de base de dados, através de
drivers registrados a sua API. Contrariamente à crença popular, JDBC não é uma sigla e
sim um nome registrado pela Sun Microsystems que representa um tipo de tecnologia.
Não é "Java Database Connectivity" como muita gente pensa.

JDBC possui um conjunto de classes e API, fornecendo a capacidade de conectar


"qualquer" banco de dados relacional e manipulá-los através de instruções SQL, ha um
determinado programa. Para cada banco de dados a ser conectado, utiliza se um driver
JDBC específico.
O JDBC é a API padrão para acesso a dados no Java, por padrão inclui apenas
alguns drivers como o JDBC-ODBC, que permite utilizar um driver ODBC para acessar
um banco de dados; esta conexão serve como uma ponte de aceso entre o JDBC e o
ODBC. Outros drivers para acesso ao MySQL, Firebird, PostgreSQL, SQLite, entre outros
podem ser adquiridos e registrados ao JDBC.
59

Figura 8: Estrutura base do JDBC. O desenvolvedor trabalha com objetos simples em


Java. O DriverManager em conjunto com o driver especifico, fornece o acesso ao banco
de dados. BRILL(2001)

5.5.2 ADO.NET

Conforme MOREIRA (2005), o ADO.NET (ActiveX Data Objects), foi projetado pela
Microsoft, contendo um conjunto de classes que permite acesso estável a todo tipo de
banco de dados, além de recursos como suporte nativo a XML, transações, interfaces de
generalização de acesso a bancos (Factory), entre outras.

ADO.NET é o nome da biblioteca Microsoft para acesso a banco de dados para a


plataforma .NET, é acessível de qualquer linguagem de programação. Possui o suporte
para acesso desconectado a banco de dados, integração XML facilitando a integração de
informações com outros programas ou até mesmo outras plataformas e integração com o
Visual Studio através de wizards (componentes visuais) ou de forma manual. Outras
IDE's como MonoDevelop e #Develop ainda não possui integração total ao ADO.NET,
seja na questão em modo designer. Segundo a MSDN (2008), o ADO possui acesso ao
SQL Server, OLEDB, Oracle e ODBC. ODBC serve como uma ponte para acesso outros
bancos de dados como Firebird, PostgreSQL, MySQL, etc.
60

Figura 9: Arquitetura ADO.NET. MSDN (2009)

5.5.3 Outros modos de acesso a dados com o .NET

5.5.4 Open DataBase Connectivity (ODBC)

O driver ODBC é uma opção para acesso a dados a qual possui suporte a diversos
tipos de banco de dados, ocorrendo da mesma maneira que o JDBC, a cada tipo de
banco possui um outro driver específico a ser registrado para o acesso. O ODBC, esta
disponível tanto no Java e no Mono .NET.

5.5.4.1 NPGSQL

O NpgSQL é o provedor padrão do Mono para acesso a dados no PostgreSQL,


funcionando também sob a plataforma Microsoft .NET. É um componente open source
distribuído pela Pgfoundry. Este componente oferece a funcionalidade de
desenvolvimento tanto para Desktop quanto para Web.
61

Figura 10: Principio básico de acesso a base de dados PostgreSQL,


utilizando o NpgSQL. Autor(2009)

5.5.4.2 PgSqlNET Free Express

Desenvolvido pela Devart é um componente de acesso a dados para o


PostgreSQL. Na sua versão completa (professional) a qual inclui todas as vantagens do
modo designer de configuração do acesso à interação entre as tabelas, facilitando o
desenvolvimento, no entanto é uma versão proprietária. Na versão express inclui toda a
infraestrutura de acesso a dados com exceção do modo designer, assim tendo de ser
codificado manualmente vários parâmetros em um determinado projeto de software.
62

CAPITULO V

6 COMPARATIVOS DAS TECNOLOGIAS JAVA E MONO .NET FRAMEWORK

Neste quinto capítulo inicia o processo de comparação das tecnologias Java e


Mono .NET Framework, analisando e demonstrando alguns de seus pontos críticos como
desempenho em relação ao sistema operacional seja Windows ou Linux aqui comparado.
Em uma analise breve comentando sobre as linguagens Java e C# as quais foram
utilizadas, os ambientes de desenvolvimentos trabalhados e a maneira utilizada na
conexão com o banco de dados. São mostrados a este capítulo tabelas e gráficos
focando a analise quantitativa afim de melhor demonstrar o comparativo executado nestas
plataformas.

6.1 PROCESSO DE DESENVOLVIMENTO PRÁTICO


ESPECIFICAÇÃO DOS SOFTWARES UTILIZADOS NO DESENVOLVIMENTO
Plataforma MONO .NET Plataforma JAVA
Maquina Virtual Mono-Core 2.4 Maquina Virtual Jre 1.6_14
SDK Mono 2.4 SDK Jdk 1.6_14
SharpDevelop 3.1 Netbeans 6.7
IDE (Windows) IDE (Win/Linux)
MonoDevelop 2.0
(Linux)
Componente de acesso a dados
NpgSQL 2.0.6 Jdbc – driver postgresql-8.4-701.jdbc3

Sistemas Operacionais Executados / Desenvolvidos


Windows XP pro SP3 x86
Linux: Ubuntu 9.04 x86

Sistemas Operacionais Executados Windows 7 Ultimate beta x64


openSUSE 11.1 x64
Windows XP pro SP3 x86
Linux: Ubuntu 9.04 x86
Sistema Operacional Desenvolvido Windows 7 Ultimate beta x64
openSUSE 11.1 x64

Sistema Gerenciador de Banco de Dados


Banco de Dados PostgreSQL 8.4 x86
Sistema Operacional (Servidor) Linux: Ubuntu 9.04 x86
Figura 11: Especificação dos softwares utilizados no processo de
comparação das tecnologias Java e Mono .NET. Autor(2009)
63

Figura 12: Topologia Cliente-Servidor, aplicada nos teste entre as plataformas


Java e Mono. Autor (2009)

6.2 ANALISE DO APLICATIVO COMPARADO

Foi desenvolvido sob cada plataforma, um aplicativo para execução em modo


Console, cujo seu objetivo foi demonstrar o acesso a dados, e alguns conceitos de
orientação a objetos, o qual é característica das linguagens também comparadas. Após o
desenvolvimento foi executado estes, em dois sistemas operacionais distinto afim de
compara-los . O aplicativo consistiu em um CRUD (Create – Retrieve – Update – Delete),
que são as funções principais que um aplicativo que esta acessando dados deve possuir.
Este de forma automática poderia manipular uma quantidade “n” de dados, neste caso em
uma tabela contendo algumas tuplas do tipo inteiro, texto, numérico e data. Os valores
enviado para a base de dados PostgreSQL já eram predefinidos.
Este aplicativo executou uma bateria de 10 testes afim de coletar dados quanto ao
tempo para ser avaliado através de tabelas e gráficos o seu desempenho. Trabalhou se
nesta implementação a questão de chamadas de classes, troca de mensagens entre
métodos, comunicação entre na rede (Cliente-Servidor) e a integração quanto ao sistema
operacional e o hardware.
64

6.2.1 Analise do processo de desenvolvimento prático

6.2.1.1 Das linguagens de programação Java e C#

Das linguagens comparadas as quais foram o Java pertencente a plataforma Java


e o C# sob o Mono .NET Framework, a razão pela qual foi de se escolher estas, é por
estarem embarcadas por padrão sob o ambiente de desenvolvimento e a plataforma em
si.

6.2.1.2 Da maneira de conexão com o banco de dados

No modo de conexão ao banco de dados, referente ao Java utilizou-se o JDBC


com o driver específico para o PostgreSQL .

Ao Mono .NET, foi usado o componente NpgSQL, este por ser o padrão de
utilização no Mono para a conexão com o PostgreSQL.

6.3 BANCO DE DADOS UTILIZADO

6.3.1 PostgreSQL

Conforme GONZAGA (2007), o PostgreSQL é um gerenciador de banco de dados


objeto-relacional (ORDBMS) de código aberto, descendente do Postgres versão 4.2,
desenvolvido na universidade da Califórnia em Berkely. O PostgreSQL é robusto,
confiável, rico em recursos, implementa características de orientação a objetos e suporta
grande parte do SQL:2003.

6.3.2 Analise no processo de teste quanto ao banco de dados

Foi criado um banco de dados no PostgreSQL, neste caso foi manipulado apenas
uma tabela, esta contendo 6 tuplas, de tipos diversos, afim de testar as tecnologias
65

estudadas. O comparativo não foi focado no banco mais sim na tecnologia, para mostrar o
processo de inserção, localização, alteração e remoção, ou seja, demonstrando no
aplicativo um CRUD(Create, Retrieve, Update, Delete). Neste processo pode se testar
tanto o Hardware como a Rede, pois sua execução foi feita da maneira Cliente/Servidor,
seja um computador com o Gerenciador de Banco de dados PostgreSQL e outro
computador servindo de Cliente para os testes nas plataformas Java e Mono.

Foi separado o banco de dados do aplicativo, afim de não ser acessado


localmente, a questão do aplicativo não poder acessa-lo de maneira local, resulta o
motivo dos resultados não ficarem instáveis, uma vez que no processo de uma grande
quantia de dados estarem sendo processados no banco e a aplicação estar manipulando
estes dados, havendo um confronto quanto ao uso do hardware e no gerenciamento no
sistema operacional.

6.3.2.1 Do desempenho no acesso a dados

Quanto ao desempenho destes, houve também a influência do sistema operacional


e o gerenciador de banco de dados no lado servidor, ou seja, levando em consideração
na parte de Hardware, configurações na sua otimização e versão da plataforma de
execução. Neste procedimento usou-se configurações padrões definidas já na instalação
do sistema.

6.4 ANALISE DOS AMBIENTES DE DESENVOLVIMENTO UTILIZADOS

No processo de comparação entre as plataformas Java e Mono, foi utilizado as


IDE's Netbeans (Windows/Linux), MonoDevelop (Linux) e o SharpDevelop (Windows)
para desenvolver e compilar os aplicativos a serem analisados. Em geral estes ambientes
atenderam muito bem os requisitos, porém deve se levar em consideração que não foi
desenvolvido algo tão complexo para verificar se algum destes ambientes contivessem
alguma deficiência. Analisando estas 3 IDE's open source, o Netbeans leva uma certa
vantagem em ser multiplataforma assim podendo de maneira facilitada ser compilados
projetos tanto em Windows ou no Linux sem ter de sofrer adaptações ao projeto. Este fato
66

ocorre já de uma maneira parcial nos ambientes Sharp Develop e MonoDevelop. Apesar
do MonoDevelop já estar possuindo versões ainda em testes para o Windows (2009)
tornando o desenvolvimento de um projeto totalmente multiplataforma (lembrando, seu
executável independente da IDE será multiplataforma), este possui algumas falhas nas
quais impossibilita o desenvolvimento de determinados aplicativos neste caso foi no
acesso à instalação de componentes como o NpgSQL, no ambiente Windows, usado no
desenvolvimento dos aplicativos a serem comparados.

Retirando a questão de código aberto e multiplataforma, estão concorrendo frente a


frente o Visual Studio (VS) e o Netbeans, o VS, um ambiente proprietário da Microsoft
como descrito no capítulo 4, quando tratado ao desenvolvimento em Mono .NET ou
Microsoft .NET como é o padrão deste, há grandes projetos esta é a IDE adequada isto é,
caso queira utilizar de uma ferramenta proprietária.

6.4.1 Quanto a produtividade e desempenho nas plataformas Java e Mono .NET

Houve altas e baixas tanto no processo de desenvolvimento seja na tecnologia


Java e Mono .NET, no entanto isso já é algo de se esperar independente da tecnologia
trabalhada. A documentação, além do padrão fornecida nestes ambientes quanto a fontes
externas no adequado entendimento, é o "motor" principal na produção de um software e
isso conteve nos dois ambientes estudados.

6.5 RESULTADOS OBTIDOS NOS TESTES

Conforme aplicativos desenvolvido e executado em sistemas operacionais


distintos, gerou os seguintes resultados, que estão sendo confrontados logo a seguir. Os
valores estão definidos em milissegundo (ms). As seguintes comparações são
executadas:

• O processo de gravação de uma quantia “n” de caracteres por linha, através de um


laço de repetição, para um arquivo comum de texto.

• Um CRUD, demonstrando o processo e inserção, listagem, alteração e remoção.


67

6.5.1 Resultados obtidos no processo de gravação em arquivo texto

Comparativo: Gravação em arquivo. Sistema Operacional Windows 7 x64.


Teste nº Java Mono
Teste de desempenho: Processo de gravação em arquivo.
1 75 20
80
2 44 13
3 37 12 60
Tempo (ms)

4 35 13 40 Java
5 41 12 Mono
6 35 13 20
7 45 13 0
8 41 30 1 2 3 4 5 6 7 8 9 10
9 42 20 Teste nº
10 45 13
Gráfico 1: Resultados obtidos no processo de gravação de dados em arquivo,
executados sob o sistema operacional Windows, através do console DOS. Autor
(2009).

Comparativo: Gravação em arquivo. Sistema Operacional open SUSE 11.1 x64 Linux.
Teste nº Java Mono Teste desempenho: Gravação em arquivo
1 62 55
80
2 63 25
3 49 25 60
Tempo (ms)

4 54 24 40 Java
5 52 30 Mono
6 38 29 20
7 47 25 0
8 47 27 1 2 3 4 5 6 7 8 9 10
9 50 25
Teste nº
10 47 29
Figura 13: Resultados obtidos no processo de gravação de dados em arquivo,
executados sob o sistema operacional Linux, através do gnome-terminal. Autor (2009).
68

6.5.2 Comparativo: CRUD. Testes efetuados no Sistema Operacional Windows.

Gráfico 2: Gráfico demonstrando e comparando o desempenho no processo de


inserção em uma bateria de 10 testes, a cada teste 10000 inseridos um a um. Teste
efetuado sob o sistema operacional Windows. Autor(2009).

Gráfico 3: Gráfico demonstrando e comparando o desempenho no processo de


listagem, também entendido como localização em uma bateria de 10 testes, a cada
teste 10000 listados. Teste efetuado sob o sistema operacional Windows.
Autor(2009).
69

Gráfico 4: Gráfico demonstrando e comparando o desempenho no processo de


alteração em uma bateria de 10 testes, a cada teste 10000 alterados um a um.
Teste efetuado sob o sistema operacional Windows. Autor(2009).

Gráfico 5: Gráfico demonstrando e comparando o desempenho no processo de


remoção em uma bateria de 10 testes, a cada teste 10000 removidos um a um.
Teste efetuado sob o sistema operacional Windows. Autor(2009).
70

6.5.3 Comparativo: CRUD. Testes efetuados no Sistema Operacional LINUX

Gráfico 6: Gráfico demonstrando e comparando o desempenho no processo de


inserção em uma bateria de 10 testes, a cada teste 10000 inseridos um a um. Teste
efetuado sob o sistema operacional Linux. Autor(2009).

Gráfico 7: Gráfico demonstrando e comparando o desempenho no processo de


listagem ou também considerado com uma localização em uma bateria de 10 testes,
a cada teste 10000 registros foram listados em modo console. Teste efetuado sob o
sistema operacional Linux. Autor(2009).
71

Gráfico 8: Gráfico demonstrando e comparando o desempenho no processo de


alteração em uma bateria de 10 testes, a cada teste 10000 registros alterados um a
um. Teste efetuado sob o sistema operacional Linux. Autor(2009).

Gráfico 9: Gráfico demonstrando e comparando o desempenho no processo de


remoção em uma bateria de 10 testes, a cada teste 10000 registros removidos um a
um. Teste efetuado sob o sistema operacional Linux. Autor(2009).
72

6.6 DOS APLICATIVOS COMPARADOS.

Primeiramente foi compilado um programa sob cada tecnologia demonstrando um


conjunto de laços de repetição o qual inseria uma certa quantidade de caracteres para um
arquivo de texto. Referente aos resultados: o tempo do Java em relação ao Mono era o
dobro. Até este ponto podê se ter uma comprovação dos vários mitos que são relatados
do Java quanto ao seu desempenho, assim tornando-o quase reais.

Porém quando se desenvolveu um aplicativo, demonstrando um CRUD este de


forma automatizada, interligado num gerenciador de banco de dados PostgreSQL,
contendo uma tabela com colunas possuindo alguns certos tipos de dados. Este aplicativo
também mostrava o processo de troca de mensagem entre métodos, chamadas de
classes e comunicação em rede. Analisando as características contida nas duas
tecnologias. Conforme gráficos e tabelas de valores demonstrados anteriormente (tempo
em milissegundo (ms)) o Java teve uma certa vantagem nos processos de Inserção,
Alteração e Remoção quanto ao Mono .NET, apenas perdendo na amostragem dos dados
no ambiente Windows, agora neste ponto ficou unanime a questão quanto a lentidão do
Java. Em proporção, quanto a estes resultados obtidos, um software executado sob estas
plataformas quanto mais complexo ele for, mais tenderá quanto ao desempenho para
ambas as partes, isso serve de base para softwares executados sob maquinas virtuais,
como neste caso, ou para execução nativa. Outro fator levantado é a influência do
sistema operacional sob a plataforma de execução, como notado no comparativo de
listagem a uma variação do Windows para o Linux quanto ao desempenho do Java.

O objetivo destes aplicativos não era otimiza-los em nenhuma circunstância, assim


mostrando o verdadeiro desempenho de maneira geral, o que cada tecnologia oferecia,
nesta circunstância.

6.7 DOS SISTEMAS OPERACIONAIS USADOS NOS TESTES

Em relação aos sistemas operacionais executados, seja, analisando seu


desempenho, houve algumas diferenças entre o Linux e Windows, esta diferença foi
quanto sua estabilidade. Enquanto o Windows ocorreu alguns picos quanto ao tempo de
73

execução o Linux não sofreu nenhuma grande variação mantendo quase constante sua
velocidade. Tanto o sistema operacional Windows XP e Ubuntu, sua instalação era
“limpa”, ou seja, nenhum aplicativo a mais que não fosse a maquina virtual Java e o .NET
Framework, e é claro o sistema operacional (obvio).

Também pode ser levado em consideração ao hardware, o qual detinha o sistema.


Conforme gráficos mostrados houve picos que ocorreram em ambas as partes e no
Windows com uma alta variação, isso se deve ao fato, da maneira que o sistema gerencia
os processos.

Quanto aos sistemas operacionais openSUSE e Windows 7 foram apenas testados


a integração de projeto e sua execução, ou seja, verificando a compatibilidade e sua
questão multiplataforma.

Seus resultados. Houve total compatibilidade tanto no Java quanto o Mono .NET
nestes sistemas operacionais e é claro quanto aos que foram usados no processo de
comparação de desempenho. No Windows foi testado a execução do programa também
sobre a maquina virtual Microsoft .NET afim verificar a compatibilidade entre plataformas,
apesar do Mono ter surgido da Microsoft .NET.

6.8 COMPARATIVO GERAL ENTRE AS PLATAFORMAS JAVA E MONO .NET


FRAMEWORK

6.8.1 Analise dos tipos de dados das linguagens Java e C#

Conforme Tabela 1, esta demonstra algumas similaridades como também algumas


diferenças entre as linguagens Java e C#, que são padrões das tecnologias estudadas.

Há diferença, e em alguns casos muita, quando então analisado um grande bloco


de código fonte implementado sob estas linguagens. No caso da implementação efetuada
para se obter os testes (em anexo), tentou se manter compatibilidade uma com a outra,
quanto as regras e padrões oferecidos para cada linguagem. O que diferenciou foi a
sintaxe de código pois o principio foi o mesmo, a parte mais notável foi a forma tratada na
comunicação com a base de dados.
74

Equivalência comparativa de alguns tipos de dados, entre as


linguagens Java e C#
Java C# Java C#
abstract abstract interface interface
extends : instanceof is
super base synchronized lock
Boolean bool long long
break break package namespace
case case new new
catch catch private private
char char protected protected
class class public public
const* const return return
final const/readonly byte sbyte
continue continue short short
default default static static
do do String string
double double switch switch
else else this this
native extern throw throw
float float import using
goto goto void void
if if volatile volatile
int int while while

Tabela 1: Equivalência entre alguns tipos de dados das


linguagens Java e C#. MOK (2003, adaptado).

6.8.2 Analise dos ambientes de desenvolvimento

Analise dos ambientes de desenvolvimento quanto as plataformas suportadas e Licença.


Plataforma Ambiente Plataforma Licença
Mono .NET SharpDevelop Windows Livre
Mono .NET MonoDevelop Linux / Windows / Solaris Livre
Mono .NET X-Develop Linux / Windows Proprietária / Grátis (Versão Trial)
Mono .NET Visual Studio Windows Proprietária / Grátis (Versão Express)
JAVA / .NET Eclipse Linux / Windows / Solaris Livre
JAVA Netbeans Linux / Windows / Solaris Livre
Mono .NET DelphiPrism(Plugin VS) Windows / MAC OS Proprietária / Grátis (Versão Trial)
Tabela 2: Analise comparativa das IDE's. Plataforma (S.O. suportado) e Licença.
Autor (2009)
Na tabela abaixo esta sendo verificado alguns ambientes de desenvolvimento,
analisando a questão de sistema operacional suportado, e licença de uso. Nota se que
pode ser usado tanto para a plataforma Mono ou Java ferramentas open source,
diminuindo custos no processo de desenvolvimento de software.
75

6.8.3 Aspectos gerais das plataformas estudadas

Conforme Tabela 3, esta demonstrando de uma forma geral, alguns fatores em


comum que cada plataforma possui, e alguns pontos que o diferenciam.

Aspectos gerais entre as tecnologias MONO e Java


Suporte para a Plataforma JAVA MONO
Portabilidade de Plataforma Multi Plataforma Multi Plataforma
Linguagens de programação Multi Linguagem Multi Lingauagem
Orientação a Objetos Linguagens O.O. Linguagens O.O.
Normalização JCP ECMA
Licença GPL 2 / CDDL GPL 2 / MIT x11
Compilação e Excução do
Código JVM CLR
Código intermédiario Bytecode CIL (IL)
Identificação do executável .class .exe / .dll
IDE possui. possui.
Mobilidade possui. possui.
Suporte WEB JSP ASP.NET
ADO.NET / Componentes
Acesso a dados JDBC terceirizados
Fornecedor Sun Microsystems Novell (Ximian)
Preço Livre. Livre.

Tabela 3: Aspectos gerais que demonstram algumas similaridades e


diferenças, para o Java e o Mono .NET. Autor (2009)
76

6.8.4 Analise conceitual das licenças utilizadas

Comparativo: Licenças de uso, utilizadas pelas tecnologias estudadas


Java Mono
GPLv2
GPL: GNU Public License, Gnu is not Unix - (GNU), é uma licença que pretende garantir sua liberdade de
compartilhar e alterar o software livre, sempre com o objetivo de melhorá-lo. Esta Licença Pública Geral
aplica-se à maioria dos softwares da Free Software Foundation e a qualquer outro programa cujo autor
decida aplicá-la. Tal fundação, criada em 1984, faz a fiscalização do uso dos produtos de código aberto e
desenvolveu os parâmetros que definem o software livre e as quatro liberdades que o caracterizam, que são:
* uso pessoal, acadêmico ou comercial;
* distribuição, que permite fazer cópias e distribuí-las;
* estudo ou alteração, adequação do software para alguma necessidade específica;
* distribuição das alterações.
Popular no mundo do código aberto, a GPL foi criada em 1989, e revisada para GPLv2 em 1991.
De forma implícita a GPLv2 proibi, distribuir software e depois limitar seus usos através de patentes nele
implementadas em uma restrição adicional.
* Library GPL (LGPL): é uma variação da licença GPL que permite o desenvolvimento de programas de
código aberto que contenham módulos proprietários.
CDDL MIT x11
Criada pela Sun, é uma licença de código aberto Esta licença também denominada licença X ou licença
que utilizou a Mozilla Public License (MPL) e a X11, foi desenvolvida pelo Massachusetts Institute of
tornou reutilizável sem modificações, criando uma Technology (MIT). É uma licença não copyleft utilizada
licença copyleft que fornece proteções e liberdade em software livre, que permite a reutilização de
nos ambientes de código aberto e permite a criação software licenciado em programas livres ou
de trabalhos mais amplos para objetivos comerciais. proprietários.
Esta licença mantém todas as características da A permissão é concedida, a título gratuito, para
MPL e apresenta várias melhorias, tais como: a qualquer pessoa que obtenha uma cópia deste
definição de modificações para melhor compreensão software e documentações associadas (o "Software"),
da cobertura da licença, detalhes sobre a escolha para tratar com o Software sem restrição, incluindo,
da lei, foro e jurisdição. Também foi colocada a sem limitação, os direitos para usar, copiar, modificar,
opção de tornar o software coberto disponível sob mesclar, publicar, distribuir, sublicenciar e / ou vender
uma licença especifica. cópias do Software.
GARANTIAS
Abrangido, o software é fornecido sob esta licença
"como está", sem garantia de qualquer tipo,
O software é fornecido "como está", sem garantia de
expressa ou implícita, incluindo, sem limitações,
qualquer tipo, expressa ou implícitas, incluindo mas
garantias de que o coberto software é livre de
não se limitando às garantias de comercialização,
defeitos, comercialmente, de acordo para um
adequação a um determinado propósito e não infração.
determinado fim ou não infração. todo o risco quanto
em nenhum caso a detentores autores ou ser
à qualidade e desempenho do software coberto está
responsabilizados por qualquer reivindicação, dano ou
com você. se algum software coberto provar
outras responsabilidade, seja em uma ação de
defeituoso em qualquer aspecto, você (não o
cumprimento de contrato ou de outra forma,
desenvolvedor inicial ou qualquer outro colaborador)
decorrentes, fora de ou em conexão com o software
assume os custos de qualquer serviço necessário,
ou o uso ou outros em negociações o software.
reparo ou correção. esta isenção de garantia
constitui uma parte essencial desta licença.
A CDDL é uma licença de código aberto aprovada MIT x11 é uma licença de código aberto aprovada pela
pela Open Source Initiative (OSI). Open Source Initiative (OSI).

Tabela 4: Analise comparativa das licenças utilizadas por cada tecnologia. OSI (2009,
adaptado)
77

CAPITULO VI

7 CONCLUSÃO

Conclui se neste trabalho que as tecnologias Java e Mono .NET Framework possui
o mesmo objetivo e apresentam certas semelhanças em si.

Tanto o Mono .NET quanto o Java, estão disponíveis em vários sistemas


operacionais, ou seja, são ambientes multiplataforma, assim um aplicativo desenvolvido
sob um determinado sistema operacional poderá ser executado sobre outro distinto desde
que tenha a maquina virtual disponível sobre este.

Quanto as linguagens de programação Java e C#, estas possuem o paradigma


orientado a objeto originado do C++, por este motivo nota se uma certa compatibilidade
entre elas. Tendo conhecimento sob uma destas linguagens, seja Java ou C#, já não se
torna tão complexo o entendimento da outra a ser implementada, o que ira mudar será
apenas a sintaxe do código a qual é normatizado pela tecnologia detentora.

Outras linguagens são suportadas tanto para plataforma Java e Mono .NET, esta
ideia multilinguagem em teoria vem da pioneira Microsoft com a plataforma .NET,
oferecendo suporte ao C# (padrão), F#, VB.NET, IronRuby, IronPython, Object Pascal,
etc. A plataforma Mono herda também estas características. A tecnologia Java em
principio apenas suportava o Java (linguagem), hoje este já fornece suporte a linguagem
Groovy, JRuby, Jython entre algumas mais que estão por suportar.

O que mostra no termo multilinguagem suportado entre as tecnologias estudas, é a


questão da não influencia da linguagem de programação sob o desempenho do aplicativo,
uma vez que compilado, independente da linguagem utilizada é gerado um código
intermediário que será interpretado pelo JIT compiler contido na maquina virtual JVM
(Java) ou no CLR (Mono .NET).

A questão multilinguagem apenas oferece uma facilidade quanto aos


desenvolvedores vindos de outras linguagens, podendo por um determinado tempo
desenvolver com a linguagem que melhor se adéqua. Porém é mais aconselhável
aprender e desenvolver com as linguagens padrões ou nativas da plataforma, ou seja,
estas oferecem uma melhor integridade e suporte para com a plataforma.
78

As tecnologias são semelhantes em alguns aspectos como a estrutura da maquina


virtual que contém os mesmos conceitos para um código intermediário sendo que no Java
é um Bytecode, e no Mono um Intermediate Language.

A tecnologia Mono é originada da Microsoft .NET, suas características a que


diferem porém não perdendo compatibilidade, é ser open source, multiplataforma e tendo
integrado outros componentes de terceiros.

Um beneficio importante vinculado ao Java e Mono .NET é de serem open source,


ou seja, serem livres, assim o desenvolvedor poderá utilizar estas plataformas sem a
necessidade do pagamento dos royalties a empresa detentora. Esta é uma grande
vantagem nos dias de hoje (2009), e algo que esta cada vez mais se difundindo no
mercado de softwares, onde o que se vende é o serviço e não o produto dependo da
licença a ser utilizado.

No desenvolvimento de software, ambas as tecnologias disponham de IDE's, capaz


de atender o que a plataforma oferece, algumas contenham mais interatividade em seu
modo visual enquanto outras menos, porém sua tendência a cada dia é dispor destas
novas melhorias conforme novas versões lançadas no mercado. Neste estudo foi utilizado
o Netbeans para o Java, por ser de fácil instalação e multiplataforma. Para o Mono .NET
utilizou-se o #Develop no Windows e o MonoDevelop no Linux, apesar deste ultimo já
estar disponível em versões de teste para o sistema operacional Windows, ainda possui
algumas falhas que impedem a produtividade no desenvolvimento. Utilizou-se destes
ambientes por serem open source, possuírem uma boa documentação, serem conhecidos
na área de programação e por escolha do Autor, conforme linha de pesquisa.

No processo de desenvolvimento de software, a escolha de uma IDE relacionada a


plataforma sob a qual sera implementada, vai variar da cultura da equipe de trabalho, ou
seja, será escolhida a que melhor atenda os requisitos para o sistema.

Nota-se no trabalho prático que houve certa vantagem do Java sobre o Mono .NET,
no processo de Inserção, Alteração e Remoção, tendo quase o dobro de tempo a menos
que o Mono quando manipulado aquela quantia "n" de registros, isto nos dois sistemas
operacionais comparados. Já no processo de Seleção ou listagem no Linux, manteve-se a
faixa de tempo entre estas plataformas uma variação minima entre uma e outra não
havendo muita diferença. Já no Windows, o Mono .NET teve uma forte vantagem em
relação ao Java na listagem em modo Console. O que pode verificar neste fato é a
79

integração que se tem entre a tecnologia comparada e o sistema operacional em si. O


Windows por ser baseado em .NET tende a ter um melhor desempenho para os
aplicativos executados sob a plataforma Mono ou Microsoft .NET como foi o caso
ocorrido, apenas no processo de amostragem dos dados.

Esta analise quantitativa consistiu em obter resultados através da manipulação de


registros no Banco de Dados, a ser chegado em parte de uma conclusão, para este
trabalho, pois vale lembrar, que foi utilizado versões específicas das plataformas no
processo de comparação, conforme disponibilizadas pela empresa detentora, (2º
semestre de 2009). Por serem tecnologias open source, novas versões contendo
melhorias e correções, são disponibilizadas em um curto intervalo de tempo, assim como
estes resultados obtidos poderão sofrer variações num futuro próximo.

A influencia do banco de dados, persistiu na rede de forma igualitária para ambos


aplicativos, e a influencia do desempenho também interferiu no modo que o componente
de acesso a dados intervia sob o sistema. O gerenciador de banco de dados PostgreSQL,
atendeu os requisitos propostos neste processo comparativo. Dos componentes de
acesso o JDBC na plataforma Java, em analise teórica é mais prático ser modificado para
funcionar sob outra base de dados sem sofrer grandes modificações, pois é apenas
alterado o driver de conexão com o banco, havendo alguns casos de alteração nas
instruções SQL. Enquanto no Mono .NET através do NpgSQL, o qual é um componente
especifico para acesso ao PostgreSQL, não haverá esta facilidade, tendo que além da
alteração do componente, a modificação do código fonte.

O comparativo se baseou em um aplicativo desenvolvido para ser executado em


modo Console, não contendo um visual gráfico. Os resultados serviram como parte da
base para analise considerativa deste trabalho, em específico, de maneira geral para esta
implementação a ser comparado. Pois existe diversos produtos específicos com as
mesmas finalidades integrados a estas tecnologias que tendem a possuir um melhor
funcionamento uma do que a outra em um processo comparativo.

Há um futuro promissor para estas tecnologias pois as empresas detentoras como


a Sun Microsystems (Java) e a Novell (Mono) em conjunto com a comunidade open
source, a cada dia, estão implementando novas melhorias e funcionalidades a ser
incorporada sob a plataforma.
80

Como pode ser observado, cada tecnologia apresenta suas vantagens e


desvantagem. Porém isto é tratado como uma questão de cultura definida pelo time de
desenvolvimento em uma organização, pois estas tecnologias seguem a mesma
tendencia.

7.1 SUGESTÃO PARA TRABALHOS FUTUROS

Estudos que podem ser vinculados a este trabalho:

• Usar estes mesmos critérios de analise, desenvolvendo um comparativo quanto ao


desenvolvimento para Web utilizando das tecnologias Java e Mono .NET
Framework.

• Desenvolver um estudo sobre dispositivos móveis utilizando se destas plataformas,


como também analisar o nicho de mercado abrangido sob cada uma.

• Fazer uma analise de softwares empresariais implementados sob as plataformas


Java e Mono. Exemplo de softwares gestores Enterprise Resource Planning (ERP)
open source utilizando destas tecnologias: Freedom ERP (Java), Adempiere
(Java), Nmwerp(Mono), Nibble ERP (Mono).

• Estudo aprofundado na segurança dos aplicativos executados sob estas


plataformas estudada, seja comparando a questão de aplicativos executados
nativamente ou sob maquinas virtuais.

• Elaborar um comparativo, estudando e analisando Web Services e servidores de


componentes vinculado, as tecnologias estudadas.
81

REFERENCIAS

BAGNALL, Brian; CHEN, Philip; GOLDBERG, Stephen. C# for Java Programmers.


Rockland : Syngress Publishing, Inc., 2002.
BARNABY, Tom. Distributed .NET Programming in C#. New York, NY : Apress, 2002.
BEYER, Derek. C# COM+ Programing. New York, NY : M&T Books, 2001.
BILL ,Robert W. Jython for Java Programmers. Indianopolis IN : New Riders Publishing.
2001.
BINI, Ola. Practical JRuby on Rails Web 2.0 Projects: Bringing Ruby on Rails to the
Java Platform. New York, NY : Apress, 2007.
BORNSTEIN Niel M. e DUMBILL Edd, Mono: Developer's Notebook. Sebastopol, CA :
O'Reilly Media, Inc., 2004.
BRILL, Gregory. CodeNotes for J2EE, JDBC, JSP and Servlets. ed.2. New York, NY :
Random House, 2001.
BURD, Barry. Beginning with Java for Dummies. ed.2. Indianópolis, IN : Wiley
Publishing, 2005.
Deitel H. M. e Deitel P. J. / trad. Lisbôa Carlos Arthur Lang, Java como programar. 4.ed.
Porto Alegre, RS : BOOKMAN Companhia Editora, 2003.
Dummies, C# 2005 For Dummies. Indianapolis, IN : Wiley Publishing, 2006.
ENGEL, Joshua. Programming for the Java Virtual Machine. Boston, MA : Addison
Wesley, Pearson Education, Inc., 1999.
FERGUSON, Jeff [et al.]. C# Bible. Indianapolis, IN : Wiley Publishing, Inc., 2002.
GAMMA, Erich, BECK, Kent. Contributing to Eclipse: Principles, Patterns, and Plug-
Ins. Boston, MA : Addison Wesley, Pearson Education, Inc., 2003.
GONZAGA, Jorge Luiz. Dominando o PostgreSQL. Rio de Janeiro : Ciência Moderna,
2007.
GOSLING, James e Henry McGilton, White Paper The Java Language Environment:
Contents. Sun Microsystems, Inc., 1996.
GOSLING, James; JOY, Bill; STEELE, Guy; BRACHA, Gilad. Java Language
Specification. ed.3. Santa Clara, California : Addison Wesley Professional, Pearson
Education, Inc., 2005.
LENZ, Gunther; MOELLER, Thomas. .NET-A Complete Development Cycle. Boston, MA
: Addison Wesley, Pearson Education, Inc., 2003.
LIBERT, Jesse. Visual C# 2005: A Developer's Notebook. Sebastopol, CA : O'Reilly
Media, Inc., 2005.
LIBERTY, Jesse. Programming C#, ed.3. Sebastopol, CA : O'Reilly, 2003.
LIBERTY, Jesse. Programming C#. ed.2. Sebastopol, CA : O'Reilly Media, Inc., 2002.
LIMA, Alexandre Rocha e Marcondes. Mono: .NET Framework. Revista Inform, São
Paulo, n. 4, p. 16-26, 2006.
82

MAMONE, Mark. Practical Mono. New York, NY : Apress, 2006.


MATTHEW, Neil; STONES, Richard. Beginning Databases with PostgreSQL From
Novice to Professional. 2.ed. New York, NY : Apress, 2005.
MCLEAN, Scott; NAFTEL, James; WILLIAMS, Kim. Microsoft .NET Remoting,
Washington : Microsoft Press, 2002.
MEYER, Jon; DOWNING, Troy. Java Virtual Machine. Sebastopol, CA : O'Reilly
Associates., 1999.
Microsoft Developer Network, MSDN. Biblioteca MSDN, Online. Disponível em:
http://msdn.microsoft.com/pt-br/library/default.aspx. Acesso em: 17 de Março de 2009.
MOK, Heng Ngee. From Java to C#: A Developer's Guide. Boston, MA : Addison
Wesley, Pearson Education, Inc., 2003.
MOREIRA, Rodrigo e BOTTCHER, Eduardo. Acesso a dados com C#. Revista Inform,
São Paulo, n. 1, p. 12-16, 2005.
NANTZ, Brian. Open Source .NET Development. Boston, MA : Prentice Hall PTR, 2004
PARGA, Danielle Fernandes. Introdução a Java Parte 1. Revista Inform, São Paulo, n. 1,
p. 30-37, out. 2005.
OSI, Open Source Initiative. GPL, MPL, CDDL, MIT. Online. Disponível em:
http://www.opensource.org. Acesso em: 10 de Novembro de 2009.
PUVVALA, Jawahar; POTA, Alok. .NET for Java Developers: Migrating to C#. Boston,
MA: Addison Wesley, Pearson Education, Inc., 2003.
RAMMER, Ingo. Advanced .NET Remoting. New York, NY : Apress, 2002.
RODRIGUES, Laercio Guerço. Garbage Collector, Gerenciando recursos de memória.
Revista Inform, São Paulo, n. 4, p. 10-11, 2006.
SIMMONS, Robert. Hardcore Java. Sebastopol, CA : O'Reilly Media, Inc., 2004.
SOARES, Marcos. Fundamentos do Framework .NET. Revista Inform, São Paulo, n. 1,
p. 6-9, out. 2005.
Sun Microsystems, Inc., Java Technology: The Early Years. Online. Disponível em:
http://java.sun.com/features/1998/05/birthday.html. Acesso em: 15 de Março de 2009.
Sun Microsystems, Inc., JavaTM 2 SDK, Standard Edition - Documentation. Online.
Disponível em: http://java.sun.com/j2se/1.4.2/docs/index.html. Acesso em: 17 de Março de
2009.
Sun Microsystems, Inc., The Java Language Environment: Contents. Online.
Disponível em: http://java.sun.com/docs/white/langenv/index.html. Acesso em: 15 de
Março de 2009.
SYME, Don; GRANICZ, Adam e CISTERNINO, Antonio. Expert F#. New York, NY :
Apress, 2007.
THOMAS, Todd M. Java Data Access JDBC, JNDI, and JAXP. New York, NY : M&T
Books, 2002.
TROELSEN, Andrew. C# and the .NET Platform. New York, NY : Apress, 2001.
VENNERS, Bill. Inside the Java Virtual Machine. Sunnyvale, California : McGraw-Hill
Companies, Inc., 1997.
83

WATSON, Karli [et al.]. Beginning Visual C# 2005. Indianapolis, IN : Wiley Publishing,
Inc., 2006.
WESLEY, Addison. .NET Complete Development Cycle. Boston, MA : Pearson
Education, Inc., 2003.
WESLEY, Addison. .NET for Java developers migrating to C#. Boston, MA : Pearson
Education, Inc., 2004.
ZUKOWSKI, John. Java 6 Platform Revealed. New York, NY : Apress, 2006.
84

APÊNDICE A

Algoritmo exemplo C#

Algoritmo exemplo Java


85

Algoritmo JAVA demonstrando um laço de repetição e gravação em arquivo


86

Algoritmo C# demonstrando um laço de repetição e gravação em arquivo


87

APÊNDICE B – Código fonte do aplicativo utilizando um CRUD no acesso a


dados

Código fonte da tabela utilizada no comparativo

Figura 14: Script SQL da tabela, utilizado no comparativo. Autor (2009)

Dados inseridos na tabela

Figura 15: Dados inseridos no banco. Autor (2009)

Código fonte: Projeto. CRUD-Java-Java-JDBC – JAVA


...

Código fonte: Projeto. CRUD-Mono-CSharp-NpgSQL – Mono .NET Framework


...
012344506789
99248 79546682405665665042 247
9287 86
66 87!"#!9!79$!9!%&&'!%&1&(
)*+,-./0.12345262
+*+789:
+*+;<=<
+*+>./?@A+5-B+C4DECF
+*+G./HIJKA+5-B+C4DECF
+*+9L.3.M2NOI+HI+;:P7Q+H-.6B-+1IKLR-BKS3+T4UVDWU45HX04U
+*+Y:ZA+[BLPB2/K+D4\
+*+<?LI-A+:2/.B3+]0^-IBHB-
+*)
)),20ILB+7I/KI3B
120_2RB 7I/KI3B`
))P.X3.ILB02K+B+732KKBK+?L.3.M2H2K
abcdef 789:g<3LB-28BR.KL-IK`
abcdef 789:g7I/B@2I`
abcdef 789:g:B3BL28BR.KL-IK`
abcdef 789:gY/KB-B8BR.KL-IK`
abcdef 789:g>I023.M28BR.KL-IK`
abcdef 9L.3gZK0-B6B<-S?.6I`
abcdef 9L.3ghBi1I`
abcdef 5262gKS3g8BK?3L]BL`
abcdef 5262gKS3g]j>Z@0B1L.I/`
abcdef 5262g?L.3g]02//B-`
1?X3.0 032KK ,-./0.123 k)):B3.i.L2HI-+l./.0.Im
)):B032-2+B+./.0.23.M2+V+ZK0-B6B<-S?.6IlmQ44
1-.62LB KL2L.0 ZK0-B6B<-S?.6I ZK0 n opq ZK0-B6B<-S?.6Irs`
)):B032-2+B+./.0.23.M2+V+hBi1IlmQ44
1-.62LB KL2L.0 hBi1I hi1 n opq hBi1Irs`
))tuLIHI+1-./0.12344
1?X3.0 KL2L.0 6I.H i2./r]L-./Rvw 2-RKs k
fex k
]yKLBigI?Lg1-./L3/rzhZ]hZ+;<=<zs`))ZK0-B6B+12-2+I+7I/KI3B4
ZK0gBK0-B6B-rzhZ]hZ+;<=<zs`
))ZK0-B6B+12-2+I+<-S?.6I4
)*+7I/{.R?-2+0I/B@OI+0Ii+I+P2/0I+HB+:2HIK4
+++++++++++++*+>|+2+S?2/L.H2HB+HB+-BR.KL-IK+2+KB-Bi+i2/.1?32HIK4
+++++++++++++*+8BiI6B+H2HIK+B@.KLB/LBK+/I+P2/0IQ+02KI+LB/^24
+++++++++++++*+Y/.0.2+32NI+HB+-B1BL.NOIQ+B@B0?L2/HI+IK+-B{B-.HIK+hBKLBK44
+++++++++++++*)
7I/{:Prs`
]yKLBigI?Lg1-./Lrzj9<[hY:<:Z+:Z+8Z}Y]h8~]+z 
z<+]Z8Zt+t<[Y,9><:~]Azs`
]02//B- 3B.L?-2 n opq ]02//B-r]yKLBig./s`
./L jLH n Y/LBRB-g12-KBY/Lr3B.L?-2g/B@L>./Brss`
ZK0gBK0-B6B-rzj9<[hY:<:Z+:Z+8Z}Y]h8~]+<+]Z8Zt+t<[Y,9><:~]A+z€
]L-./Rg623?B~{rjLHss`
ZK0gBK0-B6B-rzhZt,~+,Z87~88Y:~A+tY>Y]Z}9[:~+liKmzs`
:B3BL28BR.KL-IK H n opq :B3BL28BR.KL-IKrs`
Hg:B3BL2-EL?HIrs`
H n o‚‚`
ƒde r./L LBKL n C` LBKL „n CW` LBKLs k
]yKLBigI?Lg1-./L3/rzhZ]hZ+[9tZ8~A+z 
]L-./Rg623?B~{rLBKLss`
…†…
012344506789
99248 79546682405665665042 247
9287 86
66 87!"#!9!79$!9!%&&'!%&1&(
)*+,-*+.-/-.012)32)4567)89:41; 3<.=>?,/@AB-9C0<-*<DDE
FFG.H+-**H4I-4=>*-.JKHLL
3M*<-N,HB<,O.=><A>01P53)8QR9LLL1DE
2NO,*-<2-NOHP>=+=@A03M*<-N,+B..-><2=N-7=AA=*0DDE
P>*-.-8-?=*<.H* = S TUV P>*-.-8-?=*<.H*0DE
=,P>*-.-8-?=*<.H0W<IDE
2NO,*-<2-NOHX=>@A03M*<-N,+B..-><2=N-7=AA=*0DDE
)*+,-*+.-/-.01YP53)8P5Z948)[P3289\1; 3<.=>?,/@AB-9C0
2NO,?-<2-NOHG-.+H..=IH0DDDE
FFG.H+-**H4I-4]=*<@?-NLL
3M*<-N,HB<,O.=><A>01]P32^[)74F4]9_^]P`^QR9LLL1DE
2NO,*-<2-NOHP>=+=@A03M*<-N,+B..-><2=N-7=AA=*0DDE
]=*<@.8-?=*<.H*0DE
2NO,*-<2-NOHX=>@A03M*<-N,+B..-><2=N-7=AA=*0DDE
)*+,-*+.-/-.01Y]P32^[)74Z)48)[P3289\1; 3<.=>?,/@AB-9C0
2NO,?-<2-NOHG-.+H..=IH0DDDE
FFG.H+-**H4I-4@A<-.@JKHLL
3M*<-N,HB<,O.=><A>01^]2)8^QR9LLL1DE
2NO,*-<2-NOHP>=+=@A03M*<-N,+B..-><2=N-7=AA=*0DDE
^A<-.@8-?=*<.H* @ S TUV ^A<-.@8-?=*<.H*0DE
@,^A<-.@8-?=*<.H0W<IDE
2NO,*-<2-NOHX=>@A03M*<-N,+B..-><2=N-7=AA=*0DDE
)*+,-*+.-/-.01Y^]2)8^5Z948)[P3289\1; 3<.=>?,/@AB-9C0
2NO,?-<2-NOHG-.+H..=IH0DDDE
FFG.H+-**H4I-4.-NHJKHLL
3M*<-N,HB<,O.=><A>018)79QR9LLL1DE
2NO,*-<2-NOHP>=+=@A03M*<-N,+B..-><2=N-7=AA=*0DDE
I S TUV Z-A-<@8-?=*<.H*0DE
I,Z-A-<@8-?=*<.H0W<IDE
2NO,*-<2-NOHX=>@A03M*<-N,+B..-><2=N-7=AA=*0DDE
)*+,-*+.-/-.01Y8)79a)5Z948)[P3289\1; 3<.=>?,/@AB-9C0
2NO,?-<2-NOHG-.+H..=IH0DDDE
bFFX=>@A=c@4A@JH4I-4.-O-<=JKHLL
3M*<-N,HB<,O.=><A>012)32)4_95_]6dZ9e1DE
)*+,-*+.-/-.012)32)4_95_]6dZ9e1DE
b fghfi 0)j+-O<=H> -jD kFF)j+-JKH4+@*H4H+H..@4@A?BN4-..HLL
3M*<-N,HB<,O.=><A>0-j,<H3<.=>?0DDE
b lmTgnno kFFWB@>IH4C=>@A=c@IH4p4+q@N@IH4H4Np<HIH4_AH*-rstLL
_AH*-0DE
b
b
FF7p<HIH4u4_H>C=?B.@JKH4O@.@4+H>-j@H4+HN4H4v@>+H4I-4Z@IH*L
OBwA=+ *<@<=+ wHHA-@> _H>CZv0D hixyVz )j+-O<=H> k
3+@>>-. A-=<B.@ S TUV 3+@>>-.03M*<-N,=>DE
hxo k
3M*<-N,HB<,O.=><A>01G^8^7)28934Z)4_95XP[68^QR941 {
1_97494v^5_94Z)4Z^Z93L1DE
_H>-j@H,*-<Z.=/-.01H.?LOH*<?.-*|ALZ.=/-.1DE
3M*<-N,HB<,O.=><016.A:1DE
_H>-j@H,*-<6.A01}Iw+:OH*<?.-*|A:FF1 { A-=<B.@,>-j<0DDE
FF6.A:4~€LLL~
3M*<-N,HB<,O.=><01GH.<@:1DE
_H>-j@H,*-<GH.<@0A-=<B.@,>-j<0DDEFFGH.<@:4‚ƒ„
3M*<-N,HB<,O.=><01v@>+H4I-4Z@IH*:1DE
_H>-j@H,*-<Zv0A-=<B.@,>-j<0DDEFFZv:42-*<-
3M*<-N,HB<,O.=><016*B@.=H:1DE
…†…
012344506789
99248 79546682405665665042 247
9287 86
66 87!"#!9!79$!9!%&&'!%&1&(
)*+,-.*/0,1203.45*67,5134./+,-16889::;*01<4,0
=>01,?/*31/;45+16@=,+A.B@89
)*+,-.*/0,1=,+A.67,5134./+,-16889::C;*01<4,0C
DE 6F)*+,-.*/<,1)*+68/50)7*0,G688 H
=>01,?/*31/;45+17+6@)IJKLMINOPQROSST@89
U
VWXYVZ XVYW9
U [\X[] 6=^_K-`,;15*+ ,-8 H
=>01,?/*31/;45+17+6@aO_bONJON)IJKLMISSTNc+@89
X]Vde ZWe K-`,;15*+6,-/1*=145+<6889
U
U
;45f.1, 01.15` f*5G )7*0,68 H
XVg H
)*+,-.*/<,1)*+68/`7*0,689
K0`/<,1h451,468/`7*0,689
U [\X[] 6K-`,;15*+ ,-8 H
,-/;45+1=1.`iP4.`,689
U
U
;45f.1, 01.15` f*5G _501.4j,<5014*068 X]Vdek =^_K-`,;15*+ H
_*`.75l.j,<5014*0 7 m ZWe _*`.75l.j,<5014*0689
j,0371=,1 7501. m 7/_501.<,?689
::K0`4,f,N`*73+.0SSS
EdV 65+1 - m n9
- om 7501./<,1p,1.q.1.68/<,1)*73?+)*3+1689 -rr8 H
=>01,?/*31/;45+16
7501./<,1p,1.q.1.68/<,1)*73?+J.?,6-8/1*2;;,4).0,68
r @c1c1@89
U
=>01,?/*31/;45+17+689
::K0`4,f,Nf.7*4,0SSS
e]DsW 67501./+,-1688 H
EdV 65+1 f m n9
f om 7501./<,1p,1.q.1.68/<,1)*73?+)*3+1689 frr8 H
=>01,?/*31/;45+167501./<,1=145+<6f8 r @tNc1c1N@89
U
=>01,?/*31/;45+17+689
U
U
U::q,75?51.G*4Nuv5?w

xyx
012344506789
99248 79546682405665665042 24024796 66 87!"#!9!79$!9!%&&'!%&1&#
()*+,-./0,123
*)*+4033.*+,-./0,5*6784890:,*-,*;<,2.33,*:.*2,-./=,*2,>*,*?0-2,*:.*@0:,3
*)(
;02A0B. +CD@E
((?8F48,7.203*6784890:0311
GHIJKL M0N0O3P4O+,--.278,-E
GHIJKL M0N0O3P4O@<8N.<Q0-0B.<E
GHIJKL M0N0O3P4ORSTU/2.;78,-E
((+4033.*2,-./0,11
;6F482 24033 +,-./0, V
((@.240<0W=,*:.*N0<8XN.83511
;<8N07. 370782 R7<8-B @<8N.< Y Z[\\E
;<8N07. 370782 R7<8-B D<4 Y Z[\\E
;<8N07. 370782 R7<8-B ],<70 Y Z[\\E
;<8N07. 370782 R7<8-B @? Y Z[\\E
;<8N07. 370782 R7<8-B D360<8, Y Z[\\E
;<8N07. 370782 R7<8-B R.-^0 Y Z[\\E
;<8N07. 370782 +,--.278,- +,- Y Z[\\E
((Q_7,:,3*2,>*`6-W=,*;0<0*3.70<*N04,<.3*;0<0*0
((2,-./=,*2,>*,*F0-2,*:.*:0:,31
;6F482 370782 N,8: 3.7@?aR7<8-B @?b V
+,-./0,O@? Y @?E
c
;6F482 370782 N,8: 3.7@<8N.<aR7<8-B @<8N.<b V
+,-./0,O@<8N.< Y @<8N.<E
c
;6F482 370782 N,8: 3.7],<70aR7<8-B ],<70b V
+,-./0,O],<70 Y ],<70E
c
;6F482 370782 N,8: 3.7R.-^0aR7<8-B R.-^0b V
+,-./0,OR.-^0 Y R.-^0E
c
;6F482 370782 N,8: 3.7D<4aR7<8-B D<4b V
+,-./0,OD<4 Y D<4E
c
;6F482 370782 N,8: 3.7D360<8,aR7<8-B D360<8,b V
+,-./0,OD360<8, Y D360<8,E
c
((Q.7,:,*<.7,<-0-:,*2,-./0,511
;6F482 370782 +,--.278,- B.7+,-ab LdKJef RSTU/2.;78,- V
LKg V
Gh a+,- YY Z[\\b V
+4033O`,<i0>.a@<8N.<bE ((j048:0*:<8N.<*:.*2,-./=,511
((C.7,<-0*;0<0*k+,-k*0*+,-./0,511
+,- Y @<8N.<Q0-0B.<OB.7+,--.278,-aD<4 l mnm l ],<70 l
m(m l @?o D360<8,o R.-^0bE
c
KpL[KZ +,-E
c qrLqd a+4033i,7s,6-:U/2.;78,- 2-`.b V
((C.7,<-0*.370*./2.W=,*;0<0*6>*RSTU/2.;78,-11
LdKJe Zpe RSTU/2.;78,-a2-`.bE
c
c
c
tut
012344506789
99248 79546682405665665042 240240 66 87!"979#9$%%&!&1'%
()*+,-./0121
*)*+31445*+,-.6*7*831445*91:6*;1<1*14*8314454*=>45<5.1?@46*.535A1.1?@46
*)*B@813:C1.1?@4*5*D3A5<1.1?@4/
*)(
((918@A5*+,-.
;18E1F5 +,-.G
((H:I3:@A5814*JA:3:C1?14
KLMNOP 0121Q4R3Q+@>>58A:@>G
KLMNOP 0121Q4R3Q9<5;1<5?SA1A5T5>AG
KLMNOP 0121Q4R3QSUBVW85;A:@>G
KLMNOP 0121Q4R3QSA1A5T5>AG
;JI3:8 83144 +,-. X
((.5831<1YZ@*?5*21<:[25:46//
;<@A58A5? +@>>58A:@> +@>G((+@>5WZ@*8@T*H.//
;<@A58A5? SA1A5T5>A SATG((=>4A<JY\54*SUB*4:T;354//
;<@A58A5? 9<5;1<5?SA1A5T5>A 94ATG((=>4A<JY\54*;1<1T5A<:C1?14//
((]7A@?@*8@>4A<JA@<6//*;JW1>?@*8@>5W1@//
;JI3:8 +,-.^_ X
PO` X
PaKbQ+@> c +@>5W1@QF5A+@>^_G
d efPea ^SUBVW85;A:@> 5W_ X
5WQ;<:>ASA18Eg<185^_G
d
d
d

hih
012344506789
99248 79546682405665665042 2402
9698 66 87!"#!9!79$!9!%&&'!"'1(&
)*+,-./012/345.06578191
+*+:-155/+0/5;6<519/-+;/-1+1-./01=>6+?/+0/345.0657
+*+@+A/0?1?1+?1+:-155/+:2BC
+*)
))D1E6./+:2BC7
;1EF13/ :2BCG
))H4I-46./E15+/+E-155/5+J.4-4K1?157
LMNOPQ 8191R5S-RD0/;10/?T.1./U/<.G
LMNOPQ 8191R5S-RTVWXYE/;.46<G
;JI-4E E-155 ,-./012/345.065 Z[QZ\]^ :2BC _
)*`/.6?6+0/5;6<519/-+;60+1-./010+JU1+SJ1.4?1?/+0/345.065+<6+I1<E6a
+++++*E6<b60U/+;101U/.06+V.?2/345.0657
+++++*)
;JI-4E 964? ,-./012/345.06c4<. V.?2/345.065d _
QPe _
^fNZPRD5.U g ^fNZPR:6<R;0/;10/T.1./U/<.c3/.TE04;.cddG
hOP c4<. Y g iG Y jg V.?2/345.065G Ykkd _
,-./01c^fNZPRD5.Ul YdG
m
m noQnp cTVWXYE/;.46< /Yd _
/YR;04<.T.1EFq01E/cdG
m
m
))2/.60<1+5E04;.a77
;0491./ T.04<3 3/.TE04;.cd _
PZQfP\ rBDC,qX+.1Isti+r k
rTXq+4?u+va+9./Y.6tiu+va+9./Y.6twu+va+9?1.1u+var k
r+9<JU/04E6u+va+9I6-/1<6u+v+r k
r+xyX2X+4?+u+vzrG
m
))T/.1+;101U/.065a+/+1;-4E1+<6+H1<E6+?/+C1?6577
;0491./ 964? ,-./01cD0/;10/?T.1./U/<. D5.Ul 4<. {?d
QpPO|^ TVWXYE/;.46< _
D5.UR5/.{<.cil {?dG
D5.UR5/.T.04<3cwl r1IE?/b3A}8F-U<6;S05.J9~Y}Kiw€‚ƒ„…†trdG
D5.UR5/.T.04<3c€l r1IE?/b3A}8F-U<6;S05.J9~Y}Kiw€‚ƒ„…†trdG
D5.UR5/.C1./cl 8191R5S-RC1./R91-J/‡bcrwtt†itw†rddG
D5.UR5/.C6JI-/c‚l †t†tt7ti k †7‚dG
D5.UR5/.H66-/1<cƒl hoˆ^ZdG
D5.UR5/.{<.c„l {?dG
D5.UR/Y/EJ./B;?1./cdG
m
m

‰Š‰
012344506789
99248 79546682405665665042 240209
9698 66 87!"979#9$%%&!&1'%
()*+,-,./0,123.45367/8/
*)*9-/33,*4,3:5;3/8,-*:,-/*4,<5=>5*?,*4,123.4536
*)*@*A,4?/?/*?/*9-/33,*90B+
*)(
((C/D5.,*90B+6
:/DE/1, 90B+F
((G2H-25.,D/3*,*D-/33,3*I.2-2J/?/36
KLMNOP 7/8/Q3R-QC4,:/4,?S./.,<,;.F
KLMNOP 7/8/Q3R-QSTUVWD,:.25;F
:IH-2D D-/33 +,-,./0,123.453 XYPXZ[\ 90B+ ]
()^,.5?5*4,3:5;3/8,-*:54*?,-,./4*I</*RI/.2?/?,*4,123.453*;5*H/;D5_
*****)D5;`54<,*:/4/<,.45*T.?0,123.4536
*****)(
:IH-2D 852? +,-,./0,123.45a2;. T.?0,123.453b ]
POc ]
\dMXOQC3.< e \dMXOQ95;Q:4,:/4,S./.,<,;.a1,.SD42:.abbF
fNO a2;. W e gF W he T.?0,123.453F Wiib ]
+,-,./a\dMXOQC3.<j WbF
k
k lmPln aSTUVWD,:.25; ,Wb ]
,WQ:42;.S./DEo4/D,abF
k
k
((0,.54;/*3D42:._66
:428/., S.42;1 1,.SD42:.ab ]
OXPdOZ p+VUVoV*q0r^*./Hstg*p i
puvV0V*2?*w*xypF
k
((S,./*:/4/<,.45_*,*/:-2D/*;5*G/;D5*?,*+/?5366
:428/., 852? +,-,./aC4,:/4,?S./.,<,;. C3.<j 2;. z?b
PnON{\ STUVWD,:.25; ]
C3.<Q3,.z;.agj z?bF((S,./*C/4/<,.4566
C3.<Q,W,DI.,B:?/.,abF((|:-2D/*;5*G/;D5*?,*+/?5366
k
((^,.5?5*I.2-2J/?5*:/4/*4,<58,4*.5?53*53*4,123.453*?/*./H,-/*o|Gstg666
:IH-2D 852? +,-,./4s.I?5ab PnON{\ STUVWD,:.25; ]
\dMXOQS.< e \dMXOQ95;QD4,/.,S./.,<,;.abF
S.<Q,W,DI.,B:?/.,ap?,-,.,*`45<*./HstgypbF
k
k

}~}
012344506789
99248 79546682405665665042 240279998 66 87!"#!9!79$!9!%&&'!"'1(&
)*+,-./0/1/23.405.67898
+*+:;8../+0/.<5-.89/;+</;8+3-./0=>5+?/+0/23.405.6
+*+@+A/0?8?8+?8+:;8../+:1BC
+*)
))D8E54/+:1BC6
<8EF82/ :1BCG
))H3I;354/E8.+/+E;8../.+J43;3K8?8.6
LMNOPQ 7898R.S;RD0/<80/?T484/U/-4G
LMNOPQ 7898R.S;RTVWXYE/<435-G
<JI;3E E;8.. ,-./0/1/23.405. Z[QZ\]^ :1BC _
)*`/45?5+0/.<5-.89/;+<50+3-./030+JU8+SJ843?8?/+0/23.405.+-5+I8-E5a
+++++*E5-b50U/+<808U/405+V4?1/23.405.6
+++++*)
<JI;3E 953? ,-./0/1/23.405c3-4 V4?1/23.405.d _
QPe _
^fNZPRD.4U g ^fNZPR:5-R<0/<80/T484/U/-4c2/4TE03<4cddG
hOP c3-4 Y g iG Y jg V4?1/23.405.G Ykkd _
,-./0/c^fNZPRD.4Ul YdG
m
m noQnp cTVWXYE/<435- /Yd _
/YR<03-4T48EFq08E/cdG
m
m
))1/450-8+.E03<4a66
<03984/ T403-2 2/4TE03<4cd _
PZQfP\ r,sTX1q+,sqt+48Iuvi+r k
rw3?a+94/Y45via+94/Y45vxa+9?848a+9-JU/03E5a+9I5;/8-5y+r k
rz{WBXT+r k
rw|a+|a+|a+|a+|a+|yrG
m
))T/48+<808U/405.a+/+8<;3E8+-5+H8-E5+?/+C8?5.66
<03984/ 953? ,-./0/cD0/<80/?T484/U/-4 D.4Ul 3-4 ,?d
QpPO}^ TVWXYE/<435- _
D.4UR./4,-4cil ,?dG
D.4UR./4T403-2cxl r{H:CX~€‚ƒW`stDV1TqBz„…†‡ixˆ‰Š‹ŒŽvrdG
D.4UR./4T403-2cˆl r{H:CX~€‚ƒW`stDV1TqBz„…†‡ixˆ‰Š‹ŒŽvrdG
D.4UR./4C84/c‰l 7898R.S;RC84/R98;J/tbcrxvvŽ‡ii‡xvrddG
D.4UR./4C5JI;/cŠl iŽŽŽvŽ6vŽdG
D.4UR./4H55;/8-c‹l QPfZdG
D.4UR/Y/EJ4/B<?84/cdG
m
m


012344506789
99248 79546682405665665042 2402 6
8698 66 87!"#$"9"79%"9"&''("#(1&(
)*+,-./012/3451678-69:/;/
+*+<0/664+846=->6/;40+=40/+,167/54?+-@+,-./012/AB-+C4+8451678-69
+*+D+E48C/C/+C/+<0/664+<3FG
+*)
))H/.-74+<3FG9
=/.I/54 <3FGJ
))K1L01-74./6+4+.0/6646+@71012/C/69
MNOPQR :/;/S6T0S346@07U47J
MNOPQR :/;/S6T0SUV,WX.4=71->J
=@L01. .0/66 ,-./012/3451678-6 YZRY[\] <3FG ^
)*347-8>/+346@07U47+.->74>C-+-6+8451678-6_+.->`-8?4+6.81=7+C4
+++++=46T@16/+>-+K/>.-9+*)
=@L01. 346@07U47 ,167/54?ab RcQPd] UV,WX.4=71-> ^
]eOYQSH67? f ]eOYQS<->S=84=/84U7/74?4>7a547U.81=7abbJ
QYReQ[ ]eOYQSH67?S4X4.@74V@48gabJ
h
))347-8>/+6.81=7_99
=81;/74 U781>5 547U.81=7ab ^
QYReQ[ iUW,W<j+1C_+;74X7-kl_+;74X7-km_+;C/7/_+i n
i;>@?481.-_+;L-04/>-+i n
io3pq+7/Lrkl+i n
ip3GW3+Ks+;L-04/>-+C46._+;74X7-kl+/6._+;74X7-km+/6.iJ
h
h

tut
012344506789
99248 79546682405665665042 28
2 99!8 "66 87#$%&$9$79'$9$())*$%*1+%
,-./0123435267849:;<4<
.-.=><003./0123435267849?.7@8>8A<B9.C<2<.D32<2.7E.<267849.E90@2<FB9
.-.90.2307>@<B90.9G@8B90.C<2<.H7FIJ9.B9.=KLM:
.-,
,,N<19@3.L@8>
C<1O<D3 L@8>P
,,Q8G>89@31<0.7@8>8A<B<0
RSTUVW ;<4<X89XY8>3Z28@32P
RSTUVW ;<4<X89X[\/]13C@89FP
,,=><003./012343.5267849
C7G>81 1><00 /0123435267849 ^
C284<@3 Y8>3Z28@32 _28@32P,,B31><2<.3.8F818<>8A<.4`28<43>.Y8>3Z28@32
,,=9F0@27@92./0123435267849::
C7G>81 /0123435267849ab ^
,,=28<.30@27@72<.C<2<.9.<267849?.B3H8F8FB9.037.23C908@9289::
WVc ^
WdReX_28@32 f ghi Y8>3Z28@32aj:,,@30@3k;<4<:@]@jbP
l mnWmd a[\/]13C@89F 3]b ^
3]XC28F@o@<1Op2<13abP
l
l
,,/012343.C<2<.<267849:::
C7G>81 498B 30123432ao@28FD B301q o@28FD 4<>92b WdVUie [\/]13C@89F ^
WdReX_28@32X_28@3ajrFj s B301 s jr@j s 4<>92bP
l
,,/012343.C<2<.<267849:::
C7G>81 498B 30123432ao@28FD B301b WdVUie [\/]13C@89F ^
WdReX_28@32X_28@3ajrFj s B301bP
l
C7G>81 Y8>3Z28@32 D3@Z28@32ab ^
VhWtVg WdReX_28@32P
l
l

uvu
012344506789
99248 79546682405665665042 28
239 66 87!"979#9$%%&!&1'!
()*+,-./01232
*)*45266,*7,-./8*97:5:;2</*=/*.>/?,66/*<,*2=25:6,*<,*7,-./
*)*=/6*?/-.2>27:3/60
*)(
((@2?/7,*A7:5
.2?B2C, A7:5D
((E:F5:/7,?26*97:5:;2<2600
((45266,*+,-./000
.9F5:? ?5266 +,-./ G
((H,?52>2IJ/*<,*32>:K3,:600
.>:327, 5/=C +,-./L=:?:25 M ND
.>:327, 5/=C +,-./O:=25 M ND
((P,72*+,-./*L=:?:25000
.9F5:? 3/:< 6,7+,-./O:=25Q5/=C +,-./O:=25R G
STUVW+,-./O:=25 M +,-./O:=25D
X
((P,72*+,-./*O:=25000
.9F5:? 3/:< 6,7+,-./L=:?:25Q5/=C +,-./L=:?:25R G
STUVW+,-./L=:?:25 M +,-./L=:?:25D
X
.9F5:? 5/=C C,7+,-./@,>?/>>:</QR G
YZS[Y\ QSTUVW+,-./O:=25 ] STUVW+,-./L=:?:25RD
X
X

^_^
/* Principal.cs
* CRUD
* Mono .NET FRAMEWORK
* Linux: Mono 2.4
* Windows: (Testados) mono for windows 2.4.3 e [MS .NET 2.0 e 3.5 SP1]
* Utilização do componente NpgSQL 2.06
* IDE: SharpDevelop (Windows) - MonoDevelop (Linux)
* Autor: Daniel Schroeder
*/
//Bibliotecas e classes utilizadas
using System;
using Npgsql;
using CRUD_Mono_CSharp_NpgSQL.CRUD;
using CRUD_Mono_CSharp_NpgSQL.Util;
//Pacote CRUD_Mono_CSharp_NpgSQL
namespace CRUD_Mono_CSharp_NpgSQL
{//Delimitador (inicio)
public class Principal {
//Declara e inicializa - EscreveArquivo(),..
private static EscreveArquivo Esc = new EscreveArquivo();
//Declara e inicializa - Tempo(),..
private static Tempo Tmp = new Tempo();
//Método principal..
public static void Main(string[] args) {
try{

Console.WriteLine("TESTE MONO .NET FRAMEWORK");//Escreve para o Console


..
Esc.escrever("TESTE MONO .NET FRAMEWORK");//Escreve para o Arquivo..
/* Configura conexão com o Banco de Dados.
* Lê a quantidade de registros a serem manipulados.
* Remove dados existentes no Banco, caso tenha.
* Inicia laço de repetição, executando os referidos Testes..
*/
ConfDB();
Console.Write("QUANTIDADE DE REGISTROS A SEREM MANIPULADOS: ");
int Qtd = Convert.ToInt32(Console.ReadLine());
Esc.escrever("QUANTIDADE DE REGISTROS A SEREM MANIPULADOS: ",Convert.ToString
(Qtd));
Esc.escrever("TEMPO PERCORRIDO: MILISEGUNDO (ms)");
DeletaRegistros d = new DeletaRegistros();
d.Deletar_tudo();
d = null;

for (int test = 1; test <= 10; test++) {


Console.WriteLine("TESTE NUMERO: "+Convert.ToString(test));
Esc.escrever("TESTE NUMERO: ", Convert.ToString(test));
//Processo de inserção..
Console.WriteLine("INSERÇÃO...");
Tmp.setTempoInicial(System.DateTime.Now.Ticks);
InsereRegistros i = new InsereRegistros();
i.InsereRegistro(Qtd);
Tmp.setTempoFinal(System.DateTime.Now.Ticks);
Esc.escrever("[INSERINDO REGISTRO]",Convert.ToString(Tmp.getTempoPercorrido
()));
//Processo de Listagem..
Console.WriteLine("LISTAGEM / LOCALIZAÇÃO...");
Tmp.setTempoInicial(System.DateTime.Now.Ticks);
ListarRegistros();
Tmp.setTempoFinal(System.DateTime.Now.Ticks);
Esc.escrever("[LISTAGEM DE REGISTRO]",Convert.ToString(Tmp.getTempoPercorrido
()));
//Processo de alteração..
Console.WriteLine("ALTERAÇÃO...");
Tmp.setTempoInicial(System.DateTime.Now.Ticks);
AlteraRegistros a = new AlteraRegistros();
a.AlteraRegistro(Qtd);
Tmp.setTempoFinal(System.DateTime.Now.Ticks);
Esc.escrever("[ALTERANDO REGISTRO]",Convert.ToString(Tmp.getTempoPercorrido
()));
//Processo de remoção..
Console.WriteLine("REMOÇÃO...");
Tmp.setTempoInicial(System.DateTime.Now.Ticks);
d = new DeletaRegistros();
d.DeletaRegistro(Qtd);
Tmp.setTempoFinal(System.DateTime.Now.Ticks);
Esc.escrever("[REMOVENDO REGISTRO]",Convert.ToString(Tmp.getTempoPercorrido
()));
}//Finaliza laço de repetição..
Console.WriteLine("TESTE CONCLUÍDO!");
Esc.escrever("TESTE CONCLUÍDO!");
}catch(Exception ex){//Exceção caso ocorra algum erro..
Console.WriteLine(ex.ToString());
}finally{//Quando finalizado é chamado o método Close(),..
Close();
}
}
//Método - Configuração para conexao com o Banco de Dados.
public static Boolean ConfDB(){
try{
Console.WriteLine("PARAMETROS DE CONFIGURAÇÃO COM O BANCO DE DADOS.");

Console.Write("Url: ");
Conexao.setUrl(Console.ReadLine());//Url: 127.0.0.1
Console.Write("Porta: ");
Conexao.setPorta(Console.ReadLine());//Porta: 5432
Console.Write("Banco de Dados: ");
Conexao.setDB(Console.ReadLine());//DB: Teste
Console.Write("Usuario: ");
Conexao.setUsuario(Console.ReadLine());//postgres
Console.Write("Senha: ");
Conexao.setSenha(Console.ReadLine());//*postgres*
if(Conexao.getCon().State == System.Data.ConnectionState.Open) Console
.WriteLine("CONEXÃO ATIVA..!");
return true;
}catch(NpgsqlException ex){
Console.WriteLine("FALHA NA CONEXÃO..! \n");
throw new Exception(ex.ToString());
}
}

private static void Close() {


try{
Conexao.getCon().Close();
Esc.getWriter().Close();
}catch(Exception ex){
ex.GetBaseException();
}
}

private static void ListarRegistros() {


LocalizaRegistros l = new LocalizaRegistros();
NpgsqlDataReader lista = l.Listagem();
//Escreve colunas...
for(int x=0; x < lista.FieldCount; x++){
Console.Write("{0} \t ", lista.GetName(x));
}
Console.WriteLine();
//Escreve valores...
while(lista.Read()){
for(int x=0; x < lista.FieldCount; x++){
Console.Write("{0} \t ", lista[x]);
}
Console.WriteLine();
}
}
}
}//Delimitador (fim)
/* Conexao.cs
* Classe Conexao, utilizado no processo de conexão com o Banco de Dados
*/
//Bibliotecas utilizadas.
using System;
using Npgsql;
//Pacote CRUD..
namespace CRUD_Mono_CSharp_NpgSQL.CRUD{
//Classe Conexao
public class Conexao
{
//Declaração de variáveis,..
private static String Url = null;
private static String Porta = null;
private static String DB = null;
private static String Usuario = null;
private static String Senha = null;
private static NpgsqlConnection Con =null;

//Métodos com função para setar valores para a conexão com o banco de dados.
public static void setDB(String DB) {
Conexao.DB = DB;
}

public static void setPorta(String Porta) {


Conexao.Porta = Porta;
}

public static void setSenha(String Senha) {


Conexao.Senha = Senha;
}

public static void setUrl(String Url) {


Conexao.Url = Url;
}

public static void setUsuario(String Usuario) {


Conexao.Usuario = Usuario;
}

//Método publico retornando a conexao,..


public static NpgsqlConnection getCon() {
try{
if(Con == null){
Con = new NpgsqlConnection("Server="+Url+"; Port="+Porta+
"; User ID="+Usuario+"; Password="+Senha
+
"; DataBase="+DB+";");
Con.Open();
}
return Con;
}catch(NpgsqlException ex){
throw new Exception(ex.ToString());
}
}
}
}
/* CRUD.cs
* Classe CRUD, é classe Pai, para as classes InsereDados, DeletaDados,
* LocalizaDados e AlteraDados.
*/

//Bibliotecas utilizadas
using System;
using Npgsql;

//Pacote CRUD
namespace CRUD_Mono_CSharp_NpgSQL.CRUD
{
//Classe CRUD
public class CRUD
{
//Declaração de variáveis,..
protected NpgsqlConnection Con;//Conexão com BD..
protected NpgsqlCommand Cmd;//Executar comandos SQL..
protected NpgsqlDataReader Dtr;//Buscar resultados SQL..

//Método construtor,.. puxando conexao..


public CRUD()
{
try {
this.Con = Conexao.getCon();
} catch (NpgsqlException ex) {
ex.GetBaseException();
}
}
}
}
/* AlteraRegistros.cs
* Classe responsavel pela alteração de registros.
* É herdada da Classe CRUD
*/
//Bibliotecas e classes utilizadas.
using System;
using System.Data;
using Npgsql;

namespace CRUD_Mono_CSharp_NpgSQL.CRUD {

public class AlteraRegistros : CRUD {


/*Metodo responsavel por alterar uma quatidade registros no banco,
*conforme parametro QtdRegistros.
*/
public void AlteraRegistro(int QtdRegistros) {
try {
Cmd = new NpgsqlCommand(getScript(), Con);
//Seta parametros...
Cmd.Parameters.Add(new Npgsql.NpgsqlParameter(":id", DbType.Int32));
Cmd.Parameters.Add(new Npgsql.NpgsqlParameter(":vtexto01", DbType.String
));
Cmd.Parameters.Add(new Npgsql.NpgsqlParameter(":vtexto02", DbType.String
));
Cmd.Parameters.Add(new Npgsql.NpgsqlParameter(":vdata", DbType.Date));

Cmd.Parameters.Add(new Npgsql.NpgsqlParameter(":vnumerico", DbType.Double


));
Cmd.Parameters.Add(new Npgsql.NpgsqlParameter(":vboleano", DbType.Boolean
));
Cmd.Parameters.Add(new Npgsql.NpgsqlParameter(":id", DbType.Int32));
for (int x = 1; x <= QtdRegistros; x++) {
Altera(Cmd, x);
}
} catch (NpgsqlException ex) {
throw new Exception(ex.ToString());
}
}
//Retorna script,..
private String getScript() {
return "UPDATE tab_01 "+
"SET id= :id, vtexto01= :vtexto01, vtexto02= :vtexto02, vdata=
:vdata, vnumerico=:vnumerico, vboleano=:vboleano "+
" WHERE id = :id;";
}
//Seta parametros, e aplica no Banco de Dados..
private void Altera(NpgsqlCommand Cmd, int Id) {
Cmd.Parameters[0].Value = Id;
Cmd.Parameters[1].Value = "abcdefghyjklmnopqrstuvwxyz-1234567890";
Cmd.Parameters[2].Value = "abcdefghyjklmnopqrstuvwxyz-1234567890";
Cmd.Parameters[3].Value = Convert.ToDateTime("2009-10-29");
Cmd.Parameters[4].Value = 90900.01 + 9.5;
Cmd.Parameters[5].Value = false;
Cmd.Parameters[6].Value = Id;
Cmd.ExecuteNonQuery();
}
}
}
/* DeletaRegistros.java
* Classe responsavel pela remoção de registros.
* É herdada da Classe CRUD
*/
//Bibliotecas e classes utilizadas.
using System;
using System.Data;
using Npgsql;

namespace CRUD_Mono_CSharp_NpgSQL.CRUD {

public class DeletaRegistros : CRUD {


/*Metodo responsavel por deletar uma quatidade registros no banco,
*conforme parametro QtdRegistros.
*/
public void DeletaRegistro(int QtdRegistros) {
try {
Cmd = new NpgsqlCommand(getScript(), Con);
//Seta parametros...
Cmd.Parameters.Add(new Npgsql.NpgsqlParameter(":id", DbType.Int32));
for (int x = 1; x <= QtdRegistros; x++) {
Deleta(Cmd, x);
}
} catch (NpgsqlException ex) {
throw new Exception(ex.ToString());
}
}
//Retorna script,..
private String getScript() {
return "DELETE FROM tab_01 "+
"WHERE id = :id;";
}
//Seta parametros, e aplica no Banco de Dados..
private void Deleta(NpgsqlCommand Cmd, int Id) {
Cmd.Parameters[0].Value = Id;//Seta parametro..
Cmd.ExecuteNonQuery();//Aplica no Banco de Dados..
}
//Metodo utilizado para remover todos os registros da tabela TAB_01...
public void Deletar_tudo() {
Cmd = new NpgsqlCommand(getScript(), Con);
Cmd.CommandText = "delete from tab_01;";
Cmd.ExecuteNonQuery();
}
}
}
/* InsereRegistros.cs
* Classe responsavel pela inserção de registros.
* É herdada da Classe CRUD
*/
//Bibliotecas e classes utilizadas.
using System;
using System.Data;
using Npgsql;

namespace CRUD_Mono_CSharp_NpgSQL.CRUD
{
public class InsereRegistros : CRUD {
/*Metodo responsavel por inserir uma quatidade registros no banco,
*conforme parametro QtdRegistros.
*/
public void InsereRegistro(int QtdRegistros) {
try {
Cmd = new NpgsqlCommand(getScript(), Con);
//Seta parametros...
Cmd.Parameters.Add(new Npgsql.NpgsqlParameter(":id", DbType.Int32));
Cmd.Parameters.Add(new Npgsql.NpgsqlParameter(":vtexto01", DbType.String
));
Cmd.Parameters.Add(new Npgsql.NpgsqlParameter(":vtexto02", DbType.String
));
Cmd.Parameters.Add(new Npgsql.NpgsqlParameter(":vdata", DbType.Date));

Cmd.Parameters.Add(new Npgsql.NpgsqlParameter(":vnumerico", DbType.Double


));
Cmd.Parameters.Add(new Npgsql.NpgsqlParameter(":vboleano", DbType.Boolean
));
for (int x = 1; x <= QtdRegistros; x++) {
Insere(Cmd, x);
}
} catch (NpgsqlException ex) {
throw new Exception(ex.ToString());
}
}
//Retorna script,..
private String getScript() {
return "INSERT INTO tab_01 "+
"(id, vtexto01, vtexto02, vdata, vnumerico, vboleano) "+
"VALUES "+
"(:id, :vtexto01, :vtexto02, :vdata, :vnumerico, :vboleano);";

}
//Seta parametros, e aplica no Banco de Dados..
private void Insere(NpgsqlCommand Cmd, int Id) {
Cmd.Parameters[0].Value = Id;
Cmd.Parameters[1].Value = "ABCDEFGHYJKLMNOPQRSTUVWXYZ-1234567890
";
Cmd.Parameters[2].Value = "ABCDEFGHYJKLMNOPQRSTUVWXYZ-1234567890
";
Cmd.Parameters[3].Value = Convert.ToDateTime("2009-11-20");
Cmd.Parameters[4].Value = 1999099.09;
Cmd.Parameters[5].Value = true;
Cmd.ExecuteNonQuery();
}
}
}
/* LocalizaRegistros.cs
* Classe responsavel pela listagem ou localização de registros.
* É herdada da Classe CRUD
*/
//Bibliotecas e classes utilizadas.
using System;
using System.Data;
using Npgsql;

namespace CRUD_Mono_CSharp_NpgSQL.CRUD {

public class LocalizaRegistros : CRUD {


/*Retorna NpgsqlDataReader contendo os registros, conforme script de pesquisa
no Banco. */
public NpgsqlDataReader Listagem() {
Cmd = new NpgsqlCommand(getScript(), Con);
return Cmd.ExecuteReader();
}
//Retorna script,..
private String getScript() {
return "SELECT id, vtexto01, vtexto02, vdata, vnumerico, vboleano " +
"FROM tab_01 " +
"ORDER BY vboleano desc, vtexto01 asc, vtexto02 asc";
}

}
}
/* EscreveArquivo.cs
* Classe EscreveArquivo, utilizado para gerar um arquivo mostrando os resultados obtidos

* para função do CRUD.


*/
//Bibliotecas utilizadas
using System;
using System.IO;
//Pacote Util
namespace CRUD_Mono_CSharp_NpgSQL.Util{
public class EscreveArquivo { //Classe EscreveArquivo.
private StreamWriter writer;//declara arquivo, e seta arquivo..
//Construtor EscreveArquivo..
public EscreveArquivo(){
//Cria estrutura para o arquivo, definindo seu repositorio..
this.writer = File.CreateText(".//teste-mono.txt");
}
//Escreve para arquivo...
public void escrever(string desc, string valor){
this.writer.WriteLine(""+desc+"\t"+valor);
}
//Escreve para arquivo...
public void escrever(string desc){
this.writer.WriteLine(""+desc);
}
//Retorna um StreamWriter
public StreamWriter getWriter(){
return this.writer;
}
}
}
/* Tempo.cs
* Classe tempo, utilizado no processo de analise de tempo nos comparativos.
*/
//Bibliotecas utilizadas
using System;
//Pacote Util
namespace CRUD_Mono_CSharp_NpgSQL.Util {
class Tempo {//Classe Tempo.
//Declara variáveis e deixando como padrão 0;
private long TempoInicial = 0;
private long TempoFinal = 0;

//Seta Tempo Inicial...


public void setTempoFinal(long TempoFinal){
this.TempoFinal = TempoFinal;
}
//Seta Tempo Final...
public void setTempoInicial(long TempoInicial){
this.TempoInicial = TempoInicial;
}
//Retorna tempo percorrido..
public long getTempoPercorrido() {
return (this.TempoFinal - this.TempoInicial)/System.TimeSpan.TicksPerMillisecond
;
}
}
}
88

APÊNDICE C - Disponibilidade da Documentação, Plataforma, IDE's e o Banco


de Dados utilizado.

Plataformas

Plataforma Mono .NET Framework, disponível em: http://www.Mono-project.com

Plataforma Java, disponível em: http://java.sun.com/

IDE's

Visual Studio, disponível em: http://msdn.microsoft.com/pt-br/vstudio/default.aspx

Delhi Prism, disponível em: http://www.embarcadero.com/products/delphi-prism

MonoDevelop, disponível em: http://monodevelop.com

SharpDevelop, disponível: http://www.icsharpcode.net

Eclipse, disponível em: http://www.eclipse.org

Netbeans, disponível: http://www.netbeans.org

Banco de Dados

PostgreSQL: http://www.postgresql.org
89

APÊNDICE D – Ambientes de Desenvolvimento utilizados na Implementação dos


Aplicativos, Logomarca das plataformas comparada e Tela das aplicações.

Figura 16: Tela Principal. Netbeans 6.7 (Win32), sob outro sistema operacional sua interface é a
mesma. Autor (2009)

Figura 17: Splash NetBeans 6.7.1. Autor (2009)


90

Figura 18: Tela Principal. SharpDevelop 3.1 (Win32). Autor (2009)

Figura 19: Splash SharpDevelop 3.1. Autor (2009)


91

Figura 20: Tela Principal. MonoDevelop 2.0, Linux. Autor (2009)

Figura 21: Splash MonoDevelop 2.0. Autor (2009)


92

Figura 22: Logomarca: Java. Sun (2009)

Figura 23: Logomarca: Mono. Mono (2009)


93

Figura 24: Aplicativo Java, sendo executado sobre o Console do Windows (MS-DOS). No
Linux foi executado sob o console gnome-terminal. Os resultados quanto ao tempo eram
gravados para um arquivo de texto. Autor (2009)

Figura 25: Aplicativo Mono .NET, sendo executado sobre o Console do Windows (MS-
DOS). No Linux foi executado sob o console gnome-terminal. Os resultados quanto ao
tempo eram gravados para um arquivo de texto. Autor(2009)