Use o Sistema de Gerenciamento de Recursos do Windows 10 em um app ou jogo herdadoUse the Windows 10 Resource Management System in a legacy app or game

Os apps e jogos .NET e Win32 geralmente são localizados em diferentes idiomas para expandir totalmente o mercado ao qual se destinam..NET and Win32 apps and games are often localized into different languages to expand their total addressable market. Para obter mais informações sobre a proposta de valor de localização do aplicativo, consulte Globalização e localização.For more info about the value proposition of localizing your app, see Globalization and localization. Empacotando o aplicativo ou jogo .NET ou Win32 como um pacote .msix ou .appx, você pode aproveitar o Sistema de Gerenciamento de Recursos para carregar recursos de aplicativo personalizados para o contexto de runtime.By packaging your .NET or Win32 app or game as an .msix or .appx package, you can leverage the Resource Management System to load app resources tailored to the run-time context. Este tópico detalhado descreve as técnicas.This in-depth topic describes the techniques.

Há muitas maneiras de localizar um aplicativo Win32 tradicionais, mas o Windows 8 introduziu um novo sistema de gerenciamento de recursos que funciona entre linguagens de programação, entre tipos de aplicativos e fornece uma funcionalidade que transcende a simples localização.There are many ways to localize a traditional Win32 application, but Windows 8 introduced a new resource-management system that works across programming languages, across application types, and provides functionality over and above simple localization. Esse sistema será chamado de "MRT" neste tópico.This system will be referred to as "MRT" in this topic. Antigamente, a sigla significava "Modern Resource Technology", mas o termo "Modern" deixou de ser utilizado.Historically, that stood for "Modern Resource Technology" but the term "Modern" has been discontinued. O gerenciador de recursos também pode ser conhecido como MRM (Modern Resource Manager) ou PRI ( Índice de Recurso do Pacote).The resource manager might also be known as MRM (Modern Resource Manager) or PRI (Package Resource Index).

Combinado com a implantação baseada em MSIX ou. Appx (por exemplo, da Microsoft Store), o MRT pode fornecer automaticamente os recursos mais aplicáveis a um determinado usuário/dispositivo, o que minimiza o download e o tamanho da instalação do seu aplicativo.Combined with MSIX-based or .appx-based deployment (for example, from the Microsoft Store), MRT can automatically deliver the most-applicable resources for a given user / device which minimizes the download and install size of your application. Essa redução de tamanho pode ser significativa para aplicativos com uma grande quantidade de conteúdo localizado, talvez na ordem de vários gigabytes para jogos AAA.This size reduction can be significant for applications with a large amount of localized content, perhaps on the order of several gigabytes for AAA games. Os benefícios adicionais do MRT incluem listagens localizadas no Shell do Windows e na Microsoft Store, lógica de fallback automática quando o idioma preferencial de um usuário não corresponde aos recursos disponíveis.Additional benefits of MRT include localized listings in the Windows Shell and the Microsoft Store, automatic fallback logic when a user's preferred language doesn't match your available resources.

Este documento descreve a arquitetura de alto nível do MRT e fornece um guia de portabilidade para ajudar a migrar aplicativos Win32 herdados para MRT com o mínimo de alterações no código.This document describes the high-level architecture of MRT and provides a porting guide to help move legacy Win32 applications to MRT with minimal code changes. Depois que a migração para o MRT é feita, benefícios adicionais (por exemplo, a capacidade de segmentar recursos por fator de escala ou tema do sistema) são disponibilizados para o desenvolvedor.Once the move to MRT is made, additional benefits (such as the ability to segment resources by scale factor or system theme) become available to the developer. Observe que a localização baseada em MRT funciona para aplicativos UWP e Win32 processados pela Ponte de Desktop (também conhecida como "Centennial").Note that MRT-based localization works for both UWP applications and Win32 applications processed by the Desktop Bridge (aka "Centennial").

Em muitas situações, você pode continuar usando o código-fonte e os formatos de localização existentes, integrando-se, ao mesmo tempo, ao MRT para resolver recursos em tempo de execução e minimizar os tamanhos dos downloads; não é uma abordagem "tudo ou nada".In many situations, you can continue to use your existing localization formats and source code whilst integrating with MRT for resolving resources at runtime and minimizing download sizes - it's not an all-or-nothing approach. A tabela a seguir resume o trabalho e o custo estimado/benefício de cada estágio.The following table summarizes the work and estimated cost/benefit of each stage. Esta tabela não inclui tarefas de não localização, como fornecimento de ícones de aplicativos de alta resolução ou de alto contraste.This table doesn't include non-localization tasks, such as providing high-resolution or high-contrast application icons. Para obter mais informações sobre como fornecer vários ativos para blocos, ícones etc., consulte Personalizar os recursos para idioma, escala, alto contraste e outros qualificadores.For more info about providing multiple assets for tiles, icons, etc., See Tailor your resources for language, scale, high contrast, and other qualifiers.

TrabalhoWork BenefícioBenefit Custo estimadoEstimated cost
Localizar manifesto do pacoteLocalize package manifest Descobrir o mínimo de trabalho necessário para que o conteúdo localizado apareça no Shell do Windows e na Microsoft StoreBare minimum work required to have your localized content appear in the Windows Shell and in the Microsoft Store PequenoSmall
Usar o MRT para identificar e localizar recursosUse MRT to identify and locate resources Pré-requisito para minimizar os tamanhos dos downloads e das instalações; fallback de idioma automáticoPre-requisite to minimizing download and install sizes; automatic language fallback MédiaMedium
Criar pacotes de recursosBuild resource packs Etapa final para minimizar os tamanhos dos downloads e das instalaçõesFinal step to minimize download and install sizes PequenoSmall
Migrar para formatos de recurso MRT e APIsMigrate to MRT resource formats and APIs Tamanhos de arquivo significativamente menores (dependendo da tecnologia de recurso existente)Significantly smaller file sizes (depending on existing resource technology) GrandeLarge

IntroduçãoIntroduction

A maioria dos aplicativos não triviais contém elementos de interface do usuário conhecidos como recursos, que são dissociados do código do aplicativo (em contraposição aos valores embutidos em código criados no próprio código-fonte).Most non-trivial applications contain user-interface elements known as resources that are decoupled from the application's code (contrasted with hard-coded values that are authored in the source code itself). Há vários motivos para preferirmos os recursos, em vez dos valores embutidos em código: a facilidade de edição por não desenvolvedores é um deles, por exemplo; mas um dos principais motivos é permitir que o aplicativo selecione representações diferentes do mesmo recurso lógico em tempo de execução.There are several reasons to prefer resources over hard-coded values - ease of editing by non-developers, for example - but one of the key reasons is to enable the application to pick different representations of the same logical resource at runtime. Por exemplo, o texto a ser exibido em um botão (ou a imagem a ser exibida em um ícone) pode ser diferente dependendo dos idiomas que o usuário compreende, as características do dispositivo de exibição ou se o usuário tem alguma tecnologia adaptativa habilitada.For example, the text to display on a button (or the image to display in an icon) might differ depending on the language(s) the user understands, the characteristics of the display device, or whether the user has any assistive technologies enabled.

Desse modo, o objetivo principal de qualquer tecnologia de gerenciamento de recursos é converter, em tempo de execução, uma solicitação de nome de recurso lógico ou simbólico (como SAVE_BUTTON_LABEL) de um conjunto de candidatos possíveis (por exemplo, "Salvar", "Speichern" ou "저장") no melhor valor real possível (por exemplo, "Salvar").Thus the primary purpose of any resource-management technology is to translate, at runtime, a request for a logical or symbolic resource name (such as SAVE_BUTTON_LABEL) into the best possible actual value (eg, "Save") from a set of possible candidates (eg, "Save", "Speichern", or "저장"). O MRT fornece essa função e permite que os aplicativos identifiquem os candidatos a recursos usando uma ampla variedade de atributos, chamados qualificadores, como o idioma do usuário, o fator de escala da exibição, o tema selecionado pelo usuário e outros fatores ambientais.MRT provides such a function, and enables applications to identify resource candidates using a wide variety of attributes, called qualifiers, such as the user's language, the display scale-factor, the user's selected theme, and other environmental factors. O MRT oferece até mesmo suporte a qualificadores personalizados em aplicativos que precisam dele (por exemplo, um aplicativo pode fornecer ativos de gráfico diferentes para os usuários que fizeram logon usando uma conta x usuários convidados, sem adicionar explicitamente essa verificação em cada parte do aplicativo).MRT even supports custom qualifiers for applications that need it (for example, an application could provide different graphic assets for users that had logged in with an account vs. guest users, without explicitly adding this check into every part of their application). O MRT funciona com recursos de cadeia de caracteres e recursos baseados em arquivo; estes últimos são implementados como referências aos dados externos (os arquivos propriamente ditos).MRT works with both string resources and file-based resources, where file-based resources are implemented as references to the external data (the files themselves).

ExemploExample

Este é um exemplo simples de um aplicativo que tem rótulos de texto em dois botões (openButton e saveButton) e um arquivo PNG usado para um logotipo (logoImage).Here's a simple example of an application that has text labels on two buttons (openButton and saveButton) and a PNG file used for a logo (logoImage). Os rótulos de texto são localizados em inglês e alemão, e o logotipo é otimizado para desktops normais (fator de escala 100%) e telefones de alta resolução (fator de escala 300%).The text labels are localized into English and German, and the logo is optimized for normal desktop displays (100% scale factor) and high-resolution phones (300% scale factor). Observe que este diagrama apresenta uma visão geral conceitual do modelo; ele não é mapeado exatamente para a implementação.Note that this diagram presents a high-level, conceptual view of the model; it does not map exactly to implementation.

Captura de tela de um rótulo de código-fonte, um rótulo de tabela de pesquisa e um rótulo de arquivos em disco.

