Prompt Engineering und strukturierte Ausgabe in .NET: OpenAI, Azure, Anthropic, Gemini

Ein Support-Bot, der direkt von einem ASP.NET Core-Controller auf GPT-4o zugreift, kann dazu führen, dass eine Demo angefordert wird. Danach verlangt der Unternehmenskunde eine regionale Datenspeicherung, die Abteilung für Sicherheit wünscht Claude für lange Dokumente, und die Finanzabteilung möchte wissen, warum jede Frage zehnmal so teuer ist wie geschätzt. Jeder dieser Anfragen zieht einen in Richtung eines anderen Anbieters oder in Richtung einer Abstraktion, die es ermöglicht, diese Anbieter auszutauschen.

OpenAI, Azure OpenAI, Anthropic und Gemini verkaufen alle dasselbe Grundprodukt: verwalteten Chat, Tool-Aufrufe sowie Embeddings – ohne die Notwendigkeit, eigene GPUs zu hosten. Sie unterscheiden sich in der Verpackung, den verfügbaren Regionen, den Compliance-Anforderungen, der Qualität der SDKs sowie der Abrechnungsmethode. Für einen .NET-Dienst, der über Jahre hinweg genutzt wird, sind diese Unterschiede wichtiger als das Modell, das letzte Woche die Bestenliste angeführt hat.

Welcher Anbieter eignet sich für welche Aufgabe

• OpenAI-Plattform: der schnellste Weg zu den neuesten Modellen. Geeignet für Produkte, die bereits mit den Datenbeschränkungen von OpenAI zurechtkommen.
• Azure OpenAI: wenn die Arbeitslast innerhalb eines Azure-Tenants mit Unternehmensidentität, Netzwerkfunktionen und regionalen Kontrollmechanismen betrieben werden muss.
• Anthropic: starke Leistung bei der Verarbeitung langer Kontexte sowie sorgfältige Befolgung von Anweisungen. Geeignet für Agenten, die mit vielen Dokumenten arbeiten müssen.
• Gemini: Lösungen, die mit Google Cloud integriert sind, mit multimodalen Stärken sowie Produkte, die eng mit Workspace verbunden sind.

Gehen Sie nicht standardmäßig auf mehrere Anbieter über. Bei einem Team, einer Region und ohne Compliance-Anforderungen bedeutet ein einziger Anbieter weniger Komplexität. Jede Abstraktion verursacht zusätzliche Kosten.

Reife des SDKs und die zu installierenden Pakete

Was Sie hier beurteilen, sind offizielle Client-Bibliotheken, idiomatische asynchrone Muster sowie die Häufigkeit von Breaking Changes. Ein SDK, das sich gegen die Lebensdauer von HttpClient sowie die Abhängigkeitsinjektion wehrt, wird Sie mehr kosten als die Gebühren für Token. Für alle vier Aspekte sollten Sie Erstparteipakete oder gut unterstützte Community-Pakete erwarten, prüfen Sie jedoch vor der Standardisierung die aktuellen NuGet-Versionen sowie die Authentifizierungsverfahren (API-Schlüssel gegenüber Entra ID).

// Official OpenAI SDK
dotnet add package OpenAI

// Azure AI Foundry (Azure OpenAI)
dotnet add package Azure.AI.OpenAI

// Anthropic Claude (official, beta as of 2026)
dotnet add package Anthropic

// Gemini via Google Cloud Vertex AI (IChatClient-compatible, January 2026)
dotnet add package Google.Cloud.VertexAI.Extensions --prerelease

// Abstraction layer (ships with all provider adapters)
dotnet add package Microsoft.Extensions.AI

Microsoft.Extensions.AI ist der Bestandteil, der sie miteinander verbindet: Jedes SDK stellt einen IChatClient zur Verfügung, sodass der Rest der Anwendung anbieterneutral bleiben kann.

Preismechaniken und Modellrouting

Jeder Anbieter berechnet Gebühren für Tokens, doch die Details beeinflussen den Gesamtbetrag: Eingangs- und Ausgangstokens werden unterschiedlich bewertet, in Cache gespeicherte Tokens sind günstiger, Tools können einen Aufpreis verursachen, und einige Tarife haben Mindestgebühren. Langer Kontext sowie agentenbasierte Lösungen mit vielen Tools erhöhen die Rechnung schnell. Azure berechnet die Gebühren über das Azure-Messsystem, während die anderen drei Anbieter eine Anbieterkontoabrechnung verwenden.

