> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dodopayments.com/llms.txt
> Use this file to discover all available pages before exploring further.

# C#

> अपने .NET अनुप्रयोगों में Dodo Payments को आधुनिक async/await समर्थन के साथ एकीकृत करें

C# SDK से C# में लिखे गए अनुप्रयोगों से Dodo Payments REST API तक सुविधाजनक पहुँच प्रदान होती है। इसमें एक असिंक्रोनस Task-आधारित API है जिसमें स्ट्रॉन्ग टाइपिंग, ऑटोमैटिक रिट्राइज, और व्यापक त्रुटि प्रबंधन है।

## स्थापना

पैकेज को [NuGet](https://www.nuget.org/packages/DodoPayments.Client) से इंस्टॉल करें:

```bash theme={null}
dotnet add package DodoPayments.Client
```

<Info>
  SDK के लिए .NET 8.0 या इसके बाद का संस्करण आवश्यक है। यह ASP.NET Core, कंसोल अनुप्रयोगों, और अन्य .NET प्रोजेक्ट प्रकारों के साथ काम करता है।
</Info>

## त्वरित आरम्भ

क्लाइंट को इनिशियलाइज़ करें और एक चेकआउट सेशन बनाएं:

```csharp theme={null}
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);
```

<Warning>
  हमेशा अपने API कुंजियों को environment variables, user secrets, या Azure Key Vault का उपयोग करके सुरक्षित रूप से संग्रहीत करें। उन्हें अपने स्रोत कोड में हार्डकोड न करें या संस्करण नियंत्रण में कमिट न करें।
</Warning>

## प्रमुख विशेषताएँ

<CardGroup cols={2}>
  <Card title="Async/Await" icon="bolt">
    Full async Task-based API के साथ गैर-अवरुद्ध संचालन
  </Card>

  <Card title="Strong Typing" icon="shield-check">
    Nullable reference types के साथ व्यापक प्रकार सुरक्षा
  </Card>

  <Card title="Smart Retries" icon="repeat">
    अस्थायी त्रुटियों के लिए एक्सपोनेंशियल बैकऑफ़ के साथ स्वचालित रिट्राइज
  </Card>

  <Card title="Error Handling" icon="triangle-exclamation">
    सटीक त्रुटि प्रबंधन के लिए बिल्ट-इन अपवाद पदानुक्रम
  </Card>
</CardGroup>

## कॉन्फ़िगरेशन

### पर्यावरण चर

```bash .env theme={null}
DODO_PAYMENTS_API_KEY=your_api_key_here
```

```csharp theme={null}
// Automatically reads from environment variables
DodoPaymentsClient client = new();
```

| प्रॉपर्टी     | पर्यावरण चर                 | आवश्यक | डिफ़ॉल्ट मान                      |
| ------------- | --------------------------- | ------ | --------------------------------- |
| `BearerToken` | `DODO_PAYMENTS_API_KEY`     | true   | -                                 |
| `WebhookKey`  | `DODO_PAYMENTS_WEBHOOK_KEY` | false  | -                                 |
| `BaseUrl`     | `DODO_PAYMENTS_BASE_URL`    | true   | `"https://live.dodopayments.com"` |

### मैनुअल कॉन्फिगरेशन

```csharp theme={null}
DodoPaymentsClient client = new() { BearerToken = "My Bearer Token" };
```

### वातावरण

लाइव और टेस्ट मोड के बीच स्विच करें:

```csharp theme={null}
using DodoPayments.Client.Core;

DodoPaymentsClient client = new() { BaseUrl = EnvironmentUrl.TestMode };
```

### रिट्राइज

SDK डिफ़ॉल्ट रूप से 2 बार एक्सपोनेंशियल बैकऑफ़ के साथ स्वचालित रूप से पुनः प्रयास करता है। यह कनेक्शन त्रुटियों और स्थिति कोड 408, 409, 429, और 5xx पर पुनः प्रयास करता है।

```csharp theme={null}
// Custom retry count
DodoPaymentsClient client = new() { MaxRetries = 3 };
```

### टाइमआउट्स

अनुरोध डिफ़ॉल्ट रूप से 1 मिनट के बाद टाइम आउट हो जाते हैं।

```csharp theme={null}
DodoPaymentsClient client = new() { Timeout = TimeSpan.FromSeconds(30) };
```

### प्रति-अनुरोध ओवरराइड्स

एकल अनुरोध के लिए अस्थायी रूप से कॉन्फ़िगरेशन को `WithOptions` का उपयोग करके संशोधित करें:

```csharp theme={null}
var response = await client
    .WithOptions(options => options with
    {
        Timeout = TimeSpan.FromSeconds(10),
        MaxRetries = 5,
    })
    .CheckoutSessions.Create(parameters);
```

## सामान्य ऑपरेशन्स

### एक चेकआउट सेशन बनाएँ

```csharp theme={null}
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.CheckoutUrl}");
```

### ग्राहकों का प्रबंधन करें

```csharp theme={null}
// Create a customer
var customer = await client.Customers.Create(new CustomerCreateParams
{
    Email = "customer@example.com",
    Name = "John Doe"
});

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

### सब्सक्रिप्शन को हैंडल करें

```csharp theme={null}
using DodoPayments.Client.Models.Payments;
using DodoPayments.Client.Models.Subscriptions;

// Create a subscription
var subscription = await client.Subscriptions.Create(new SubscriptionCreateParams
{
    Billing = new BillingAddress
    {
        Country = "US",
        City = "San Francisco",
        State = "CA",
        Street = "1 Market St",
        Zipcode = "94105",
    },
    Customer = new AttachExistingCustomer { CustomerID = "cus_123" },
    ProductID = "pdt_456",
    Quantity = 1,
});

// Charge an on-demand subscription
// ProductPrice is in the lowest currency denomination (e.g., 2500 = $25.00 USD)
var charge = await client.Subscriptions.Charge(
    subscription.SubscriptionId,
    new SubscriptionChargeParams { ProductPrice = 2500 }
);
```

<Info>
  `Billing` कम से कम दो-अक्षरों का ISO `Country` कोड आवश्यक है। एक मौजूदा ग्राहक को संलग्न करने के लिए `AttachExistingCustomer` का उपयोग करें, या एक नया बनाने के लिए `NewCustomer` का उपयोग करें। `ProductPrice` सबसे कम मुद्रा संप्रदाय में है।
</Info>

## त्रुटि प्रबंधन

SDK HTTP स्थिति कोड के आधार पर विशिष्ट अपवाद उत्पन्न करता है। सभी 4xx त्रुटियाँ `DodoPayments4xxException` से इनहेरिट करती हैं।

| स्थिति | अपवाद                                       |
| ------ | ------------------------------------------- |
| 400    | `DodoPaymentsBadRequestException`           |
| 401    | `DodoPaymentsUnauthorizedException`         |
| 403    | `DodoPaymentsForbiddenException`            |
| 404    | `DodoPaymentsNotFoundException`             |
| 422    | `DodoPaymentsUnprocessableEntityException`  |
| 429    | `DodoPaymentsRateLimitException`            |
| 5xx    | `DodoPayments5xxException`                  |
| अन्य   | `DodoPaymentsUnexpectedStatusCodeException` |

अन्य अपवाद प्रकार:

* `DodoPaymentsIOException`: I/O नेटवर्किंग त्रुटियाँ
* `DodoPaymentsInvalidDataException`: प्रसारित डेटा की व्याख्या करने में विफलता
* `DodoPaymentsException`: सभी अपवादों के लिए मूल वर्ग

## पेजिनेशन

### ऑटो-पेजिनेशन

`Paginate` विधि का उपयोग करते हुए सभी पृष्ठों में सभी परिणामों को पार करें, जो एक `IAsyncEnumerable` लौटाती है:

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

### मैन्युअल पेजिनेशन

```csharp theme={null}
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 एकीकरण

अपने DI कंटेनर में क्लाइंट को पंजीकृत करें:

```csharp Program.cs theme={null}
using DodoPayments.Client;

var builder = WebApplication.CreateBuilder(args);

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

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

```json appsettings.json theme={null}
{
  "DodoPayments": {
    "ApiKey": "your_api_key_here"
  }
}
```

<Tip>
  विकास के लिए, चाबियों को `appsettings.json` में संग्रहीत करने के बजाय [user secrets](https://learn.microsoft.com/en-us/aspnet/core/security/app-secrets) का उपयोग करें।

  ```bash theme={null}
  dotnet user-secrets init
  dotnet user-secrets set "DodoPayments:ApiKey" "your_api_key_here"
  ```
</Tip>

## संसाधन

<CardGroup cols={2}>
  <Card title="NuGet Package" icon="box" href="https://www.nuget.org/packages/DodoPayments.Client">
    NuGet Gallery पर पैकेज देखें
  </Card>

  <Card title="GitHub Repository" icon="github" href="https://github.com/dodopayments/dodopayments-csharp">
    स्रोत कोड देखें और योगदान करें
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    संपूर्ण API प्रलेखन
  </Card>

  <Card title="Discord Community" icon="discord" href="https://discord.gg/bYqAp4ayYh">
    सहायता प्राप्त करें और डेवलपर्स के साथ जुड़ें
  </Card>
</CardGroup>

## समर्थन

क्या आपको C# SDK के साथ सहायता चाहिए?

* **Discord**: वास्तविक समय समर्थन के लिए हमारे [community server](https://discord.gg/bYqAp4ayYh) से जुड़ें
* **ईमेल**: [support@dodopayments.com](mailto:support@dodopayments.com) पर हमसे संपर्क करें
* **GitHub**: [repository](https://github.com/dodopayments/dodopayments-csharp) पर एक issue खोलें