Passer au contenu principal
Le SDK C# fournit un accès pratique à l’API REST de Dodo Payments depuis des applications écrites en C#. Il propose une API basée sur des tâches async avec un typage fort et est actuellement en version bêta.
Le SDK C# est actuellement en version bêta. Nous travaillons activement sur des améliorations et accueillons vos retours.

​
Installation

Installez le SDK en utilisant le CLI .NET : 
dotnet add package DodoPayments.Client
Le SDK nécessite .NET 8.0 ou supérieur. Il fonctionne avec ASP.NET Core, des applications Console et d’autres types de projets .NET.

​
Démarrage rapide

Initialisez le client et créez une session de paiement : 
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);
Stockez toujours vos clés API en toute sécurité en utilisant des variables d’environnement, des secrets utilisateur ou Azure Key Vault. Ne les intégrez jamais en dur dans votre code source ou ne les engagez pas dans le contrôle de version.

​
Fonctionnalités principales

Async/Await

API complète basée sur des tâches async pour des opérations non bloquantes

Typage fort

Sécurité de type complète avec des types de référence nullable

Injection de dépendances

Support de première classe pour l’injection de dépendances .NET

Configuration

Configuration simple via des variables d’environnement ou appsettings.json

​
Configuration

​
Variables d’environnement

Configurez en utilisant des variables d’environnement :
.env
DODO_PAYMENTS_API_KEY=your_api_key_here

// Automatically reads from environment variables
DodoPaymentsClient client = new();

​
Configuration manuelle

Configurez manuellement avec un jeton d’accès : 
DodoPaymentsClient client = new() { BearerToken = "My Bearer Token" };

​
Opérations courantes

​
Créer une session de paiement

Générez une session de paiement : 
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}");

​
Gérer les clients

Créez et récupérez des informations sur les clients : 
// Create a customer
var createParams = new CustomerCreateParams
{
    Email = "[email protected]",
    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})");

​
Gérer les abonnements

Créez et gérez des abonnements récurrents : 
// 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);

​
Intégration ASP.NET Core

​
Enregistrement du service

Enregistrez le client dans 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();

​
Configuration

Ajoutez la configuration dans appsettings.json :
appsettings.json
{
  "DodoPayments": {
    "ApiKey": "your_api_key_here"
  }
}

​
Contrôleur API

Créez un contrôleur en utilisant l’injection de dépendances : 
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);

​
Modèle de couche de service

Créez un service pour la logique métier : 
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;
        }
    }
}

​
Secrets utilisateur (Développement)

Pour le développement, utilisez des secrets utilisateur pour stocker les clés API : 
dotnet user-secrets init
dotnet user-secrets set "DodoPayments:ApiKey" "your_api_key_here"

​
Tests

Exemple de test unitaire utilisant 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);
    }
}

​
Ressources

Dépôt GitHub

Voir le code source et contribuer

Référence API

Documentation API complète

Communauté Discord

Obtenez de l’aide et connectez-vous avec des développeurs

Signaler des problèmes

Signalez des bugs ou demandez des fonctionnalités

​
Support

Besoin d’aide avec le SDK C# ?

​
Contribuer

Étant donné que le SDK est en version bêta, vos retours et contributions sont particulièrement précieux ! Consultez les directives de contribution pour commencer.