Barramento de Serviço do Azure biblioteca de clientes para .NET – versão 7.16.2

Artigo
10/11/2023

Barramento de Serviço do Azure permite criar aplicativos que aproveitam os padrões de mensagens assíncronas usando um serviço altamente confiável para intermediar mensagens entre produtores e consumidores. Barramento de Serviço do Azure fornece mensagens flexíveis e intermediadas entre o cliente e o servidor, juntamente com mensagens FIFO (primeiro a entrar e sair) estruturadas e recursos de publicação/assinatura com roteamento complexo. Se você quiser saber mais sobre Barramento de Serviço do Azure, convém revisar: O que é Barramento de Serviço do Azure?

Use a biblioteca de clientes para Barramento de Serviço do Azure para:

Transferir dados empresariais: aproveite o sistema de mensagens para troca durável de informações, como vendas ou ordens de compra, diários ou movimentações de inventário.
Desacoplar aplicativos: aprimore a confiabilidade e a escalabilidade de aplicativos e serviços, aliviando remetentes e receptores da necessidade de estar online ao mesmo tempo.
Controlar como as mensagens são processadas: dê suporte a consumidores concorrentes tradicionais para mensagens usando filas ou permita a cada consumidor sua própria instância de uma mensagem usando tópicos e assinaturas.
Implementar fluxos de trabalho complexos: as sessões de mensagem dão suporte a cenários que exigem ordenação de mensagens ou adiamento de mensagens.

Introdução

Pré-requisitos

Assinatura do Microsoft Azure: Para usar os serviços do Azure, incluindo Barramento de Serviço do Azure, você precisará de uma assinatura. Se você não tiver uma conta existente do Azure, poderá se inscrever para uma avaliação gratuita ou usar os benefícios do assinante do MSDN ao criar uma conta.
Namespace do Barramento de Serviço: Para interagir com Barramento de Serviço do Azure, você também precisará ter um namespace disponível. Se você não estiver familiarizado com a criação de recursos do Azure, convém seguir o guia passo a passo para criar um namespace do Barramento de Serviço usando o portal do Azure. Lá, você também pode encontrar instruções detalhadas para usar os modelos da CLI do Azure, Azure PowerShell ou ARM (Azure Resource Manager) para criar uma entidade de barramento de serviço.
C# 8.0: A biblioteca de clientes Barramento de Serviço do Azure usa novos recursos que foram introduzidos no C# 8.0. Para aproveitar a sintaxe do C# 8.0, é recomendável compilar usando o SDK do .NET Core 3.0 ou superior com uma versão de idioma do latest.

Os usuários do Visual Studio que desejam aproveitar ao máximo a sintaxe do C# 8.0 precisarão usar o Visual Studio 2019 ou posterior. O Visual Studio 2019, incluindo a edição Community gratuita, pode ser baixado aqui. Os usuários do Visual Studio 2017 podem aproveitar a sintaxe do C# 8 usando o pacote NuGet Microsoft.Net.Compilers e definindo a versão do idioma, embora a experiência de edição possa não ser ideal.

Você ainda pode usar a biblioteca com versões anteriores da linguagem C#, mas precisará gerenciar membros descartáveis assíncronos e enumeráveis e assíncronos manualmente, em vez de se beneficiar da nova sintaxe. Você ainda pode direcionar qualquer versão de estrutura compatível com o SDK do .NET Core, incluindo versões anteriores do .NET Core ou do .NET Framework. Para obter mais informações, consulte: como especificar estruturas de destino.

Observação importante: Para compilar ou executar os exemplos e os exemplos sem modificação, o uso do C# 8.0 é obrigatório. Você ainda poderá executar os exemplos se decidir ajustá-los para outras versões de idioma.

Para criar rapidamente os recursos necessários do Barramento de Serviço no Azure e receber um cadeia de conexão para eles, você pode implantar nosso modelo de exemplo clicando em:

Instalar o pacote

Instale a biblioteca de clientes Barramento de Serviço do Azure para .NET com o NuGet:

dotnet add package Azure.Messaging.ServiceBus

Autenticar o cliente

Para que a biblioteca de clientes do Barramento de Serviço interaja com uma fila ou tópico, ela precisará entender como se conectar e autorizar com ela. O meio mais fácil para fazer isso é usar um cadeia de conexão, que é criado automaticamente ao criar um namespace do Barramento de Serviço. Se você não estiver familiarizado com políticas de acesso compartilhado no Azure, convém seguir o guia passo a passo para obter uma cadeia de conexão do Barramento de Serviço.

