Introdução ao .NET Native

Quer esteja a escrever uma nova aplicação UWP ou a migrar uma aplicação existente do Windows 8.x (anteriormente também denominada aplicação da Microsoft Store), pode seguir o mesmo conjunto de procedimentos. Para criar um aplicativo .NET nativo, execute estas etapas:

1. Desenvolva um aplicativo da Plataforma Universal do Windows (UWP) e teste as compilações de depuração do seu aplicativo para garantir que ele funcione corretamente.

2. Gerencie o uso de reflexão e serialização adicionais.

3. Implemente e teste as versões compiladas da sua aplicação.

4. Resolva manualmente os metadados ausentes e repita a etapa 3 até que todos os problemas sejam resolvidos.

Etapa 1: Desenvolver e testar compilações de depuração do seu aplicativo UWP

Quer esteja a desenvolver uma nova aplicação ou a migrar uma existente, segue o mesmo processo que para qualquer aplicação do Windows.

1. Crie um novo projeto UWP no Visual Studio usando o modelo de aplicativo Universal do Windows para Visual C# ou Visual Basic. Por padrão, todos os aplicativos UWP destinam-se ao CoreCLR e suas compilações de versão são compiladas usando a cadeia de ferramentas nativa do .NET.

2. Observe que há alguns problemas de compatibilidade conhecidos entre a compilação de projetos de aplicativo UWP com a cadeia de ferramentas .NET Native e sem ela. Consulte o guia de migração para obter mais informações.

Agora você pode escrever código C# ou Visual Basic na área de superfície nativa do .NET que é executada no sistema local (ou no simulador).

Por padrão, as compilações de depuração são realizadas em JIT para permitir a rápida execução com a tecla F5, enquanto as compilações de lançamento são feitas usando a tecnologia de pré-compilação .NET Native. Isso significa que você deve criar e testar as compilações de depuração do seu aplicativo para garantir que elas funcionem normalmente antes de compilá-las com a cadeia de ferramentas nativa do .NET.

Etapa 2: Lidar com reflexão adicional e uso de serialização

Um arquivo de diretivas de tempo de execução, Default.rd.xml, é adicionado automaticamente ao seu projeto quando você o cria. Se você desenvolver em C#, ele será encontrado na pasta Propriedades do seu projeto. Se você desenvolver no Visual Basic, ele será encontrado na pasta Meu projeto do seu projeto.

O arquivo de diretivas de tempo de execução é usado para definir os metadados de que seu aplicativo precisa em tempo de execução. Em alguns casos, a versão padrão do arquivo pode ser adequada. No entanto, alguns códigos que dependem de serialização ou reflexão podem exigir entradas adicionais no arquivo de diretivas de tempo de execução.

Serialização

Há duas categorias de serializadores, e ambos podem exigir entradas adicionais no arquivo de diretivas de tempo de execução:

• Serializadores não baseados em reflexão. Os serializadores encontrados na biblioteca de classes do .NET Framework, como as classes DataContractSerializer, DataContractJsonSerializere XmlSerializer, não dependem de reflexão. No entanto, eles exigem que o código seja gerado com base no objeto a ser serializado ou desserializado. Para obter mais informações, consulte a seção "Microsoft Serializers" em Serialização e Metadados.

• Serializadores de terceiros. Bibliotecas de serialização de terceiros, a mais comum das quais é o serializador JSON Newtonsoft, são geralmente baseadas em reflexão e exigem entradas no arquivo *.rd.xml para suportar a serialização e desserialização de objetos. Para obter mais informações, consulte a seção "Serializadores de terceiros" em Serialização e metadados.

Métodos que se baseiam na reflexão

Em alguns casos, o uso da reflexão no código não é óbvio. Algumas APIs comuns ou padrões de programação não são considerados parte da API de reflexão, mas dependem da reflexão para serem executados com êxito. Isso inclui os seguintes métodos de instanciação de tipo e construção de método:

• O método Type.MakeGenericType

