Vai al contenuto principale
Il SDK C# fornisce un accesso conveniente all’API REST di Dodo Payments da applicazioni scritte in C#. Presenta un’API basata su Task async con tipizzazione forte ed è attualmente in beta.
Il SDK C# è attualmente in beta. Stiamo lavorando attivamente a miglioramenti e accogliamo il tuo feedback.

​
Installazione

Installa il SDK utilizzando il .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.

​
Inizio Veloce

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);
Conserva sempre le tue chiavi API in modo sicuro utilizzando variabili d’ambiente, segreti utente o Azure Key Vault. Non codificarle mai nel tuo codice sorgente o committarle nel controllo di versione.

​
Caratteristiche Principali

Async/Await

API completa basata su Task async per operazioni non bloccanti

Tipizzazione Forte

Sicurezza di tipo completa con tipi di riferimento nullable

Dependency Injection

Supporto di prima classe per l’iniezione delle dipendenze in .NET

Configurazione

Configurazione semplice tramite variabili d’ambiente o appsettings.json

​
Configurazione

​
Variabili d’Ambiente

Configura utilizzando 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:
ProprietàVariabile d’ambienteRichiestaValore predefinito
BearerTokenDODO_PAYMENTS_API_KEYtrue-
WebhookKeyDODO_PAYMENTS_WEBHOOK_KEYfalse-
BaseUrlDODO_PAYMENTS_BASE_URLtrue"https://live.dodopayments.com"

​
Configurazione Manuale

Configura manualmente con il 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}");

​
Gestisci i 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})");

​
Gestisci gli Abbonamenti

Crea e gestisci abbonamenti 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 di risultati paginati con modi convenienti per accedere ai risultati sia una pagina alla volta che elemento per elemento attraverso tutte le pagine.

​
Auto-Paginazione

Per iterare attraverso tutti i risultati su tutte le pagine, utilizza 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 pagina individuali 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 ASP.NET Core

​
Registrazione del Servizio

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 configurazione in appsettings.json:
appsettings.json
{
  "DodoPayments": {
    "ApiKey": "your_api_key_here"
  }
}

​
Controller API

Crea un controller utilizzando l’iniezione delle dipendenze: 
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);

​
Modello di Servizio

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

​
Segreti Utente (Sviluppo)

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

​
Test

Esempio di test unitario utilizzando 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

Repository GitHub

Visualizza il codice sorgente e contribuisci

Riferimento API

Documentazione API completa

Comunità Discord

Ottieni aiuto e connettiti con gli sviluppatori

Segnala Problemi

Segnala bug o richiedi funzionalità

​
Supporto

Hai bisogno di aiuto con l’SDK C#?

​
Contribuire

Poiché l’SDK è in beta, il tuo feedback e i tuoi contributi sono particolarmente preziosi! Controlla le linee guida per la contribuzione per iniziare.