Depois de ter um cadeia de conexão, você poderá autenticar seu cliente com ele.

// Create a ServiceBusClient that will authenticate using a connection string
string connectionString = "<connection_string>";
await using var client = new ServiceBusClient(connectionString);

Para ver como autenticar usando o Azure.Identity, veja este exemplo.

Para obter exemplos de como autenticar para um aplicativo ASP.NET Core, exiba este exemplo.

Para ver como iniciar a conexão com um ponto de extremidade personalizado, exiba este exemplo.

Principais conceitos

Depois de inicializar um ServiceBusClient, você poderá interagir com os tipos de recursos primários em um Namespace do Barramento de Serviço, dos quais vários podem existir e em que a transmissão real de mensagens ocorre, o namespace geralmente serve como um contêiner de aplicativo:

Fila: permite o envio e o recebimento de mensagens. Geralmente usado para comunicação ponto a ponto.
Tópico: em vez de Filas, os tópicos são mais adequados para cenários de publicação/assinatura. Um tópico pode ser enviado, mas requer uma assinatura, da qual pode haver várias em paralelo, para consumir.
Assinatura: o mecanismo a ser consumido de um Tópico. Cada assinatura é independente e recebe uma cópia de cada mensagem enviada ao tópico. Regras e Filtros podem ser usados para personalizar quais mensagens são recebidas por uma assinatura específica.

Para obter mais informações sobre esses recursos, consulte O que é Barramento de Serviço do Azure?.

Para interagir com esses recursos, deve-se estar familiarizado com os seguintes conceitos do SDK:

Um cliente do Barramento de Serviço é a interface principal para desenvolvedores que interagem com a biblioteca de clientes do Barramento de Serviço. Ele serve como o gateway do qual toda a interação com a biblioteca ocorrerá.
Um remetente do Barramento de Serviço tem o escopo de uma fila ou tópico específico e é criado usando o cliente do Barramento de Serviço. O remetente permite que você envie mensagens para uma fila ou tópico. Ele também permite que o agendamento de mensagens esteja disponível para entrega em uma data especificada.
Um receptor do Barramento de Serviço tem escopo para uma fila ou assinatura específica e é criado usando o cliente do Barramento de Serviço. O receptor permite que você receba mensagens de uma fila ou assinatura. Ele também permite que as mensagens sejam resolvidas depois de recebê-las. Há quatro maneiras de resolver mensagens:
- Concluído – faz com que a mensagem seja excluída da fila ou do tópico.
- Abandon – libera o bloqueio do receptor na mensagem, permitindo que a mensagem seja recebida por outros receptores.
- Adiar – adia o recebimento da mensagem por meios normais. Para receber mensagens adiadas, o número de sequência da mensagem precisa ser retido.
- DeadLetter – move a mensagem para a fila de Mensagens Mortas. Isso impedirá que a mensagem seja recebida novamente. Para receber mensagens da fila de Mensagens Mortas, um receptor com escopo para a fila de Mensagens Mortas é necessário.
Um receptor de sessão do Barramento de Serviço tem o escopo de uma fila ou assinatura habilitada para sessão específica e é criado usando o cliente do Barramento de Serviço. O receptor de sessão é quase idêntico ao receptor padrão, com a diferença sendo que as operações de gerenciamento de sessão são expostas, que se aplicam apenas a entidades habilitadas para sessão. Essas operações incluem obter e definir o estado da sessão, bem como renovar bloqueios de sessão.
Um processador do Barramento de Serviço tem escopo para uma fila ou assinatura específica e é criado usando o cliente do Barramento de Serviço. O ServiceBusProcessor pode ser considerado como uma abstração em torno de um conjunto de receptores. Ele usa um modelo de retorno de chamada para permitir que o código seja especificado quando uma mensagem é recebida e quando ocorre uma exceção. Ele oferece a conclusão automática de mensagens processadas, a renovação automática do bloqueio de mensagens e a execução simultânea de manipuladores de eventos especificados pelo usuário. Devido ao conjunto de recursos, ele deve ser a ferramenta go to para escrever aplicativos que recebem de entidades do Barramento de Serviço. O ServiceBusReceiver é recomendado para cenários mais complexos em que o processador não é capaz de fornecer o controle refinado que se pode esperar ao usar o ServiceBusReceiver diretamente.
Um processador de sessão do Barramento de Serviço tem o escopo de uma fila ou assinatura habilitada para sessão específica e é criado usando o cliente do Barramento de Serviço. O processador de sessão é quase idêntico ao processador padrão, com a diferença sendo que as operações de gerenciamento de sessão são expostas, que se aplicam apenas a entidades habilitadas para sessão.

