Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido manualmente. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Processo de execução gerenciada

O processo de execução gerenciada inclui as seguintes etapas, que serão discutidas em detalhes mais adiante neste tópico:

  1. Escolhendo um compilador

    Para obter os benefícios fornecidos pelo Common Language Runtime, você deve usar um ou mais compiladores de linguagem que têm como alvo o runtime.

  2. Compilando seu código para MSIL.

    Compilação converte seu código fonte para o Microsoft Intermediate Language (MSIL) e gera os metadados necessários.

  3. Compilando MSIL para código nativo

    No momento da execução, um just-in-time (JIT) traduz o MSIL em código nativo. Durante esta compilação, o código deve passar por um processo de verificação que examina o MSIL e metadados para descobrir se o código pode ser determinado como sendo de tipagem segura.

  4. Executando o código

    O Common Language Runtime fornece a infra-estrutura que habilita que execução ocorra e os serviços que podem ser utilizados durante a execução.

Para obter as vantagens fornecidas pelo Common Language Runtime (CLR), você deve usar um ou mais compiladores de linguagem que têm como alvo o runtime, como Visual Basic, C#, Visual C++, F# ou um dos muitos compiladores de terceiros como o Eiffel, Perl ou o compilador COBOL.

Por ser um ambiente de execução multi-linguagem, o runtime suporta uma ampla variedade de tipos de dados e recursos de linguagem. O compilador de linguagem que você usa determina quais recursos de tempo de execução estão disponíveis, e você cria seu código usando esses recursos. Seu compilador, não o runtime, estabelece a sintaxe que seu código deve usar. Se o componente deve ser completamente utilizável por componentes escritos em outras linguagens, os tipos exportados do seu componente devem expor somente recursos de linguagem incluídos na Independência da linguagem e componentes independentes da linguagem (CLS). Você pode usar o atributo CLSCompliantAttribute para garantir que seu código seja compatível com CLS. Para obter mais informações, consulte Independência da linguagem e componentes independentes da linguagem.

Voltar ao início

Quando compila para código gerenciado, o compilador converte seu código fonte em Microsoft Intermediate Language (MSIL), que é um conjunto de instruções independentes de CPU o qual pode ser eficientemente convertido em código nativo. O MSIL inclui instruções para carregamento, armazenamento, inicialização e chamada de métodos em objetos, bem como instruções para operações aritméticas e lógicas, fluxo de controle, acesso direto à memória, tratamento de exceções e outras operações. Para o código ser executado, o MSIL deve ser convertido no código específico da CPU, geralmente por um Compilador JIT (just-in-time). Como o Common Language Runtime fornece um ou mais compiladores JIT para cada arquitetura de computador para a qual dá suporte, o mesmo conjunto de MSIL pode ser compilado por JIT e executado em qualquer arquitetura compatível.

Quando um compilador produz MSIL, ele também produz metadados. Metadados descrevem os tipos no seu código, incluindo a definição de cada tipo, as assinaturas de membros de cada tipo, os membros que seu código referencia e outros dados que o tempo de execução usa no tempo de execução. O MSIL e os metadados estão contidos em um arquivo PE (Portable Executable) com base no e que estende o arquivo PE Microsoft publicado e o COFF (Common Object File Format) usados historicamente no conteúdo executável. Este formato de arquivo, que acomoda o MSIL ou código nativo, bem como metadados, permite que o sistema operacional reconheça imagens comuns em tempo de execução de linguagem. A presença de metadados no arquivo com MSIL permite que seu código se descreva, o que significa que não há necessidade de bibliotecas de tipos ou IDL (Interface Definition Language). O Runtime localiza e extrai os metadados do arquivo conforme for necessário durante a execução.

Voltar ao início

Para executar o MSIL, ele deve ser compilado no CLR para código nativo da arquitetura do computador de destino. O .NET Framework fornece duas maneiras de executar esta conversão:

k5532s8a.collapse_all(pt-br,VS.110).gifCompilação pelo compilador JIT

A Compilação JIT converte MSIL para código nativo por demanda no tempo de execução do aplicativo, quando o conteúdo de um assembly é carregado e executado. Como o CLR fornece um compilador JIT para cada arquitetura de CPU compatível, os desenvolvedores podem compilar um conjunto de assemblies MSIL que pode ser compilado pelo JIT e executado em diferentes computadores com arquiteturas diferentes. No entanto, se seu código gerenciado chama APIs nativas específicas da plataforma ou uma biblioteca de classes específica da plataforma, ele será executado somente nesse sistema operacional.

A compilação JIT leva em conta a possibilidade de um código jamais ser chamado durante a execução. Em vez de usar o tempo e a memória para converter todo o MSIL em um arquivo PE para código nativo, ele converte o MSIL conforme necessário durante a execução e armazena o código nativo resultante na memória de forma que seja acessível para chamadas subsequentes no contexto desse processo. O carregador cria e atribui um stub para cada método em um tipo quando o tipo é carregado e inicializado. Quando um método é chamado pela primeira vez, o stub passa o controle para o compilador JIT, que converte o MSIL para esse método em código nativo e modifica o stub para apontar diretamente para o código nativo gerado. Portanto, as chamadas subsequentes para o método compilado por JIT vão diretamente para o código nativo.

