Começar com .NET Native

Quer esteja a escrever uma nova aplicação UWP ou a migrar uma aplicação já existente para Windows 8.x (anteriormente também chamada de aplicação da Microsoft Store), pode seguir o mesmo conjunto de procedimentos. Para criar uma aplicação .NET Native, siga estes passos:

1. Desenvolve uma Plataforma Universal do Windows (UWP) app e testa as compilações de depuração da tua app para garantir que funciona 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 já existente, segue o mesmo processo que em qualquer aplicação Windows.

1. Crie um novo projeto UWP no Visual Studio usando o modelo de aplicação Universal Windows para Visual C# ou Visual Basic. Por defeito, todas as aplicações UWP têm como alvo o CoreCLR e as suas versões de lançamento são compiladas usando a cadeia de ferramentas nativa .NET.

2. Note que existem alguns problemas conhecidos de compatibilidade entre compilar projetos de aplicações UWP com a cadeia de ferramentas .NET Native e sem ela. Consulte o guia de migração para obter mais informações.

Agora pode escrever código em C# ou Visual Basic contra a área de superfície nativa .NET que corre no sistema local (ou no simulador).

Por defeito, as compilações de depuração são compiladas em JIT para permitir uma rápida implementação do F5, enquanto as versões de lançamento são compiladas utilizando a tecnologia de pré-compilação .NET Native. Isto significa que deve construir e testar as compilações de depuração da sua aplicação para garantir que funcionam normalmente antes de as compilar com a cadeia de ferramentas .NET Native.

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 desenvolveres em Visual Basic, encontra-se na pasta My Project do teu 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, DataContractJsonSerializer e 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 mais informações, consulte a secção "Microsoft Serializadores" 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 binaries .NET Native são colocados no subdiretório ILC.out do diretório especificado na caixa de texto Build output path da caixa de diálogo Properties do projeto, aba Compile. Binaries que não estão nesta pasta não foram compilados com .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 tiver testado e depurado as compilações de depuração da sua aplicação e estiver confiante de que eliminou as exceções MissingMetadataException e MissingInteropDataException, deve testar a sua aplicação como uma aplicação otimizada .NET Nativa. 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 vais encontrar com .NET Native e que não encontras no ambiente de trabalho é uma exceção de runtime MissingMetadataException, MissingInteropDataException, ou 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 Runtime em .NET Native Apps

Ver também

• Diretivas de Tempo de Execução (rd.xml) Referência do Arquivo de Configuração
• .NET Nativo e Compilação
• Reflection e .NET Nativo
• APIs que dependem da Reflexão
• Serialização e Metadados
• migrar a sua aplicação Windows 8.x para .NET nativa