No gráfico, o código do aplicativo faz referência aos três nomes de recurso lógico.In the graphic, the application code references the three logical resource names. Em tempo de execução, a pseudofunção GetResource usa o MRT para analisar esses nomes de recurso na tabela de recursos (conhecida como arquivo PRI) e localizar o candidato mais apropriado com base nas condições ambientais (o idioma do usuário e o fator de escala do visor).At runtime, the GetResource pseudo-function uses MRT to look those resource names up in the resource table (known as PRI file) and find the most appropriate candidate based on the ambient conditions (the user's language and the display's scale-factor). No caso dos rótulos, as cadeias de caracteres são usadas diretamente.In the case of the labels, the strings are used directly. No caso da imagem do logotipo, as cadeias de caracteres são interpretadas como nomes de arquivo, e os arquivos são lidos no disco.In the case of the logo image, the strings are interpreted as filenames and the files are read off disk.

Se o usuário fala em um idioma diferente do inglês ou do alemão, ou tem um fator de escala de exibição diferente de 100% ou 300%, o MRT escolhe o candidato de correspondência "mais próximo" com base em um conjunto de regras de fallback (consulte o sistema de gerenciamento de recursos para obter mais informações).If the user speaks a language other than English or German, or has a display scale-factor other than 100% or 300%, MRT picks the "closest" matching candidate based on a set of fallback rules (see Resource Management System for more background).

Observe que o MRT dá suporte a recursos que são personalizados para mais de um qualificador; por exemplo, se a imagem do logotipo continha texto inserido que também precisava ser localizado, o logotipo teria quatro candidatos: EN/Scale-100, DE/Scale-100, EN/Scale-300 e DE/Scale-300.Note that MRT supports resources that are tailored to more than one qualifier - for example, if the logo image contained embedded text that also needed to be localized, the logo would have four candidates: EN/Scale-100, DE/Scale-100, EN/Scale-300 and DE/Scale-300.

Seções deste documentoSections in this document

As seções a seguir descrevem as tarefas de alto nível necessárias para integrar o MRT ao aplicativo.The following sections outline the high-level tasks required to integrate MRT with your application.

Fase 0: Criar um pacote de aplicativosPhase 0: Build an application package

Esta seção descreve como obter o aplicativo de área de trabalho existente criando como um pacote de aplicativos.This section outlines how to get your existing Desktop application building as an application package. Nenhum recurso MRT é usado neste estágio.No MRT features are used at this stage.

Fase 1: Localizar o manifesto do aplicativoPhase 1: Localize the application manifest

Esta seção descreve como localizar o manifesto do aplicativo (para que ele seja exibido corretamente no Shell do Windows), usando ainda o formato de recurso herdado e a API para empacotar e localizar recursos.This section outlines how to localize your application's manifest (so that it appears correctly in the Windows Shell) whilst still using your legacy resource format and API to package and locate resources.

Fase 2: Usar o MRT para identificar e localizar recursosPhase 2: Use MRT to identify and locate resources

Esta seção descreve como modificar o código do aplicativo (e possivelmente o layout do recurso) para localizar recursos usando o MRT, usando ainda os formatos de recurso e APIs existentes para carregar e consumir os recursos.This section outlines how to modify your application code (and possibly resource layout) to locate resources using MRT, whilst still using your existing resource formats and APIs to load and consume the resources.

Fase 3: Criar pacotes de recursosPhase 3: Build resource packs

Esta seção descreve as alterações finais necessárias para separar os recursos em pacotes de recursos distintos, minimizando o tamanho do download e (da instalação) do aplicativo.This section outlines the final changes needed to separate your resources into separate resource packs, minimizing the download (and install) size of your app.

Não abordado neste documentoNot covered in this document

Depois de concluir as fases 0-3 acima, você terá um "pacote" de aplicativo que pode ser enviado ao Microsoft Store e que minimizará o download e o tamanho da instalação para os usuários omitindo os recursos que eles não precisam (por exemplo, os idiomas que não falam).After completing Phases 0-3 above, you will have an application "bundle" that can be submitted to the Microsoft Store and that will minimize the download and install size for users by omitting the resources they don't need (eg, languages they don't speak). É possível fazer melhorias adicionais no tamanho e na funcionalidade do aplicativo através da execução de uma etapa final.Further improvements in application size and functionality can be made by taking one final step.

Etapa 4: Migrar para formatos de recurso MRT e APIsPhase 4: Migrate to MRT resource formats and APIs

Esta fase está além do escopo deste documento. Ela envolve a migração dos recursos (principalmente as cadeias de caracteres) de formatos herdados, como DLLs MUI ou assemblies de recurso .NET, para arquivos PRI.This phase is beyond the scope of this document; it entails moving your resources (particularly strings) from legacy formats such as MUI DLLs or .NET resource assemblies into PRI files. Ela pode resultar em economia de espaço adicional para tamanhos de download e instalação.This can lead to further space savings for download & install sizes. Ele também permite o uso de outros recursos MRT, como minimizar o download e a instalação de arquivos de imagem com base no fator de escala, nas configurações de acessibilidade etc.It also allows use of other MRT features such as minimizing the download and install of image files by based on scale factor, accessibility settings, and so on.

Fase 0: Criar um pacote de aplicativosPhase 0: Build an application package

Antes de fazer qualquer alteração nos recursos do aplicativo, primeiro você deve substituir a tecnologia de empacotamento e instalação atual pela tecnologia de empacotamento e implantação de UWP padrão.Before you make any changes to your application's resources, you must first replace your current packaging and installation technology with the standard UWP packaging and deployment technology. Há três modos de fazer isso:There are three ways to do this:

  • Se você tiver um aplicativo de área de trabalho grande com um instalador complexo ou se utilizar muitos pontos de extensibilidade do sistema operacional, poderá usar a ferramenta de conversão de aplicativo da área de trabalho para gerar o layout do arquivo UWP e as informações de manifesto do instalador do aplicativo existente (por exemplo, um MSI).If you have a large desktop application with a complex installer or you utilize lots of OS extensibility points, you can use the Desktop App Converter tool to generate the UWP file layout and manifest information from your existing app installer (for example, an MSI).
  • Se você tiver um aplicativo de área de trabalho menor com relativamente poucos arquivos ou um instalador simples e sem ganchos de extensibilidade, poderá criar manualmente o layout do arquivo e as informações do manifesto.If you have a smaller desktop application with relatively few files or a simple installer and no extensibility hooks, you can create the file layout and manifest information manually.
  • Se você estiver recompilando da origem e quiser atualizar seu aplicativo para ser um aplicativo UWP puro, poderá criar um novo projeto no Visual Studio e confiar no IDE para fazer grande parte do trabalho para você.If you're rebuilding from source and want to update your app to be a pure UWP application, you can create a new project in Visual Studio and rely on the IDE to do much of the work for you.

Se você quiser usar o conversor de aplicativo de área de trabalho, confira empacotar um aplicativo de área de trabalho usando o conversor de aplicativo de desktop para obter mais informações sobre o processo de conversão.If you want to use the Desktop App Converter, see Package a desktop application using the Desktop App Converter for more information on the conversion process. Um conjunto completo de exemplos do Desktop Converter pode ser encontrado no repositório Exemplos de Ponte de Desktop para UWP do GitHub.A complete set of Desktop Converter samples can be found on the Desktop Bridge to UWP samples GitHub repo.

Se desejar criar o pacote manualmente, você precisará criar uma estrutura de diretório que inclua todos os arquivos do aplicativo (executáveis e conteúdo, mas não código-fonte) e um arquivo de manifesto de pacote (. appxmanifest).If you want to manually create the package, you will need to create a directory structure that includes all your application's files (executables and content, but not source code) and a package manifest file (.appxmanifest). Um exemplo pode ser encontrado no exemplo Hello, World GitHub, mas um arquivo de manifesto de pacote básico que executa o executável da área de trabalho chamado ContosoDemo.exe é o seguinte, em que o texto realçado seria substituído por seus próprios valores.An example can be found in the Hello, World GitHub sample, but a basic package manifest file that runs the desktop executable named ContosoDemo.exe is as follows, where the highlighted text would be replaced by your own values.

<?xml version="1.0" encoding="utf-8" ?>
<Package xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
         xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest"
         xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
         xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
         IgnorableNamespaces="uap mp rescap">
    <Identity Name="Contoso.Demo"
              Publisher="CN=Contoso.Demo"
              Version="1.0.0.0" />
    <Properties>
    <DisplayName>Contoso App</DisplayName>
    <PublisherDisplayName>Contoso, Inc</PublisherDisplayName>
    <Logo>Assets\StoreLogo.png</Logo>
  </Properties>
    <Dependencies>
    <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.14393.0" 
                        MaxVersionTested="10.0.14393.0" />
  </Dependencies>
    <Resources>
    <Resource Language="en-US" />
  </Resources>
    <Applications>
    <Application Id="ContosoDemo" Executable="ContosoDemo.exe" 
                 EntryPoint="Windows.FullTrustApplication">
    <uap:VisualElements DisplayName="Contoso Demo" BackgroundColor="#777777" 
                        Square150x150Logo="Assets\Square150x150Logo.png" 
                        Square44x44Logo="Assets\Square44x44Logo.png" 
        Description="Contoso Demo">
      </uap:VisualElements>
    </Application>
  </Applications>
    <Capabilities>
    <rescap:Capability Name="runFullTrust" />
  </Capabilities>
</Package>

Para obter mais informações sobre o arquivo de manifesto do pacote e o layout do pacote, consulte manifesto do pacote de aplicativo.For more information about the package manifest file and package layout, see App package manifest.

Por fim, se você estiver usando o Visual Studio para criar um novo projeto e migrar seu código existente para dentro do, consulte criar um aplicativo "Olá, mundo".Finally, if you're using Visual Studio to create a new project and migrate your existing code across, see Create a "Hello, world" app. Você pode incluir o código existente no novo projeto, mas provavelmente terá que fazer alterações significativas de código (particularmente na interface do usuário) para executar como um aplicativo UWP puro.You can include your existing code into the new project, but you will likely have to make significant code changes (particularly in the user interface) in order to run as a pure UWP app. Essas alterações estão fora do escopo deste documento.These changes are outside the scope of this document.

Fase 1: localizar o manifestoPhase 1: Localize the manifest

Etapa 1,1: atualizar cadeias de caracteres & ativos no manifestoStep 1.1: Update strings & assets in the manifest