Die Finanzabteilung wird ein Wirtschaftsmodell erstellen, weshalb Ihre Architektur Nutzungszahlen liefern muss, denen sie vertrauen können. Stellen Sie sicher, dass jeder Aufruf hinter einem Messsystem erfolgt, das Modell, Tokens sowie Feature-Flags protokolliert. Budgets sollten im Code sowie in Cloud-Billing-Alerts festgelegt werden. Das Routing nach Aufgabenkomplexität ist die kostengünstigste Lösung:

// Partial example — model routing based on task complexity
public class ModelRouter
{
    // Route cheap, simple tasks to the nano model
    // Route complex multi-step reasoning to the full model
    public string SelectModel(TaskComplexity complexity) => complexity switch
    {
        TaskComplexity.Classification  => "gpt-5.4-nano",   // ~20x cheaper than full
        TaskComplexity.Conversational  => "gpt-5.4-mini",   // ~5x cheaper
        TaskComplexity.Reasoning       => "gpt-5.4",         // full capability
        _                              => "gpt-5.4-mini"
    };
}

Unternehmenskonformität: Identität, Netzwerk und Standort

Sicherheitsfragen führen dazu, dass Projekte scheitern, die nur auf Demo-Latenz optimiert sind. Die Fragen betreffen die Identität, die Netzwerkisolation, die Datenspeicherung und die regionale Verfügbarkeit.

Azure OpenAI übernimmt Azure RBAC, Private Link sowie die Möglichkeit, den Standort auszuwählen. OpenAI und Anthropic bieten Organisationskontrollen sowie Optionen ohne Datenspeicherung – allerdings mit Einschränkungen, die man lesen muss. Gemini folgt den Mustern von Google Cloud IAM und VPC.

Bei der Authentifizierung in ASP.NET Core sollte man für Azure OpenAI eine verwaltete Identität bevorzugen. Bei Anbietern von API-Schlüsseln sollten die Geheimnisse beim Start aus dem Key Vault geladen und ohne Neuveröffentlichung der Anweisungen ausgetauscht werden. Binden Sie niemals Anbieter-Schlüssel an Benutzer-JWTs.

Die rechtliche Prüfung muss die Option zur Verweigerung der Nutzung für Schulzwecke, Unterauftragsverarbeiter sowie die Formulierungen im DPA für jeden aktivierten Anbieter umfassen – nicht nur für den Hauptanbieter. Mehrere Anbieter bedeuten mehrere Verträge.

Gestrukturierte Ausgabe mit JSON Schema

Die Unterstützung für JSON Schema sowie eingeschränkte Dekodierung variiert je nach Anbieter. Wählen Sie lieber Anbieter, die ein Schema für die Tool-Argumente und -Antworten durchsetzen können, dem Ihre C#-Deserialisierer bereits vertrauen, und wenden Sie bei schwacher Durchsetzungsmöglichkeit Methoden wie Validierung und erneuter Versuch an. Mit Azure OpenAI können Sie das Schema streng gestalten:

// Full example — Azure OpenAI structured output with strict schema enforcement
using Azure.AI.OpenAI;
using OpenAI.Chat;
using System.ComponentModel;
using System.Text.Json;

// Define the schema type — only JSON Schema primitives are supported
public class SupportTicketAnalysis
{
    public string Category { get; set; } = string.Empty;        // e.g. "billing", "technical"
    public string Priority { get; set; } = string.Empty;        // "low", "medium", "high", "critical"

    [Description("One to two sentence summary of the issue")]
    public string Summary { get; set; } = string.Empty;

    public string[] RequiredTeams { get; set; } = [];           // which teams must be looped in

    [Description("Estimated resolution time as a human-readable string, e.g. '2 business days'")]
    public string EstimatedResolution { get; set; } = string.Empty;
}

