Today in this article, we will cover below aspects,

Issue Description

Redis connection throws an error,

It was not possible to connect to the redis server(s); to create a disconnected multiplexer, disable AbortOnConnectFail.
at StackExchange.Redis.ConnectionMultiplexer.ConnectImpl(Func`1 multiplexerFactory, TextWriter log)
at MyApp.Web.Redis.StackExchangeClientConnection..ctor(ProviderConfiguration configuration)
at MyApp.Web.Data.GetInventoryData()

Resolution

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

Before trying this fix, please make sure the Redis server is up and running.

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

StackExchange.Redis has a setting called AbortOnConnectFail which handles connectivity errors.

Please note that the default value for AbortOnConnectFail setting flag is “True”, meaning connection resiliency will not be in effect for any transient error like network bleep, etc. Due to this application will not re-connect automatically in some cases.

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

Transient erros are most common in Cloud enviornment due to shared resources.

Setting abortConnect as false will resolve the issue and connection resiliency will be implemented.

Note – when AbortOnConnectFail = false setting is used then a total of 3 retry attempts during the initial connect will be performed. However, this setting can be customized as per need.

I was able to fix the error by using the below code for C# applicaiton

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

                var multiplexer = ConnectionMultiplexer.Connect(configurationOptions); ;

Note : For Azure Redis, the cloud instance property is already set with abortConnect=false  as the default behavior.

However, It may not be the case for other cloud providers.

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.

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 StackExchange.Redis -To create a disconnected multiplexer, disable AbortOnConnectFail first appeared on TheCodeBuzz.

Today in this article we will see a few Redis Cache Design and Best Practices for Development to be considered while developing the application leveraging the Cache architecture.

We will cover the below aspects in this article,

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

Cache lets you temporarily copy frequently accessed data to fast storage near to the application.

Caching helps increase response times for client applications by serving data more quickly(data storage is located closer to the application than the original source.)

Cache plays a crucial part in the below aspects of application management,

• Performance

• High Availability

• Reduced downtime

Let’s look at a few high-level guidelines and best practices for developing the application using the Cache architecture.

Naming convention for Redis Key and Namespace

It’s important to follow the basic naming conventions for Redis Key and Namespace upfront to avoid any issues with managing the data on the server.

Redis Cache server is most time used as a shared server across applications/projects and it is likely to contain more data with a similar format as the application grows in size with multiple use cases.

Redis cache is based on key-value pair but with a curated data structure and as long as the key is unique, you are set to leverage all benefits of the data management.

 SET key value 

If all of your data has to be stored in a single database, please create a namespace with a key prefix.

Below is an example of a key naming pattern

// Set keys for Saving account 


SET Saving:key1 value
SET Saving:key2 value



// Set keys for Credit Account


SET Credit:key1 value
SET Credit:key2 value


// Set keys for Personal account 


SET Personal:key1 value
SET Personal:key2 value

The above pattern can be extended as required so that we get the benefit for the same key managed by different applications or domains or modules.

Like we can add additional identifiers like Bank of ABCD

Set keys for Bank of ABCD with saving Account


SET BOA:Saving:key1 value 

SET BOA:Saving:key2 value 

Size/Lenth of Redis Key and Namespace

There are few Guidelines on Redis Key and Namespace

It is important to keep your Redis key names as short as possible.

Even shorter keys should follow the above namespace and key rules.

Any key above 1024 bytes is not recommended as key size may cause issues considering memory and bandwidth.

• Redis key size max is 512 MB.
• Redis Value size max is 512 MB.

The Performance issue however is more observed when dealing with a high volume of data and which also depends on the Redis server configuration.

Use the SCAN Vs KEYS command guidelines

KEY commands

• KEYS command, which returns all matched elements at once, is risky to use in production.

• It may cause your Redis server to become inefficient and even exhaust its RAM resources.

SCAN Commands

• SCAN commands allow you to inspect data without risking your server being blocked.

• SCAN command allows you to get the data without requiring the use of a slave.

• The SCAN command enables you to retrieve keys in the keyspace using a cursor.

• SCAN also accepts a key name pattern and an optional count argument.

• The major difference between SCAN and KEYS is that it is possible to get the same key name more than once with SCAN.

Redis server powerful with rich query pattern – Use Lua Scripts

• Lua scripts on the Redis server make your query pattern very rich with great performance and less server-side resource consumption.

• Server-side query/logics run near to actual data which reduces network latency and redundant transmission of data.

Storing the data on the server

There are multiple ways, data can be stored on the Redis server. Like as below,

• Multiple Redis instances

• Single Redis instances

Cache frequently used data

• Determine data to be cached.

• Cache your most frequently accessed data.

• Cache critical or authoritative information only if needed with the right strategy.

• Do restrict caching for frequently modified data.

Managing concurrency in a cache

Redis cache is designed to be shared by multiple instances of application/system.

However, one can follow any of the below approaches to make sure data is accessed considering the concurrency.

• Optimistic– application checks if data in the cache has changed since it was retrieved. A useful approach when updates are infrequent.

• Pessimistic– When it retrieves the data, the application locks it in the cache to prevent another instance from changing it.

Manage Key Expiration in Redis Cache

• Managing the key Expiration is an important aspect while managing the keys in Reds cache.

• Understand your datastore pattern.

• Carefully check the data expiration. Too short Key expiration will make objects to expires sooner in Cache thereby increasing the call to your backend server also too long data will make you used stale old data producing issues.

Redis – Security for Data

• Redis does not allow data encryption natively, encoding must be done by client applications.

• As Redis does not offer transport security by default, the use of an SSL proxy is recommended if you need to protect data as it travels across the network.

• Redis is designed to run inside a trusted environment and data is accessed by only trusted clients.

Useful References:

• Connection Resiliency for Redis Cache -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 Design and Best Practices for Development first appeared on TheCodeBuzz.

Today in this article we shall see how to enable Redis connect with SSL certificate using C# .NET application.

Install StackExchange.Redis 

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

as below,

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

Or using .NET CLI

dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis --version 5.0.1

Console application with Redis SSL

            var configurationOptions = new ConfigurationOptions
            {
                EndPoints = { "localhost:6379" },
                Ssl = true
            };

            configurationOptions.CertificateSelection += delegate {
                var cert = new X509Certificate2(PATH_TO_CERT_FILE, "");
                return cert;
            };


            var redis = await ConnectionMultiplexer.ConnectAsync(configurationOptions);
            Console.WriteLine(redis.GetDatabase().Ping());
        
    

• ConfigurationOptions let’s you specify SSL property using the property “Ssl”. Please set this as true.

• PATH_TO_CERT_FILE is the location of the X509Certificate2 certificate file on the server.

Example– “c:\\cert\\path\\CERT.pfx”;

If using the ASP.NET Core application below is a sample that can be used to specify the certificate file.

If using the cloud with docker, please specify the docker file with the certificate location.

ASP.NET Core example for Redis SSL

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
            {
               var configurationOptions = new ConfigurationOptions
                {
                    EndPoints = { $"{Configuration.GetValue<string>("RedisCache:Host")}:{Configuration.GetValue<int>("RedisCache:Port")}" },
                    Ssl = true,
                };
                configurationOptions.CertificateSelection += delegate
                {
                    var cert = new X509Certificate2(Configuration.GetValue<string>("RedisCache:CertificatePath"), "");
                    return cert;
                };
                var multiplexer = ConnectionMultiplexer.Connect(configurationOptions); ;
                
                services.AddSingleton<IConnectionMultiplexer>(multiplexer);
            }

In a case using a self-signed certificate, then please make sure to install the certificate on your server.

References:

• Redis Distributed cache in .NET with examples

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 Connect with SSL/TLS using C# .NET first appeared on TheCodeBuzz.

Today in this article, we shall see how to Publish and Subscribe messages with Redis using C# .NET Core.

Redis is widely regarded as the most efficient cache tool for stateless back-end app servers.

Many people are however unaware that apart from an excellent cache server, it also provides built-in Publishing / Subscribe / Messaging functionality helping developers create event-driven based applications, microservices, etc.

Today in this article, we will cover below aspects,

Today in this article, we shall try to cover the basics pub-sub model and how to get started.

Getting started

Let’s start creating .NET Core console application as below,

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

as below,

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

Publish/Subscribe messages with Redis – subscriber example C#

Below shows a simple example for Redis subscribers.

            using ConnectionMultiplexer redis = 
            ConnectionMultiplexer.Connect(redisConnectionString);
            ISubscriber subScriber = redis.GetSubscriber();
            //Subscribe to the channel "thecode-buzz-channel"
            subScriber.Subscribe(publishChannel, (channel, message) =>
            {
                //Output received message
                Console.WriteLine($"[{DateTime.Now:HH:mm:ss}]: {$"Message {message} received successfully"}");
            });

Above we are using the ConnectionMultiplexer interface to create subscriber objects to subscribe to the name channel.

Publish/Subscribe messages with Redis – Publisher example c#

Below shows a simple example for Redis Publisher,

            using ConnectionMultiplexer redis = 
            ConnectionMultiplexer.Connect(redisConnectionString);
            ISubscriber sub = redis.GetSubscriber();
            for (int i = 0; i <= 10; i++)
            {
                sub.Publish(publishChannel, $"Message {i}");
                Console.WriteLine($"Message {i} published successfully");
                Thread.Sleep(2000);
            }

ConnectionMultiplexer lets you create publisher objects to create a publisher which can publish the business events to the registered named channel.

For example, we are simply publishing 10 messages to the Redis channel.

All the clients which are subscribed for the updates will receive updates when the message is published to the channel successfully.

ConnectionMultiplexer interface can be used via dependency injection providing better control on lifetime management of the instance. Please visit this article for more details.

References:

• Getting Started with Kafka in ASP.NET Core

• Redis-Dependency Injection of the ConnectionMultiplexer

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.

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 Publish and Subscribe messages with Redis – C# .NET Core first appeared on TheCodeBuzz.