Para obter mais conceitos e discussões mais profundas, consulte: Recursos avançados do Barramento de Serviço.

Tempo de vida do cliente

Os ServiceBusClient, remetentes, receptores e processadores são seguros para armazenar em cache e usar como singleton durante o tempo de vida do aplicativo, o que é uma prática recomendada quando as mensagens estão sendo enviadas ou recebidas regularmente. Eles são responsáveis pelo gerenciamento eficiente de rede, CPU e uso de memória, trabalhando para manter o uso baixo durante períodos de inatividade.

Esses tipos são descartáveis e chamam DisposeAsync ou CloseAsync são necessários para garantir que os recursos de rede e outros objetos não gerenciados sejam devidamente limpos. É importante observar que, quando uma ServiceBusClient instância é descartada, ela fecha e limpa automaticamente todos os remetentes, receptores e processadores que foram criados usando-a.

Acesso thread-safe

Garantimos que todos os métodos de instância do cliente sejam thread-safe e independentes uns dos outros (diretriz). Isso garante que a recomendação de reutilize instâncias de cliente seja sempre segura, mesmo entre threads.

Conceitos adicionais

Opções | do clienteDiagnostics | Zombando

Exemplos

Barramento de Serviço do Azure biblioteca de clientes para .NET

Enviar e receber uma mensagem

O envio de mensagens é executado usando o ServiceBusSender. O recebimento é executado usando o ServiceBusReceiver.

string connectionString = "<connection_string>";
string queueName = "<queue_name>";
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
await using var client = new ServiceBusClient(connectionString);

// create the sender
ServiceBusSender sender = client.CreateSender(queueName);

// create a message that we can send. UTF-8 encoding is used when providing a string.
ServiceBusMessage message = new ServiceBusMessage("Hello world!");

// send the message
await sender.SendMessageAsync(message);

// create a receiver that we can use to receive the message
ServiceBusReceiver receiver = client.CreateReceiver(queueName);

// the received message is a different type as it contains some service set properties
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync();

// get the message body as a string
string body = receivedMessage.Body.ToString();
Console.WriteLine(body);

Enviar um lote de mensagens

Há duas maneiras de enviar várias mensagens ao mesmo tempo. A primeira maneira de fazer isso usa o envio em lote seguro. Com o envio em lote seguro, você pode criar um ServiceBusMessageBatch objeto , o que permitirá que você tente adicionar mensagens uma de cada vez ao lote usando o TryAdd método . Se a mensagem não puder caber no lote, TryAdd retornará false.

// add the messages that we plan to send to a local queue
Queue<ServiceBusMessage> messages = new Queue<ServiceBusMessage>();
messages.Enqueue(new ServiceBusMessage("First message"));
messages.Enqueue(new ServiceBusMessage("Second message"));
messages.Enqueue(new ServiceBusMessage("Third message"));

// create a message batch that we can send
// total number of messages to be sent to the Service Bus queue
int messageCount = messages.Count;

// while all messages are not sent to the Service Bus queue
while (messages.Count > 0)
{
    // start a new batch
    using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();

    // add the first message to the batch
    if (messageBatch.TryAddMessage(messages.Peek()))
    {
        // dequeue the message from the .NET queue once the message is added to the batch
        messages.Dequeue();
    }
    else
    {
        // if the first message can't fit, then it is too large for the batch
        throw new Exception($"Message {messageCount - messages.Count} is too large and cannot be sent.");
    }

    // add as many messages as possible to the current batch
    while (messages.Count > 0 && messageBatch.TryAddMessage(messages.Peek()))
    {
        // dequeue the message from the .NET queue as it has been added to the batch
        messages.Dequeue();
    }

    // now, send the batch
    await sender.SendMessagesAsync(messageBatch);

    // if there are any remaining messages in the .NET queue, the while loop repeats
}

