Übersicht über Protokoll- und Hilfsmethoden von Azure SDK für .NET

Der folgende Code verwendet ContentSafetyClient, um die AnalyzeText-Hilfsmethode aufzurufen:

using Azure.AI.ContentSafety;
using Azure.Identity;

// Create the client
ContentSafetyClient client = new(
    new Uri("https://contentsafetyai.cognitiveservices.azure.com/"),
    new DefaultAzureCredential());

// Call the convenience method
AnalyzeTextResult result = client.AnalyzeText("What is Microsoft Azure?");

// Display the results
foreach (TextCategoriesAnalysis item in result.CategoriesAnalysis)
{
    Console.WriteLine($"{item.Category}: {item.Severity}");
}

Im vorherigen Code werden die folgenden Muster der Azure.Core-Hilfsmethode veranschaulicht:

• Verwendet einen standardmäßigen C#-Primitivtyp oder -Modelltyp als Parameter.
• Gibt einen benutzerfreundlichen C#-Typ zurück, der das Ergebnis des Vorgangs darstellt.

Der folgende Code verwendet ContentSafetyClient, um die AnalyzeText-Protokollmethode aufzurufen:

using Azure;
using Azure.AI.ContentSafety;
using Azure.Core;
using Azure.Core.Serialization;
using Azure.Identity;

// Create the client
ContentSafetyClient client = new(
    new Uri("https://contentsafetyai.cognitiveservices.azure.com/"),
    new DefaultAzureCredential());

// Create the prompt
RequestContent prompt = RequestContent.Create(new
{
    text = "What is Microsoft Azure?",
});

// Call the protocol method
Response response = client.AnalyzeText(
    prompt,
    new RequestContext
    {
        ErrorOptions = ErrorOptions.NoThrow,
    });

// Any non-200 response code from Azure AI Content Safety AnalyzeText REST API isn't considered a success response.
// See REST API details at https://azure-ai-content-safety-api-docs.developer.azure-api.net/api-details#api=content-safety-service-2023-10-01&operation=TextOperations_AnalyzeText
if (response.Status != 200)
{
    throw new RequestFailedException(response);
}

// With this dynamic instance, you can use response content like a convenience model. As convenience APIs are added
// to the library, this approach helps you evolve code from protocol to convenience with minimal code changes.
dynamic content = response.Content.ToDynamicFromJson(JsonPropertyNames.CamelCase);

// Display the results
foreach (var item in content.CategoriesAnalysis)
{
    Console.WriteLine($"{item.Category}: {item.Severity}");
}

Im vorherigen Code werden die folgenden Muster der Azure.Core-Protokollmethode veranschaulicht:

1. Erstellen Sie die Anforderung mithilfe eines RequestContent Objekts für den Anforderungstext.
2. Rufen Sie die Protokollmethode mithilfe eines RequestContext Objekts zum Konfigurieren von Anforderungsoptionen auf.
3. Verarbeiten Sie die Antwort. Weitere Informationen finden Sie hier:
   • Der HTTP-Statuscode aus dem Response-Objekt zum Ermitteln von Erfolg oder Fehlschlagen.
   • Daten aus dem Inhalt des Objekts Response in einen dynamischen Typ mithilfe von ToDynamicFromJson. Weitere Informationen finden Sie unter Ankündigung der Unterstützung von Dynamic JSON in der Azure Core-Bibliothek für .NET.

Betrachten Sie den folgenden Code, der ChatClient verwendet, um die CompleteChat-Hilfsmethode aufzurufen:

using OpenAI.Chat;

// Create the client
ChatClient client = new(
    model: "gpt-4o-mini",
    credential: Environment.GetEnvironmentVariable("OPENAI_API_KEY")!);

// Call the convenience method
ChatCompletion completion = client.CompleteChat("What is Microsoft Azure?");

// Display the results
Console.WriteLine($"[{completion.Role}]: {completion}");

Im vorherigen Code werden die folgenden Muster der System.ClientModel-Hilfsmethode veranschaulicht:

• Verwendet einen standardmäßigen C#-Primitivtyp oder -Modelltyp als Parameter.
• Gibt einen ClientResult-Typ zurück, der das Ergebnis des Vorgangs darstellt.