Na fase 0, você criou um arquivo de manifesto de pacote básico (. appxmanifest) para seu aplicativo (com base nos valores fornecidos ao conversor, extraído do MSI ou inserido manualmente no manifesto), mas ele não conterá informações localizadas, nem dará suporte a recursos adicionais como ativos de bloco inicial de alta resolução, etc.In Phase 0 you created a basic package manifest (.appxmanifest) file for your application (based on values provided to the converter, extracted from the MSI, or manually entered into the manifest) but it will not contain localized information, nor will it support additional features like high-resolution Start tile assets, etc.

Para garantir que o nome e a descrição do seu aplicativo sejam localizados corretamente, você deve definir alguns recursos em um conjunto de arquivos de recursos e atualizar o manifesto do pacote para referenciá-los.To ensure your application's name and description are correctly localized, you must define some resources in a set of resource files, and update the package manifest to reference them.

Criando um arquivo de recurso padrãoCreating a default resource file

A primeira etapa é criar um arquivo de recurso padrão no seu idioma padrão (por exemplo, Português (Brasil)).The first step is to create a default resource file in your default language (eg, US English). Você pode fazer isso manualmente com um editor de texto ou por meio do Designer de Recursos no Visual Studio.You can do this either manually with a text editor, or via the Resource Designer in Visual Studio.

Se você quiser criar os recursos manualmente:If you want to create the resources manually:

  1. Crie um arquivo XML denominado resources.resw e coloque-o na subpasta Strings\en-us do projeto.Create an XML file named resources.resw and place it in a Strings\en-us subfolder of your project. Use o código BCP-47 apropriado se o idioma padrão não for inglês dos EUA.Use the appropriate BCP-47 code if your default language is not US English.
  2. No arquivo XML, adicione o conteúdo a seguir, no qual o texto realçado é substituído pelo texto apropriado do app, no idioma padrão.In the XML file, add the following content, where the highlighted text is replaced with the appropriate text for your app, in your default language.

Observação

Há restrições quanto aos comprimentos de algumas dessas cadeias de caracteres.There are restrictions on the lengths of some of these strings. Para obter mais informações, consulte VisualElements.For more info, see VisualElements.

<?xml version="1.0" encoding="utf-8"?>
<root>
  <data name="ApplicationDescription">
    <value>Contoso Demo app with localized resources (English)</value>
  </data>
  <data name="ApplicationDisplayName">
    <value>Contoso Demo Sample (English)</value>
  </data>
  <data name="PackageDisplayName">
    <value>Contoso Demo Package (English)</value>
  </data>
  <data name="PublisherDisplayName">
    <value>Contoso Samples, USA</value>
  </data>
  <data name="TileShortName">
    <value>Contoso (EN)</value>
  </data>
</root>

Se você quiser usar o designer no Visual Studio:If you want to use the designer in Visual Studio:

  1. Crie a Strings\en-us pasta (ou outra linguagem conforme apropriado) em seu projeto e adicione um novo item à pasta raiz do seu projeto, usando o nome padrão de resources.resw .Create the Strings\en-us folder (or other language as appropriate) in your project and add a New Item to the root folder of your project, using the default name of resources.resw. Certifique-se de escolher arquivo de recursos (. resw) e não dicionário de recursos -um dicionário de recursos é um arquivo usado por aplicativos XAML.Be sure to choose Resources File (.resw) and not Resource Dictionary - a Resource Dictionary is a file used by XAML applications.
  2. Usando o designer, insira as seguintes cadeias de caracteres (use os mesmos Names, mas substitua os Values pelo texto apropriado para o aplicativo):Using the designer, enter the following strings (use the same Names but replace the Values with the appropriate text for your application):

Captura de tela de um rótulo de código-fonte, um rótulo de tabela de pesquisa e um rótulo de arquivos em disco.

Observação

Se começar com o designer do Visual Studio, você sempre poderá editar o XML diretamente pressionando F7 .If you start with the Visual Studio designer, you can always edit the XML directly by pressing F7. Mas, se você começar com um arquivo XML mínimo, o designer não reconhecerá o arquivo por não ter vários metadados adicionais; você pode corrigir isso copiando as informações XSD clichês de um arquivo gerado pelo designer para o arquivo XML editado manualmente.But if you start with a minimal XML file, the designer will not recognize the file because it's missing a lot of additional metadata; you can fix this by copying the boilerplate XSD information from a designer-generated file into your hand-edited XML file.

Atualizar o manifesto para fazer referência aos recursosUpdate the manifest to reference the resources

Depois que você tiver os valores definidos no .resw arquivo, a próxima etapa será atualizar o manifesto para referenciar as cadeias de caracteres de recurso.After you have the values defined in the .resw file, the next step is to update the manifest to reference the resource strings. Mais uma vez, você pode editar um arquivo XML diretamente ou contar com o Designer de Manifesto do Visual Studio.Again, you can edit an XML file directly, or rely on the Visual Studio Manifest Designer.

Se você estiver editando o XML diretamente, abra o arquivo AppxManifest.xml e faça as seguintes alterações nos valores realçados - use exatamente este texto, e não o texto específico do seu aplicativo.If you are editing XML directly, open the AppxManifest.xml file and make the following changes to the highlighted values - use this exact text, not text specific to your application. Não há nenhuma exigência para o uso desses nomes de recurso exatos; você pode escolher o nome, desde que ele corresponda exatamente ao que estiver no arquivo .resw.There is no requirement to use these exact resource names—you can choose your own—but whatever you choose must exactly match whatever is in the .resw file. Esses nomes devem corresponder aos Names criados no arquivo .resw, prefixados com o esquema ms-resource: e o namespace Resources/.These names should match the Names you created in the .resw file, prefixed with the ms-resource: scheme and the Resources/ namespace.

Observação

Muitos elementos do manifesto foram omitidos deste trecho de código-não exclua nada!Many elements of the manifest have been omitted from this snippet - do not delete anything!

<?xml version="1.0" encoding="utf-8"?>
<Package>
  <Properties>
    <DisplayName>ms-resource:Resources/PackageDisplayName</DisplayName>
    <PublisherDisplayName>ms-resource:Resources/PublisherDisplayName</PublisherDisplayName>
  </Properties>
  <Applications>
    <Application>
      <uap:VisualElements DisplayName="ms-resource:Resources/ApplicationDisplayName"
        Description="ms-resource:Resources/ApplicationDescription">
        <uap:DefaultTile ShortName="ms-resource:Resources/TileShortName">
          <uap:ShowNameOnTiles>
            <uap:ShowOn Tile="square150x150Logo" />
          </uap:ShowNameOnTiles>
        </uap:DefaultTile>
      </uap:VisualElements>
    </Application>
  </Applications>
</Package>

Se você estiver usando o designer de manifesto do Visual Studio, abra o arquivo. appxmanifest e altere os valores de valores realçados na guia *aplicativo e na guia empacotamento :If you are using the Visual Studio manifest designer, open the .appxmanifest file and change the highlighted values values in the *Application tab and the Packaging tab:

Captura de tela de um rótulo de código-fonte, um rótulo de tabela de pesquisa e um rótulo de arquivos em disco.

Captura de tela de um rótulo de código-fonte, um rótulo de tabela de pesquisa e um rótulo de arquivos em disco.

Etapa 1,2: compilar o arquivo PRI, criar um pacote MSIX e verificar se ele está funcionandoStep 1.2: Build PRI file, make an MSIX package, and verify it's working

Agora você poderá criar o arquivo .pri e implantar o aplicativo para verificar se as informações corretas (em seu idioma padrão) estão aparecendo no menu Iniciar.You should now be able to build the .pri file and deploy the application to verify that the correct information (in your default language) is appearing in the Start Menu.

Se você estiver criando no Visual Studio, basta pressionar Ctrl+Shift+B para compilar o projeto e, em seguida, clicar com o botão direito do mouse no projeto e escolher Deploy no menu de contexto.If you're building in Visual Studio, simply press Ctrl+Shift+B to build the project and then right-click on the project and choose Deploy from the context menu.

Se você estiver compilando manualmente, siga estas etapas para criar um arquivo de configuração para a MakePRI ferramenta e para gerar o .pri próprio arquivo (mais informações podem ser encontradas no empacotamento manual do aplicativo):If you're building manually, follow these steps to create a configuration file for MakePRI tool and to generate the .pri file itself (more information can be found in Manual app packaging):

  1. Abra um prompt de comando do desenvolvedor na pasta visual studio 2017 ou Visual Studio 2019 no menu iniciar.Open a developer command prompt from the Visual Studio 2017 or Visual Studio 2019 folder in the Start menu.

  2. Alterne para o diretório raiz do projeto (aquele que contém o arquivo. appxmanifest e a pasta cadeias de caracteres ).Switch to the project root directory (the one that contains the .appxmanifest file and the Strings folder).

  3. Digite o comando a seguir, substituindo "contoso_demo.xml" por um nome adequado para seu projeto e "en-US" pelo idioma padrão do seu aplicativo (ou mantenha en-US se aplicável).Type the following command, replacing "contoso_demo.xml" with a name suitable for your project, and "en-US" with the default language of your app (or keep it en-US if applicable). Observe que o arquivo XML é criado no diretório pai (não no diretório do projeto), já que ele não faz parte do aplicativo (você pode escolher qualquer outro diretório desejado, mas certifique-se de substituí-lo em comandos futuros).Note the XML file is created in the parent directory (not in the project directory) since it's not part of the application (you can choose any other directory you want, but be sure to substitute that in future commands).

    makepri createconfig /cf ..\contoso_demo.xml /dq en-US /pv 10.0 /o
    

    Você pode digitar makepri createconfig /? para ver o que cada parâmetro faz, mas, em resumo:You can type makepri createconfig /? to see what each parameter does, but in summary:

    • /cf define o nome de arquivo de configuração (a saída desse comando)/cf sets the Configuration Filename (the output of this command)
    • /dq define os qualificadores padrão, neste caso, o idioma en-US/dq sets the Default Qualifiers, in this case the language en-US
    • /pv define a versão da plataforma, neste caso, Windows 10/pv sets the Platform Version, in this case Windows 10
    • /o define-o para substituir o arquivo de saída se ele existir/o sets it to Overwrite the output file if it exists
  4. Agora você tem um arquivo de configuração, execute MakePRI novamente para procurar recursos no disco e empacotá-los em um arquivo PRI.Now you have a configuration file, run MakePRI again to actually search the disk for resources and package them into a PRI file. Substitua "contoso_demop.xml" pelo nome de arquivo XML usado na etapa anterior e especifique o diretório pai para entrada e saída:Replace "contoso_demop.xml" with the XML filename you used in the previous step, and be sure to specify the parent directory for both input and output:

    makepri new /pr . /cf ..\contoso_demo.xml /of ..\resources.pri /mf AppX /o
    

    Você pode digitar makepri new /? para ver o que cada parâmetro faz, mas, em resumo:You can type makepri new /? to see what each parameter does, but in a nutshell:

    • /pr define a raiz do projeto (nesse caso, o diretório atual)/pr sets the Project Root (in this case, the current directory)
    • /cf define o nome de arquivo de configuração, criado na etapa anterior/cf sets the Configuration Filename, created in the previous step
    • /of define o arquivo de saída/of sets the Output File
    • /mf Cria um arquivo de mapeamento (para que possamos excluir arquivos no pacote em uma etapa posterior)/mf creates a Mapping File (so we can exclude files in the package in a later step)
    • /o define-o para substituir o arquivo de saída se ele existir/o sets it to Overwrite the output file if it exists
  5. Agora você tem um arquivo .pri com os recursos de idioma padrão (por exemplo, en-US).Now you have a .pri file with the default language resources (eg, en-US). Para verificar se ele funcionou corretamente, execute o comando a seguir:To verify that it worked correctly, you can run the following command:

    makepri dump /if ..\resources.pri /of ..\resources /o
    

    Você pode digitar makepri dump /? para ver o que cada parâmetro faz, mas, em resumo:You can type makepri dump /? to see what each parameter does, but in a nutshell:

    • /if define o nome de arquivo de entrada/if sets the Input Filename
    • /of define o nome de arquivo de saída ( .xml será anexado automaticamente)/of sets the Output Filename (.xml will be appended automatically)
    • /o define-o para substituir o arquivo de saída se ele existir/o sets it to Overwrite the output file if it exists
  6. Por fim, você pode abrir ..\resources.xmlem um editor de texto e verificar se ele lista os valores <NamedResource> (como ApplicationDescription e PublisherDisplayName) juntamente com os valores <Candidate> do idioma padrão escolhido (haverá outro conteúdo no início do arquivo; ignore isso por enquanto).Finally, you can open ..\resources.xml in a text editor and verify it lists your <NamedResource> values (like ApplicationDescription and PublisherDisplayName) along with <Candidate> values for your chosen default language (there will be other content in the beginning of the file; ignore that for now).

