Agora vamos falar um pouco mais sobre os diversos aspectos do Framework .NET e como cada um destes aspectos se propõem a solucionar problemas do model atual de desenvolvimento.

Linguagens habilitadas ao .NET.

O que significa uma linguagem ser “habilitado ao .NET?”

Significa que a linguagem é capaz de gerar, como resultado da compilação, código MSIL. Uma vez gerado o código MSIL, o mesmo é executado sob o controle do CLR. Ou seja, para o Framework .NET, uma vez gerado o código MSIL, não importa a partir de qual linguagem o mesmo foi gerado, pois a maneira como o mesmo é executado é sempre a mesma.

Juntamente com o Framework .NET, a Microsoft disponibiliza as seguintes linguagens:

• Visual Basic .NET (VB.NET)
• C++
• C#

Podemos criar nossos programas em qualquer uma destas linguagens. Ao compilarmos o programa, o resultado será código MSIL, o qual passa a ser executado pelo CLR. Quando a Inprise lançar o Delphi habilitado ao .NET, teremos a opção de compilar um programa Delphi para gerar código MSIL. Uma vez gerado o código MSIL, para o CLR não importa em qual linguagem o programa foi codificado.

Mais adiante, nos capítulos 3, 4 e 5 estaremos apresentando uma introdução aos principais elementos da linguagem C#. Nos capítulos restantes do livro, estaremos utilizando a linguagem C# para a criação de páginas ASP.NET.

Um rápida apresentação do VB.NET

Com exceção do C# que é uma nova linguagem, o VB.NET é a linguagem que mais sofreu modificações em relação as versões anteriores. Foram introduzidas algumas características a muito tempo esperadas, tais como:

• Foram adicionadas mais características de orientação a objetos, tais como herança verdadeira, construtores parametrizados e overriding de métodos e propriedades.
• Mais facilidades para o desenvolvimento de aplicações Internet. Por exemplo, para criar páginas ASP.NET, ao invés de VBScript utilizamos diretamente o VB.NET ou o C#.
• Herança visual: Esta é uma características que os desenvolvedores do Delphi já tinham a algum tempo. Com o VB.NET podemos criar um formulário com as características básicas para todos os formulários da aplicação. Quando precisarmos um formulários com características adicionais, podemos construir este novo formulário baseado, isto é, herdando as características do formulário básico, depois é só adicionar os elementos necessários. Ao criarmos o nosso formulário, herdando do formulário básico, o formulário que está sendo criado terá, automaticamente, todos os elementos do formulário básico. Além dos elementos, o código para tratamento de eventos também é herdado. O melhor de tudo, ao alterarmos o formulário básico, todas as alterações são refletidas nos formulários herdados. A herança visual facilita, enormemente, a criação de aplicações que tenham uma interface consistente e de fácil alteração.
• Tratamento estruturado de exceções: com o VB.NET, temos muito mais recursos para o tratamento de erros e exceções do que o bom e velho On Error do Visual Basic. Isso faz com que possamos criar programas mais confiáveis.

Falar sobre as novidades do VB.NET é assunto para um capítulo inteiro. Ensinar o VB.NET: assunto para um livro inteiro. Em um trabalho futuro estaremos tratando desta nova e excitante versão do VB.

Um rápida apresentação C#

O C# é a nova linguagem da Microsoft, apresentada juntamente com o Framework .NET. O C# foi construído com base nos conceitos de Orientação a objetos. As diretivas básicas para a criação do C# foram as seguintes:

• Uma linguagem orientada a objetos e tão poderosa quanto o C++
• Uma linguagem tão fácil de utilizar quanto o VB

O pessoal da Microsoft realmente conseguiu aliar estas duas características em uma só linguagem: Poder e Simplicidade. Conforme veremos nos capítulos 3, 4 e 5 o C# é de fácil aprendizagem e utilização, ao mesmo tempo que nos fornece poderosos mecanismos, antes só encontrados no C++.

Como não poderia deixar de ser, vamos dar o tradicional exemplo do Hello Word !!!, utilizando o C#. Apresentarei o código e os passos para compilar e rodar o nosso primeiro programa em C#. Nos demais capítulos deste livro aprenderemos mais sobre esta linguagem. Para criar o nosso primeiro programa, utilizaremos o Bloco de Notas do Windows .

Abra o Bloco de notas e digite o texto indicado na Listagem 1.1:

Listagem 1.1 – Hello Word!

using System;
class primeiroprograma
{
            // Meu primeiro programa em C#
            // O tradicional Hello Word !!