A segunda maneira usa a SendMessagesAsync sobrecarga que aceita um IEnumerable de ServiceBusMessage. Com esse método, tentaremos ajustar todas as mensagens fornecidas em um único lote de mensagens que enviaremos ao serviço. Se as mensagens forem muito grandes para caber em um único lote, a operação gerará uma exceção.

IList<ServiceBusMessage> messages = new List<ServiceBusMessage>();
messages.Add(new ServiceBusMessage("First"));
messages.Add(new ServiceBusMessage("Second"));
// send the messages
await sender.SendMessagesAsync(messages);

Recebendo um lote de mensagens

// create a receiver that we can use to receive the messages
ServiceBusReceiver receiver = client.CreateReceiver(queueName);

// the received message is a different type as it contains some service set properties
// a batch of messages (maximum of 2 in this case) are received
IReadOnlyList<ServiceBusReceivedMessage> receivedMessages = await receiver.ReceiveMessagesAsync(maxMessages: 2);

// go through each of the messages received
foreach (ServiceBusReceivedMessage receivedMessage in receivedMessages)
{
    // get the message body as a string
    string body = receivedMessage.Body.ToString();
}

Concluir uma mensagem

Para remover uma mensagem de uma fila ou assinatura, podemos chamar o CompleteMessageAsync método .

string connectionString = "<connection_string>";
string queueName = "<queue_name>";
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
await using var client = new ServiceBusClient(connectionString);

// create the sender
ServiceBusSender sender = client.CreateSender(queueName);

// create a message that we can send
ServiceBusMessage message = new ServiceBusMessage("Hello world!");

// send the message
await sender.SendMessageAsync(message);

// create a receiver that we can use to receive and settle the message
ServiceBusReceiver receiver = client.CreateReceiver(queueName);

// the received message is a different type as it contains some service set properties
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync();

// complete the message, thereby deleting it from the service
await receiver.CompleteMessageAsync(receivedMessage);

Abandonar uma mensagem

Abandonar uma mensagem libera o bloqueio do receptor, o que permite que a mensagem seja recebida por este ou por outros receptores.

ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync();

// abandon the message, thereby releasing the lock and allowing it to be received again by this or other receivers
await receiver.AbandonMessageAsync(receivedMessage);

Adiar uma mensagem

Adiar uma mensagem impedirá que ela seja recebida novamente usando os ReceiveMessageAsync métodos ou ReceiveMessagesAsync . Em vez disso, há métodos separados ReceiveDeferredMessageAsync e ReceiveDeferredMessagesAsync para receber mensagens adiadas.

ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync();

// defer the message, thereby preventing the message from being received again without using
// the received deferred message API.
await receiver.DeferMessageAsync(receivedMessage);

// receive the deferred message by specifying the service set sequence number of the original
// received message
ServiceBusReceivedMessage deferredMessage = await receiver.ReceiveDeferredMessageAsync(receivedMessage.SequenceNumber);

Mensagens mortas uma mensagem

A mensagem de mensagens mortas é semelhante a adiar com uma main diferença é que as mensagens serão automaticamente mortas pelo serviço depois de terem sido recebidas um determinado número de vezes. Os aplicativos podem optar por mensagens de mensagens mortas manualmente com base em seus requisitos. Quando uma mensagem está morta, ela é realmente movida para uma subconsulta da fila original. Observe que o ServiceBusReceiver é usado para receber mensagens da subconsulta de mensagens mortas, independentemente de a fila main estar habilitada para sessão ou não.

ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync();

// Dead-letter the message, thereby preventing the message from being received again without receiving from the dead letter queue.
// We can optionally pass a dead letter reason and dead letter description to further describe the reason for dead-lettering the message.
await receiver.DeadLetterMessageAsync(receivedMessage, "sample reason", "sample description");

// receive the dead lettered message with receiver scoped to the dead letter queue.
ServiceBusReceiver dlqReceiver = client.CreateReceiver(queueName, new ServiceBusReceiverOptions
{
    SubQueue = SubQueue.DeadLetter
});
ServiceBusReceivedMessage dlqMessage = await dlqReceiver.ReceiveMessageAsync();

// The reason and the description that we specified when dead-lettering the message will be available in the received dead letter message.
string reason = dlqMessage.DeadLetterReason;
string description = dlqMessage.DeadLetterErrorDescription;

