Azure Service Bus ügyfélkódtár a .NET-hez – 7.13.1-es verzió

  • Cikk

Azure Service Bus lehetővé teszi az aszinkron üzenetkezelési minták előnyeit kihasználó alkalmazások létrehozását egy rendkívül megbízható szolgáltatás használatával az üzenetek termelők és fogyasztók közötti közvetítéséhez. Azure Service Bus rugalmas, közvetítőalapú üzenetküldést biztosít az ügyfél és a kiszolgáló között, valamint strukturált, első és kimenő (FIFO) üzenetküldést, valamint közzétételi/feliratkozási képességeket összetett útválasztással. Ha többet szeretne megtudni a Azure Service Bus, tekintse át a következőt: Mi az a Azure Service Bus?

Használja az ügyfélkódtárat a Azure Service Bus a következőhöz:

  • Üzleti adatok átvitele: az üzenetküldést tartós információcserére használja, például értékesítési vagy vásárlási megrendelések, naplók vagy leltármozgások céljából.

  • Alkalmazások leválasztása: az alkalmazások és szolgáltatások megbízhatóságának és skálázhatóságának javítása, a feladók és fogadók tehermentesítése az egyidejű online szükséglettől.

  • Az üzenetek feldolgozásának szabályozása: támogatja a hagyományos versengő fogyasztókat az üzenetsorokat használó üzenetekhez, vagy lehetővé teszi az egyes fogyasztók számára az üzenetek saját példányának használatát témakörök és előfizetések használatával.

  • Összetett munkafolyamatok implementálása: az üzenet-munkamenetek olyan forgatókönyveket támogatnak, amelyek üzenetsorrendezést vagy üzenet halasztást igényelnek.

Forráskód | Csomag (NuGet) | API-referenciadokumentáció | Termékdokumentáció | Migrálási útmutató | Hibaelhárítási útmutató

Első lépések

Előfeltételek

  • Microsoft Azure-előfizetés: Az Azure-szolgáltatások, köztük a Azure Service Bus használatához előfizetésre lesz szüksége. Ha nem rendelkezik meglévő Azure-fiókkal, regisztrálhat egy ingyenes próbaverzióra, vagy használhatja az MSDN-előfizetői előnyöket a fiók létrehozásakor.

  • Service Bus-névtér: A Azure Service Bus használatához egy névtérnek is rendelkezésre kell állnia. Ha nem ismeri az Azure-erőforrások létrehozását, érdemes lehet követnie a Service Bus-névtér Azure Portal használatával történő létrehozásához szükséges részletes útmutatót. Itt részletes útmutatást is találhat az Azure CLI, a Azure PowerShell vagy az Azure Resource Manager (ARM) sablonok Service Bus-entitások létrehozásához való használatához.

  • C# 8.0: A Azure Service Bus ügyfélkódtár a C# 8.0-s verziójában bevezetett új funkciókat használja. A C# 8.0 szintaxis kihasználása érdekében javasoljuk, hogy a .NET Core SDK 3.0-s vagy újabb verzióját használja a nyelv verziójávallatest.

    A C# 8.0 szintaxist teljes mértékben kihasználni kívánó Visual Studio-felhasználóknak a Visual Studio 2019-et vagy újabb verziót kell használniuk. A Visual Studio 2019, beleértve az ingyenes közösségi kiadást is, itt tölthető le. A Visual Studio 2017 felhasználói kihasználhatják a C# 8 szintaxis előnyeit a Microsoft.Net.Compilers NuGet csomag használatával és a nyelvi verzió beállításával, bár a szerkesztési élmény nem feltétlenül ideális.

    A kódtárat továbbra is használhatja a korábbi C#-nyelvi verziókkal, de az új szintaxis használata helyett manuálisan kell kezelnie az aszinkron számozható és aszinkron eldobható tagokat. Továbbra is a .NET Core SDK által támogatott keretrendszerverziókat célozhatja meg, beleértve a .NET Core vagy a .NET-keretrendszer korábbi verzióit is. További információ: cél-keretrendszerek megadása.

    Fontos megjegyzés: A példákés minták módosítás nélküli létrehozásához vagy futtatásához a C# 8.0 használata kötelező. Továbbra is futtathatja a mintákat, ha úgy dönt, hogy más nyelvi verziókhoz módosítja őket.

Ha gyorsan létre szeretné hozni a szükséges Service Bus-erőforrásokat az Azure-ban, és kapcsolati sztring szeretne kapni, a mintasablont a következőre kattintva helyezheti üzembe:

Üzembe helyezés az Azure-ban

A csomag telepítése

Telepítse a .NET-hez készült Azure Service Bus ügyfélkódtárat a NuGet használatával:

dotnet add package Azure.Messaging.ServiceBus

Az ügyfél hitelesítése

Ahhoz, hogy a Service Bus ügyfélkódtár egy üzenetsort vagy témakört használjon, meg kell értenie, hogyan csatlakozhat hozzá és engedélyezheti azt. Ennek legegyszerűbb módja egy kapcsolati sztring használata, amely automatikusan jön létre a Service Bus-névtér létrehozásakor. Ha nem ismeri a megosztott hozzáférési szabályzatokat az Azure-ban, előfordulhat, hogy a Service Bus-kapcsolati sztring beszerzéséhez kövesse a részletes útmutatót.

Miután rendelkezik egy kapcsolati sztring, hitelesítheti vele az ügyfelet.

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

Az Azure.Identity használatával történő hitelesítés megtekintéséhez tekintse meg ezt a példát.

Ha meg szeretné tudni, hogyan kezdeményezheti a kapcsolatot egy egyéni végponttal, tekintse meg ezt a mintát.

ASP.NET Core

Ha függőségként szeretne injektálni ServiceBusClient egy ASP.NET Core alkalmazásban, telepítse az Azure-ügyfélkódtár-integrációt ASP.NET Core csomaghoz.

dotnet add package Microsoft.Extensions.Azure

Ezután regisztrálja az ügyfelet a Startup.ConfigureServices metódusban:

public void ConfigureServices(IServiceCollection services)
{
    services.AddAzureClients(builder =>
    {
        builder.AddServiceBusClient(Configuration.GetConnectionString("ServiceBus"));
    });
  
    services.AddControllers();
}

Az előző kód használatához adja hozzá a következőt a konfigurációhoz:

{
  "ConnectionStrings": {
    "ServiceBus": "<connection_string>"
  }
}

További részletekért lásd: Függőséginjektálás a .NET-hez készült Azure SDK-val.

Fő fogalmak

A inicializálást ServiceBusClientkövetően a Service Bus-névtéren belül kezelheti az elsődleges erőforrástípusokat, amelyek közül több is létezhet, és amelyen a tényleges üzenetátvitel történik, a névtér gyakran alkalmazástárolóként szolgál:

  • Üzenetsor: Lehetővé teszi az üzenetek küldését és fogadását. Gyakran használják pont–pont kommunikációhoz.

  • Témakör: Az üzenetsorokkal ellentétben a témakörök jobban megfelelnek a közzétételi/feliratkozási forgatókönyveknek. Egy témakör elküldhető a címzettnek, de olyan előfizetést igényel, amelyből egyszerre több is lehet.

  • Előfizetés: A témakörből felhasználandó mechanizmus. Minden előfizetés független, és megkapja a témakörbe küldött üzenetek másolatát. A szabályok és szűrők segítségével testre szabható, hogy egy adott előfizetés mely üzeneteket fogadja.

További információ ezekről az erőforrásokról: Mi az a Azure Service Bus?.

