Perguntas frequentes sobre C++/WinRTFrequently-asked questions about C++/WinRT

As respostas às perguntas que você pode ter sobre a criação e o consumo de APIs do Windows Runtime com C++/WinRT.Answers to questions that you're likely to have about authoring and consuming Windows Runtime APIs with C++/WinRT.

Importante

Para ver as notas sobre a versão do C++/WinRT, confira Novidades e alterações no C++/WinRT 2.0.For release notes about C++/WinRT, see News, and changes, in C++/WinRT 2.0.

Observação

Caso sua pergunta seja sobre uma mensagem de erro já vista, consulte também o tópico Solução de problemas de C++/WinRT.If your question is about an error message that you've seen, then also see the Troubleshooting C++/WinRT topic.

Onde posso encontrar aplicativos de exemplo do C++/WinRT?Where can I find C++/WinRT sample apps?

Confira Aplicativos de exemplo do C++/WinRT.See C++/WinRT sample apps.

Como redireciono meu projeto do C++/WinRT para uma versão posterior do SDK do Windows?How do I retarget my C++/WinRT project to a later version of the Windows SDK?

Confira Como redirecionar seu projeto do C++/WinRT para uma versão posterior do SDK do Windows.See How to retarget your C++/WinRT project to a later version of the Windows SDK.

Por que meu novo projeto não será compilado, agora que migrei para o C++/WinRT 2.0?Why won't my new project compile, now that I've moved to C++/WinRT 2.0?

Para o conjunto completo de alterações (incluindo alterações significativas), confira Notícias e alterações do C++/WinRT 2.0.For the full set of changes (including breaking changes), see News, and changes, in C++/WinRT 2.0. Por exemplo, se estiver usando for baseado em intervalo em uma coleção do Windows Runtime, você precisará #include <winrt/Windows.Foundation.Collections.h>.For example, if you're using a range-based for on a Windows Runtime collection, then you'll now need to #include <winrt/Windows.Foundation.Collections.h>.

Por que meu novo projeto não será compilado?Why won't my new project compile? Estou usando o Visual Studio 2017 (versão 15.8.0 ou superior) e a versão 17134 do SDKI'm using Visual Studio 2017 (version 15.8.0 or higher), and SDK version 17134

Se você estiver usando o Visual Studio 2017 (versão 15.8.0 ou superior) e visando o SDK do Windows versão 10.0.17134.0 (Windows 10, versão 1803), haverá falha de compilação de um projeto do C++/WinRT recentemente criado com o erro "erro C3861: 'from_abi': Identificador não encontrado" e com outros erros que são originados em base.h.If you're using Visual Studio 2017 (version 15.8.0 or higher), and targeting the Windows SDK version 10.0.17134.0 (Windows 10, version 1803), then a newly created C++/WinRT project may fail to compile with the error "error C3861: 'from_abi': identifier not found", and with other errors originating in base.h. A solução é visar uma versão posterior (mais compatível) do SDK do Windows ou definir a propriedade do projeto C/C++ > Language > Conformance mode: No (além disso, se /permissive- for exibido na propriedade do projeto C/C++ > Linha de comando em Opções Adicionais, exclua-o).The solution is to either target a later (more conformant) version of the Windows SDK, or set project property C/C++ > Language > Conformance mode: No (also, if /permissive- appears in project property C/C++ > Command Line under Additional Options, then delete it).

Como resolvo o erro de compilação "O C++/WinRT VSIX não fornece mais suporte à compilação do projeto.How do I resolve the build error "The C++/WinRT VSIX no longer provides project build support. Adicione uma referência de projeto ao pacote do Nuget Microsoft.Windows.CppWinRT"?Please add a project reference to the Microsoft.Windows.CppWinRT Nuget package"?

Instale o pacote do NuGet Microsoft.Windows.CppWinRT em seu projeto.Install the Microsoft.Windows.CppWinRT NuGet package into your project. Para obter detalhes, confira Versões anteriores da extensão do VSIX.For details, see Earlier versions of the VSIX extension.

Como faço para personalizar o suporte ao build no pacote NuGet?How do I customize the build support in the NuGet package?