Para obter mais informações, consulte a visão geral das filas de mensagens mortas do ServiceBus.

Usando o processador

O ServiceBusProcessor pode ser considerado como uma abstração em torno de um conjunto de receptores. Ele usa um modelo de retorno de chamada para permitir que o código seja especificado quando uma mensagem é recebida e quando ocorre uma exceção. Ele oferece a conclusão automática de mensagens processadas, a renovação automática do bloqueio de mensagens e a execução simultânea de manipuladores de eventos especificados pelo usuário. Devido ao conjunto de recursos, ele deve ser a ferramenta go to para escrever aplicativos que recebem de entidades do Barramento de Serviço. O ServiceBusReceiver é recomendado para cenários mais complexos em que o processador não é capaz de fornecer o controle refinado que se pode esperar ao usar o ServiceBusReceiver diretamente.

string connectionString = "<connection_string>";
string queueName = "<queue_name>";
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
await using var client = new ServiceBusClient(connectionString);

// create the sender
ServiceBusSender sender = client.CreateSender(queueName);

// create a set of messages that we can send
ServiceBusMessage[] messages = new ServiceBusMessage[]
{
    new ServiceBusMessage("First"),
    new ServiceBusMessage("Second")
};

// send the message batch
await sender.SendMessagesAsync(messages);

// create the options to use for configuring the processor
var options = new ServiceBusProcessorOptions
{
    // By default or when AutoCompleteMessages is set to true, the processor will complete the message after executing the message handler
    // Set AutoCompleteMessages to false to [settle messages](/azure/service-bus-messaging/message-transfers-locks-settlement#peeklock) on your own.
    // In both cases, if the message handler throws an exception without settling the message, the processor will abandon the message.
    AutoCompleteMessages = false,

    // I can also allow for multi-threading
    MaxConcurrentCalls = 2
};

// create a processor that we can use to process the messages
await using ServiceBusProcessor processor = client.CreateProcessor(queueName, options);

// configure the message and error handler to use
processor.ProcessMessageAsync += MessageHandler;
processor.ProcessErrorAsync += ErrorHandler;

async Task MessageHandler(ProcessMessageEventArgs args)
{
    string body = args.Message.Body.ToString();
    Console.WriteLine(body);

    // we can evaluate application logic and use that to determine how to settle the message.
    await args.CompleteMessageAsync(args.Message);
}

Task ErrorHandler(ProcessErrorEventArgs args)
{
    // the error source tells me at what point in the processing an error occurred
    Console.WriteLine(args.ErrorSource);
    // the fully qualified namespace is available
    Console.WriteLine(args.FullyQualifiedNamespace);
    // as well as the entity path
    Console.WriteLine(args.EntityPath);
    Console.WriteLine(args.Exception.ToString());
    return Task.CompletedTask;
}

// start processing
await processor.StartProcessingAsync();

// since the processing happens in the background, we add a Console.ReadKey to allow the processing to continue until a key is pressed.
Console.ReadKey();

Autenticação com o Azure.Identity

A biblioteca de Identidade do Azure fornece suporte fácil ao Azure Active Directory para autenticação.

// Create a ServiceBusClient that will authenticate through Active Directory
string fullyQualifiedNamespace = "yournamespace.servicebus.windows.net";
await using var client = new ServiceBusClient(fullyQualifiedNamespace, new DefaultAzureCredential());

Trabalhando com sessões

As sessões fornecem um mecanismo para agrupar mensagens relacionadas. Para usar sessões, você precisa trabalhar com uma entidade habilitada para sessão.

Registrando-se com ASP.NET Core injeção de dependência

Para injetar ServiceBusClient como uma dependência em um aplicativo ASP.NET Core, instale a integração da biblioteca de clientes do Azure para ASP.NET Core pacote.

dotnet add package Microsoft.Extensions.Azure

Em seguida, registre o cliente onde seus serviços estão configurados. Para aplicativos ASP.NET Core, isso geralmente é diretamente no Program.cs ou no StartupConfigureServices método :

public void ConfigureServices(IServiceCollection services)
{
    services.AddAzureClients(builder =>
    {
        builder.AddServiceBusClient("<< SERVICE BUS CONNECTION STRING >>");
    });

    // Register other services, controllers, and other infrastructure.
}

