Passo a passo—Crie um componente C#/WinRT e consuma-o a partir de C++/WinRT

O C#/WinRT permite que os desenvolvedores que usam o .NET criem seus próprios componentes do Tempo de Execução do Windows em C# usando um projeto de biblioteca de classes. Os componentes criados podem ser consumidos em aplicativos de desktop nativos como uma referência de pacote ou como uma referência de projeto com algumas modificações.

Este passo a passo demonstra como criar um componente simples do Tempo de Execução do Windows usando C#/WinRT, distribuir o componente como um pacote NuGet e consumir o componente de um aplicativo de console C++/WinRT. Para obter o exemplo completo que fornece o código para este artigo, consulte o C#/WinRT authoring sample. Para obter mais detalhes sobre criação, consulte Componentes de criação.

Para obter orientações sobre como criar controles WinUI com C#/WinRT especificamente para uso em aplicações do Windows App SDK, consulte o artigo Passo a passo: criar um componente C# com controles WinUI 3 e consumir de uma aplicação C++ Windows App SDK

Pré-requisitos

Este passo a passo requer as seguintes ferramentas e componentes:

Visual Studio 2022
SDK do .NET 6.0 ou posterior
C++/WinRT VSIX para modelos de projeto C++/WinRT

Criar um componente simples do Tempo de Execução do Windows usando C#/WinRT

Comece criando um novo projeto no Visual Studio. Selecione a Biblioteca de Classes modelo de projeto e nomeie o projeto AuthoringDemo. Você precisará fazer as seguintes adições e modificações ao projeto:

Atualize o no ficheiro AuthoringDemo.csproj e adicione os seguintes elementos ao :
```
<PropertyGroup>
    <TargetFramework>net8.0-windows10.0.19041.0</TargetFramework>
    <Platforms>x64</Platforms>
</PropertyGroup>
```
Para acessar os tipos do Tempo de Execução do Windows, você precisa definir uma versão específica do SDK do Windows no TFM. Para obter mais detalhes sobre a versão suportada, consulte .NET 6 e versões posteriores: Use a opção TFM.
Instale o pacote Microsoft.Windows.CsWinRT NuGet em seu projeto.

a) No Gerenciador de Soluções, clique com o botão direito do mouse no nó do projeto e selecione Gerenciar Pacotes NuGet.

b) Pesquise o pacote Microsoft.Windows.CsWinRT NuGet e instale a versão mais recente. Este passo a passo usa C#/WinRT versão 1.4.1.
Adicione um novo elemento PropertyGroup que defina a propriedade CsWinRTComponent. Isso especifica que o seu projeto é um componente do Tempo de Execução do Windows para que um arquivo de .winmd seja gerado quando você compila o projeto.
```
<PropertyGroup>   
    <CsWinRTComponent>true</CsWinRTComponent>
</PropertyGroup>
```
Para obter uma lista completa das propriedades do projeto C#/WinRT, consulte a documentação do NuGet C#/WinRT.
Você pode criar suas classes em tempo de execução usando arquivos de classe-biblioteca .cs. Clique com o botão direito do mouse no arquivo Class1.cs e renomeie-o para Example.cs. Adicione o seguinte código a este arquivo, que adiciona uma propriedade pública e um método à classe de tempo de execução. Lembre-se de marcar todas as classes que você deseja expor no componente de tempo de execução como public.
```
namespace AuthoringDemo
{
    public sealed class Example
    {
        public int SampleProperty { get; set; }

        public static string SayHello()
        {
            return "Hello from your C# WinRT component";
        }
    }
}
```
Agora você pode criar o projeto para gerar o arquivo .winmd para seu componente. Clique com o botão direito do mouse no projeto no Gerenciador de Soluções e clique em Compilar. Você verá o arquivo de AuthoringDemo.winmd gerado em sua pasta de saída de compilação.

Gerar um pacote NuGet para o componente

A maioria dos desenvolvedores desejará distribuir e compartilhar seu componente do Tempo de Execução do Windows como um pacote NuGet. Outra opção é consumir o componente como referência de projeto. As etapas a seguir demonstram como empacotar o componente AuthoringDemo. Quando você gera o pacote, o C#/WinRT configura o componente e os assemblies de hospedagem no pacote para permitir o consumo de aplicativos nativos.

Há várias maneiras de gerar o pacote NuGet:

Se você quiser gerar um pacote NuGet toda vez que criar o projeto, adicione a seguinte propriedade ao arquivo de projeto AuthoringDemo e reconstrua o projeto.
```
<PropertyGroup>
    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
</PropertyGroup>
```
Como alternativa, você pode gerar um pacote NuGet clicando com o botão direito do mouse no projeto AuthoringDemo no Gerenciador de Soluções e selecionando Pack.