Ezeknek az erőforrásoknak a használatához ismernie kell a következő SDK-fogalmakat:

  • A Service Bus-ügyfél a Service Bus-ügyfélkódtárat kezelő fejlesztők elsődleges felülete. Ez az átjáróként szolgál, ahonnan a kódtár minden interakciója megtörténik.

  • A Service Bus-küldő hatóköre egy adott üzenetsorra vagy témakörre terjed ki, és a Service Bus-ügyfél használatával jön létre. A feladó lehetővé teszi, hogy üzeneteket küldjön egy üzenetsorba vagy témakörbe. Azt is lehetővé teszi, hogy az üzenetek ütemezése elérhető legyen a kézbesítéshez egy megadott időpontban.

  • A Service Bus-fogadó hatóköre egy adott üzenetsorra vagy előfizetésre terjed ki, és a Service Bus-ügyfél használatával jön létre. A fogadó lehetővé teszi, hogy üzeneteket fogadjon egy üzenetsorból vagy előfizetésből. Azt is lehetővé teszi, hogy az üzeneteket a fogadásuk után rendezzék. Az üzenetek rendezésének négy módja van:

    • Kész – az üzenet törlődik az üzenetsorból vagy a témakörből.
    • Magára hagyás – feloldja a fogadó zárolását az üzeneten, így az üzenetet más fogadók is megkaphatják.
    • Halasztás – az üzenet normál módon való fogadásától való elhatárolódik. A késleltetett üzenetek fogadásához meg kell őrizni az üzenet sorszámát.
    • DeadLetter – áthelyezi az üzenetet a Kézbesítetlen levelek üzenetsorba. Ez megakadályozza az üzenet újbóli fogadását. Ahhoz, hogy üzeneteket fogadhasson a Kézbesítetlen levelek üzenetsorból, szükség van egy címzettre, amely a Kézbesítetlen levelek üzenetsorra terjed ki.

  • A Service Bus-munkamenet-fogadó hatóköre egy adott munkamenet-kompatibilis üzenetsorra vagy előfizetésre terjed ki, és a Service Bus-ügyfél használatával jön létre. A munkamenet-fogadó majdnem megegyezik a standard fogadóval, azzal a különbséggel, hogy a munkamenet-kezelési műveletek csak a munkamenet-kompatibilis entitásokra vonatkoznak. Ezek a műveletek közé tartozik a munkamenet állapotának lekérése és beállítása, valamint a munkamenet-zárolások megújítása.

  • A Service Bus-processzorok hatóköre egy adott üzenetsorra vagy előfizetésre terjed ki, és a Service Bus-ügyfél használatával jön létre. A ServiceBusProcessor felfogható absztrakció a fogadók köré. Visszahívási modellt használ, amely lehetővé teszi a kód megadását az üzenet fogadásakor és kivétel esetén. Biztosítja a feldolgozott üzenetek automatikus befejezését, az automatikus üzenetzárolás megújítását és a felhasználó által megadott eseménykezelők egyidejű végrehajtását. A szolgáltatáskészlet miatt a Service Bus-entitásoktól kapott alkalmazások írására szolgáló go to eszköznek kell lennie. A ServiceBusReceiver olyan összetettebb forgatókönyvekhez ajánlott, amelyekben a processzor nem tudja biztosítani a ServiceBusReceiver közvetlen használatakor várható részletes vezérlést.

  • A Service Bus-munkamenetfeldolgozók hatóköre egy adott munkamenet-kompatibilis üzenetsorra vagy előfizetésre terjed ki, és a Service Bus-ügyfél használatával jön létre. A munkamenet-feldolgozó majdnem megegyezik a standard processzorral, azzal a különbséggel, hogy a munkamenet-kezelési műveletek csak a munkamenet-kompatibilis entitásokra vonatkoznak.

További fogalmakért és részletesebb vitaért lásd: Service Bus Speciális funkciók.

Ügyfélélettartam

A ServiceBusClient, feladók, fogadók és processzorok biztonságosan gyorsítótárazhatók és használhatók egyetlentonként az alkalmazás teljes élettartama alatt, ami az ajánlott eljárás, ha az üzeneteket rendszeresen küldik vagy fogadják. Ők felelősek a hálózati, PROCESSZOR- és memóriahasználat hatékony felügyeletéért, és azon dolgoznak, hogy a használat alacsony maradjon az inaktivitási időszakokban.

Ezek a típusok eldobhatóak, és meghívhatók, DisposeAsync vagy CloseAsync szükségesek ahhoz, hogy a hálózati erőforrások és más nem felügyelt objektumok megfelelően legyenek megtisztítva. Fontos megjegyezni, hogy egy ServiceBusClient példány megsemmisítésekor automatikusan bezárja és törli az ezzel létrehozott feladókat, fogadókat és processzorokat.

Menetbiztonság

Garantáljuk, hogy minden ügyfélpéldány-metódus szálbiztos és független egymástól (iránymutatás). Ez biztosítja, hogy az ügyfélpéldányok újrafelhasználására vonatkozó javaslat mindig biztonságos legyen, még a szálak között is.

További fogalmak

Ügyfélbeállítások | Diagnosztika | Gúnyos

Példák

Üzenet küldése és fogadása

Az üzenetküldés a paranccsal történik.ServiceBusSender A fogadás a paranccsal történik.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);

Üzenetköteg küldése

Kétféleképpen küldhet egyszerre több üzenetet. Ennek első módja a biztonságos kötegelés. Biztonságos kötegeléssel létrehozhat egy ServiceBusMessageBatch objektumot, amely lehetővé teszi, hogy a metódus használatával egyenként kísérelje meg az üzenetek hozzáadását a TryAdd köteghez. Ha az üzenet nem fér el a kötegbe, TryAdd hamis értéket ad vissza.

// 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 második módszer a SendMessagesAsync túlterhelést használja, amely elfogadja az IEnumerable (IEnumerable) függvényt ServiceBusMessage. Ezzel a módszerrel megpróbáljuk az összes megadott üzenetet egyetlen üzenetkötegbe illeszteni, amelyet elküldünk a szolgáltatásnak. Ha az üzenetek túl nagyok ahhoz, hogy egyetlen kötegben elférjenek, a művelet kivételt jelez.

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

Üzenetköteg fogadása

// 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();
}

Üzenet befejezése