k5532s8a.collapse_all(pt-br,VS.110).gifGeração de código do tempo de instalação usando NGen.exe

Como o compilador JIT converte o MSIL do assembly para código nativo quando métodos individuais definidos nesse assembly são chamados, ele afeta o desempenho negativamente no tempo de execução. Na maioria dos casos, esse desempenho diminuído é aceitável. Mais importante ainda, o código gerado pelo compilador JIT está vinculado ao processo que desencadeou a compilação. Ele não pode ser compartilhado entre vários processos. Para permitir que o código gerado seja compartilhado por várias invocações de um aplicativo ou por vários processos que compartilham um conjunto de assemblies, o CLR dá suporte a um modo de compilação antecipado. Esse modo de compilação antecipado usa o Ngen.exe (Gerador de Imagens Nativas) para converter assemblies MSIL em código nativo de maneira semelhante ao compilador JIT. No entanto, a operação de Ngen.exe é diferente daquele do compilador JIT de três maneiras:

  • Ele executa a conversão do MSIL em código nativo antes de executar o aplicativo, e não durante a execução do aplicativo.

  • Ele cria um assembly inteiro por vez, em vez de um método de cada vez.

  • Persiste o código gerado no cache de imagem nativo como um arquivo no disco.

k5532s8a.collapse_all(pt-br,VS.110).gifVerificação de código

Como parte de sua compilação para código nativo, o código MSIL deve passar por um processo de verificação, a menos que um administrador estabeleça uma política de segurança permitindo que o código ignore a verificação. A verificação examina o MSIL e os metadados para descobrir se o código é fortemente tipado, o que significa que ele acessa apenas os locais de memória que está autorizado a acessar. A segurança de tipo ajuda a isolar objetos uns dos outros e a protegê-los de danos não intencionais ou corrupção mal-intencionada. Ele também oferece a garantia de que as restrições de segurança em código pode ser executada de forma confiável.

O tempo de execução se baseia no fato de que as seguintes afirmações são verdadeiras para o código que é verificável tipo de seguro:

  • Uma referência a um tipo é estritamente compatível com o tipo que está sendo referenciado.

  • Apenas operações adequadamente definidas são chamadas em um objeto.

  • Identidades são o que dizem ser.

Durante o processo de verificação, o código MSIL é examinado em uma tentativa de confirmar que o código possa acessar locais de memória e chamar métodos apenas por tipos corretamente definidos. Por exemplo, o código não pode permitir que os campos de um objeto a ser acessado de uma forma que permite posições de memória a ser invadido. Além disso, a verificação inspeciona o código para determinar se o MSIL foi gerada corretamente, porque MSIL incorreto pode levar a uma violação das regras de segurança do tipo. O processo de verificação passa um conjunto bem definido de código de tipo seguro, e passa somente o código que é o tipo de seguro. Entretanto, alguns códigos fortemente tipados podem não passar nessa verificação devido às limitações do processo de verificação, e algumas linguagens, por projeto, não produzem código fortemente tipado verificável. Se o código de tipo seguro é exigido pela política de segurança, mas o código não passar na verificação, uma exceção é lançada quando o código é executado.

Voltar ao início

O CLR fornece a infraestrutura que permite que a execução gerenciada ocorra e os serviços que podem ser usados durante a execução. Antes de um método poder ser executado, ele deve ser compilado para código específico do processador. Cada método para MSIL gerado é compilado por JIT quando é chamado pela primeira vez e executado. A próxima vez que o método é executado, o código existente JIT nativo é executado. O processo de compilação por JIT e a execução do código é repetido até a execução ser concluída.

Durante a execução, o código gerenciado recebe serviços como coleta de lixo, segurança, interoperabilidade com código não gerenciado, suporte à depuração entre linguagens e suporte avançado à implantação e ao controle de versão.

No Microsoft Windows XP e Windows Vista, o carregador do sistema operacional verifica módulos gerenciados examinando um bit no cabeçalho COFF. O conjunto de bits indica a ser um módulo de gestão. Se o carregador detecta módulos gerenciados, ele carrega mscoree.dll e _CorValidateImage, e _CorImageUnloading notifica o carregador quando as imagens do módulo gerenciado são carregadas e descarregadas. _CorValidateImage executa as seguintes ações:

  1. Garante que o código é um código gerenciado válido.

  2. Altera o ponto de entrada na imagem para um ponto de entrada em tempo de execução.

No Windows 64 bits, _CorValidateImage modifica a imagem que está na memória transformando-a do formato PE32 para o formato PE32+.

Voltar ao início

Contribuições da comunidade

ADICIONAR
A Microsoft está realizando uma pesquisa online para saber sua opinião sobre o site do MSDN. Se você optar por participar, a pesquisa online lhe será apresentada quando você sair do site do MSDN.

Deseja participar?
Mostrar:
© 2014 Microsoft