Zum Hauptinhalt springen
Das C# SDK bietet bequemen Zugriff auf die Dodo Payments REST API aus in C# geschriebenen Anwendungen. Es verfügt über eine asynchrone Task-basierte API mit starker Typisierung und befindet sich derzeit in der Beta-Phase.
Das C# SDK befindet sich derzeit in der Beta-Phase. Wir arbeiten aktiv an Verbesserungen und freuen uns über Ihr Feedback.

​
Installation

Installieren Sie das SDK mit der .NET CLI: 
dotnet add package DodoPayments.Client
Das SDK erfordert .NET Standard 2.0 oder höher. Es funktioniert mit ASP.NET Core, Konsolenanwendungen und anderen .NET-Projekttypen.

​
Schnellstart

Initialisieren Sie den Client und erstellen Sie eine Checkout-Sitzung: 
using System;
using DodoPayments.Client;
using DodoPayments.Client.Models.CheckoutSessions;

// Configured using the DODO_PAYMENTS_API_KEY and DODO_PAYMENTS_BASE_URL environment variables
DodoPaymentsClient client = new();

CheckoutSessionCreateParams parameters = new()
{
    ProductCart =
    [
        new()
        {
            ProductID = "product_id",
            Quantity = 1,
        },
    ],
};

var checkoutSessionResponse = await client.CheckoutSessions.Create(parameters);

Console.WriteLine(checkoutSessionResponse.SessionId);
Bewahren Sie Ihre API-Schlüssel immer sicher auf, indem Sie Umgebungsvariablen, Benutzgeheimnisse oder Azure Key Vault verwenden. Hardcodieren Sie sie niemals in Ihrem Quellcode oder committen Sie sie in die Versionskontrolle.

​
Kernfunktionen

Async/Await

Vollständige asynchrone Task-basierte API für nicht-blockierende Operationen

Starke Typisierung

Umfassende Typensicherheit mit nullable Referenztypen

Dependency Injection

Erstklassige Unterstützung für .NET Dependency Injection

Konfiguration

Einfache Konfiguration über Umgebungsvariablen oder appsettings.json

​
Konfiguration

​
Umgebungsvariablen

Konfigurieren Sie mit Umgebungsvariablen:
.env
DODO_PAYMENTS_API_KEY=your_api_key_here

// Automatically reads from environment variables
DodoPaymentsClient client = new();
Siehe diese Tabelle für die verfügbaren Optionen:
EigenschaftUmgebungsvariableErforderlichStandardwert
BearerTokenDODO_PAYMENTS_API_KEYtrue-
WebhookKeyDODO_PAYMENTS_WEBHOOK_KEYfalse-
BaseUrlDODO_PAYMENTS_BASE_URLtrue"https://live.dodopayments.com"

​
Manuelle Konfiguration

Manuell mit Bearer-Token konfigurieren: 
DodoPaymentsClient client = new() { BearerToken = "My Bearer Token" };

​
Häufige Operationen

​
Erstellen einer Checkout-Sitzung

Generieren Sie eine Checkout-Sitzung: 
var parameters = new CheckoutSessionCreateParams
{
    ProductCart =
    [
        new()
        {
            ProductID = "prod_123",
            Quantity = 1
        }
    ],
    ReturnUrl = "https://yourdomain.com/return"
};

var session = await client.CheckoutSessions.Create(parameters);
Console.WriteLine($"Checkout URL: {session.Url}");

​
Kunden verwalten

Kundeninformationen erstellen und abrufen: 
// Create a customer
var createParams = new CustomerCreateParams
{
    Email = "customer@example.com",
    Name = "John Doe",
    Metadata = new Dictionary<string, string>
    {
        { "user_id", "12345" }
    }
};

var customer = await client.Customers.Create(createParams);

// Retrieve customer
var retrieved = await client.Customers.Retrieve("cus_123");
Console.WriteLine($"Customer: {retrieved.Name} ({retrieved.Email})");

​
Abonnements verwalten

Erstellen und verwalten Sie wiederkehrende Abonnements: 
// Create a subscription
var subscriptionParams = new SubscriptionCreateParams
{
    CustomerID = "cus_123",
    ProductID = "prod_456",
    PriceID = "price_789"
};

var subscription = await client.Subscriptions.Create(subscriptionParams);

// Cancel subscription
await client.Subscriptions.Cancel(subscription.Id);

​
Paginierung

Das SDK definiert Methoden, die paginierte Listen von Ergebnissen zurückgeben, mit bequemen Möglichkeiten, Ergebnisse entweder seitenweise oder elementweise über alle Seiten hinweg zuzugreifen.

​
Automatische Paginierung

Um durch alle Ergebnisse über alle Seiten hinweg zu iterieren, verwenden Sie die Paginate Methode: 
using System;

var page = await client.Payments.List(parameters);
await foreach (var item in page.Paginate())
{
    Console.WriteLine(item);
}

​
Manuelle Paginierung

Um auf einzelne Seitenartikel zuzugreifen und manuell die nächste Seite anzufordern: 
using System;

var page = await client.Payments.List();
while (true)
{
    foreach (var item in page.Items)
    {
        Console.WriteLine(item);
    }
    if (!page.HasNext())
    {
        break;
    }
    page = await page.Next();
}