Para aplicativos que preferem usar uma credencial compartilhada Azure.Identity para seus clientes, o registro parece um pouco diferente:

public void ConfigureServices(IServiceCollection services)
 {
     services.AddAzureClients(builder =>
     {
         // This will register the ServiceBusClient using an Azure Identity credential.
         builder.AddServiceBusClientWithNamespace("<< YOUR NAMESPACE >>.servicebus.windows.net");

         // By default, DefaultAzureCredential is used, which is likely desired for most
         // scenarios. If you need to restrict to a specific credential instance, you could
         // register that instance as the default credential instead.
         builder.UseCredential(new ManagedIdentityCredential());
     });

     // Register other services, controllers, and other infrastructure.
 }

Também é possível registrar sub-clientes, como ServiceBusSender e ServiceBusReceiver com DI usando a instância registrada ServiceBusClient . Por exemplo, para registrar um remetente para cada fila que pertence ao namespace:

public async Task ConfigureServicesAsync(IServiceCollection services)
{
    // Query the available queues for the Service Bus namespace.
    var adminClient = new ServiceBusAdministrationClient("<< SERVICE BUS CONNECTION STRING >>");
    var queueNames = new List<string>();

    // Because the result is async, they need to be captured to a standard list to avoid async
    // calls when registering.  Failure to do so results in an error with the services collection.
    await foreach (var queue in adminClient.GetQueuesAsync())
    {
        queueNames.Add(queue.Name);
    }

    // After registering the ServiceBusClient, register a named factory for each
    // queue.  This allows them to be lazily created and managed as singleton instances.

    services.AddAzureClients(builder =>
    {
        builder.AddServiceBusClient("<< SERVICE BUS CONNECTION STRING >>");

        foreach (var queueName in queueNames)
        {
            builder.AddClient<ServiceBusSender, ServiceBusClientOptions>((_, _, provider) =>
                provider
                    .GetService<ServiceBusClient>()
                    .CreateSender(queueName)
            )
            .WithName(queueName);
        }
    });

    // Register other services, controllers, and other infrastructure.
}

Como os remetentes são nomeados para sua fila associada, ao injetar, você não se associa a eles diretamente. Em vez disso, você associará a uma fábrica que pode ser usada para recuperar o remetente nomeado:

public class ServiceBusSendingController : ControllerBase
{
    private readonly ServiceBusSender _sender;

    public ServiceBusSendingController(IAzureClientFactory<ServiceBusSender> serviceBusSenderFactory)
    {
        // Though the method is called "CreateClient", the factory will manage the sender as a
        // singleton, creating a new instance only on the first use.
        _sender = serviceBusSenderFactory.CreateClient("<< QUEUE NAME >>");
    }
}

Para obter mais detalhes e exemplos, consulte Injeção de dependência com o SDK do Azure para .NET.

Solução de problemas

Consulte o Guia de Solução de Problemas do Barramento de Serviço.

Próximas etapas

Além dos cenários introdutórios discutidos, a biblioteca de clientes Barramento de Serviço do Azure oferece suporte para cenários adicionais para ajudar a aproveitar o conjunto completo de recursos do serviço Barramento de Serviço do Azure. Para ajudar a explorar alguns desses cenários, a biblioteca de clientes do Barramento de Serviço oferece um projeto de exemplos para servir como ilustração para cenários comuns. Confira os exemplos README para obter detalhes.

Contribuição

Este projeto aceita contribuições e sugestões. A maioria das contribuições exige que você concorde com um CLA (Contrato de Licença do Colaborador) declarando que você tem o direito de nos conceder, e de fato concede, os direitos de usar sua contribuição. Para obter detalhes, visite https://cla.microsoft.com.

Quando você envia uma solicitação de pull, um bot do CLA determina automaticamente se você precisa fornecer um CLA e preencher a PR corretamente (por exemplo, rótulo, comentário). Basta seguir as instruções fornecidas pelo bot. Você só precisará fazer isso uma vez em todos os repositórios que usam nosso CLA.

Este projeto adotou o Código de Conduta de Software Livre da Microsoft. Para obter mais informações, confira as Perguntas frequentes sobre o Código de Conduta ou contate opencode@microsoft.com para enviar outras perguntas ou comentários.

Consulte nosso guia de contribuição para obter mais informações.

Impressões

Share via