Today in this article, we shall see how to use Redis Distributed Cache in C#.NET with Examples.

We will see how cache can play important role improving a system’s performance and scalability and best user experience.

We will cover below aspects,

I have used API with SQL server data access using the Entity framework example in this article.

Once data with key-value pair is cached, then every consecutive data access for the same will be done through the cache.

What is Caching?

• Caching is a strategy for improving a system’s performance and scalability.

• Caching lets you temporarily copy and let you access frequently used data from the storage near the application.

• Caching increases response times for client applications by supplying the data more quickly.

What is Redis Distributed Cache

Redis is a distributed in-memory database that allows you to read and write data.

Faster than Disk – Redis can respond in milliseconds or less.

They can read data faster than disk-based databases because they store data in memory.

• In Redis, all writes are asynchronous, so clients can read and write data without being interrupted.

• Redis reads the data from the snapshot or logs file and utilizes it to build the in-memory cache when it starts up.

• Redis is a key-value store that accepts simple types as well as complicated data structures like hashes, lists, and sets as values.

• It supports a set of atomic operations.

We shall cover the basic aspects of Redis cache implementation below,

• Install the Redis Nuget package.

• Configure Redis Cache in the API pipeline.

• Get the data from the cache for the input request.

Getting started

Create .NET 3.1 or 6 API or ASP.NET Core MVC applications.

Please install the Redis NuGet package Microsoft.Extensions.Caching.StackExchangeRedis

as below,

Install-Package Microsoft.Extensions.Caching.StackExchangeRedis -Version 5.0.0

Note- Please use any latest available compatible version.

Redis Distributed cache in C#.NET

Please add Redis services to the Service collection as below,

public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            services.AddScoped<IEmployeeRepository, EmployeeRepository>();
            services.AddSingleton<IRedisCacheService, RedisCacheService>();
            services.AddDbContext<EmployeeContext>(options =>
            {
                options.UseSqlServer(Configuration.GetConnectionString("EmployeeDB"),
                sqlServerOptionsAction: sqlOptions =>
                {
                    sqlOptions.EnableRetryOnFailure();
                });
            });
            services.AddStackExchangeRedisCache(options =>
            {
                options.Configuration = $"{Configuration.GetValue<string>("RedisCache:Host")}:{Configuration.GetValue<int>("RedisCache:Port")}";
            });

AddStackExchangeRedisCache – It let you add Redis-distributed caching services to the specified IServiceCollection.

Let’s define a simple interface with Read and Write access,

public interface IRedisCacheService
    {
        T Get<T>(string key);
        T Set<T>(string key, T value);
    }

Redis Cache using IDistributedCache interface

Below is the basic implementation of the interface method.

Above we have registered the implementation of IDistributedCache using a wrapper interface i.e IRedisCacheService.

IRedisCacheService interface provides the below methods to work with the distributed cache.

public class RedisCacheService : IRedisCacheService
    {
        private readonly IDistributedCache _cache;
        public RedisCacheService(IDistributedCache cache)
        {
            _cache = cache;
        }
        public T Get<T>(string key)
        {
            var value = _cache.GetString(key);
            if (value != null)
            {
                return JsonSerializer.Deserialize<T>(value);
            }
            return default;
        }
    }

Below is a generic Set method that will save or write data to Redis Cache.

 public T Set<T>(string key, T value)
        {
            var timeOut = new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(24),
                SlidingExpiration = TimeSpan.FromMinutes(60)
            };
            _cache.SetString(key, JsonSerializer.Serialize(value), timeOut);
            return value;
        }

The IRedisCacheService interface is defined as below

public interface IRedisCacheService
    {
        T Get<T>(string key);
        T Set<T>(string key, T value);
    }

AbsoluteExpirationRelativeToNow and SlidingExpiration usage is explained below.

Redis cache timeout

AbsoluteExpirationRelativeToNow – That means the element added to the cache, will remain in memory for the specified time/hours, and then entry will expire from the cache whether the element is accessed or not during that time.

Example: Above AbsoluteExpirationRelativeToNow is set as 24 hours.