Ha el szeretne távolítani egy üzenetet egy üzenetsorból vagy előfizetésből, meghívhatjuk a metódust CompleteAsync .

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);

Üzenet elhagyása

Az üzenet elhagyása feloldja a fogadó zárolását, ami lehetővé teszi az üzenet fogadását ez vagy más fogadók számára.

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);

Üzenet elhalasztása

Ha elhalaszt egy üzenetet, azzal megakadályozza, hogy a vagy ReceiveMessagesAsync metódusok használatával újra megkapja az ReceiveMessageAsync üzenetet. Ehelyett léteznek külön módszerek, ReceiveDeferredMessageAsync és ReceiveDeferredMessagesAsync halasztott üzenetek fogadása.

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);

Üzenet kézbesítetlen levele

Az üzenetek holt betűvel való megjelölése hasonló a halasztáshoz. Az egyik fő különbség az, hogy az üzeneteket a szolgáltatás automatikusan kézbesítetlenül küldi el, miután bizonyos számú alkalommal megkapták őket. Az alkalmazások dönthetnek úgy, hogy a saját igényeiknek megfelelően manuálisan kézbesítetlen leveleket küldenek. Ha egy üzenet kézbesítetlen betűvel van elküldve, az az eredeti üzenetsor egy alkonyára kerül. Vegye figyelembe, hogy a ServiceBusReceiver parancs a kézbesítetlen levelek alküldetéséből érkező üzenetek fogadására szolgál, függetlenül attól, hogy a fő üzenetsor munkamenet-kompatibilis-e.

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;

További információkért tekintse meg a ServiceBus kézbesítetlen levelek üzenetsorainak áttekintését.

A processzor használata

A ServiceBusProcessor felfogható absztrakció a fogadók köré. Visszahívási modellt használ, amely lehetővé teszi a kód megadását az üzenet fogadásakor és kivétel esetén. Biztosítja a feldolgozott üzenetek automatikus befejezését, az automatikus üzenetzárolás megújítását és a felhasználó által megadott eseménykezelők egyidejű végrehajtását. A szolgáltatáskészlet miatt a Service Bus-entitásoktól kapott alkalmazások írására szolgáló go to eszköznek kell lennie. A ServiceBusReceiver olyan összetettebb forgatókönyvekhez ajánlott, amelyekben a processzor nem tudja biztosítani a ServiceBusReceiver közvetlen használatakor várható részletes vezérlést.

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();

Hitelesítés az Azure.Identity használatával

Az Azure Identity-kódtár egyszerű Azure Active Directory-támogatást nyújt a hitelesítéshez.

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

Munkamenetek használata

A munkamenetek lehetővé teszik a kapcsolódó üzenetek csoportosítását. A munkamenetek használatához munkamenet-kompatibilis entitással kell dolgoznia.

Hibaelhárítás

Tekintse meg a Service Bus hibaelhárítási útmutatót.

Következő lépések

A tárgyalt bevezető forgatókönyveken túl az Azure Service Bus ügyfélkódtár további forgatókönyveket is támogat, amelyek segítenek kihasználni a Azure Service Bus szolgáltatás teljes funkciókészletét. A Service Bus ügyféloldali kódtára néhány ilyen forgatókönyv megismerése érdekében mintaprojektet kínál, amely a gyakori forgatókönyvek szemléltetésére szolgál. A részletekért tekintse meg a README mintákat .

Közreműködés

A projektben szívesen fogadjuk a hozzájárulásokat és a javaslatokat. A legtöbb hozzájáruláshoz el kell fogadnia egy Közreműködői licencszerződést (CLA-t), amelyben kijelenti, hogy jogosult arra, hogy ránk ruházza hozzájárulása felhasználási jogát, és ezt ténylegesen meg is teszi. További részletekért lásd: https://cla.microsoft.com.

A lekéréses kérelmek elküldésekor egy CLA-robot automatikusan meghatározza, hogy kell-e biztosítania CLA-t, és megfelelően kitölti a lekéréses kérelmet (például címke, megjegyzés). Egyszerűen csak kövesse a robot által megadott utasításokat. Ezt csak egyszer kell elvégeznie az összes olyan tárházban, amely a CLA-t használja.

A projekt a Microsoft nyílt forráskódú projekteket szabályozó etikai kódexe, a Microsoft Open Source Code of Conduct hatálya alá esik. További információkért lásd a viselkedési szabályzattal kapcsolatos gyakori kérdéseket , vagy vegye fel a kapcsolatot opencode@microsoft.com az esetleges további kérdésekkel vagy megjegyzésekkel.

További információért tekintse meg a közreműködői útmutatónkat .

Megjelenések