Passo a passo — criar um componente C#/WinRT e consumi-lo do C++/WinRT

O C#/WinRT permite que os desenvolvedores que usam o .NET criem seus próprios componentes do Windows Runtime em C# usando um projeto de biblioteca de classes. Os componentes criados podem ser consumidos em aplicativos nativos da área de trabalho 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 Windows Runtime 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 deste artigo, consulte o exemplo de criação do C#/WinRT. Para obter mais detalhes sobre a redação, consulte os componentes de redação.

Para obter um passo a passo sobre como criar controles WinUI com C#/WinRT especificamente para uso em aplicativos do SDK de Aplicativos do Windows, consulte o artigo Passo a passo: Criar um componente C# com controles WinUI 3 e consumir de um aplicativo SDK do Aplicativo do Windows C++

Pré-requisitos

Este passo a passo requer as seguintes ferramentas e componentes:

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

Criar um componente simples do Windows Runtime usando C#/WinRT

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

Atualize o no arquivo AuthoringDemo.csproj do e adicione os seguintes elementos ao :
```
<PropertyGroup>
    <TargetFramework>net8.0-windows10.0.19041.0</TargetFramework>
    <Platforms>x64</Platforms>
</PropertyGroup>
```
Para acessar tipos do Windows Runtime, você precisa definir uma versão específica do SDK do Windows no TFM. Para obter mais detalhes sobre a versão com suporte, consulte .NET 6 e posteriores: utilize a opção TFM.
Instale o pacote NuGet Microsoft.Windows.CsWinRT 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 NuGet Microsoft.Windows.CsWinRT e instale a versão mais recente. Este passo a passo usa c#/WinRT versão 1.4.1.
Adicione um novo PropertyGroup elemento que define a CsWinRTComponent propriedade. Isso especifica que seu projeto é um componente do Windows Runtime para que um .winmd arquivo seja gerado quando você compilar o projeto.
```
<PropertyGroup>   
    <CsWinRTComponent>true</CsWinRTComponent>
</PropertyGroup>
```
Para obter uma lista completa das propriedades do projeto C#/WinRT, consulte a documentação do NuGet do C#/WinRT.
Você pode criar suas classes de tempo de execução utilizando os arquivos de classe da biblioteca .cs. Clique com o botão direito do mouse no arquivo e renomeie-o Class1.cs para Example.cs. Adicione o código a seguir a este arquivo, que adiciona uma propriedade pública e um método à classe de runtime. Lembre-se de marcar todas as classes que você deseja expor no componente de runtime 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 para o .winmd componente. Clique com o botão direito do mouse no projeto no Gerenciador de Soluçõese clique em Compilar. Você verá o arquivo AuthoringDemo.winmd gerado na pasta de saída da compilação.

Gerar um pacote NuGet para o componente

A maioria dos desenvolvedores desejará distribuir e compartilhar seu componente do Windows Runtime 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, C#/WinRT configura o componente e hospeda os assemblies no pacote para habilitar o consumo por aplicativos nativos.

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

Se você quiser gerar um pacote NuGet sempre que compilar o projeto, adicione a propriedade a seguir ao arquivo de projeto AuthoringDemo e recompile 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 Pacote.

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

Consumir o componente de um aplicativo C++/WinRT

Os componentes do Windows Runtime criados em C#/WinRT podem ser consumidos de qualquer linguagem compatível com o WinRT (Windows Runtime). 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 é compatível tanto com referência de pacote quanto com 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 C# exigem .NET 6.

Adicione um novo projeto de Aplicativo do Console do C++/WinRT à sua solução. Observe que esse projeto também pode fazer parte de uma solução diferente se você escolher.

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

b. Na caixa de diálogo Adicionar Novo Projeto, pesquise o modelo de projeto do Aplicativo de Console do C++/WinRT . Selecione o template e clique em Próximo.

c. Dê o nome do 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 de pacote):
  
  a. Clique com o botão direito do mouse no projeto CppConsoleApp e selecione Gerenciar pacotes NuGet. Talvez seja necessário configurar suas fontes de pacotes para adicionar uma referência ao pacote NuGet AuthoringDemo. Para fazer isso, clique no ícone Configurações no Gerenciador de Pacotes do NuGet e adicione uma origem do pacote para o caminho apropriado.
  
  b. Depois de configurar as fontes do pacote, pesquise por AuthoringDemo e clique em Instalar.
- Opção 2 (referência do projeto):
  
  a. Clique com o botão direito do mouse 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 a hospedagem de componentes gerenciados, consulte Hospedagem de componentes gerenciados.

a. Para adicionar o arquivo de manifesto, clique novamente com o botão direito do mouse no projeto e escolha Adicionar –> Novo Item. Pesquise o modelo de Arquivo de Texto e nomeie-o CppConsoleApp.exe.manifest. Cole o seguinte conteúdo, que especifica as classes de runtime usando entradas de registro de classe ativável.
```
<?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 aplicativos empacotados, o consumidor do aplicativo precisa registrar as classes ativáveis no arquivo de manifesto do pacote Package.appxmanifest, conforme explicado em Passo a Passo: Criar um Componente C# com Controles do WinUI 3 e Consumir de uma Aplicação do SDK de Aplicativos C++ do Windows.

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

Abra main.cpp nos Arquivos de Origem do projeto e substitua-o pelo conteúdo a seguir.

#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