Você pode abrir o arquivo de mapeamento ..\resources.map.txt para verificar se ele contém os arquivos necessários para seu projeto (incluindo o arquivo PRI, que não faz parte do diretório do projeto).You can open the mapping file ..\resources.map.txt to verify it contains the files needed for your project (including the PRI file, which is not part of the project's directory). Importante: o arquivo de mapeamento não incluirá uma referência ao arquivo resources.resw porque o conteúdo desse arquivo já foi inserido no arquivo PRI.Importantly, the mapping file will not include a reference to your resources.resw file because the contents of that file have already been embedded in the PRI file. No entanto, ele conterá outros recursos, como os nomes de arquivo das imagens.It will, however, contain other resources like the filenames of your images.

Criando e assinando o pacoteBuilding and signing the package

Agora que o arquivo PRI já foi criado, você pode criar e assinar o pacote:Now the PRI file is built, you can build and sign the package:

  1. Para criar o pacote do aplicativo, execute o comando a seguir, substituindo contoso_demo.appx pelo nome do arquivo. msix/. Appx que você deseja criar e escolhendo um diretório diferente para o arquivo (Este exemplo usa o diretório pai; ele pode estar em qualquer lugar, mas não deve ser o diretório do projeto).To create the app package, run the following command replacing contoso_demo.appx with the name of the .msix/.appx file you want to create and making sure to choose a different directory for the file (this sample uses the parent directory; it can be anywhere but should not be the project directory).

    makeappx pack /m AppXManifest.xml /f ..\resources.map.txt /p ..\contoso_demo.appx /o
    

    Você pode digitar makeappx pack /? para ver o que cada parâmetro faz, mas, em resumo:You can type makeappx pack /? to see what each parameter does, but in a nutshell:

    • /m define o arquivo de manifesto a ser usado/m sets the Manifest file to use
    • /f define o arquivo de mapeamento a ser usado (criado na etapa anterior)/f sets the mapping File to use (created in the previous step)
    • /p define o nome do pacote de saída/p sets the output Package name
    • /o define-o para substituir o arquivo de saída se ele existir/o sets it to Overwrite the output file if it exists
  2. Depois que o pacote é criado, ele deve ser assinado.After the package is created, it must be signed. A maneira mais fácil de obter um certificado de assinatura é criando um projeto universal do Windows vazio no Visual Studio e copiando o .pfx arquivo que ele cria, mas você pode criar um manualmente usando os MakeCert Pvk2Pfx utilitários e conforme descrito em como criar um certificado de assinatura de pacote de aplicativo.The easiest way to get a signing certificate is by creating an empty Universal Windows project in Visual Studio and copying the .pfx file it creates, but you can create one manually using the MakeCert and Pvk2Pfx utilities as described in How to create an app package signing certificate.

    Importante

    Se você criar um certificado de assinatura manualmente, certifique-se de colocar os arquivos em um diretório diferente do seu projeto de origem ou da origem do pacote, caso contrário, ele pode ser incluído como parte do pacote, incluindo a chave privada!If you manually create a signing certificate, make sure you place the files in a different directory than your source project or your package source, otherwise it might get included as part of the package, including the private key!

  3. Para assinar o pacote, use o comando a seguir.To sign the package, use the following command. Observe que o Publisher especificado no elemento Identity do AppxManifest.xml deve coincidir com o Subject do certificado (esse não é o elemento <PublisherDisplayName>, que é o nome de exibição localizado que aparecerá para os usuários).Note that the Publisher specified in the Identity element of the AppxManifest.xml must match the Subject of the certificate (this is not the <PublisherDisplayName> element, which is the localized display name to show to users). Como sempre, substitua os nomes de arquivo contoso_demo... pelos nomes apropriados para o projeto e (muito importante) assegure que o arquivo .pfx não está no diretório atual (caso contrário, ele teria sido criado como parte do pacote, incluindo a chave privada de assinatura):As usual, replace the contoso_demo... filenames with the names appropriate for your project, and (very important) make sure the .pfx file is not in the current directory (otherwise it would have been created as part of your package, including the private signing key!):

    signtool sign /fd SHA256 /a /f ..\contoso_demo_key.pfx ..\contoso_demo.appx
    

    Você pode digitar signtool sign /? para ver o que cada parâmetro faz, mas, em resumo:You can type signtool sign /? to see what each parameter does, but in a nutshell:

    • /fd define o algoritmo de síntese de arquivo (SHA256 é o padrão para. AppX)/fd sets the File Digest algorithm (SHA256 is the default for .appx)
    • /a selecionará automaticamente o melhor certificado/a will Automatically select the best certificate
    • /f Especifica o arquivo de entrada que contém o certificado de autenticação/f specifies the input File that contains the signing certificate

Por fim, você pode clicar duas vezes no arquivo .appx para instalá-lo ou, se preferir a linha de comando, você pode abrir um prompt do PowerShell, ir para o diretório que contém o pacote e digitar o seguinte (substituindo contoso_demo.appx pelo nome do pacote):Finally, you can now double-click on the .appx file to install it, or if you prefer the command-line you can open a PowerShell prompt, change to the directory containing the package, and type the following (replacing contoso_demo.appx with your package name):

add-appxpackage contoso_demo.appx

Se você receber erros informando que o certificado não é confiável, verifique se ele é adicionado ao repositório da máquina (e não ao repositório do usuário).If you receive errors about the certificate not being trusted, make sure it is added to the machine store (not the user store). Para adicionar o certificado ao repositório do computador, use a linha de comando ou o Windows Explorer.To add the certificate to the machine store, you can either use the command-line or Windows Explorer.

Para usar a linha de comando:To use the command-line:

  1. Execute um prompt de comando do Visual Studio 2017 ou do Visual Studio 2019 como administrador.Run a Visual Studio 2017 or Visual Studio 2019 command prompt as an Administrator.

  2. Vá para o diretório que contém o arquivo .cer (Lembre-se de verificar se esse arquivo está fora dos diretórios de origem ou de projeto!)Switch to the directory that contains the .cer file (remember to ensure this is outside of your source or project directories!)

  3. Digite o comando a seguir, substituindo contoso_demo.cer pelo nome de arquivo:Type the following command, replacing contoso_demo.cer with your filename:

    certutil -addstore TrustedPeople contoso_demo.cer
    

    Você pode executar certutil -addstore /? para ver o que cada parâmetro faz, mas, em resumo:You can run certutil -addstore /? to see what each parameter does, but in a nutshell:

    • -addstore Adiciona um certificado a um repositório de certificados-addstore adds a certificate to a certificate store
    • TrustedPeople indica o repositório no qual o certificado é colocadoTrustedPeople indicates the store into which the certificate is placed

Para usar o Windows Explorer:To use Windows Explorer:

  1. Navegue até a pasta que contém o arquivo .pfxNavigate to the folder that contains the .pfx file
  2. Clique duas vezes no arquivo .pfx; o Assistente para Importação de Certificados apareceráDouble-click on the .pfx file and the Certicicate Import Wizard should appear
  3. Escolha Local Machine e clique em NextChoose Local Machine and click Next
  4. Aceite a solicitação de elevação de administrador do controle de conta de usuário, se ela aparecer, e clique em NextAccept the User Account Control admin elevation prompt, if it appears, and click Next
  5. Digite a senha para a chave privada, se houver uma, e clique em NextEnter the password for the private key, if there is one, and click Next
  6. Selecione Place all certificates in the following storeSelect Place all certificates in the following store
  7. Clique em Browse e escolha a pasta Trusted People (e não "Trusted Publishers")Click Browse, and choose the Trusted People folder (not "Trusted Publishers")
  8. Clique em Next e, em seguida, FinishClick Next and then Finish

Após adicionar o certificado ao repositório Trusted People, tente instalar o pacote novamente.After adding the certificate to the Trusted People store, try installing the package again.

Você verá seu aplicativo na lista "Todos os Aplicativos" do menu Iniciar, com as informações corretas do arquivo .resw / .pri.You should now see your app appear in the Start Menu's "All Apps" list, with the correct information from the .resw / .pri file. Se aparecer uma cadeia de caracteres em branco ou a cadeia de caracteres ms-resource:..., algo deu errado. Verifique novamente as edições para saber se estão corretas.If you see a blank string or the string ms-resource:... then something has gone wrong - double check your edits and make sure they're correct. Se você clicar com o botão direito do mouse no seu aplicativo no menu Iniciar, poderá fixá-lo como um bloco e verificar se as informações corretas são exibidas nesse local também.If you right-click on your app in the Start Menu, you can Pin it as a tile and verify the correct information is displayed there also.

Etapa 1.3: Adicionar mais idiomas com suporteStep 1.3: Add more supported languages

Depois que as alterações tiverem sido feitas no manifesto do pacote e o resources.resw arquivo inicial tiver sido criado, é fácil adicionar mais idiomas.After the changes have been made to the package manifest and the initial resources.resw file has been created, adding additional languages is easy.

Criar recursos localizados adicionaisCreate additional localized resources

Primeiro, crie os valores de recurso localizados adicionais.First, create the additional localized resource values.

Na pasta Strings, crie pastas adicionais para cada idioma com suporte usando o código BCP-47 apropriado (por exemplo, Strings\de-DE).Within the Strings folder, create additional folders for each language you support using the appropriate BCP-47 code (for example, Strings\de-DE). Em cada uma dessas pastas, crie um arquivo resources.resw (usando um editor XML ou o designer do Visual Studio) que inclua os valores de recurso traduzidos.Within each of these folders, create a resources.resw file (using either an XML editor or the Visual Studio designer) that includes the translated resource values. Parte-se do pressuposto de que as cadeias de caracteres localizadas já existem em algum lugar, e você só precisa copiá-las para o arquivo .resw; este documento não abrange a etapa de tradução.It is assumed you already have the localized strings available somewhere, and you just need to copy them into the .resw file; this document does not cover the translation step itself.

Por exemplo, o arquivo Strings\de-DE\resources.resw teria esta aparência, com o texto realçado alterado de en-US:For example, the Strings\de-DE\resources.resw file might look like this, with the highlighted text changed from en-US:

<?xml version="1.0" encoding="utf-8"?>
<root>
  <data name="ApplicationDescription">
    <value>Contoso Demo app with localized resources (German)</value>
  </data>
  <data name="ApplicationDisplayName">
    <value>Contoso Demo Sample (German)</value>
  </data>
  <data name="PackageDisplayName">
    <value>Contoso Demo Package (German)</value>
  </data>
  <data name="PublisherDisplayName">
    <value>Contoso Samples, DE</value>
  </data>
  <data name="TileShortName">
    <value>Contoso (DE)</value>
  </data>
</root>

As etapas a seguir pressupõem que você adicionou recursos para de-DE e fr-FR, mas o mesmo padrão pode ser seguido para qualquer idioma.The following steps assume you added resources for both de-DE and fr-FR, but the same pattern can be followed for any language.

Atualizar o manifesto do pacote para listar os idiomas com suporteUpdate the package manifest to list supported languages

O manifesto do pacote deve ser atualizado para listar os idiomas com suporte do aplicativo.The package manifest must be updated to list the languages supported by the app. O Desktop App Converter adiciona o idioma padrão, mas os outros devem ser adicionados explicitamente.The Desktop App Converter adds the default language, but the others must be added explicitly. Se você estiver editando o arquivo AppxManifest.xml diretamente, atualize o nó Resources da seguinte maneira, adicionando quantos elementos forem necessárias, substituindo os idiomas apropriados com suporte e assegurando que a primeira entrada na lista é o idioma padrão (fallback).If you're editing the AppxManifest.xml file directly, update the Resources node as follows, adding as many elements as you need, and substituting the appropriate languages you support and making sure the first entry in the list is the default (fallback) language. Neste exemplo, o padrão é Inglês (EUA) com suporte adicional para Alemão (Alemanha) e Francês (França):In this example, the default is English (US) with additional support for both German (Germany) and French (France):

<Resources>
  <Resource Language="EN-US" />
  <Resource Language="DE-DE" />
  <Resource Language="FR-FR" />
</Resources>

Se você estiver usando o Visual Studio, não precisará fazer nada; se você analisar o Package.appxmanifest, verá o valor especial x-generate, que faz com que o processo de compilação insira os idiomas encontrados no projeto (com base nas pastas nomeadas com códigos BCP-47).If you are using Visual Studio, you shouldn't need to do anything; if you look at Package.appxmanifest you should see the special x-generate value, which causes the build process to insert the languages it finds in your project (based on the folders named with BCP-47 codes). Observe que esse não é um valor válido para um manifesto de pacote real; Ele funciona apenas para projetos do Visual Studio:Note that this is not a valid value for a real package manifest; it only works for Visual Studio projects:

<Resources>
  <Resource Language="x-generate" />
</Resources>

Crie novamente com os valores localizadosRe-build with the localized values

Agora você pode compilar e implantar o aplicativo novamente e, se você alterar sua preferência de idioma no Windows, verá os valores recém-localizados no menu Iniciar (veja a seguir instruções sobre como alterar o idioma).Now you can build and deploy your application, again, and if you change your language preference in Windows you should see the newly-localized values appear in the Start menu (instructions for how to change your language are below).

No Visual Studio, mais uma vez você pode simplesmente usar Ctrl+Shift+B para criar e clicar com o botão direito do mouse no projeto para Deploy.For Visual Studio, again you can just use Ctrl+Shift+B to build, and right-click the project to Deploy.

Se você estiver criando manualmente o projeto, siga as mesmas etapas acima, mas adicione outros idiomas, separados por sublinhados, à lista de qualificadores padrão (/dq) ao criar o arquivo de configuração.If you're manually building the project, follow the same steps as above but add the additional languages, separated by underscores, to the default qualifiers list (/dq) when creating the configuration file. Por exemplo, para oferecer suporte aos recursos em inglês, alemão e francês adicionados na etapa anterior:For example, to support the English, German, and French resources added in the previous step:

makepri createconfig /cf ..\contoso_demo.xml /dq en-US_de-DE_fr-FR /pv 10.0 /o

Isso criará um arquivo PRI que contém todos os idiomas especificados que você pode usar facilmente no teste.This will create a PRI file that contains all the specified languagesthat you can easily use for testing. Se o tamanho total dos recursos for pequeno ou se você oferecer suporte apenas a um pequeno número de idiomas, isso pode ser aceitável no envio do aplicativo, mas apenas se você quiser os benefícios da minimização dos tamanhos de instalação/download para os recursos nos quais precisa fazer o trabalho adicional de criação de pacotes de idiomas separados.If the total size of your resources is small, or you only support a small number of languages, this might be acceptable for your shipping app; it's only if you want the benefits of minimizing install / download size for your resources that you need to do the additional work of building separate language packs.

Testar com os valores localizadosTest with the localized values

Para testar as novas alterações localizadas, basta adicionar um novo idioma preferencial de interface do usuário ao Windows.To test the new localized changes, you simply add a new preferred UI language to Windows. Não é necessário baixar pacotes de idiomas, reinicializar o sistema ou exibir a interface do usuário do Windows em um idioma estrangeiro.There is no need to download language packs, reboot the system, or have your entire Windows UI appear in a foreign language.

  1. Execute o aplicativo Settings (Windows + I)Run the Settings app (Windows + I)
  2. Acesse Time & languageGo to Time & language
  3. Acesse Region & languageGo to Region & language
  4. Clique em Add a languageClick Add a language
  5. Digite (ou selecione) o idioma desejado (por exemplo, Deutsch ou German)Type (or select) the language you want (eg Deutsch or German)
  • Se houver idiomas secundários, escolha o desejado (por exemplo, Deutsch / Deutschland)If there are sub-languages, choose the one you want (eg, Deutsch / Deutschland)
  1. Selecione o novo idioma na lista de idiomasSelect the new language in the language list
  2. Clique em Set as defaultClick Set as default

Agora, abra o menu Iniciar e procure o aplicativo; você verá os valores localizados do idioma selecionado (pode ser que outros aplicativos também apareçam localizados).Now open the Start menu and search for your application, and you should see the localized values for the selected language (other apps might also appear localized). Se o nome localizado não aparecer imediatamente, aguarde alguns minutos até que o cache do menu Iniciar seja atualizado.If you don't see the localized name right away, wait a few minutes until the Start Menu's cache is refreshed. Para retornar ao idioma nativo, basta torná-lo o idioma padrão na lista de idiomas.To return to your native language, just make it the default language in the language list.

Etapa 1,4: Localizando mais partes do manifesto do pacote (opcional)Step 1.4: Localizing more parts of the package manifest (optional)

Outras seções do manifesto do pacote podem ser localizadas.Other sections of the package manifest can be localized. Por exemplo, se o aplicativo manipular extensões de arquivo, ele deverá ter uma extensão windows.fileTypeAssociation no manifesto, usando o texto realçado em verde exatamente conforme mostrado (desde que ele faça referência aos recursos) e substituindo o texto realçado em amarelo com informações específicas do aplicativo:For example, if your application handles file-extensions then it should have a windows.fileTypeAssociation extension in the manifest, using the green highlighted text exactly as shown (since it will refer to resources), and replacing the yellow highlighted text with information specific to your application:

<Extensions>
  <uap:Extension Category="windows.fileTypeAssociation">
    <uap:FileTypeAssociation Name="default">
      <uap:DisplayName>ms-resource:Resources/FileTypeDisplayName</uap:DisplayName>
      <uap:Logo>Assets\StoreLogo.png</uap:Logo>
      <uap:InfoTip>ms-resource:Resources/FileTypeInfoTip</uap:InfoTip>
      <uap:SupportedFileTypes>
        <uap:FileType ContentType="application/x-contoso">.contoso</uap:FileType>
      </uap:SupportedFileTypes>
    </uap:FileTypeAssociation>
  </uap:Extension>
</Extensions>

Você também pode adicionar essas informações por meio do Designer de Manifesto do Visual Studio, usando a guia Declarations, anotando os valores realçados:You can also add this information using the Visual Studio Manifest Designer, using the Declarations tab, taking note of the highlighted values:

Captura de tela de um rótulo de código-fonte, um rótulo de tabela de pesquisa e um rótulo de arquivos em disco.

Agora, adicione os nomes de recurso correspondentes a cada um dos arquivos .resw, substituindo o texto realçado pelo texto apropriado para seu aplicativo (lembre-se de fazer isso para cada idioma com suporte!):Now add the corresponding resource names to each of your .resw files, replacing the highlighted text with the appropriate text for your app (remember to do this for each supported language!):

... existing content...
<data name="FileTypeDisplayName">
  <value>Contoso Demo File</value>
</data>
<data name="FileTypeInfoTip">
  <value>Files used by Contoso Demo App</value>
</data>

Isso aparecerá em partes do shell do Windows, como o Explorador de Arquivos:This will then show up in parts of the Windows shell, such as File Explorer:

Captura de tela de um rótulo de código-fonte, um rótulo de tabela de pesquisa e um rótulo de arquivos em disco.

Compile e teste o pacote como antes, praticando quaisquer novos cenários que mostrarão as novas cadeias de caracteres da interface do usuário.Build and test the package as before, exercising any new scenarios that should show the new UI strings.

Fase 2: Usar o MRT para identificar e localizar recursosPhase 2: Use MRT to identify and locate resources

A seção anterior mostrou como usar o MRT para localizar o arquivo de manifesto do aplicativo para que o Shell do Windows possa exibir corretamente o nome do aplicativo e outros metadados.The previous section showed how to use MRT to localize your app's manifest file so that the Windows Shell can correctly display the app's name and other metadata. Nenhuma alteração de código foi necessária para isso; foi necessário apenas o uso dos arquivos .resw e de algumas ferramentas adicionais.No code changes were required for this; it simply required the use of .resw files and some additional tools. Esta seção mostrará como usar o MRT para localizar recursos nos formatos de recurso existentes e usando o código de manipulação de recursos existente com alterações mínimas.This section will show how to use MRT to locate resources in your existing resource formats and using your existing resource-handling code with minimal changes.

Suposições sobre o layout de arquivo e o código de aplicativo existentesAssumptions about existing file layout & application code

Como existem muitas maneiras de localizar aplicativos de área de trabalho Win32, este documento fará algumas pressuposições simples sobre a estrutura do aplicativo existente que você precisa para mapear para seu ambiente específico.Because there are many ways to localize Win32 Desktop apps, this paper will make some simplifying assumptions about the existing application's structure that you will need to map to your specific environment. Talvez seja necessário fazer algumas alterações na base de código ou no layout de recurso existente em conformidade com os requisitos do MRT, mas isso está fora do escopo deste documento.You might need to make some changes to your existing codebase or resource layout to conform to the requirements of MRT, and those are largely out of scope for this document.

Layout do arquivo de recursoResource file layout

Este artigo pressupõe que todos os recursos localizados tenham os mesmos nomes de arquivo (por exemplo, ou contoso_demo.exe.mui contoso_strings.dll ou contoso.strings.xml ), mas que eles sejam colocados em pastas diferentes com nomes bcp-47 ( en-US , de-DE , etc.).This article assumes your localized resources all have the same filenames (eg, contoso_demo.exe.mui or contoso_strings.dll or contoso.strings.xml) but that they are placed in different folders with BCP-47 names (en-US, de-DE, etc.). Não importa quantos arquivos de recurso você tenha, quais são seus nomes, quais são seus formatos de arquivo/APIs associadas etc. O que importa é que cada recurso lógico tenha o mesmo nome de arquivo (mas seja colocado em um diretório físico diferente).It doesn't matter how many resource files you have, what their names are, what their file-formats / associated APIs are, etc. The only thing that matters is that every logical resource has the same filename (but placed in a different physical directory).

Por outro lado, se o aplicativo usar uma estrutura de arquivo simples com um único diretório Resources contendo os arquivos english_strings.dll e french_strings.dll, ele não fará um mapeamento satisfatório para o MRT.As a counter-example, if your application uses a flat file-structure with a single Resources directory containing the files english_strings.dll and french_strings.dll, it would not map well to MRT. Uma estrutura melhor seria o diretório Resources com subdiretórios e arquivos en\strings.dll e fr\strings.dll.A better structure would be a Resources directory with subdirectories and files en\strings.dll and fr\strings.dll. Também é possível usar o mesmo nome de arquivo base, mas com qualificadores inseridos, como strings.lang-en.dll e strings.lang-fr.dll; no entanto, o uso de diretórios com os códigos de idioma é conceitualmente mais simples, então, vamos nos concentrar nisso.It's also possible to use the same base filename but with embedded qualifiers, such as strings.lang-en.dll and strings.lang-fr.dll, but using directories with the language codes is conceptually simpler so it's what we'll focus on.

Observação

Ainda é possível usar o MRT e os benefícios do empacotamento, mesmo que você não possa seguir essa Convenção de nomenclatura de arquivo; Ele apenas requer mais trabalho.It is still possible to use MRT and the benefits of packaging even if you can't follow this file naming convention; it just requires more work.

Por exemplo, o aplicativo pode ter um conjunto de comandos de interface do usuário personalizados (usado nos rótulos de botão etc.) em um arquivo de texto simples denominado ui.txt, disposto abaixo da pasta UICommands:For example, the application might have a set of custom UI commands (used for button labels etc.) in a simple text file named ui.txt, laid out under a UICommands folder:

+ ProjectRoot
|--+ Strings
|  |--+ en-US
|  |  \--- resources.resw
|  \--+ de-DE
|     \--- resources.resw
|--+ UICommands
|  |--+ en-US
|  |  \--- ui.txt
|  \--+ de-DE
|     \--- ui.txt
|--- AppxManifest.xml
|--- ...rest of project...

Código de carregamento de recursosResource loading code

Este artigo pressupõe que em algum momento em seu código você deseja localizar o arquivo que contém um recurso localizado, carregá-lo e usá-lo.This article assumes that at some point in your code you want to locate the file that contains a localized resource, load it, and then use it. As APIs usadas para carregar os recursos, as APIs usadas para extrair os recursos etc. não são importantes.The APIs used to load the resources, the APIs used to extract the resources, etc. are not important. Em pseudocódigo, há basicamente três etapas:In pseudocode, there are basically three steps:

set userLanguage = GetUsersPreferredLanguage()
set resourceFile = FindResourceFileForLanguage(MY_RESOURCE_NAME, userLanguage)
set resource = LoadResource(resourceFile) 
    
// now use 'resource' however you want

O MRT requer apenas a alteração das duas primeiras etapas deste processo: como determinar os melhores recursos candidatos e como localizá-los.MRT only requires changing the first two steps in this process - how you determine the best candidate resources and how you locate them. Ele não exige que você mude a forma de carregamento ou uso dos recursos (embora forneça recursos para fazer isso, caso você queira aproveitá-los).It doesn't require you to change how you load or use the resources (although it provides facilities for doing that if you want to take advantage of them).

Por exemplo, o aplicativo pode usar a API Win32 GetUserPreferredUILanguages, a função CRT sprintf e a API Win32 CreateFile para substituir as três funções de pseudocódigo acima e, em seguida, analisar manualmente o arquivo de texto procurando os pares name=value.For example, the application might use the Win32 API GetUserPreferredUILanguages, the CRT function sprintf, and the Win32 API CreateFile to replace the three pseudocode functions above, then manually parse the text file looking for name=value pairs. (Os detalhes não são importantes; o exemplo serve apenas para ilustrar que o MRT não tem impacto sobre as técnicas usadas para manipular recursos depois que eles são localizados).(The details are not important; this is merely to illustrate that MRT has no impact on the techniques used to handle resources once they have been located).

Etapa 2.1: Alterações de código para usar o MRT na localização de arquivosStep 2.1: Code changes to use MRT to locate files

Alternar o código para usar o MRT na localização de recursos não é difícil.Switching your code to use MRT for locating resources is not difficult. Ele requer o uso de alguns tipos de WinRT e algumas linhas de código.It requires using a handful of WinRT types and a few lines of code. Os principais tipos que você usará são:The main types that you will use are as follows:

  • ResourceContext, que encapsula o conjunto atualmente ativo de valores de qualificador (idioma, fator de escala etc.)ResourceContext, which encapsulates the currently active set of qualifier values (language, scale factor, etc.)
  • ResourceManager (a versão WinRT, e não a versão .NET), que permite o acesso a todos os recursos no arquivo PRIResourceManager (the WinRT version, not the .NET version), which enables access to all the resources from the PRI file
  • ResourceMap, que representa um subconjunto específico de recursos no arquivo PRI (neste exemplo, os recursos baseados em arquivo versus os recursos de cadeia de caracteres)ResourceMap, which represents a specific subset of the resources in the PRI file (in this example, the file-based resources vs. the string resources)
  • NamedResource, que representa um recurso lógico e todos os seus candidatos possíveisNamedResource, which represents a logical resource and all its possible candidates
  • ResourceCandidate, que representa um único recurso candidato concretoResourceCandidate, which represents a single concrete candidate resource

No pseudocódigo, esta é a maneira como resolveria um determinado nome de arquivo de recurso (como UICommands\ui.txt no exemplo acima):In pseudo-code, the way you would resolve a given resource file name (like UICommands\ui.txt in the sample above) is as follows:

// Get the ResourceContext that applies to this app
set resourceContext = ResourceContext.GetForViewIndependentUse()
    
// Get the current ResourceManager (there's one per app)
set resourceManager = ResourceManager.Current
    
// Get the "Files" ResourceMap from the ResourceManager
set fileResources = resourceManager.MainResourceMap.GetSubtree("Files")
    
// Find the NamedResource with the logical filename we're looking for,
// by indexing into the ResourceMap
set desiredResource = fileResources["UICommands\ui.txt"]
    
// Get the ResourceCandidate that best matches our ResourceContext
set bestCandidate = desiredResource.Resolve(resourceContext)
   
// Get the string value (the filename) from the ResourceCandidate
set absoluteFileName = bestCandidate.ValueAsString

Observe que o código não solicita uma pasta de idioma específica, por exemplo, UICommands\en-US\ui.txt, mesmo que essa seja a forma como os arquivos existam no disco.Note in particular that the code does not request a specific language folder - like UICommands\en-US\ui.txt - even though that is how the files exist on-disk. Em vez disso, ele solicita o nome de arquivo lógicoUICommands\ui.txt e conta com o MRT para localizar o arquivo em disco apropriado em um dos diretórios de idioma.Instead, it asks for the logical filename UICommands\ui.txt and relies on MRT to find the appropriate on-disk file in one of the language directories.

A partir daqui, o aplicativo de exemplo pode continuar usando CreateFile para carregar absoluteFileName e analisar os pares name=value exatamente como antes; nada dessa lógica precisar mudar no aplicativo.From here, the sample app could continue to use CreateFile to load the absoluteFileName and parse the name=value pairs just as before; none of that logic needs to change in the app. Se você estiver escrevendo em C# ou C++/CX, o código real não é muito mais complicado do que esse (e, na verdade, muitas das variáveis intermediárias podem ser omitidas); consulte a seção Carregando recursos .NET a seguir.If you are writing in C# or C++/CX, the actual code is not much more complicated than this (and in fact many of the intermediate variables can be elided) - see the section on Loading .NET resources, below. Os aplicativos baseados em C++/WRL serão mais complexos devido às APIs de baixo nível baseadas em COM usadas para ativar e chamar as APIs do WinRT, mas as etapas fundamentais necessárias são as mesmas; consulte a seção Carregando recursos MUI Win32 a seguir.C++/WRL-based applications will be more complex due to the low-level COM-based APIs used to activate and call the WinRT APIs, but the fundamental steps you take are the same - see the section on Loading Win32 MUI resources, below.

Carregando recursos .NETLoading .NET resources

Como o .NET tem um mecanismo interno para localizar e carregar recursos (conhecidos como "Assemblies satélites"), não há nenhum código explícito a ser substituído no exemplo resumido anterior; no .NET, basta que as DLLs de recurso estejam nos diretórios apropriados que elas serão localizadas automaticamente para você.Because .NET has a built-in mechanism for locating and loading resources (known as "Satellite Assemblies"), there is no explicit code to replace as in the synthetic example above - in .NET you just need your resource DLLs in the appropriate directories and they are automatically located for you. Quando um aplicativo é empacotado como um MSIX ou. Appx usando pacotes de recursos, a estrutura de diretório é um pouco diferente – em vez de ter os diretórios de recursos em subdiretórios do diretório principal do aplicativo, eles são os pares dele (ou não estarão presentes se o usuário não tiver o idioma listado em suas preferências).When an app is packaged as an MSIX or .appx using resource packs, the directory structure is somewhat different - rather than having the resource directories be subdirectories of the main application directory, they are peers of it (or not present at all if the user doesn't have the language listed in their preferences).

Por exemplo, imagine um aplicativo .NET com o layout a seguir, em que todos os arquivos estão abaixo da pasta MainApp:For example, imagine a .NET application with the following layout, where all the files exist under the MainApp folder:

+ MainApp
|--+ en-us
|  \--- MainApp.resources.dll
|--+ de-de
|  \--- MainApp.resources.dll
|--+ fr-fr
|  \--- MainApp.resources.dll
\--- MainApp.exe

Após a conversão para. Appx, o layout terá uma aparência semelhante a esta, supondo en-US que o idioma padrão e o usuário tenham o alemão e o francês listados em sua lista de idiomas:After conversion to .appx, the layout will look something like this, assuming en-US was the default language and the user has both German and French listed in their language list:

+ WindowsAppsRoot
|--+ MainApp_neutral
|  |--+ en-us
|  |  \--- MainApp.resources.dll
|  \--- MainApp.exe
|--+ MainApp_neutral_resources.language_de
|  \--+ de-de
|     \--- MainApp.resources.dll
\--+ MainApp_neutral_resources.language_fr
   \--+ fr-fr
      \--- MainApp.resources.dll

Como os recursos localizados não existem mais nos subdiretórios abaixo do local de instalação do executável principal, a resolução de recurso .NET interna apresenta falha.Because the localized resources no longer exist in sub-directories underneath the main executable's install location, the built-in .NET resource resolution fails. Felizmente, o .NET tem um mecanismo bem definido para manipulação de tentativas de carregamento de assembly com falha: o evento AssemblyResolve.Luckily, .NET has a well-defined mechanism for handling failed assembly load attempts - the AssemblyResolve event. Um aplicativo .NET que usa o MRT deve se registrar nesse evento e fornecer o assembly ausente do subsistema do recurso .NET.A .NET app using MRT must register for this event and provide the missing assembly for the .NET resource subsystem.

Um exemplo sucinto de como usar as APIs do WinRT para localizar os assemblies satélites usados pelo .NET é apresentado a seguir; o código mostrado é intencionalmente compactado para mostrar uma implementação mínima, embora você possa vê-lo estreitamente mapeado para o pseudocódigo acima, com o ResolveEventArgs transmitido fornecendo o assembly que precisamos localizar.A concise example of how to use the WinRT APIs to locate satellite assemblies used by .NET is as follows; the code as-presented is intentionally compressed to show a minimal implementation, although you can see it maps closely to the pseudo-code above, with the passed-in ResolveEventArgs providing the name of the assembly we need to locate. Uma versão executável desse código (com comentários detalhados e tratamento de erros) pode ser encontrada no arquivo PriResourceRsolver.cs, no exemplo Resolvedor de assembly .NET do GitHub .A runnable version of this code (with detailed comments and error-handling) can be found in the file PriResourceRsolver.cs in the .NET Assembly Resolver sample on GitHub.

static class PriResourceResolver
{
  internal static Assembly ResolveResourceDll(object sender, ResolveEventArgs args)
  {
    var fullAssemblyName = new AssemblyName(args.Name);
    var fileName = string.Format(@"{0}.dll", fullAssemblyName.Name);

    var resourceContext = ResourceContext.GetForViewIndependentUse();
    resourceContext.Languages = new[] { fullAssemblyName.CultureName };

    var resource = ResourceManager.Current.MainResourceMap.GetSubtree("Files")[fileName];

    // Note use of 'UnsafeLoadFrom' - this is required for apps installed with .appx, but
    // in general is discouraged. The full sample provides a safer wrapper of this method
    return Assembly.UnsafeLoadFrom(resource.Resolve(resourceContext).ValueAsString);
  }
}

Dada a classe acima, você adicionaria o seguinte em algum lugar no início do código de inicialização do aplicativo (antes que qualquer recurso localizado precise ser carregado):Given the class above, you would add the following somewhere early-on in your application's startup code (before any localized resources would need to load):

void EnableMrtResourceLookup()
{
  AppDomain.CurrentDomain.AssemblyResolve += PriResourceResolver.ResolveResourceDll;
}

O tempo de execução do .NET acionará o evento AssemblyResolve sempre que não conseguir encontrar as DLLs de recurso; nesse momento, o manipulador de eventos fornecido localizará o arquivo desejado via MRT e retornará o assembly.The .NET runtime will raise the AssemblyResolve event whenever it can't find the resource DLLs, at which point the provided event handler will locate the desired file via MRT and return the assembly.

Observação

Se seu aplicativo já tiver um AssemblyResolve manipulador para outras finalidades, você precisará integrar o código de resolução de recursos com o código existente.If your app already has an AssemblyResolve handler for other purposes, you will need to integrate the resource-resolving code with your existing code.

Carregando recursos MUI Win32Loading Win32 MUI resources

O carregamento de recursos MUI Win32 é basicamente igual ao carregamento de assemblies satélites .NET, só que usando código C++/CX ou C++/WRL.Loading Win32 MUI resources is essentially the same as loading .NET Satellite Assemblies, but using either C++/CX or C++/WRL code instead. O uso do C++/CX oferece um código muito mais simples que corresponde estreitamente ao código C# acima, mas ele usa extensões de linguagem C++, opções de compilador e sobrecarga de tempo de execução adicional, que você possivelmente deseja evitar.Using C++/CX allows for much simpler code that closely matches the C# code above, but it uses C++ language extensions, compiler switches, and additional runtime overheard you might wish to avoid. Se esse for o caso, o uso do C++/WRL oferece uma solução de impacto muito menor, porém, com um código mais detalhado.If that is the case, using C++/WRL provides a much lower-impact solution at the cost of more verbose code. No entanto, se você estiver familiarizado com a programação ATL (ou COM, em geral), o WRL lhe parecerá familiar.Nevertheless, if you are familiar with ATL programming (or COM in general) then WRL should feel familiar.

A função de exemplo a seguir mostra como usar C++/WRL para carregar uma DLL de recurso específica e retornar um HINSTANCE que pode ser usado para carregar ainda mais recursos através das APIs de recurso Win32 usuais.The following sample function shows how to use C++/WRL to load a specific resource DLL and return an HINSTANCE that can be used to load further resources using the usual Win32 resource APIs. Observe que, diferente do exemplo C#, que inicializa explicitamente o ResourceContext com o idioma solicitado pelo tempo de execução do .NET, esse código conta com o idioma atual do usuário.Note that unlike the C# sample that explicitly initializes the ResourceContext with the language requested by the .NET runtime, this code relies on the user's current language.

#include <roapi.h>
#include <wrl\client.h>
#include <wrl\wrappers\corewrappers.h>
#include <Windows.ApplicationModel.resources.core.h>
#include <Windows.Foundation.h>
   
#define IF_FAIL_RETURN(hr) if (FAILED((hr))) return hr;
    
HRESULT GetMrtResourceHandle(LPCWSTR resourceFilePath,  HINSTANCE* resourceHandle)
{
  using namespace Microsoft::WRL;
  using namespace Microsoft::WRL::Wrappers;
  using namespace ABI::Windows::ApplicationModel::Resources::Core;
  using namespace ABI::Windows::Foundation;
    
  *resourceHandle = nullptr;
  HRESULT hr{ S_OK };
  RoInitializeWrapper roInit{ RO_INIT_SINGLETHREADED };
  IF_FAIL_RETURN(roInit);
    
  // Get Windows.ApplicationModel.Resources.Core.ResourceManager statics
  ComPtr<IResourceManagerStatics> resourceManagerStatics;
  IF_FAIL_RETURN(GetActivationFactory(
    HStringReference(
    RuntimeClass_Windows_ApplicationModel_Resources_Core_ResourceManager).Get(),
    &resourceManagerStatics));
    
  // Get .Current property
  ComPtr<IResourceManager> resourceManager;
  IF_FAIL_RETURN(resourceManagerStatics->get_Current(&resourceManager));
    
  // get .MainResourceMap property
  ComPtr<IResourceMap> resourceMap;
  IF_FAIL_RETURN(resourceManager->get_MainResourceMap(&resourceMap));
    
  // Call .GetValue with supplied filename
  ComPtr<IResourceCandidate> resourceCandidate;
  IF_FAIL_RETURN(resourceMap->GetValue(HStringReference(resourceFilePath).Get(),
    &resourceCandidate));
    
  // Get .ValueAsString property
  HString resolvedResourceFilePath;
  IF_FAIL_RETURN(resourceCandidate->get_ValueAsString(
    resolvedResourceFilePath.GetAddressOf()));
    
  // Finally, load the DLL and return the hInst.
  *resourceHandle = LoadLibraryEx(resolvedResourceFilePath.GetRawBuffer(nullptr),
    nullptr, LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_IMAGE_RESOURCE);
    
  return S_OK;
}

Fase 3: Criando pacotes de recursosPhase 3: Building resource packs

Agora que você tem um "pacote gordo" com todos os recursos, há dois caminhos para criar um pacote principal separado e pacotes de recursos, a fim de minimizar os tamanhos dos downloads e das instalações:Now that you have a "fat pack" that contains all resources, there are two paths towards building separate main package and resource packages in order to minimize download and install sizes:

  • Execute um pacote gordo por meio da ferramenta de geração de pacotes para criar pacotes de recursos automaticamente.Take an existing fat pack and run it through the Bundle Generator tool to automatically create resource packs. Essa será a abordagem preferencial se você tiver um sistema de compilação que já produz um pacote gordo e quiser processá-lo posteriormente para gerar os pacotes de recursos.This is the preferred approach if you have a build system that already produces a fat pack and you want to post-process it to generate the resource packs.
  • Produza diretamente os pacotes de recursos individuais e compile-os em um único pacote.Directly produce the individual resource packages and build them into a bundle. Essa será a abordagem preferencial se você tiver mais controle sobre o sistema de compilação e puder criar os pacotes diretamente.This is the preferred approach if you have more control over your build system and can build the packages directly.

Etapa 3.1: Criando o pacoteStep 3.1: Creating the bundle

Usando a ferramenta de geração de pacotesUsing the Bundle Generator tool

Para usar a ferramenta de geração de pacotes, o arquivo de configuração PRI criado para o pacote precisa ser atualizado manualmente para remover a seção <packaging>.In order to use the Bundle Generator tool, the PRI config file created for the package needs to be manually updated to remove the <packaging> section.

Se você estiver usando o Visual Studio, consulte verificar se os recursos estão instalados em um dispositivo, independentemente de um dispositivo precisar deles para obter informações sobre como criar todos os idiomas no pacote principal, criando os arquivos priconfig.packaging.xml e priconfig.default.xml .If you're using Visual Studio, refer to Ensure that resources are installed on a device regardless of whether a device requires them for information on how to build all languages into the main package by creating the files priconfig.packaging.xml and priconfig.default.xml.

Se você estiver editando manualmente os arquivos, siga estas etapas:If you're manually editing files, follow these steps:

  1. Crie o arquivo de configuração da mesma maneira que antes, substituindo pelo caminho, nome de arquivo e idiomas corretos:Create the config file the same way as before, substituting the correct path, file name and languages:

    makepri createconfig /cf ..\contoso_demo.xml /dq en-US_de-DE_es-MX /pv 10.0 /o
    
  2. Abra manualmente o arquivo .xml criado e exclua toda a seção &lt;packaging&rt; (mas mantenha todo o restante intacto):Manually open the created .xml file and delete the entire &lt;packaging&rt; section (but keep everything else intact):

    <?xml version="1.0" encoding="UTF-8" standalone="yes" ?> 
    <resources targetOsVersion="10.0.0" majorVersion="1">
      <!-- Packaging section has been deleted... -->
      <index root="\" startIndexAt="\">
        <default>
        ...
        ...
    
  3. Compile o arquivo .pri e o pacote .appx como antes, usando o arquivo de configuração atualizado e o diretório e os nomes de arquivo apropriados (consulte acima para obter mais informações sobre esses comandos):Build the .pri file and the .appx package as before, using the updated configuration file and the appropriate directory and file names (see above for more information on these commands):

    makepri new /pr . /cf ..\contoso_demo.xml /of ..\resources.pri /mf AppX /o
    makeappx pack /m AppXManifest.xml /f ..\resources.map.txt /p ..\contoso_demo.appx /o
    
  4. Depois que o pacote tiver sido criado, use o seguinte comando para criar o pacote, usando os nomes de arquivo e diretório apropriados:AFter the package has been created, use the following command to create the bundle, using the appropriate directory and file names:

    BundleGenerator.exe -Package ..\contoso_demo.appx -Destination ..\bundle -BundleName contoso_demo
    

Agora você pode ir para a etapa final, assinando (veja abaixo).Now you can move to the final step, signing (see below).

Criando manualmente pacotes de recursosManually creating resource packages

A criação manual de pacotes de recursos requer a execução de um conjunto de comandos um pouco diferente para criar arquivos .pri e .appx separados; como esses comandos são semelhantes aos usados acima para criar pacotes gordos, não é necessária muita explicação.Manually creating resource packages requires running a slightly different set of commands to build separate .pri and .appx files - these are all similar to the commands used above to create fat packages, so minimal explanation is given. Observação: todos os comandos pressupõem que o diretório atual é o diretório que contém o arquivo AppXManifest.xml, mas todos os arquivos são colocados no diretório pai (você pode usar um diretório diferente, se necessário, mas não deve poluir o diretório do projeto com nenhum desses arquivos).Note: All the commands assume that the current directory is the directory containing the AppXManifest.xml file, but all files are placed into the parent directory (you can use a different directory, if necessary, but you shouldn't pollute the project directory with any of these files). Como sempre, substitua os nomes de arquivo "Contoso" pelos seus próprios nomes de arquivo.As always, replace the "Contoso" filenames with your own file names.

  1. Use o comando a seguir para criar um arquivo de configuração que nomeie somente o idioma padrão como qualificador padrão; neste caso, en-US:Use the following command to create a config file that names only the default language as the default qualifier - in this case, en-US:

    makepri createconfig /cf ..\contoso_demo.xml /dq en-US /pv 10.0 /o
    
  2. Crie um arquivo padrão .pri e .map.txt para o pacote principal, além de um conjunto adicional de arquivos para cada idioma encontrado no projeto, com o seguinte comando:Create a default .pri and .map.txt file for the main package, plus an additional set of files for each language found in your project, with the following command:

    makepri new /pr . /cf ..\contoso_demo.xml /of ..\resources.pri /mf AppX /o
    
  3. Use o comando a seguir para criar o pacote principal (que contém o código executável e os recursos de idioma padrão).Use the following command to create the main package (which contains the executable code and default language resources). Como sempre, altere o nome conforme achar apropriado, embora você deva colocar o pacote em um diretório separado para facilitar a criação do pacote posteriormente (este exemplo usa o diretório ..\bundle):As always, change the name as you see fit, although you should put the package in a separate directory to make creating the bundle easier later (this example uses the ..\bundle directory):

    makeappx pack /m .\AppXManifest.xml /f ..\resources.map.txt /p ..\bundle\contoso_demo.main.appx /o
    
  4. Depois que o pacote principal for criado, use o comando a seguir uma vez para cada idioma adicional (ou seja, repita esse comando para cada arquivo de mapa de idioma gerado na etapa anterior).After the main package has been created, use the following command once for each additional language (ie, repeat this command for each language map file generated in the previous step). Mais uma vez, a saída será gerada em um diretório separado (o mesmo do pacote principal).Again, the output should be in a separate directory (the same one as the main package). Observe que o idioma é especificado nas duas opções: /f e /p; use o novo argumento /r (o que indica que é necessário um pacote de recursos):Note the language is specified both in the /f option and the /p option, and the use of the new /r argument (which indicates a Resource Package is desired):

    makeappx pack /r /m .\AppXManifest.xml /f ..\resources.language-de.map.txt /p ..\bundle\contoso_demo.de.appx /o
    
  5. Combine todos os pacotes do diretório de pacotes em um único arquivo .appxbundle.Combine all the packages from the bundle directory into a single .appxbundle file. A nova opção /d especifica o diretório a ser usado para todos os arquivos do pacote (isso acontece porque os arquivos .appx são colocados em um diretório separado na etapa anterior):The new /d option specifies the directory to use for all the files in the bundle (this is why the .appx files are put into a separate directory in the previous step):

    makeappx bundle /d ..\bundle /p ..\contoso_demo.appxbundle /o
    

A etapa final para criar o pacote está assinando.The final step to building the package is signing.

Etapa 3.2: Assinando o pacoteStep 3.2: Signing the bundle

Depois que você criar o arquivo .appxbundle (seja manualmente ou por meio da ferramenta de geração de pacotes), terá um único arquivo com o pacote principal, além de todos os pacotes de recursos.Once you have created the .appxbundle file (either through the Bundle Generator tool or manually) you will have a single file that contains the main package plus all the resource packages. A etapa final é assinar o arquivo para que o Windows o instale:The final step is to sign the file so that Windows will install it:

signtool sign /fd SHA256 /a /f ..\contoso_demo_key.pfx ..\contoso_demo.appxbundle

Isso produzirá um arquivo .appxbundle assinado que contém o pacote principal, além de todos os pacotes de recursos específicos do idioma.This will produce a signed .appxbundle file that contains the main package plus all the language-specific resource packages. Para instalar o aplicativo e quaisquer idiomas apropriados com base nas preferências de idioma do Windows do usuário, clique duas vezes no arquivo assinado, como você faria em um arquivo de pacote.It can be double-clicked just like a package file to install the app plus any appropriate language(s) based on the user's Windows language preferences.