Cache with .NET (Couchbase)

Mustafa Gönültaş
Haziran 06, 2025
Türkçe Oku
This blog post examines the use of Couchbase Server as both a cache and a flexible NoSQL data store to enhance performance and scalability in .NET applications. Couchbase offers powerful benefits such as reducing database load, ensuring consistency in distributed environments, and providing horizontal scalability. The article demonstrates how to configure and use this hybrid solution with a simple example of Couchbase integration with ASP.NET Core Web API.

Using Couchbase Cache with .NET: The Power of NoSQL and Distributed Caching (Cache Series Part 3)

Performance and scalability are the cornerstones of modern software architectures. In previous parts of our Caching in .NET series, we've explored in-memory and distributed caching solutions like Redis. In this installment, we'll delve into Couchbase Server, a solution that not only acts as a fast cache but also stands out as a flexible NoSQL data store.

Couchbase Server offers a powerful solution for enhancing application performance and reducing server load, especially in high-traffic and data-intensive environments. In this blog post, we'll explain what Couchbase is, why it can be used as both a cache and a data store, its benefits, common use cases, and provide a simple example of how you can implement Couchbase in your ASP.NET Core Web API applications.

What is Couchbase Server?

Couchbase Server is an open-source, memory-first, distributed NoSQL document database. It's commonly used as both a primary data storage unit and an ultra-fast cache. Couchbase combines the simplicity of key-value storage with the document-based flexibility of MongoDB. It stores data as JSON documents, making it ideal for applications requiring flexible schemas. As a distributed system, it natively supports horizontal scalability and high availability.

Why Should You Use Couchbase Cache? Benefits and Necessity

Using Couchbase as both a NoSQL database and a powerful cache provides numerous significant benefits:

  • Performance and Speed: By storing data in a memory-first approach, Couchbase offers incredibly fast read and write operations. This significantly reduces application response times, especially for frequently accessed data.

  • Database and Cache in One Platform: Having a single system that can both persistently store data and act as a cache simplifies the architecture and reduces data synchronization complexity.

  • Consistency and High Availability in Distributed Environments: Couchbase ensures high availability and automatic failover by replicating data across multiple nodes. This guarantees that your data is accessible even during server outages.

  • Flexible Schema (JSON Documents): Storing data as JSON documents provides great flexibility for applications with rapidly changing or evolving schema requirements.

  • Scalability: It's easy to scale both the database and cache layers horizontally within a single platform. You can increase capacity and performance by adding new nodes.

  • Cross Data Center Replication (XDCR): Supports data replication across data centers for globally distributed applications, crucial for disaster recovery and geographical distribution scenarios.

  • N1QL Query Language: You can perform complex queries on JSON documents using N1QL (Non-First Normal Form Query Language), a powerful SQL-like query language.

Common Couchbase Use Cases

Couchbase's hybrid nature makes it ideal for many different scenarios:

  • Advanced Caching: Ultra-fast caching of frequently read data in high-performance websites and APIs.

  • Session Management: Storing scalable, high-performance, and durable session data.

  • User Profiles and Personalization: Rapid storage and access of dynamically changing user data and preferences.

  • Real-time Analytics: Fast access to real-time data like leaderboards in games or instant analytics.

  • Catalogs and Inventory Systems: Large datasets that are frequently updated and queried, such as product catalogs.

  • Object Storage: Storing key-value or document-based objects managed by the application.

Using Couchbase with ASP.NET Core Web API

To use Couchbase in your ASP.NET Core applications, we leverage the Couchbase .NET SDK. This SDK simplifies interaction with Couchbase clusters.

Here's a simple example of how to use Couchbase in an ASP.NET Core Web API application:

1. Install NuGet Package:

First, you need to add the Couchbase.Extensions.Caching.Distributed NuGet package to your project. This package allows you to use the IDistributedCache interface with Couchbase. The core Couchbase SDK will also come as a dependency.

Install-Package Couchbase.Extensions.Caching.Distributed

2. Service Configuration (Program.cs):

You need to configure the Couchbase cache service in your Program.cs file. Here you specify the connection information for your Couchbase cluster and the bucket to be used.

using Couchbase.Extensions.Caching.Distributed;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System;
using System.Text.Json; // For JSON serialization
using System.Threading.Tasks;