Item will be held in cache for the entire 24 hours and then entry will be expired.

It will be removed early only if SlidingExpiration is set, and its condition is met.

SlidingExpiration – Gets or sets how long a cache entry can be inactive (e.g. not accessed) before it will be removed.

This will not extend the entry lifetime beyond the absolute expiration (if it is set).

Example: Above SlidingExpiration is set as 60 min.

If the item is not accessed within 60 min then the item will be removed from the cache.

If it is getting accessed at least one time within 60 min then it will be held in the cache let’s say for the entire 24 hours and then entry will get expired based on AbsoluteExpiration time.

Let’s do a dependency injection of our custom Interface.

Starting RedisServer

Lets start Redis Server and start its instance to accept the data for caching.

Once we execute the API with the required input ID, first-time Employee details will be fetched from the database but next time same ID-related will be fetched directly from the cache instead of the SQL server.

Redis-Dependency Injection of the ConnectionMultiplexer

ConnectionMultiplexer StackExchange’s principal object can be leveraged using dependency injection and is recommended to use.

It provides multipurpose usage like accessing the Redis database and lets you perform read, write, update, or delete operations, provide pub/sub features, etc.

• Redis-Dependency Injection using ConnectionMultiplexer

Useful References:

• Redis Cache Best Practices for Development

• Using NCache for Distributed Cache in C#.NET

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Redis Distributed Cache in C#.NET with Examples first appeared on TheCodeBuzz.

Today in this article, we will see how to fix Redis error “It was not possible to connect to the redis server. There was an authentication failure; check that passwords or client certificates.“

We will cover few possible resolutions which could help you fix the issue.

Issue Description

Redis connection throws an error,

StackExchange.Redis.RedisConnectionException: ‘It was not possible to connect to the redis server(s). There was an authentication failure; check that passwords (or client certificates) are configured correctly. SocketFailure on localhost:6379/Interactive, Initializing/NotStarted, last: NONE, origin:

Resolution

I found the error is due to configuration settings required for a Redis connection being missing.

Resolution 1

Before trying any fix, please make sure the Redis server is up and running. This error may occur if Redis Server is down or faulted.

Resolution 2

Please make sure your connection details including username and password are accurate.

Resolution 3

Sometimes a network bleep could lead to such connectivity issues. Mainly transient errors are common in cloud environment.

Please make sure resiliency for the connection is implemented.

Please visit: – Best practices for Redis cache management

It’s recommended that if you set abortConnect=false in your connection string.

As default behavior, Redis will auto-reconnect if a network has any transient error occurs.

The default value for abortConnect is true.

I was able to fix the error by using the below code (for .NET). However, you may try identifying similar settings in project based on other language like Java, python or node etc.