​
ASP.NET Core-Integration

​
Dienstregistrierung

Registrieren Sie den Client in Program.cs:
Program.cs
using DodoPayments.Client;

var builder = WebApplication.CreateBuilder(args);

// Register DodoPayments client
builder.Services.AddSingleton<DodoPaymentsClient>(sp =>
{
    var configuration = sp.GetRequiredService<IConfiguration>();
    return new DodoPaymentsClient
    {
        BearerToken = configuration["DodoPayments:ApiKey"]
    };
});

builder.Services.AddControllers();

var app = builder.Build();
app.MapControllers();
app.Run();

​
Konfiguration

Fügen Sie die Konfiguration in appsettings.json hinzu:
appsettings.json
{
  "DodoPayments": {
    "ApiKey": "your_api_key_here"
  }
}

​
API-Controller

Erstellen Sie einen Controller mit Dependency Injection: 
using Microsoft.AspNetCore.Mvc;
using DodoPayments.Client;
using DodoPayments.Client.Models.CheckoutSessions;

[ApiController]
[Route("api/[controller]")]
public class PaymentsController : ControllerBase
{
    private readonly DodoPaymentsClient _client;
    private readonly ILogger<PaymentsController> _logger;

    public PaymentsController(DodoPaymentsClient client, ILogger<PaymentsController> logger)
    {
        _client = client;
        _logger = logger;
    }

    [HttpPost("checkout")]
    public async Task<IActionResult> CreateCheckout([FromBody] CheckoutRequest request)
    {
        try
        {
            var parameters = new CheckoutSessionCreateParams
            {
                ProductCart = request.Items,
                ReturnUrl = Url.Action("Return", "Checkout", null, Request.Scheme)
            };

            var session = await _client.CheckoutSessions.Create(parameters);

            return Ok(new { checkoutUrl = session.Url });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to create checkout");
            return BadRequest(new { error = ex.Message });
        }
    }
}

public record CheckoutRequest(List<ProductCartItem> Items);

​
Service-Layer-Muster

Erstellen Sie einen Dienst für Geschäftslogik: 
public interface IPaymentService
{
    Task<CheckoutSessionResponse> CreateCheckoutAsync(List<ProductCartItem> items);
    Task<PaymentResponse> ProcessPaymentAsync(decimal amount, string currency, string customerId);
}

public class PaymentService : IPaymentService
{
    private readonly DodoPaymentsClient _client;
    private readonly ILogger<PaymentService> _logger;

    public PaymentService(DodoPaymentsClient client, ILogger<PaymentService> logger)
    {
        _client = client;
        _logger = logger;
    }

    public async Task<CheckoutSessionResponse> CreateCheckoutAsync(List<ProductCartItem> items)
    {
        var parameters = new CheckoutSessionCreateParams
        {
            ProductCart = items,
            ReturnUrl = "https://yourdomain.com/return"
        };

        return await _client.CheckoutSessions.Create(parameters);
    }

    public async Task<PaymentResponse> ProcessPaymentAsync(
        decimal amount,
        string currency,
        string customerId)
    {
        try
        {
            var parameters = new PaymentCreateParams
            {
                Amount = (long)(amount * 100), // Convert to cents
                Currency = currency,
                CustomerID = customerId
            };

            return await _client.Payments.Create(parameters);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to process payment");
            throw;
        }
    }
}

​
Benutzerdaten (Entwicklung)

Für die Entwicklung verwenden Sie Benutzerdaten, um API-Schlüssel zu speichern: 
dotnet user-secrets init
dotnet user-secrets set "DodoPayments:ApiKey" "your_api_key_here"

​
Testen

Beispiel für einen Unit-Test mit xUnit: 
using Xunit;
using DodoPayments.Client;
using DodoPayments.Client.Models.CheckoutSessions;

public class PaymentServiceTests
{
    private readonly DodoPaymentsClient _client;

    public PaymentServiceTests()
    {
        _client = new DodoPaymentsClient
        {
            BearerToken = "test_key"
        };
    }

    [Fact]
    public async Task CreateCheckout_ShouldReturnSession()
    {
        // Arrange
        var parameters = new CheckoutSessionCreateParams
        {
            ProductCart =
            [
                new()
                {
                    ProductID = "prod_test",
                    Quantity = 1
                }
            ]
        };

        // Act
        var session = await _client.CheckoutSessions.Create(parameters);

        // Assert
        Assert.NotNull(session);
        Assert.NotNull(session.SessionId);
    }
}

​
Ressourcen

GitHub-Repository

Quellcode anzeigen und beitragen

API-Referenz

Vollständige API-Dokumentation

Discord-Community

Hilfe erhalten und mit Entwicklern verbinden

Probleme melden

Fehler melden oder Funktionen anfordern

​
Unterstützung

Brauchen Sie Hilfe mit dem C# SDK?

​
Mitwirken

Da sich das SDK in der Beta-Phase befindet, sind Ihr Feedback und Ihre Beiträge besonders wertvoll! Überprüfen Sie die Mitwirkungsrichtlinien, um loszulegen.