            public static void Main()
            {
                        string umamensagem = "Hello Word !!!";
                        Console.WriteLine(umamensagem);
            }
}

Salve este programa no disco com o nome de primeiroprograma.cs. Agora vamos compilar o programa e executa-lo.

Para compilar o programa, abra um Prompt de Comando (Iniciar -> Programas -> Acessórios -> Prompt de comando). Na janela do prompt vá para a pasta onde você salvou o arquivo hello.cs e execute o seguinte comando:

csc primeiroprograma.cs

Com este comando estamos compilando o arquivo fonte primeiroprograma.cs, para gerar um executável .exe. O resultado deste comando é indicado na Figura 1.8, onde utilizamos o comando dir, para mostrar que a compilação gerou o executável primeiroprograma.exe.

Figura 1.8 Compilando o primeiro programa em C#

Para executar o nosso programa, basta digitar primeiroprograma e pressinar Enter. O programa será executado, conforme indicado na Figura 1.9:

Figura 1.9 Executando o primeiro programa em C#.

Bem, por enquanto é isto, fizemos apenas uma pequena apresentação da linguagem C#. Teremos três capítulos deste livro (3, 4 e 5), para tratar desta linguagem. Apenas um último detalhe que gostaria de chamar a atenção: Observe, para aqueles que conhecem Java ou C++, a semelhança entre a estrutura de um programa em C# e um programa em uma destas linguagens.
S= Common Type System

O Framework .NET disponibiliza, na forma de objetos, um conjunto de tipos de dados comuns, os quais podem ser utilizados por todas as linguagens habilitadas ao .NET. Isso significa que uma variável do tipo Long, terá a mesma estrutura e ocupará o mesmo número de bytes, quer seja no VB.NET, no C#, no C++ ou em qualquer outra linguagem habilitada ao .NET. Este conjunto de tipos comuns, que pode ser utilizado por qualquer linguagem é chamado de Common Type System, que a partir de agora abreviaremos por CTS.

Dentre outras coisas, é o CTS que facilita a integração entre as programas e serviços criados, utilizando-se diferentes linguagens do .NET. No modelo antigo, uma das dificuldades de fazer com que um Componente COM+ criado com o Visual C++ pudesse ser utilizado por um programa escrito em Visual Basic, é que as linguagens possuíam um diferente  conjunto de tipos básicos. Para que os componentes, escritos em diferentes linguagens, pudessem se comunicar, o programador tinha que mapear os tipos de uma linguagem, para os tipos correspondentes em outra linguagem, fazendo as conversões necessárias. Vejam o quanto este procedimento é trabalhoso. Com o CTS do .NET simplesmente esta preocupação não existe, uma vez que todas as linguagens tem acesso a um conjunto de tipos comum a todas elas.

Conforme descrito na documentação do Framework .NET, são as seguintes as principais funções do CTS:

• Fornece uma estrutura que possibilita a integração entre diferentes linguagens habilitadas ao .NET, com uma execução mais rápida, uma vez que a sobrecarga para a conversão entre os diferentes tipos de diferentes linguagens, deixa de existir.
• Fornece uma estrutura de tipos com base em um modelo orientado a objetos, o que facilita a criação de novas linguagens habilitadas ao .NET, favorecendo a utilização de boas práticas de programação, como por exemplo a herança. Uma vez que os tipos são objetos, podemos criar tipos derivados dos objetos básicos, os quais herdam todas as características dos objetos básicos.
• O CTS define algumas regras que toda linguagem deve seguir, para ser habilitada ao .NET. Por seguirem um conjunto de regras comum, a interação entre programas escritos em diferentes linguagens fica bem mais fácil.

No Capítulo 2, quando detalharemos o CLR, vamos detalhar um pouco mais sobre o CTS.

Metadata

Na seção “Questões a considerarmos nos modelos de 3 ou mais camadas utilizados atualmente”, descrevemos, como uma das inconveniências do modelo de componentes baseados em COM/COM+, o fato que os mesmos, para poderem ser utilizados, precisam ser registrados. Ao registrarmos um componente COM/COM+, uma série de informações sobre o mesmo, são gravadas na Registry do sistema. Estas informações são utilizadas pelos programas que precisam acessar o componente. Se alguma destas informações estiver errada ou tiver sido alterada, o componente não poderá ser acessado e os programas que utilizam o componente deixarão de funcionar corretamente.