var configurationOptions = new ConfigurationOptions
                {
                    EndPoints = { $"{Configuration.GetValue<string>("RedisCache:Host")}: 
                    {Configuration.GetValue<int>("RedisCache:Port")}" },
                    Ssl = true,
                    AbortOnConnectFail = false,
                };
                var multiplexer = ConnectionMultiplexer.Connect(configurationOptions)

Resolution 4

Please re-verify certificates configuration are accurate. Please visit this for more details.

Reference :

• Best practices for Redis cache managment

• Redis-Dependency Injection of the ConnectionMultiplexer

• REDIS CLI COMMANDS

That’s all! Happy coding!

Does this help you fix your issue?

Do you have any better solutions or suggestions? Please sound off your comments below.

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Redis Error – It was not possible to connect to the Redis server first appeared on TheCodeBuzz.

Today in this article we shall see how to implement Redis Cache Connection Resiliency with examples in the .NET application.

We will use StackExchange.Redis NuGet package for getting supported connection manager class for performing connection or re-connections or timeout configuration.

Connection resiliency is a critical component of application communication that uses shared resources (particularly in the cloud) because these resources are more vulnerable to transient faults.

The StackExchange.Redis client uses a connection manager class that is configured through a set of options, including:

Configuring the ConnectionMultiplexer with resiliency options

Below is a sample example of how to configure the ConnectionMultiplexer with resiliency options. Below we have used an instance of the configuration options class, with required options defined and passing it to the Connect method.

Retry policies are configured before connecting to the cache.

Connection Resiliency for Redis- Retry with exponential backoff

The below example shows a retry strategy using exponential backoff.

  


                var options = new ConfigurationOptions
                {
                    EndPoints = { $"{Configuration.GetValue<string>("RedisCache:Host")}: 
                                {Configuration.GetValue<int>("RedisCache:Port")}" },

                    ConnectRetry = 5,

                    ReconnectRetryPolicy = new ExponentialRetry(deltaBackOffms , 
                                                                maxdeltaBackOffms),

                    ConnectTimeout = 1000

                };

                var redisMultiplexer = ConnectionMultiplexer.Connect(options);

           

Above time in milliseconds can be defined as the below example,

                var deltaBackOffms = 

                Convert.ToInt32(TimeSpan.FromSeconds(5).TotalMilliseconds);

                var maxdeltaBackOffms = 

                Convert.ToInt32(TimeSpan.FromSeconds(20).TotalMilliseconds);

ConfigurationOptions discussed above are defined as below,

• ConnectRetry – The number of times to repeat connect attempts during the initial connection operation. The default value is 3.

• ReconnectRetryPolicy. The retry strategy to use. The default value is LinearRetry 5000 ms

• ConnectTimeout. The maximum waiting time is in milliseconds.

Connection Resiliency for Redis – Retry using string options

Alternatively, we can define configuration via string declaration as below

         
           var configOptions = $"{host},connectRetry=3,connectTimeout=1000";
           var redisMultiplexer = ConnectionMultiplexer.Connect(configOptions);

           services.AddSingleton<IConnectionMultiplexer>(redisMultiplexer);

Where ‘host‘ is defined as below,

var host = $"{Configuration.GetValue("RedisCache:Host")}:
{Configuration.GetValue("RedisCache:Port")}";

Above we are making use of the configuration to read the apsetting.json file,

For more details: Configuration in ASP.NET Core

Using ConnectionMultiplexer via Dependency Injection

if you are using ASP.NET Core or MVC application, then ConnectionMultiplexer via Dependency Injection can be injected by defining the service scope in the API pipeline as below,

services.AddSingleton(redisMultiplexer);

For more details: Redis-Dependency Injection of the ConnectionMultiplexer

Redis Retry guidelines

Consider the following guidelines when using Azure Cache for Redis,

• Retry policies become effective when establishing a connection to the cache (when the application first starts.)

• It’s recommended to use falling back by accessing an original data source. This is preferred over a number of retry attempts.

Other useful references :

• Redis-Dependency Injection of the ConnectionMultiplexer

• Cache Design and Best practices

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Redis Cache Connection Resiliency ASP.NET Core first appeared on TheCodeBuzz.

Today in this article we shall see how to connect to Remote Redis Server. We shall see all the basic commands and various ways of connecting.

Today in this article, we will cover below aspects,

Redis-cli connects to remote Redis Server – using host & port

By default redis-cli connects to the server at 127.0.0.1 i.e your localhost and port 6379.

You can change the host or port using command-line options.

To use a different hostname or an IP address, use -h. To use a different port, use -p.

Command

redis-cli -h host -p port

Example

Connect to Remote Redis Server using the password

If your Redis server is password protected then additionally -a command is used.

-a command is actually equivalent of the below AUTH command,

AUTH <password>

Command

redis-cli -h host -p port -a password

Example

Connect to Remote Redis using uri option in command

You can connect to the Redis server using the valid URL option  -u <uri> option.

Command

$ redis-cli -u redis://password@host:port

Example:

redis-cli -u redis://passowrdkey@thecodebuzz....com:6379 ping

Connect to Remote Redis Server using SSL/TLS

By default, redis-cli connects to Redis via a standard TCP connection. 

Command using —tls or  —cacert or — cacertdir can be used to enable SSL/TLS.

Reference :

• How to Run Redis on Windows – Guidelines

• REDIS CLI COMMANDS

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Connect to Remote Redis Server – Guidelines first appeared on TheCodeBuzz.

Today in this article, we shall see how to use Redis Distributed cache in .NET or .NET Core C# application using Redis-Dependency Injection Of The ConnectionMultiplexer.

Today in this article, we will cover below aspects,

Redis is a distributed in-memory database that allows you to read and write data. Faster than Disk – Redis can respond in milliseconds or less.

We already covered the basic approach of using StackExchange.Redis and generic IDistributedCache interface.

Please refer to the below article for more details,

• Redis Distributed cache in .NET with examples

What is ConnectionMultiplexer

• ConnectionMultiplexer StackExchange’s principal object has multipurpose usage like accessing the Redis database and letting you perform read, write, update or delete operations, provide pub/sub features, etc.

• It is a thread-safe and ready-to-use application. All of the following examples will presume you have a ConnectionMultiplexer instance saved for later usage.

• The ConnectionMultiplexer is designed to be shared and reused between callers.

• Per operation, you should not establish a ConnectionMultiplexer.

• It recommends sharing and reusing the ConnectionMultiplexer object. In the below example, we are creating a singleton instance and using it for all request processing.

Getting started

Create .NET 3.1 or 6 API or ASP.NET Core MVC applications.

Please install the Redis NuGet package Microsoft.Extensions.Caching.StackExchangeRedis as below,

> Install-Package Microsoft.Extensions.Caching.StackExchangeRedis -Version <version>

Configure Redis using Dependency Injection of the ConnectionMultiplexer Redis

Configure Redis using Dependency Injection of stackexchange.redis as below by registering IConnectionMultiplexer

public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            services.AddScoped<ISalaryRepository, SalaryRepository>();
            services.AddDbContext<EmployeeContext>(options =>
            {
                options.UseSqlServer(Configuration.GetConnectionString("EmployeeDB"),
                sqlServerOptionsAction: sqlOptions =>
                {
                    sqlOptions.EnableRetryOnFailure();
                });
            });
            if (_hostEnvironment.IsDevelopment())
            {
                services.AddDistributedMemoryCache();//Use this for only DEV testing purpose
            }
            else
            {
                 services.AddSingleton<IConnectionMultiplexer>(sp => 
                 ConnectionMultiplexer.Connect(new ConfigurationOptions
                {
                  EndPoints = { $"{Configuration.GetValue<string>("RedisCache:Host")}: 
                  {Configuration.GetValue<int>("RedisCache:Port")}" },
                  AbortOnConnectFail = false,
               }));
            }

Above you can use ConnectionMultiplexer.Connect or ConnectionMultiplexer.ConnectAsync, passing in either a configuration string or a ConfigurationOptions object. 

If you have SSL enabled please use the below setting to connect to the Redis cache setting,

services.AddSingleton<IConnectionMultiplexer>(sp => ConnectionMultiplexer.Connect(new ConfigurationOptions
            {
                EndPoints = { $"{Configuration.GetValue<string>("RedisCache:Host")}:{Configuration.GetValue<int>("RedisCache:Port")}" },
                Ssl = true,
                AbortOnConnectFail = false,
            }));

Redis Connection for Replica set

If you have a master/replica setup then specify the connection using the below approach. Redis will identify the master automatically and establish the connection.

ConnectionMultiplexer.Connect("ServerA:6379,ServerB:6379, ServerC:6379");

Configure ConnectionMultiplexer using Dependency Injection as below,

Starting RedisServer

I have below used the WSL way to install Redis Server and started its instance to accept the data for caching.

Now once you start API and hit the endpoint first access of the requested ID will serve from the actual DB and any consecutive access will fetch directly from the cache instead of the SQL server.

Redis supports both synchronous and asynchronous implementations.

Redis – IDistributedCache interface

If you want to leverage the IDistributedCache interface, please see the below article for more details

• Redis Distributed cache in .NET with examples

References:

• System.Text.Json -Serialization and Deserialization in .NET

That’s all! Hope you find this article useful,

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Redis-Dependency Injection of the ConnectionMultiplexer – Best Practices first appeared on TheCodeBuzz.