sdk-connection-dotnet.cs

/*
 * Couchbase SDK connection singleton — .NET
 * Copy and adapt for your application.
 *
 * Dependencies (NuGet):
 *   dotnet add package CouchbaseNetClient
 *
 * For ASP.NET Core, prefer AddCouchbase() in Program.cs (see comment at bottom).
 */

using System;
using System.Threading;
using System.Threading.Tasks;
using Couchbase;
using Couchbase.KeyValue;

namespace MyApp;

public static class CouchbaseConnection
{
    // --- Configuration ---
    private const string CbHost       = "localhost";          // or "cb.xxxxx.cloud.couchbase.com" for Capella
    private const string CbUser       = "app-service-user";
    private const string CbPassword   = "AppSecret123!";
    private const string CbBucket     = "myapp";
    private const string CbScope      = "_default";
    private const string CbCollection = "_default";

    private static ICluster?    _cluster;
    private static ICouchbaseCollection? _collection;
    private static readonly SemaphoreSlim _lock = new(1, 1);

    /// <summary>Returns the singleton Collection, initializing the cluster on first call.</summary>
    public static async Task<ICouchbaseCollection> GetCollectionAsync()
    {
        if (_collection is not null) return _collection;

        await _lock.WaitAsync();
        try
        {
            if (_collection is not null) return _collection;
            await InitAsync();
        }
        finally
        {
            _lock.Release();
        }

        return _collection!;
    }

    /// <summary>Returns the singleton Cluster (needed for queries and transactions).</summary>
    public static async Task<ICluster> GetClusterAsync()
    {
        await GetCollectionAsync(); // ensures cluster is initialized
        return _cluster!;
    }

    private static async Task InitAsync()
    {
        // Use "couchbases://" for TLS (required for Capella, recommended for production)
        _cluster = await Cluster.ConnectAsync($"couchbase://{CbHost}", options =>
        {
            options.WithCredentials(CbUser, CbPassword);
            options.KvTimeout          = TimeSpan.FromMilliseconds(2500);
            options.QueryTimeout       = TimeSpan.FromSeconds(75);
            options.SearchTimeout      = TimeSpan.FromSeconds(75);
            options.BootstrapPollInterval = TimeSpan.FromSeconds(10);
        });

        await _cluster.WaitUntilReadyAsync(TimeSpan.FromSeconds(10));

        var bucket = await _cluster.BucketAsync(CbBucket);
        var scope  = await bucket.ScopeAsync(CbScope);
        _collection = await scope.CollectionAsync(CbCollection);
    }

    /// <summary>Call on application shutdown to release resources.</summary>
    public static async Task CloseAsync()
    {
        if (_cluster is not null)
            await _cluster.DisposeAsync();
    }
}

/*
 * --- Usage example ---
 *
 * var col     = await CouchbaseConnection.GetCollectionAsync();
 * var cluster = await CouchbaseConnection.GetClusterAsync();
 *
 * // KV upsert
 * await col.UpsertAsync("doc_1", new { type = "example", value = 42 });
 *
 * // KV get
 * var result = await col.GetAsync("doc_1");
 * var doc    = result.ContentAs<dynamic>();
 *
 * // SQL++ query
 * var rows = await cluster.QueryAsync<dynamic>(
 *     "SELECT * FROM `myapp`._default._default WHERE type = $type LIMIT 5",
 *     options => options.Parameter("type", "example")
 * );
 * await foreach (var row in rows) Console.WriteLine(row);
 *
 * await CouchbaseConnection.CloseAsync();
 *
 *
 * --- ASP.NET Core (preferred for web apps) ---
 *
 * // Program.cs
 * builder.Services.AddCouchbase(options =>
 * {
 *     options.ConnectionString = "couchbase://localhost";
 *     options.UserName         = "app-service-user";
 *     options.Password         = "AppSecret123!";
 * });
 *
 * // Inject IBucketProvider or IClusterProvider into your services.
 */