Vai al contenuto principale
L’SDK C# fornisce un accesso comodo alla REST API di Dodo Payments da applicazioni scritte in C#. Offre un’API asincrona basata su Task con tipizzazione forte.

​
Installazione

Installa l’SDK usando la .NET CLI: 
dotnet add package DodoPayments.Client
L’SDK richiede .NET Standard 2.0 o versioni successive. Funziona con ASP.NET Core, applicazioni Console e altri tipi di progetti .NET.

​
Avvio rapido

Inizializza il client e crea una sessione di checkout: 
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);
Memorizza sempre le tue chiavi API in modo sicuro usando variabili d’ambiente, user secrets o Azure Key Vault. Non inserirle mai direttamente nel codice sorgente né committarle nel controllo versione.

​
Funzionalità principali

Async/Await

API completamente asincrona basata su Task per operazioni non bloccanti

Strong Typing

Sicurezza dei tipi completa con riferimento nullable

Dependency Injection

Supporto di prima classe per dependency injection in .NET

Configuration

Configurazione semplice tramite variabili d’ambiente o appsettings.json

​
Configurazione

​
Variabili d’ambiente

Configura usando variabili d’ambiente:
.env
DODO_PAYMENTS_API_KEY=your_api_key_here

// Automatically reads from environment variables
DodoPaymentsClient client = new();
Consulta questa tabella per le opzioni disponibili:
PropertyEnvironment variableRequiredDefault value
BearerTokenDODO_PAYMENTS_API_KEYtrue-
WebhookKeyDODO_PAYMENTS_WEBHOOK_KEYfalse-
BaseUrlDODO_PAYMENTS_BASE_URLtrue"https://live.dodopayments.com"

​
Configurazione manuale

Configura manualmente con token bearer: 
DodoPaymentsClient client = new() { BearerToken = "My Bearer Token" };

​
Operazioni comuni

​
Crea una sessione di checkout

Genera una sessione di checkout: 
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}");

​
Gestione dei clienti

Crea e recupera informazioni sui clienti: 
// 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})");

​
Gestione delle sottoscrizioni

Crea e gestisci sottoscrizioni ricorrenti: 
// 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);

​
Paginazione

L’SDK definisce metodi che restituiscono elenchi paginati di risultati con modi comodi per accedere ai risultati pagina per pagina o elemento per elemento su tutte le pagine.

​
Auto-paginazione

Per iterare su tutti i risultati attraverso tutte le pagine, usa il metodo Paginate: 
using System;

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

​
Paginazione manuale

Per accedere agli elementi di ogni pagina e richiedere manualmente la pagina successiva: 
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();
}

​
Integrazione con ASP.NET Core

​
Registrazione dei servizi

Registra il 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();

​
Configurazione

Aggiungi la configurazione in appsettings.json:
appsettings.json
{
  "DodoPayments": {
    "ApiKey": "your_api_key_here"
  }
}

​
Controller API

Crea un controller usando 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);

​
Pattern del livello di servizio

Crea un servizio per la logica di business: 
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;
        }
    }
}

​
User Secrets (sviluppo)

Per lo sviluppo, usa user secrets per memorizzare le chiavi API: 
dotnet user-secrets init
dotnet user-secrets set "DodoPayments:ApiKey" "your_api_key_here"

​
Testing

Esempio di unit test con 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);
    }
}

​
Risorse

GitHub Repository

Visualizza il codice sorgente e contribuisci

API Reference

Documentazione completa dell’API

Discord Community

Ottieni aiuto e connettiti con gli sviluppatori

Report Issues

Segnala bug o richiedi funzionalità

​
Supporto

Hai bisogno di aiuto con l’SDK C#?

​
Contribuire

Accogliamo contributi! Consulta le linee guida per i contributi per iniziare.