• Os Array.CreateInstance e Type.MakeArrayType métodos

• O método MethodInfo.MakeGenericMethod.

Para obter mais informações, consulte APIs que dependem do Reflection.

Etapa 3: implantar e testar as compilações de versão do seu aplicativo

Depois de atualizares o ficheiro de diretivas de tempo de execução, podes reconstruir e implementar builds de lançamento da tua aplicação. Os binários nativos do .NET são colocados no subdiretório ILC.out do diretório especificado na caixa de texto caminho de saída do Build da caixa de diálogo Propriedades do projeto, na separador Compilar. Os binários que não estão nesta pasta não foram compilados com o .NET Native. Teste seu aplicativo minuciosamente e teste todos os cenários, incluindo cenários de falha, em cada uma de suas plataformas de destino.

Se o seu aplicativo não funcionar corretamente (especialmente nos casos em que ocorrerem exceções MissingMetadataException ou MissingInteropDataException em tempo de execução), siga as instruções na próxima seção, Etapa 4: Resolver manualmente os metadados ausentes. Ativar exceções de primeira oportunidade pode ajudá-lo a encontrar esses bugs.

Quando tiveres testado e depurado as compilações de depuração da tua aplicação e tiveres a certeza de que eliminaste as exceções MissingMetadataException e MissingInteropDataException, deves testar a tua aplicação como uma aplicação .NET Native otimizada. Para fazer isso, altere a configuração do projeto ativo de Debug para Release.

Etapa 4: Resolver manualmente os metadados ausentes

A falha mais comum que o utilizador encontrará com o .NET Native, que não encontra na área de trabalho, é uma exceção de runtime MissingMetadataException, MissingInteropDataExceptionou MissingRuntimeArtifactException. Em alguns casos, a ausência de metadados pode se manifestar em comportamentos imprevisíveis ou até mesmo em falhas de aplicativos. Esta seção discute como você pode depurar e resolver essas exceções adicionando diretivas ao arquivo de diretivas de tempo de execução. Para obter informações sobre o formato das diretivas de execução, consulte Diretivas de Execução (rd.xml) Referência de Ficheiros de Configuração. Depois de adicionar diretivas de tempo de execução, você deve implantar e testar seu aplicativo novamente e resolver qualquer nova MissingMetadataException, MissingInteropDataExceptione MissingRuntimeArtifactException exceções até não encontrar mais exceções.

Ao abordar uma exceção de metadados ausente, considere estes problemas:

• O que o aplicativo estava tentando fazer antes da exceção?

  • Por exemplo, foi vinculação de dados, serialização ou desserialização de dados, ou diretamente usando a API de reflexão?

• Este é um caso isolado ou acredita que encontrará o mesmo problema para outros tipos?

  • Por exemplo, uma exceção MissingMetadataException é lançada ao serializar um tipo no modelo de objeto do aplicativo. Se você conhece outros tipos que serão serializados, pode adicionar diretivas de tempo de execução para esses tipos (ou para seus namespaces que contêm, dependendo de quão bem o código está organizado) ao mesmo tempo.

• Você pode reescrever o código para que ele não use reflexão?

  • Por exemplo, o código usa a palavra-chave dynamic quando já sabes que tipo deves esperar?

  • O código chama um método que depende de reflexão quando alguma alternativa melhor está disponível?

Para obter alguns exemplos específicos de como lidar com exceções e outros problemas que ocorrem ao testar seu aplicativo, consulte:

• exemplo: manipulando exceções ao vincular dados

• Exemplo: Solução de problemas de programação dinâmica

• Exceções de Tempo de Execução em Aplicações Nativas .NET

Ver também

• Diretivas de Tempo de Execução (rd.xml) Referência do Arquivo de Configuração
• .NET Native e Compilação
• Reflection e .NET Native
• APIs que dependem da Reflexão
• Serialização e Metadados
• Migrando seu aplicativo do Windows 8.x para o .NET Native