O suporte ao build do C++/WinRT (propriedades/destinos) está documentado no leiame do pacote NuGet Microsoft.Windows.CppWinRT.C++/WinRT build support (props/targets) is documented in the Microsoft.Windows.CppWinRT NuGet package readme.

Quais são os requisitos para as Extensões do Visual Studio (VSIX) no C++/WinRT?What are the requirements for the C++/WinRT Visual Studio Extension (VSIX)?

Para a versão 1.0.190128.4 e posteriores da extensão VSIX, confira Suporte do Visual Studio para C++/WinRT.For version 1.0.190128.4 of the VSIX extension and later, see Visual Studio support for C++/WinRT. Para outras versões, confira Versões anteriores da extensão VSIX.For other versions, see Earlier versions of the VSIX extension.

O que é uma classe de runtime?What's a runtime class?

Uma classe de runtime é um tipo que pode ser ativado e consumido por meio de interfaces COM modernas, normalmente entre limites executáveis.A runtime class is a type that can be activated and consumed via modern COM interfaces, typically across executable boundaries. No entanto, uma classe de runtime também pode ser usada dentro da unidade de compilação que a implementa.However, a runtime class can also be used within the compilation unit that implements it. Você declara uma classe de runtime na linguagem IDL e pode implementá-la em C++ padrão usando C++/WinRT.You declare a runtime class in Interface Definition Language (IDL), and you can implement it in standard C++ using C++/WinRT.

Qual o significado de tipo projetado e tipo de implementação?What do the projected type and the implementation type mean?

Se estiver consumindo apenas uma classe do Windows Runtime (classe do tempo de execução), você estará lidando exclusivamente com tipos projetados.If you're only consuming a Windows Runtime class (runtime class), then you'll be dealing exclusively with projected types. C++/WinRT é uma projeção de linguagem, de modo que os tipos projetados fazem parte da superfície do Windows Runtime que é projetada em C++ com C++/WinRT.C++/WinRT is a language projection, so projected types are part of the surface of the Windows Runtime that's projected into C++ with C++/WinRT. Para obter mais detalhes, confira Consumir APIs com C++/WinRT.For more details, see Consume APIs with C++/WinRT.

O tipo de implementação contém a implementação de uma classe de runtime, portanto, ele só está disponível no projeto que implementa a classe de runtime.The implementation type contains the implementation of a runtime class, so it's only available in the project that implements the runtime class. Quando você estiver trabalhando em um projeto que implementa classes de runtime (um projeto do componente do Windows runtime ou um projeto que usa interface do usuário XAML), é importante estar familiarizado com a distinção entre o tipo de implementação de uma classe de runtime e o tipo projetado que representa a classe de runtime projetada em C++/WinRT.When you're working in a project that implements runtime classes (a Windows Runtime component project, or a project that uses XAML UI), it's important to be comfortable with the distinction between your implementation type for a runtime class, and the projected type that represents the runtime class projected into C++/WinRT. Para obter mais detalhes, confira Criar APIs com C++/WinRT.For more details, see Author APIs with C++/WinRT.

É necessário declarar um construtor em minha IDL da classe de runtime?Do I need to declare a constructor in my runtime class's IDL?