Der folgende Code verwendet ChatClient, um die CompleteChat-Protokollmethode aufzurufen:

using OpenAI.Chat;
using System.ClientModel;
using System.ClientModel.Primitives;
using System.Text.Json;

// Create the client
ChatClient client = new(
    model: "gpt-4o-mini",
    credential: Environment.GetEnvironmentVariable("OPENAI_API_KEY")!);

// Create the request content
BinaryData input = BinaryData.FromBytes("""
    {
        "model": "gpt-4o-mini",
        "messages": [
           {
               "role": "user",
               "content": "What is Microsoft Azure?"
           }
        ]
    }
    """u8.ToArray());
using BinaryContent content = BinaryContent.Create(input);

var requestOptions = new RequestOptions();

requestOptions.AddHeader("CustomHeader", "CustomHeaderValue");
requestOptions.ErrorOptions = ClientErrorBehaviors.NoThrow;

// Call the protocol method
ClientResult result = client.CompleteChat(
    content,
    requestOptions
);

PipelineResponse response = result.GetRawResponse();

// Any non-200 response code from CompleteChat endpoint isn't considered a success response.
if (response.Status != 200)
{
    throw new ClientResultException(response);
}

using JsonDocument output = JsonDocument.Parse(response.Content);
JsonElement message = output.RootElement
    .GetProperty("choices"u8)[0]
    .GetProperty("message"u8);

// Display the results
Console.WriteLine($@"[{message.GetProperty("role"u8)}]:
    {message.GetProperty("content"u8)}");

Im vorherigen Code werden die folgenden Muster der System.ClientModel-Protokollmethode veranschaulicht:

1. Erstellen Sie die Anforderung mithilfe eines BinaryContent Objekts für den Anforderungstext.
2. Rufen Sie die Protokollmethode mithilfe eines RequestOptions Objekts zum Konfigurieren von Anforderungsoptionen auf.
3. Verarbeiten Sie die Antwort. Weitere Informationen finden Sie hier:
   • Der HTTP-Statuscode aus dem PipelineResponse-Objekt zum Ermitteln von Erfolg oder Fehlschlagen.
   • Daten aus dem Inhalt des Objekts PipelineResponse mithilfe von System.Text.Json APIs.

Eine System.ClientModel-basierte Antwort kann wie ein Hilfsmodell verarbeitet werden, falls Sie eine Abhängigkeit von Azure.Core erstellen. Der folgende Diff zeigt diesen alternativen Ansatz, der denselben Ansatz verfolgt, wie der, der auf der Registerkarte Protokollmethode unter Von Azure.Core abhängige Bibliotheken beschrieben ist.

PipelineResponse response = result.GetRawResponse();

- using JsonDocument output = JsonDocument.Parse(response.Content);
- JsonElement message = output.RootElement
-     .GetProperty("choices"u8)[0]
-     .GetProperty("message"u8);

- Console.WriteLine($@"[{message.GetProperty("role"u8)}]:
-     {message.GetProperty("content"u8)}");

+ dynamic output = response.Content.ToDynamicFromJson(
+     JsonPropertyNames.CamelCase);
+ var message = output.Choices[0].Message;
+ Console.WriteLine($"[{message.Role}]: {message.Content}");

using Azure.AI.ContentSafety;
using Azure.Identity;
using Azure;

// Create the client
ContentSafetyClient client = new(
    new Uri("https://contentsafetyai.cognitiveservices.azure.com/"),
    new DefaultAzureCredential());

try
{
    // Call the convenience method
    AnalyzeTextResult result = client.AnalyzeText("What is Microsoft Azure?");

    // Display the results
    foreach (TextCategoriesAnalysis item in result.CategoriesAnalysis)
    {
        Console.WriteLine($"{item.Category}: {item.Severity}");
    }
} 
catch (RequestFailedException ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

using OpenAI.Chat;
using System.ClientModel;

// Create the client
ChatClient client = new(
    model: "gpt-4o-mini",
    credential: Environment.GetEnvironmentVariable("OPENAI_API_KEY")!);

try
{
    // Call the convenience method
    ChatCompletion completion = client.CompleteChat("What is Microsoft Azure?");

    // Display the results
    Console.WriteLine($"[{completion.Role}]: {completion}");
}
catch (ClientResultException ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}