Quando você cria o pacote, a janela Build deve indicar que o pacote NuGet AuthoringDemo.1.0.0.nupkg foi criado com êxito. Consulte Criar um pacote usando a da CLI dotnet para obter mais detalhes sobre as propriedades do pacote NuGet com a CLI do .NET.

Consumir o componente de uma aplicação C++/WinRT

Os componentes do Tempo de Execução do Windows criados em C#/WinRT podem ser consumidos de qualquer linguagem compatível com o Tempo de Execução do Windows (WinRT). As etapas a seguir demonstram como chamar o componente criado acima em um aplicativo de console C++/WinRT.

Observação

O consumo de um componente C#/WinRT de aplicativos C#/.NET é suportado pela referência de pacote ou referência de projeto. Esse cenário é equivalente a consumir qualquer biblioteca de classes C# comum e não envolve a ativação do WinRT na maioria dos casos. A partir do C#/WinRT 1.3.5, as referências de projeto para consumidores de C# exigem o .NET 6.

Adicione um novo C++/WinRT Console Application projeto à sua solução. Note que este projeto também pode fazer parte de uma solução diferente, se assim o desejar.

a) No Gerenciador de Soluções , clique com o botão direito do mouse no nó da solução e clique em Adicionar ->Novo Projeto.

b) Na caixa de diálogo Adicionar Novo Projeto, procure o modelo de projeto Aplicação de Consola C++/WinRT. Selecione o modelo e clique em Avançar.

c. Nomeie o novo projeto CppConsoleApp e clique em Criar.
Adicione uma referência ao componente AuthoringDemo, como um pacote NuGet ou uma referência de projeto.
- Opção 1 (Referência do pacote):
  
  a) Clique com o botão direito do rato no projeto CppConsoleApp e selecione Gerir pacotes NuGet. Talvez seja necessário configurar as fontes do pacote para adicionar uma referência ao pacote NuGet AuthoringDemo. Para fazer isso, clique no ícone Configurações no Gerenciador de Pacotes NuGet e adicione uma fonte de pacote ao caminho apropriado.
  
  b) Depois de configurar as fontes do pacote, procure o pacote AuthoringDemo e clique em Instalar.
- Opção 2 (Referência do projeto):
  
  a) Clique com o botão direito do rato no projeto CppConsoleApp e selecione Adicionar ->Referência. No nó Projetos, adicione uma referência ao projeto AuthoringDemo.
Para hospedar o componente, você precisará adicionar um arquivo de manifesto para registros de classe ativáveis. Para obter mais detalhes sobre hospedagem de componentes gerenciados, consulte Managed component hosting.

a) Para adicionar o arquivo de manifesto, clique novamente com o botão direito do mouse no projeto e escolha Adicionar -> Novo Item. Procure o modelo de Arquivo de Texto e atribua-lhe o nome CppConsoleApp.exe.manifest. Insira o seguinte conteúdo, que especifica as classes de execução usando entradas de registo de classes ativáveis:
```
<?xml version="1.0" encoding="utf-8"?>
<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
    <assemblyIdentity version="1.0.0.0" name="CppConsoleApp"/>
    <file name="WinRT.Host.dll">
        <activatableClass
            name="AuthoringDemo.Example"
            threadingModel="both"
            xmlns="urn:schemas-microsoft-com:winrt.v1" />
    </file>
</assembly>
```
O arquivo de manifesto do aplicativo é necessário para aplicativos que não são empacotados. Para aplicações empacotadas, o utilizador da aplicação precisa registar as classes que podem ser ativadas no seu ficheiro de manifesto do pacote Package.appxmanifest, conforme explicado em Passo a passo: Criar um componente C# com controlos WinUI 3 e consumir a partir de uma aplicação C++ utilizando Windows App SDK.

b) Modifique o projeto para incluir o arquivo de manifesto na saída ao implantar o projeto. Clique no arquivo CppConsoleApp.exe.manifest no Explorador de Soluções e defina a propriedade Conteúdo como Verdadeiro . Aqui está um exemplo de como isso se parece.
Abra pch.h sob os arquivos de cabeçalho do projeto e adicione a seguinte linha de código para incluir seu componente.
```
#include <winrt/AuthoringDemo.h>
```

Abra main.cpp sob os arquivos de origem do projeto e substitua-o pelo seguinte conteúdo.

#include "pch.h"
#include "iostream"

using namespace winrt;
using namespace Windows::Foundation;

int main()
{
    init_apartment();

    AuthoringDemo::Example ex;
    ex.SampleProperty(42);
    std::wcout << ex.SampleProperty() << std::endl;
    std::wcout << ex.SayHello().c_str() << std::endl;
}

Compile e execute o projeto CppConsoleApp. Agora você deve ver a saída abaixo.

Comentários

Esta página foi útil?

Last updated on 2025-08-13