Somente se a classe de tempo de execução for projetada para ser consumida fora de sua unidade de compilação de implementação (é um componente do Tempo de Execução do Windows direcionado ao consumo geral pelos aplicativos cliente do Windows Runtime).Only if the runtime class is designed to be consumed from outside its implementing compilation unit (it's a Windows Runtime component intended for general consumption by Windows Runtime client apps). Para obter detalhes completos sobre a finalidade e as consequências da declaração de construtores na IDL, confira Construtores de classe de runtime.For full details on the purpose and consequences of declaring constructor(s) in IDL, see Runtime class constructors.

Por que o vinculador fornece um erro "LNK2019: Símbolo externo não resolvido"?Why is the linker giving me a "LNK2019: Unresolved external symbol" error?

Se o símbolo não resolvido for uma API dos cabeçalhos de namespace do Windows para a projeção do C++/WinRT (no namespace winrt), a API será declarada por encaminhamento em um cabeçalho que você incluiu, mas sua definição estará em um cabeçalho ainda não incluído.If the unresolved symbol is an API from the Windows namespace headers for the C++/WinRT projection (in the winrt namespace), then the API is forward-declared in a header that you've included, but its definition is in a header that you haven't yet included. Inclua o cabeçalho nomeado para o namespace da API e compile-o novamente.Include the header named for the API's namespace, and rebuild. Para saber mais, confira Cabeçalhos de projeção do C++/WinRT.For more info, see C++/WinRT projection headers.

Se o símbolo não resolvido for uma função livre do Windows Runtime, como RoInitialize, você precisará vincular explicitamente a biblioteca WindowsApp.lib em seu projeto.If the unresolved symbol is a Windows Runtime free function, such as RoInitialize, then you'll need to explicitly link the WindowsApp.lib umbrella library in your project. A projeção de C++/WinRT depende de algumas dessas funções livres (não membro) e de pontos de entrada.The C++/WinRT projection depends on some of these free (non-member) functions and entry points. Se você usar um dos modelos de projeto da Extensão do Visual Studio (VSIX) para C++/WinRT em seu aplicativo, WindowsApp.lib será vinculado automaticamente.If you use one of the C++/WinRT Visual Studio Extension (VSIX) project templates for your application, then WindowsApp.lib is linked for you automatically. Caso contrário, você poderá usar as configurações de vínculo do projeto para inclui-lo ou fazer isso no código-fonte.Otherwise, you can use project link settings to include it, or do it in source code.

#pragma comment(lib, "windowsapp")

É importante que você resolva todos os erros de vinculador possíveis vinculando WindowsApp.lib em vez de uma biblioteca de vínculo estático alternativa, caso contrário, seu aplicativo não passará nos testes do Kit de Certificação de Aplicativos Windows usados pelo Visual Studio e pela Microsoft Store para validar os envios (isso significa que, consequentemente, não será possível para o aplicativo ser ingerido com êxito pela Microsoft Store).It's important that you resolve any linker errors that you can by linking WindowsApp.lib instead of an alternative static-link library, otherwise your application won't pass the Windows App Certification Kit tests used by Visual Studio and by the Microsoft Store to validate submissions (meaning that it consequently won't be possible for your application to be successfully ingested into the Microsoft Store).

Por que estou recebendo uma exceção de "classe não registrada"?Why am I getting a "class not registered" exception?

Nesse caso, o sintoma é que—ao construir uma classe de runtime ou acessar um membro estático—você vê uma exceção acionada no runtime com REGDB_E_CLASSNOTREGISTERED com um valor de REGDB.In this case, the symptom is that—when constructing a runtime class or accessing a static member—you see an exception thrown at runtime with a HRESULT value of REGDB_E_CLASSNOTREGISTERED.

Uma das causas disso é que o componente do Windows Runtime não pode ser carregado.One cause can be that your Windows Runtime component can't be loaded. Verifique se o arquivo de metadados do componente de Windows Runtime (.winmd) tem o mesmo nome do binário de componente (o .dll), que também é o nome do projeto e o nome do namespace raiz.Make sure that the component's Windows Runtime metadata file (.winmd) has the same name as the component binary (the .dll), which is also the name of the project and the name of the root namespace. Além disso, verifique se os metadados do Windows Runtime e o binário foram copiados corretamente pelo processo de compilação para a pasta Appx do aplicativo de consumo.Also make sure that the Windows Runtime metadata and the binary have been corectly copied by the build process to the consuming app's Appx folder. Confirme se o AppxManifest.xml do aplicativo de consumo (também na pasta Appx) contém um elemento <InProcessServer> que está declarando corretamente a classe ativável e o nome binário.And confirm that the consuming app's AppxManifest.xml (also in the Appx folder) contains an <InProcessServer> element correctly declaring the activatable class and the binary name.

Construção uniformeUniform construction

Esse erro também poderá ocorrer se você tentar criar uma instância de uma classe de runtime implementada localmente por meio de qualquer um dos construtores do tipo projetado (diferente de seu construtor std::nullptr_t).This error can also happen if you try to instantiate a locally-implemented runtime class via any of the projected type's constructors (other than its std::nullptr_t constructor). Para fazer isso, você precisará do recurso de C++/WinRT 2.0 que costuma ser chamado de construção uniforme.To do that, you'll need the C++/WinRT 2.0 feature that's often called uniform construction. Se desejar aceitar esse recurso, então, para saber mais e obter exemplos de código, confira Aceitar a construção uniforme e o acesso direto de implementação.If you want to opt in to that feature, then for more info, and code examples, see Opt in to uniform construction, and direct implementation access.

Para saber como criar uma instância de suas classes de runtime implementadas localmente que não exigem construção uniforme, consulte Controles XAML; associar a uma propriedade de C++/WinRT.For a way of instantiating your locally-implemented runtime classes that doesn't require uniform construction, see XAML controls; bind to a C++/WinRT property.

Devo implementar Windows::Foundation::IClosable e, em caso afirmativo, como?Should I implement Windows::Foundation::IClosable and, if so, how?

Se você tiver uma classe de tempo de execução que libera recursos em seu destruidor, e essa classe de tempo de execução foi projetada para ser consumida fora de sua unidade de compilação de implementação (é um componente do Tempo de Execução do Windows direcionado ao consumo geral pelos aplicativos cliente do Windows Runtime), é recomendável implementar também IClosable para dar suporte ao consumo de sua classe de tempo de execução por linguagens que carecem de finalização determinística.If you have a runtime class that frees resources in its destructor, and that runtime class is designed to be consumed from outside its implementing compilation unit (it's a Windows Runtime component intended for general consumption by Windows Runtime client apps), then we recommend that you also implement IClosable in order to support the consumption of your runtime class by languages that lack deterministic finalization. Certifique-se de que seus recursos sejam liberados se o destruidor, IClosable::Close, ou ambos forem chamados.Make sure that your resources are freed whether the destructor, IClosable::Close, or both are called. IClosable::Close pode ser chamado um número arbitrário de vezes.IClosable::Close may be called an arbitrary number of times.

É necessário chamar IClosable::Close nas classes de runtime que eu consumo?Do I need to call IClosable::Close on runtime classes that I consume?

IClosable existe para dar suporte a linguagens que não têm finalização determinística.IClosable exists to support languages that lack deterministic finalization. Portanto, em geral, não é necessário chamar IClosable::Close no C++/WinRT.So, in general, you don't need to call IClosable::Close from C++/WinRT. Porém, considere essas exceções a essa regra geral.But consider these exceptions to that general rule.

  • Há casos bem raros que envolvem corridas de desligamento ou adoções semifatais, em que é necessário chamar IClosable::Close.There are very rare cases involving shutdown races or semi-deadly embraces, where you do need to call IClosable::Close. Se estiver usando tipos Windows.UI.Composition, por exemplo, você poderá se deparar com casos em que queira descartar objetos em uma sequência definida, como uma alternativa para permitir que a destruição do wrapper de C++/WinRT faça o trabalho para você.If you're using Windows.UI.Composition types, as an example, then you may encounter cases where you want to dispose objects in a set sequence, as an alternative to allowing the destruction of the C++/WinRT wrapper do the work for you.
  • Se você não puder garantir que tem a última referência restante a um objeto (porque você a passou para outras APIs, que poderiam estar mantendo uma referência), será uma boa ideia chamar IClosable::Close.If you can't guarantee that you have the last remaining reference to an object (because you passed it to other APIs, which could be keeping a reference), then calling IClosable::Close is a good idea.
  • Em caso de dúvida, é seguro chamar IClosable::Close manualmente, em vez de esperar que o wrapper o chame na destruição.When in doubt, it's safe to call IClosable::Close manually, rather than waiting for the wrapper to call it on destruction.

Portanto, se você souber que tem a última referência, poderá deixar o destruidor de wrapper fazer o trabalho.So, if you know that you have the last reference, then you can let the wrapper destructor do the work. Caso precise fechá-lo antes da última referência desaparecer, chame a função Fechar.If you need to close before the last reference vanishes, then you need to call Close. Para ser à prova de exceções, você deverá usar Fechar em um tipo RAII (aquisição de recursos é inicialização) (para que o fechamento aconteça no desenrolamento).To be exception-safe, you should Close in a resource-acquisition-is-initialization (RAII) type (so that close happens on unwind). O C++/WinRT não tem um wrapper unique_close, mas você pode fazer um próprio.C++/WinRT doesn't have a unique_close wrapper, but you can make your own.

É possível usar LLVM/Clang para compilar com C++/WinRT?Can I use LLVM/Clang to compile with C++/WinRT?

Não oferecemos suporte à cadeia de ferramentas LLVM e Clang para C++/WinRT, mas podemos usá-la internamente para validar a conformidade de padrões do C ++/WinRT.We don't support the LLVM and Clang toolchain for C++/WinRT, but we do make use of it internally to validate C++/WinRT's standards conformance. Por exemplo, se quiser emular o que fazemos internamente, faça um teste, como descrito abaixo.For example, if you wanted to emulate what we do internally, then you could try an experiment such as the one described below.

Acesse a Página de Download de LLVM, procure por Baixar LLVM 6.0.0 > Binários Predefinidos e baixe Clang para Windows (64 bits) .Go to the LLVM Download Page, look for Download LLVM 6.0.0 > Pre-Built Binaries, and download Clang for Windows (64-bit). Durante a instalação, opte por adicionar LLVM à variável de sistema PATH para que você possa invocá-la em um prompt de comando.During installation, opt to add LLVM to the PATH system variable so that you'll be able to invoke it from a command prompt. Para os fins desse experimento, você pode ignorar qualquer erro de "Falha ao localizar o diretório de conjuntos de ferramentas de MSBuild" e/ou "Falha na instalação de integração do MSVC", caso os veja.For the purposes of this experiment, you can ignore any "Failed to find MSBuild toolsets directory" and/or "MSVC integration install failed" errors, if you see them. Há diversas maneiras de invocar LLVM/Clang; o exemplo a seguir mostra apenas uma delas.There are a variety of ways to invoke LLVM/Clang; the example below shows just one way.

C:\ExperimentWithLLVMClang>type main.cpp
// main.cpp
#pragma comment(lib, "windowsapp")
#pragma comment(lib, "ole32")

#include <winrt/Windows.Foundation.h>
#include <stdio.h>
#include <iostream>

using namespace winrt;

int main()
{
    winrt::init_apartment();
    Windows::Foundation::Uri rssFeedUri{ L"https://blogs.windows.com/feed" };
    std::wcout << rssFeedUri.Domain().c_str() << std::endl;
}

C:\ExperimentWithLLVMClang>clang-cl main.cpp /EHsc /I ..\.. -Xclang -std=c++17 -Xclang -Wno-delete-non-virtual-dtor -o app.exe

C:\ExperimentWithLLVMClang>app
windows.com

Como o C++/WinRT usa recursos do padrão de C++ 17, é necessário usar qualquer sinalizador de compilador para obter esse suporte; esses sinalizadores diferem de um compilador para outro.Because C++/WinRT uses features from the C++17 standard, you'll need to use whatever compiler flags are necessary to get that support; such flags differ from one compiler to another.

O Visual Studio é a ferramenta de desenvolvimento à qual oferecemos suporte e recomendamos para C++/WinRT.Visual Studio is the development tool that we support and recommend for C++/WinRT. Confira Suporte do Visual Studio para C++/WinRT.See Visual Studio support for C++/WinRT.

Por que a função de implementação gerada para uma propriedade somente leitura não tem o qualificador const?Why doesn't the generated implementation function for a read-only property have the const qualifier?

Ao declarar uma propriedade somente leitura em MIDL 3.0, você pode esperar que a ferramenta cppwinrt.exe gere um função de implementação que seja qualificada para const (um função const trata o ponteiro this como const).When you declare a read-only property in MIDL 3.0, you might expect the cppwinrt.exe tool to generate an implementation function for you that is const-qualified (a const function treats the this pointer as const).

Sem sombra de dúvida, é recomendável o uso de const sempre que possível, mas a ferramenta cppwinrt.exe em si não tenta ponderar sobre quais funções de implementação teoricamente podem ser const e quais não podem.We certainly recommend using const wherever possible, but the cppwinrt.exe tool itself doesn't attempt to reason about which implementation functions might conceivably be const, and which might not. Você pode optar por transformar em const qualquer uma das suas funções de implementação, como neste exemplo.You can choose to make any of your implementation functions const, as in this example.

struct MyStringable : winrt::implements<MyStringable, winrt::Windows::Foundation::IStringable>
{
    winrt::hstring ToString() const
    {
        return L"MyStringable";
    }
};

Você poderá remover esse qualificador const em ToString se decidir que precisa alterar o estado de algum objeto na respectiva implementação.You can remove that const qualifier on ToString should you decide that you need to alter some object state in its implementation. Porém, transforme cada uma das suas funções de membro em const ou não const, não em ambos.But make each of your member functions either const or non-const, not both. Em outras palavras, não sobrecarregue uma função de implementação em const.In other words, don't overload an implementation function on const.

Além de suas funções de implementação, outro local em que const entra em cena são nas projeções de função do Windows Runtime.Aside from your implementation functions, another other place where const comes into the picture is in Windows Runtime function projections. Considere este código.Consider this code.

int main()
{
    winrt::Windows::Foundation::IStringable s{ winrt::make<MyStringable>() };
    auto result{ s.ToString() };
}

Para a chamada a ToString acima, o comando Ir para Declaração no Visual Studio mostra que a projeção do Windows Runtime IStringable::ToString em C++/WinRT tem esta aparência.For the call to ToString above, the Go To Declaration command in Visual Studio shows that the projection of the Windows Runtime IStringable::ToString into C++/WinRT looks like this.

winrt::hstring ToString() const;

As funções na projeção são const, independentemente de como você optar por qualificar a implementação delas.Functions on the projection are const no matter how you choose to qualify your implementation of them. Nos bastidores, a projeção chama a ABI (Interface Binária de Aplicativo), que constitui uma chamada por meio de um ponteiro de interface COM.Behind the scenes, the projection calls the application binary interface (ABI), which amounts to a call through a COM interface pointer. O único estado com o qual ToString projetado interage é esse ponteiro de interface COM; e, certamente, não há necessidade de modificar esse ponteiro, de modo que a função é const.The only state that the projected ToString interacts with is that COM interface pointer; and it certainly has no need to modify that pointer, so the function is const. Isso dá a você a garantia de que nada será alterado em relação à referência IStringable pela qual você está fazendo a chamada, além de garantir que seja possível chamar ToString mesmo com uma referência de const para um IStringable.This gives you the assurance that it won't change anything about the IStringable reference that you're calling through, and it ensures that you can call ToString even with a const reference to an IStringable.

Entenda que esses exemplos de const são detalhes de implementação das projeções e implementações de C++/WinRT; eles constituem em limpeza de código para o seu benefício.Understand that these examples of const are implementation details of C++/WinRT projections and implementations; they constitute code hygiene for your benefit. Não existe nada como const no COM nem na ABI do Windows Runtime (para funções de membro).There's no such thing as const on the COM nor Windows Runtime ABI (for member functions).

Existe alguma recomendação para diminuir o tamanho do código para binários de C++/WinRT?Do you have any recommendations for decreasing the code size for C++/WinRT binaries?

Ao trabalhar com objetos do Windows Runtime, você deve evitar o padrão de codificação mostrado abaixo, pois ele pode ter um impacto negativo no seu aplicativo, gerando mais código binário que o necessário.When working with Windows Runtime objects, you should avoid the coding pattern shown below because it can have a negative impact on your application by causing more binary code than necessary to be generated.

anobject.b().c().d();
anobject.b().c().e();
anobject.b().c().f();

No mundo do Windows Runtime, o compilador é incapaz de armazenar em cache o valor de c() ou as interfaces para cada método que é chamado por meio de uma indireção ('.').In the Windows Runtime world, the compiler is unable to cache either the value of c() or the interfaces for each method that's called through an indirection ('.'). A menos que você interfira, isso resulta em mais chamadas virtuais e na sobrecarga de contagem de referência.Unless you intervene, that results in more virtual calls and reference counting overhead. O padrão acima poderia gerar facilmente duas vezes mais código do que o estritamente necessário.The pattern above could easily generate twice as much code as strictly needed. Em vez disso, prefira o padrão mostrado abaixo sempre que possível.Instead, prefer the pattern shown below wherever you can. Ele gera muito menos código, além de melhorar consideravelmente o desempenho do tempo de execução.It generates a lot less code, and it can also dramatically improve your run time performance.

auto a{ anobject.b().c() };
a.d();
a.e();
a.f();

O padrão recomendado mostrado acima se aplica não somente ao C++/WinRT, mas a todas as projeções de linguagem do Windows Runtime.The recommended pattern shown above applies not just to C++/WinRT but to all Windows Runtime language projections.

Como transformar uma cadeia de caracteres em um tipo—para navegação, por exemplo?How do I turn a string into a type—for navigation, for example?

No final do exemplo de código do modo de exibição de navegação (que é principalmente em C#), há um snippet de código do C++/WinRT mostrando como fazer isso.At the end of the Navigation view code example (which is mostly in C#), there's a C++/WinRT code snippet showing how to do this.

Como resolver ambiguidades com GetCurrentTime e/ou TRY?How do I resolve ambiguities with GetCurrentTime and/or TRY?

O arquivo de cabeçalho winrt/Windows.UI.Xaml.Media.Animation.h declara um método denominado GetCurrentTime, enquanto windows.h (via winbase.h) define uma macro denominada GetCurrentTime.The header file winrt/Windows.UI.Xaml.Media.Animation.h declares a method named GetCurrentTime, while windows.h (via winbase.h) defines a macro named GetCurrentTime. Quando os dois entram em conflito, o compilador C++ produz "Erro C4002: Muitos argumentos para a invocação de macro do tipo função GetCurrentTime".When the two collide, the C++ compiler produces "error C4002: Too many arguments for function-like macro invocation GetCurrentTime".

Da mesma forma, winrt/Windows.Globalization.h declara um método chamado TRY, enquanto afx.h define uma macro chamada TRY.Similarly, winrt/Windows.Globalization.h declares a method named TRY, while afx.h defines a macro named TRY. Quando eles entram em conflito, o compilador C++ produz o "Erro C2334: tokens inesperados antes de '{'; ignorando o corpo aparente da função".When these collide, the C++ compiler produces "error C2334: unexpected token(s) preceding '{'; skipping apparent function body".

Para corrigir um ou ambos os problemas, você pode fazer isso.To remedy one or both issues, you can do this.

#pragma push_macro("GetCurrentTime")
#pragma push_macro("TRY")
#undef GetCurrentTime
#undef TRY
#include <winrt/include_your_cppwinrt_headers_here.h>
#include <winrt/include_your_cppwinrt_headers_here.h>
#pragma pop_macro("TRY")
#pragma pop_macro("GetCurrentTime")

Como fazer para acelerar o carregamento de símbolos?How do I speed up symbol loading?

No Visual Studio, em Ferramentas > Opções > Depuração > Símbolos > marque Carregar apenas os módulos especificados.In Visual Studio, Tools > Options > Debugging > Symbols > check Load only specified modules. Você pode clicar com o botão direito do mouse nas DLLs da lista de pilhas e carregar módulos individuais.You can then right-click DLLs in the stack list, and load individual modules.

Observação

Se este tópico não respondeu à sua dúvida, você poderá encontrar ajuda visitando a comunidade de desenvolvedores do Visual Studio C++ ou usando a marcação c++-winrt no Stack Overflow.If this topic didn't answer your question, then you might find help by visiting the Visual Studio C++ developer community, or by using the c++-winrt tag on Stack Overflow.