Using Redis in .NET Core Applications: An Overview

Modern applications frequently employ Redis, a quick in-memory key-value store, for caching, session storage, message brokering, and pub/sub communication. It is the preferred option for creating scalable systems since it is developer-friendly, lightweight, and performant.

This article will demonstrate how to use the StackExchange if you're working on a.NET Core project and wish to incorporate Redis into your application. Redis library to carry out fundamental Redis tasks. For Windows users, Redis can be run on a server that supports it without the need for Linux or containerization.

Why Redis?

Redis offers several benefits when integrated with a .NET Core application.

1. Caching: Store frequently accessed data to improve response times and reduce database workloads.
2. Session Management: Handle user sessions efficiently in distributed systems.
3. Real-Time Events: Use Redis for pub/sub features to power real-time functionality like notifications or event-driven communication.
4. High Performance: Operates in memory, offering low-latency data access.
5. Scalable: With support for clustering and sharding, Redis is built for scalability.

Setting Up Redis

Using Redis

To connect your .NET Core app to Redis, you can run Redis either.

• Command-Line Installation: Use tools like Docker to run Redis on Linux or Windows.
• Pre-Configured Windows Alternative: If you’re on Windows, you can use a Redis-compatible server as a drop-in replacement for running Redis natively.

Note. For simplicity, this tutorial assumes Redis is running locally on localhost:6379.

Building a .NET Core Application with Redis

In this example, we’ll create a .NET Core console application that performs the following Redis operations.

1. Connect to a Redis server.
2. Perform basic key-value operations (set, get, delete).
3. Demonstrate key expiration and validation.

Step 1. Create the .NET Core Project.

1. Open a terminal and create a new project.

   dotnet new RedisIntegrationDemo

Step 2. Write the Code.

Here’s the full implementation in the Program.cs.

using System;
using StackExchange.Redis;
using System.Threading.Tasks;

namespace RedisIntegrationDemo
{
    class Program
    {
        // Connection string for Redis
        private const string RedisConnectionString = "localhost:6379";

        async static Task Main(string[] args)
        {
            Console.WriteLine("Connecting to Redis...");

            // Connect to Redis
            var redis = await ConnectionMultiplexer.ConnectAsync(RedisConnectionString);
            Console.WriteLine("Connected to Redis successfully.\n");

            // Access the Redis database
            IDatabase db = redis.GetDatabase();

            // Perform Redis operations
            Console.WriteLine("Performing Redis operations...");

            // 1. Set key-value pair
            string key = "SampleKey";
            string value = "Hello from Redis!";
            await db.StringSetAsync(key, value);
            Console.WriteLine($"Set: {key} => {value}");

            // 2. Get the value for the key
            string savedValue = await db.StringGetAsync(key);
            Console.WriteLine($"Get: {key} => {savedValue}");

            // 3. Set an expiration for the key
            TimeSpan expiryTime = TimeSpan.FromSeconds(10);
            await db.KeyExpireAsync(key, expiryTime);
            Console.WriteLine($"Set expiration for {key}: {expiryTime.TotalSeconds} seconds");

            // 4. Check key existence after expiration
            Console.WriteLine("\nWaiting for the key to expire...");
            await Task.Delay(12000); // Wait 12 seconds
            bool exists = await db.KeyExistsAsync(key);
            Console.WriteLine($"Key Exists After Expiration: {key} => {exists}");

            // Close the connection
            redis.Close();
            Console.WriteLine("\nAll Redis operations completed.");
        }
    }
}

Step 3. Run the Application.

To execute the application.

dotnet run

Expected Output

The program will connect to Redis, perform basic key-value operations, and validate key expiration. You should see output like this,

Install the StackExchange.Redis package for Redis connectivity.
dotnet add package StackExchange.Redis

How Redis Works with .NET Core?

Here’s what the application does step by step,

1. Connects to the Redis server using ConnectionMultiplexer, which manages connection pooling and server communication.
2. Performs basic commands.
   • StringSetAsync: Sets a key-value pair in Redis.
   • StringGetAsync: Gets the value of a key.
   • KeyExpireAsync: Sets an expiration time for a key.
   • KeyExistsAsync: Checks if a key exists.
3. Handles temporary in-memory storage of data with expiration.

If you’re working in a Windows environment and prefer not to install a native Redis instance or use Docker, you can use a Redis-compatible server as an alternative.

Setting Up a Redis-Compatible Server

• Install a Redis-compatible server for Windows.
• Once installed, the server typically runs on localhost:6379 by default, similar to Redis.
• Your application does not require any code changes to work with a Redis-compatible server.

Using a Redis-compatible server allows Redis functionality to run natively on Windows without relying on containers or virtualized environments.

Advantages of Using Redis in .NET Core

1. Performance: Redis operates fully in memory, enabling extremely low latency.
2. Ease of Use: Simplified API for common key-value needs, with additional data structures like lists, sets, and hashes.
3. Flexibility: Redis serves multiple purposes (e.g., caching, message queues, pub/sub).
4. Scalability: Redis supports clustering and high availability for scaling with demand.

Conclusion

Integrating Redis into your .NET Core application allows you to build high-quality, performant systems that can handle demanding workloads. With the StackExchange.Redis library, you can interact with Redis seamlessly.

Start by implementing Redis for simple caching or session management, and expand its usage to pub/sub and real-time data needs in your distributed .NET Core applications.

Happy coding and scaling!

Windows Hosting Recommendation

HostForLIFE.eu receives Spotlight standing advantage award for providing recommended, cheap and fast ecommerce Hosting including the latest Magento. From the leading technology company, Microsoft. All the servers are equipped with the newest Windows Server 2022 R2, SQL Server 2022, ASP.NET Core 7.0.10 , ASP.NET MVC, Silverlight 5, WebMatrix and Visual Studio Lightswitch. Security and performance are at the core of their Magento hosting operations to confirm every website and/or application hosted on their servers is highly secured and performs at optimum level. mutually of the European ASP.NET hosting suppliers, HostForLIFE guarantees 99.9% uptime and fast loading speed. From €3.49/month , HostForLIFE provides you with unlimited disk space, unlimited domains, unlimited bandwidth,etc, for your website hosting needs.