// Build the client — structured outputs require API version 2024-08-01-preview or later
var azureClient = new AzureOpenAIClient(
    new Uri(Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")!),
    new AzureKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_KEY")!),
    new AzureOpenAIClientOptions(AzureOpenAIClientOptions.ServiceVersion.V2024_08_01_Preview));

ChatClient chatClient = azureClient.GetChatClient("gpt-5.4-mini-deployment");

// Configure the request to enforce the schema strictly
var options = new ChatCompletionOptions
{
    ResponseFormat = ChatResponseFormat.CreateJsonSchemaFormat<SupportTicketAnalysis>(
        "support_ticket_analysis",  // snake_case — spaces and hyphens cause 400 errors
        strict: true)               // without this, schema compliance is best-effort only
};

List<ChatMessage> messages =
[
    new SystemChatMessage("You are a support ticket classifier. Analyze the ticket and return a structured assessment."),
    new UserChatMessage("User reports: 'My invoice shows $999 but the contract says $299. Need this fixed immediately.'")
];

// If structured outputs fail with a 400, the schema has unsupported types — check for DateTime, Uri, TimeSpan
ClientResult<ChatCompletion> result = await chatClient.CompleteChatAsync(messages, options);

// JsonSerializer.Deserialize will always succeed if the API call succeeded
SupportTicketAnalysis analysis = JsonSerializer.Deserialize<SupportTicketAnalysis>(
    result.Value.Content.Text)!;

Console.WriteLine(quot;Category: {analysis.Category}");
Console.WriteLine(quot;Priority: {analysis.Priority}");
Console.WriteLine(quot;Summary: {analysis.Summary}");

Zwei Aspekte in diesem Beispiel verursachen die meisten 400-Fehler: Die Schema-Names müssen im snake_case-Format sein, und Typen wie DateTime, Uri oder TimeSpan gehören nicht zu den Primitiven von JSON Schema. Ohne strict: true ist die Konformität nur ein Best-Effort-Ansatz.

Toolaufrufe, Embeddings und RAG

Alle vier Methoden unterstützen den Aufruf von Tools oder Funktionen, wobei jede eine andere Struktur des Payloads verwendet. Normalisieren Sie die Daten an der Grenze zu einem internen ToolCall DTO, damit der Orchestrierungskodex nicht je nach Anbieter unterschiedlich funktioniert.

Die Wahl eines Chat-Anbieters bedeutet nicht automatisch die Wahl seiner Embeddings. Legen Sie das Embedding-Modell sowie die Dimension in der Konfiguration fest und wechseln Sie diese nicht heimlich, wenn Sie den Chat-Anbieter austauschen. Cachen Sie Embeddings sowie deterministische Tool-Ergebnisse intensiv, speichern Sie aber keine Rohdaten der Chat-Antworten, die personenbezogene Informationen des Benutzers enthalten, es sei denn, eine Speicherungspolitik gilt dafür.

Eine schlanke .NET-Abstraktion mit IChatClient

Definieren Sie eine kleine Provider-Schnittstelle mit streambaren und nicht-streambaren Methoden, mappen Sie jedes SDK hinter einen Adapter und injizieren Sie es über DI. Behalten Sie Anfragen und Tools außerhalb der Adapter. Vermeiden Sie die „Gott-“-Frameworks, die die Wiederholungsversuche und Zeitlimits verbergen, die Sie anpassen müssen. Mit IChatClient liest sich die Registrierung den Provider aus der Konfiguration und umhüllt alles mit OpenTelemetry:

// Partial example — Program.cs provider registration with IChatClient
using Microsoft.Extensions.AI;
using Azure.AI.OpenAI;
using OpenAI;
using Anthropic;
using Google.Cloud.VertexAI.Extensions;

var builder = WebApplication.CreateBuilder(args);
var config = builder.Configuration;

// Read which provider to use from configuration — no code change to switch
string provider = config["AI:Provider"]!; // "azure", "openai", "anthropic", "gemini"

builder.Services.AddSingleton<IChatClient>(sp =>
{
    // Return the appropriate IChatClient implementation based on config
    return provider switch
    {
        "azure" => new AzureOpenAIClient(
                        new Uri(config["AI:Azure:Endpoint"]!),
                        new Azure.AzureKeyCredential(config["AI:Azure:Key"]!))
                    .GetChatClient(config["AI:Azure:Deployment"]!)
                    .AsIChatClient(), // extension method from Azure.AI.OpenAI

        "openai" => new OpenAIClient(config["AI:OpenAI:Key"]!)
                    .GetChatClient(config["AI:OpenAI:Model"]!)
                    .AsIChatClient(),

        "anthropic" => new AnthropicClient(config["AI:Anthropic:Key"]!)
                    .AsIChatClient(), // Anthropic SDK v10+ implements IChatClient

        "gemini" => new VertexAIChatClient(
                        projectId: config["AI:Gemini:ProjectId"]!,
                        location: config["AI:Gemini:Location"]!,
                        modelId: config["AI:Gemini:Model"]!),

        _ => throw new InvalidOperationException(quot;Unknown AI provider: {provider}")
    };
});

// Add OpenTelemetry instrumentation via pipeline decorator — applies to all providers
builder.Services.AddSingleton(sp =>
{
    var inner = sp.GetRequiredService<IChatClient>();
    return new ChatClientBuilder(inner)
        .UseOpenTelemetry(loggerFactory: sp.GetRequiredService<ILoggerFactory>(),
                          sourceName: "YourApp.AI")
        .Build();
});

Feature Flags sollten den Anbieter pro Mieter oder pro Fähigkeit auswählen. Ein einziger, statischer Client, der in Program.cs hardcodet ist, führt dazu, dass Residenzaußnahmen zu Incidents werden.

Beim Streaming ist in der Abstraktion ebenfalls ein expliziter Vertrag erforderlich: Stornotoken, Backpressure sowie die Art und Weise, wie teilweise ausgeführte Toolaufrufe die Aufrufer erreichen. Die Anbieter unterscheiden sich in diesem Punkt so stark, dass das „Einfach-Warten auf den String“ Vendor-Semantik in Ihre Controller einsickern lässt.

Ein funktionsfähiges Proof of Concept

Die gesamte Idee passt in eine kleine Web API. Starten Sie das Projekt und fügen Sie die Pakete hinzu:

dotnet new webapi -n AiProviderPoc --no-openapi
cd AiProviderPoc

dotnet add package Microsoft.Extensions.AI
dotnet add package OpenAI
dotnet add package Azure.AI.OpenAI
dotnet add package Anthropic
dotnet add package Google.Cloud.VertexAI.Extensions --prerelease

Der Prompt-Vertrag wird von jedem Anbieter geteilt. Die Ausgabetypen beschränken sich auf die Primitiven des JSON Schemas, und die Beschreibungen dienen gleichzeitig als Leitfaden für das Modell:

// PromptContracts.cs — shared across all providers
using System.ComponentModel;

namespace AiProviderPoc;

// The input to every analysis request
public record AnalysisRequest(string TicketText, string? Context = null);

// The structured output — must use only JSON Schema primitives (string, int, bool, arrays)
public class TicketAnalysis
{
    [Description("Category of issue: 'billing', 'technical', 'account', 'feature-request'")]
    public string Category { get; set; } = string.Empty;

    [Description("Severity: 'low', 'medium', 'high', 'critical'")]
    public string Severity { get; set; } = string.Empty;

    [Description("One to two sentence summary of the customer's issue")]
    public string Summary { get; set; } = string.Empty;

    [Description("Suggested action for the support agent, one sentence")]
    public string SuggestedAction { get; set; } = string.Empty;

    public bool RequiresEscalation { get; set; }

    [Description("Estimated time to resolve as human-readable string, e.g. '30 minutes' or '2 business days'")]
    public string EstimatedResolution { get; set; } = string.Empty;
}

Der Dienst besitzt den Systemprompt als stabiles, versioniertes Kontrakt und verlässt sich ausschließlich auf IChatClient. Er verwendet einen an den Anbieter ungebundenen JSON-Modus; für eine strenge Einhaltung des Schemas bei Azure oder OpenAI sollte der zuvor gezeigte direkte SDK-Ansatz verwendet werden.

// TicketAnalysisService.cs
using Microsoft.Extensions.AI;
using System.Text.Json;

namespace AiProviderPoc;

public class TicketAnalysisService(IChatClient chatClient)
{
    // The system prompt is the stable contract — versioned and centralized here
    private const string SystemPrompt =
        """
        You are a support ticket classifier for an enterprise software product.
        Analyze the provided support ticket and return a structured assessment.
        Be concise and accurate. Do not invent information not present in the ticket.
        """;

    public async Task<TicketAnalysis> AnalyzeAsync(AnalysisRequest request, CancellationToken ct = default)
    {
        // Build the message list — system prompt is fixed, user content is the ticket
        var messages = new List<ChatMessage>
        {
            new(ChatRole.System, SystemPrompt),
            new(ChatRole.User, request.TicketText)
        };

        // Use JSON mode via ChatOptions — provider-agnostic structured output
        // For strict schema enforcement with Azure/OpenAI, use the SDK-direct approach instead
        var options = new ChatOptions
        {
            ResponseFormat = ChatResponseFormat.Json
        };

        ChatResponse response = await chatClient.GetResponseAsync(messages, options, ct);

        // Deserialize — IChatClient normalizes the response shape across all providers
        return JsonSerializer.Deserialize<TicketAnalysis>(response.Text,
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true })
            ?? throw new InvalidOperationException("Model returned unparseable JSON");
    }
}

Program.cs registriert einen Client pro Provider-Branch und stellt einen einzigen Endpunkt bereit, der niemals erkennt, welcher Anbieter geantwortet hat:

using AiProviderPoc.Api;
using Anthropic;
using Azure.AI.OpenAI;
using Google.GenAI;
using Microsoft.Extensions.AI;
using OpenAI;
using System.ClientModel;          // ApiKeyCredential

var builder = WebApplication.CreateBuilder(args);
var config = builder.Configuration;

// Read provider selection from config — change "AI:Provider" to switch providers
string provider = config["AI:Provider"]
    ?? throw new InvalidOperationException("AI:Provider must be set in appsettings");

// Register IChatClient — each branch returns a different SDK's implementation
builder.Services.AddSingleton<IChatClient>(_ =>
{
    return provider.ToLowerInvariant() switch
    {
        "azure" =>
            // Azure AI Foundry: needs endpoint + key + deployment name
            new AzureOpenAIClient(
                new Uri(config["AI:Azure:Endpoint"]!),
                new ApiKeyCredential(config["AI:Azure:Key"]!))
            .GetChatClient(config["AI:Azure:Deployment"]!)
            .AsIChatClient(),

        "openai" =>
            // OpenAI direct: needs API key + model name
            new OpenAIClient(config["AI:OpenAI:Key"]!)
            .GetChatClient(config["AI:OpenAI:Model"]!)
            .AsIChatClient(),

        "anthropic" =>
            // AnthropicClient expects a ClientOptions instance (not a string API key).
            // Create a ClientOptions and pass it to the constructor.
            new AnthropicClient(
                new Anthropic.Core.ClientOptions
                {
                    ApiKey = config["AI:Anthropic:Key"]!
                })
            .AsIChatClient(),

        "gemini" =>
            // Google.GenAI: named params on Client constructor, no ClientConfig class needed.
            // Uses GOOGLE_APPLICATION_CREDENTIALS / ADC for auth; no API key required for Vertex AI.
            new Client(
                project: config["AI:Gemini:ProjectId"]!,
                location: config["AI:Gemini:Location"]!,
                vertexAI: true)
            .AsIChatClient(config["AI:Gemini:Model"]!),

        _ => throw new InvalidOperationException(quot;Unknown provider: '{provider}'. Valid: azure, openai, anthropic, gemini")
    };
});

// Register the service — depends only on IChatClient
builder.Services.AddScoped<TicketAnalysisService>();

var app = builder.Build();

// Single endpoint — provider is invisible here
app.MapPost("/analyze", async (AnalysisRequest request, TicketAnalysisService service, CancellationToken ct) =>
{
    var analysis = await service.AnalyzeAsync(request, ct);
    return Results.Ok(analysis);
});

app.Run();

Der Wechsel des Anbieters erfordert eine Konfigurationsänderung in appsettings.json:

{
  "AI": {
    "Provider": "azure",
    "Azure": {
      "Endpoint": "https://your-resource.openai.azure.com/",
      "Key": "your-azure-key",
      "Deployment": "gpt-5.4-mini-deployment"
    },
    "OpenAI": {
      "Key": "sk-...",
      "Model": "gpt-4o-mini"
    },
    "Anthropic": {
      "Key": "sk-ant-..."
    },
    "Gemini": {
      "ProjectId": "your-gcp-project",
      "Location": "us-central1",
      "Model": "gemini-2.0-flash"
    }
  }
}

Führen Sie es aus und erstellen Sie ein Ticket:

dotnet run

curl -X POST http://localhost:5000/analyze \
  -H "Content-Type: application/json" \
  -d '{"ticketText": "My subscription renews tomorrow but I was charged twice this month. Account #A-1234."}'

Die Antwort kommt in derselben Form zurück, unabhängig davon, welcher Anbieter konfiguriert ist:

{
  "category": "billing",
  "severity": "high",
  "summary": "Customer was charged twice for their subscription and is seeking a refund before their next renewal date.",
  "suggestedAction": "Review billing history for account A-1234 and initiate a refund for the duplicate charge.",
  "requiresEscalation": false,
  "estimatedResolution": "1 business day"
}

Prompt-Engineering, Bewertungen und faire Vergleiche

Wenn Sie die Qualität vergleichen, sollten Sie die Prompts sowie die Temperatureinstellungen unverändert lassen und nur Anbieter und Modell variieren. Andernfalls vergleichen Sie das Glück beim Prompt-Engineering und nicht die Anbieter selbst. Halten Sie die Prompt-Vorlagen in Versionen und führen Sie A/B-Tests unabhängig vom Anbieter-Adapter durch – sonst machen jedes Modellwechsel Ihre Prompt-Experimente ungültig.

Erstellen Sie OpenTelemetry-Spans für die Anrufe bei den Anbietern und verwenden Sie als Attribute die Anbieter- und Modellinformationen, die Token-Zahlen sowie den Abschlussgrund. Kombinieren Sie diese Online-Metriken mit Offline-Bewertungssätzen, damit der Wechsel zu einem günstigeren Modell auf Fakten und nicht auf Hoffnung beruht.

Auch die Latenzbudgets unterscheiden sich. Einige Anbieter liefern den ersten Token schneller; andere sind bei langen Ausführungen vorteilhaft. Messen Sie sowohl die Zeit bis zum ersten Token als auch die Gesamtlaufzeit für Ihre Arbeitslast, bevor Sie ein Standardmodell festlegen.

Verwendung mehrerer Anbieter in der Produktion

• Canary: Halten Sie für jede Umgebung einen goldenen Prompt bereit, der eine schema-konforme JSON-Struktur sowie eine Latenz-SLO vorschreibt, und verhindern Sie Deploys, die bei dem primären Anbieter diese Vorgaben verletzen.
• Inhaltsfilter: Azure-Inhaltsfilter sowie andere Sicherheitsschichten liefern unterschiedliche Fehlermeldungen. Koppeln Sie diese einmal Ihren Domänenausnahmen zu.
• Failover: Entscheiden Sie, welche Fehler bei einem sekundären Anbieter erneut versucht werden dürfen und welche sofort abgebrochen werden müssen – beispielsweise Autorisierungsfehler oder Ablehnungen aufgrund von Richtlinien. Ein blindes Failover kann die Zusagen zur Standortbeibehaltung verletzen.
• On-Call-Team: Schulen Sie die Mitarbeiter im Billing-Dashboard jedes aktivierten Anbieters. Ein plötzlicher Anstieg der Tokenanzahl um 2 Uhr morgens lässt sich leichter stoppen, wenn das Runbook den genauen Portalbereich angibt.
• Deprovisionierung: Deaktivieren Sie Schlüssel, löschen Sie Anwendungsregistrierungen, entfernen Sie Evaluierungsdatensätze, die Kundentexte enthalten, und archivieren Sie Kostenergebnisse.

Kurze Entscheidungscheckliste

Ist eine Repräsentationsadresse erforderlich? Beginnen Sie mit Azure OpenAI. Lange Dokumente? Nutzen Sie Benchmark Anthropic. Sind Sie bereits auf GCP? Bewerten Sie Gemini. Benötigen Sie die neuesten OpenAI-Modelle direkt nach Veröffentlichung? Verwenden Sie die OpenAI-Plattform. Benötigen Sie zwei der oben genannten Lösungen? Entwickeln Sie zunächst einen leichten Adapter sowie ein Nutzungsmonitoring-System.

Die Wahl des Anbieters ist eine Entscheidung im Rahmen der Unternehmensarchitektur mit Auswirkungen auf SDKs und Kosten. Vergleichen Sie dabei die Repräsentationsadresse, die Identitätsverwaltung, die Preistransparenz, die strukturierte Ausgabe sowie die Passgenauigkeit in der Betriebsabläufe.