var builder = WebApplication.CreateBuilder(args);

// Add controllers
builder.Services.AddControllers();
// Add Swagger/OpenAPI support
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Add Couchbase Cache service
builder.Services.AddCouchbaseDistributedCache(options =>
{
    // Read Couchbase connection details from appsettings.json
    builder.Configuration.GetSection("Couchbase").Bind(options);
});

var app = builder.Build();

// Configure the HTTP request pipeline
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();

app.Run();

3. Add Couchbase Connection String to appsettings.json:

Add the connection information for your Couchbase cluster to your appsettings.json file. Replace BucketName and Password values with your own setup.

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "Couchbase": {
    "Servers": [ "couchbase://localhost" ], // Address of your Couchbase cluster
    "BucketName": "MyCacheBucket", // Name of the bucket to use
    "Username": "admin", // Bucket access username
    "Password": "password" // Bucket access password
  }
}

4. Cache Usage (Example Web API Controller):

You can perform cache operations by injecting the IDistributedCache interface into a controller. This example includes an API endpoint that will cache and read a mock product list from Couchbase.

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Distributed;
using System.Text.Json;
using System.Threading.Tasks;
using System.Collections.Generic;

namespace MyWebApp.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class ProductsController : ControllerBase
    {
        private readonly IDistributedCache _cache;

        public ProductsController(IDistributedCache cache)
        {
            _cache = cache;
        }

        [HttpGet("get-cached-products")]
        public async Task<IActionResult> GetCachedProducts()
        {
            string cacheKey = "AllProducts";
            string cachedProductsJson = await _cache.GetStringAsync(cacheKey);

            List<Product> products;

            if (string.IsNullOrEmpty(cachedProductsJson))
            {
                // If not in cache, fetch from a database or external source
                // This part would normally be a database call or API request.
                // Simulating with a 2-second delay.
                await Task.Delay(2000);
                products = new List<Product>
                {
                    new Product { Id = 1, Name = "Laptop", Price = 1500, Category = "Electronics" },
                    new Product { Id = 2, Name = "Desk Chair", Price = 300, Category = "Furniture" },
                    new Product { Id = 3, Name = "External SSD", Price = 100, Category = "Electronics" }
                };

                // Serialize data to JSON and add to Couchbase
                cachedProductsJson = JsonSerializer.Serialize(products);
                
                var options = new DistributedCacheEntryOptions()
                                .SetAbsoluteExpiration(TimeSpan.FromMinutes(10)) // Remove definitively after 10 minutes
                                .SetSlidingExpiration(TimeSpan.FromMinutes(2)); // Remove if not accessed within 2 minutes

                await _cache.SetStringAsync(cacheKey, cachedProductsJson, options);

                return Ok(new { Source = "Database/API", Data = products, Status = "Fetched and Cached" });
            }
            else
            {
                // If in cache, read directly from cache and deserialize from JSON
                products = JsonSerializer.Deserialize<List<Product>>(cachedProductsJson);
                return Ok(new { Source = "Couchbase Cache", Data = products, Status = "From Cache" });
            }
        }

        // Sample product model
        public class Product
        {
            public int Id { get; set; }
            public string Name { get; set; }
            public decimal Price { get; set; }
            public string Category { get; set; }
        }
    }
}

In this example:

  • We add the Couchbase service with AddCouchbaseDistributedCache.

  • We inject the IDistributedCache interface into the controller.

  • We try to read data from Couchbase using GetStringAsync.

  • If data is not found, we simulate fetching from a data source with a 2-second delay and create the data.

  • We convert the data to JSON format using JsonSerializer.Serialize.

  • We write the data to Couchbase with specific expiration times (absolute and sliding expiration) using SetStringAsync.

  • We convert the JSON data received from Couchbase back into an object using JsonSerializer.Deserialize.

Conclusion

Couchbase Server offers significant advantages to your .NET applications, not just as a fast cache but also as a flexible and scalable NoSQL data store. Its distributed nature, high availability, and JSON document support make it an excellent choice for modern web applications requiring high performance and data consistency. For developers looking to unify their database and caching layers into a single platform, Couchbase is a powerful alternative.

This blog post constituted an important part of our Caching in .NET series. If you're looking to take your application's performance and scalability to the next level, start exploring Couchbase and don't forget to follow the other parts of our series!