No Framework .NET, para utilizarmos os componentes .NET (.NET Componentes), não é necessário que os mesmos sejam registrados. O próprio componente .NET, possui todas as informações necessárias ao seu funcionamento, bem como as informações necessárias para que outros aplicativos possam utiliza-los. Estas informações, que fazem parte do próprio componente .NET e ficam gravadas no arquivo que compõem componente , na forma de Metadata. Uma tradução “popularmente conhecida” para Metadata seria: dados sobre dados. No nosso caso, Metadata seriam as informações que o componente .NET possui a respeito de si mesmo, informações estas que podem ser utilizadas por outros componentes e serviços, para acessar o componente em questão.

Além de fazer com que não seja necessário o registro do componente, as informações de Metadata facilitam a interoperabilidade entre diferentes componentes, mesmo entre componentes escritos em diferentes linguagens. Estas informações são geradas, automaticamente, no momento da compilação do componente e são gravadas no arquivo .DLL ou .EXE do componente. São muitas as informações que podem ser inseridas no componente, na forma de Metadata, tais como:

• Nome e versão do componente.
• Uma chave pública para verificação da origem e da autenticidade do componente.
• Informações sobre todas as classes ou componentes, dos quais o componente depende para funcionar corretamente.
• Tipos disponibilizados (exportados) pelo componente.
• Permissões de segurança para o acesso ao componente, seus métodos e propriedades.
• Classes básicas e interfaces do Framework .NET, utilizadas pelo componente.
• Atributos personalizados, implementados no componente.
• Membros do componente (métodos, campos, propriedades, eventos, etc).

Quando o componente é acessado, o CLR carrega os meta dados do componente na memória e faz referência a estes meta dados, para obter informações sobre as classes, membros, herança e dependências do componente.

São diversos os benefícios do uso de meta dados, dentre os quais podemos destacar os seguintes:

• Módulos de código auto descritivos: O próprio componente contém toda a informação necessária para interagir com outros componentes. Desta forma o componente pode ser implementado como um único arquivo, o qual contém a sua definição (na forma de meta dados) e a sua implementação, o código do componente.
• Nunca é demais repetir: A utilização de meta dados facilita, enormemente, a interoperabilidade entre componentes criados usando diferentes linguagens.

Assemblies

Uma aplicação .NET é constituída de um conjunto de “blocos” chamados Assembly. Através dos Assemblies é que podemos controlar a distribuição de uma aplicação, fazer o controle de versões, além de definir as configurações de segurança. Um assembly é uma coleção de tipos e recursos que foram construídos para trabalharem juntos, formando com isso, uma unidade com funcionalidade e escopos bem definidos. Um assembly fornece ao CLR importantes informações sobre  a implementação de tipos da aplicação. Para o CLR, um tipo somente existe no contexto de um assembly. De uma maneira mais simples, poderíamos dizer que um assembly é o mecanismo utilizado pelo .NET, para “empacotar” todos os elementos e informações necessárias ao funcionamento de uma aplicação ou componente. Vamos simplificar mais ainda: o assembly é uma maneira de juntar e organizar os diversos elementos que formam uma aplicação ou componente.

Os assemblies foram criados para simplificar a distribuição de aplicações e resolver o problema de “versões”, existentes em aplicações baseadas em componentes. Lembram que no início deste capítulo falamos sobre o termo “DLL Hell”. Com este termo estávamos nos referindo ao problema de um programa, ao ser instalado, substituir uma DLL por uma versão mais nova ou mais antiga, fazendo com que programas que dependiam da versão anterior da DLL, deixassem de funcionar. Através do uso de assemblies e dos meta dados contidos em cada componente, é possível que diferentes versões, do mesmo componente, estejam disponíveis, ao mesmo tempo, em um computador. Desta forma, cada programa utiliza a versão do componente para o qual o programa foi criado. Ao instalarmos uma nova versão do componente, o qual vem embutido em um assembly, as versões anteriores serão mantidas, se as mesmas estiverem sendo utilizados por outros programas. Isso faz com que o inferno das DLLs (DLL Hell) seja coisa do passado.

Para resolver o problema de versões e evitar o inferno das DLLs, o CLR utiliza assemblies da seguinte maneira:

• Permite que o desenvolvedor defina regras sobre o uso de diferentes versões entre diferentes componentes .NET.
• Fornece a infraestrutura necessária para que as regras de versão definidas pelo desenvolvedor, sejam respeitadas.
• Fornece a infraestrutura necessária, para que diferentes versões de um mesmo componente de software, possam rodar, simultaneamente. Esta execução simultânea é conhecida como “syde-by-syde execution.”

Um assembly é composto de dois elementos básicos:

• Manifesto
• Um conjunto de módulos.

Nota! Veremos mais detalhes sobre assemblies e seus elementos no Capítulo 2, onde estaremos detalhando o CLR – Common Language Runtime.