GraphQL to
C#.

// Client/QueryClient.cs
using System.Net.Http;
using System.Text.Json;
using Example.Payments.Models;

namespace Example.Payments.Client;

public class QueryClient : BaseHttpClient
{
    public QueryClient(HttpClient httpClient, string baseUrl, JsonSerializerOptions? jsonOptions)
        : base(httpClient, baseUrl, jsonOptions) { }

    public async Task<Example.Payments.Models.Payment?> PaymentAsync(
        string id, CancellationToken cancellationToken = default)
    {
        var variables = new Dictionary<string, object?> { { "id", id } };
        return await ExecuteGraphQLAsync<Example.Payments.Models.Payment>(
            "query Payment($id: ID!) { payment(id: $id) { ... } }",  // full selection set generated inline
            "Payment", variables, "payment", cancellationToken).ConfigureAwait(false);
    }
}

// Client/SubscriptionClient.cs
public class SubscriptionClient : BaseHttpClient
{
    public async IAsyncEnumerable<Example.Payments.Models.Payment> PaymentSettledAsync(
        [EnumeratorCancellation] CancellationToken cancellationToken = default)
    {
        await foreach (var item in SubscribeAsync<Example.Payments.Models.Payment>(
            "subscription PaymentSettled { paymentSettled { ... } }",
            "PaymentSettled", null, "paymentSettled", cancellationToken).ConfigureAwait(false))
        {
            yield return item;
        }
    }
}

// Client/BaseHttpClient.cs (shared)
public abstract class BaseHttpClient
{
    protected readonly HttpClient _httpClient;
    protected readonly string _baseUrl;
    protected readonly JsonSerializerOptions? _jsonOptions;
    protected readonly GraphQLWebSocketConnection _ws;

    public BaseHttpClient(HttpClient httpClient, string baseUrl, JsonSerializerOptions? jsonOptions = null)
    {
        _httpClient = httpClient;
        _baseUrl = baseUrl.TrimEnd('/');
        _jsonOptions = jsonOptions;
        // http -> ws, https -> wss; subscriptions hit <baseUrl>/graphql
        var wsBase = _baseUrl.StartsWith("https://", StringComparison.OrdinalIgnoreCase)
            ? "wss://" + _baseUrl.Substring("https://".Length)
            : "ws://" + _baseUrl.Substring("http://".Length);
        _ws = new GraphQLWebSocketConnection(new Uri(wsBase + "/graphql"), _jsonOptions);
    }

    protected async Task<T?> ExecuteGraphQLAsync<T>(
        string query, string operationName,
        Dictionary<string, object?>? variables, string fieldName,
        CancellationToken cancellationToken)
    {
        var graphqlBody = new Dictionary<string, object?>
        {
            { "query", query },
            { "operationName", operationName },
        };
        if (variables != null) graphqlBody["variables"] = variables;
        using var request = new HttpRequestMessage(HttpMethod.Post, $"{_baseUrl}/graphql");
        request.Content = new StringContent(
            JsonSerializer.Serialize(graphqlBody, _jsonOptions), Encoding.UTF8, "application/json");
        using var response = await _httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
        response.EnsureSuccessStatusCode();
        // Reads data.<fieldName>; an errors[] array surfaces as HttpRequestException.
        return await ReadGraphQLFieldAsync<T>(response, fieldName, cancellationToken).ConfigureAwait(false);
    }

    // Subscriptions: one ClientWebSocket (graphql-transport-ws) multiplexes every
    // active subscription; each yields its 'next' frames as IAsyncEnumerable<T>.
    protected async IAsyncEnumerable<T> SubscribeAsync<T>(
        string query, string operationName,
        Dictionary<string, object?>? variables, string fieldName,
        [EnumeratorCancellation] CancellationToken cancellationToken)
    { /* connection_init -> subscribe -> read next/error/complete */ }
}