System.ArgumentNullException: Value cannot be null. (Parameter 'configuration') in ASP.NET Core Redis Implementation

I am implementing Redis Memory Cache in my ASP.NET Core-6 Web API application, I am using Dapper in connection with DTO to return results of queried database.

I have installed this Redis Package: StackExchange.Redis

Model:

[Table("students")]
public class Student
{
    public string registration_no { get; set; }
    public string first_name { get; set; }
    public string last_name { get; set; }
    public Date birth_date { get; set; }
    public Date entry_date { get; set; }
}

DTO:

public class StudentDto
{
    public string RegistrationNo { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public Date BirthDate { get; set; }
    public Date EntryDate { get; set; }
}

Then I used auto-mapper for the mapping:

public class StudentMapperProfile : Profile
{
    public StudentMapperProfile() 
    {
        CreateMap<Student, StudentDto>()
            .ForMember(
                dest => dest.RegistrationNo,
                opt => opt.MapFrom(src => src.registration_no)
            )
            .ForMember(
                dest => dest.FirstName,
                opt => opt.MapFrom(src => src.first_name)
            )
            .ForMember(
                dest => dest.LastName,
                opt => opt.MapFrom(src => src.last_name)
            )
            .ForMember(
                dest => dest.BirthDate,
                opt => opt.MapFrom(src => src.birth_date)
            )
            .ForMember(
                dest => dest.EntryDate,
                opt => opt.MapFrom(src => src.entry_date)
            )
            .ReverseMap();
    }
}

Response:

public class Response<T>
{
    public T Data { get; set; }
    public bool Successful { get; set; }
    public string Message { get; set; }
    public int StatusCode { get; set; }

    public Response(int statusCode, bool success, string msg, T data)
    {
        Data = data;
        Successful = success;
        StatusCode = statusCode;
        Message = msg;
    }

    public Response()
    {
    }

    public static Response<T> Success(string successMessage, T data, int statusCode = 200)
    {
        return new Response<T> { Successful = true, Message = successMessage, Data = data, StatusCode = statusCode };
    }
    public override string ToString() => JsonConvert.SerializeObject(this);
}

StudentsRepository:

public async Task<Response<IEnumerable<StudentDto>>> GetAllStudentsAsync()
{
    var response = new Response<IEnumerable<StudentDto>>();
    var cacheKey = "Student";
    using IDbConnection _dbConnection = Connection;
    if (_memoryCache.TryGetValue(cacheKey, out Response<IEnumerable<StudentDto>> cachedResponse))
    {
        return cachedResponse;
    }
    var cachedData = await _distributedCache.GetStringAsync(cacheKey);
    if (!string.IsNullOrEmpty(cachedData))
    {
        var studentsDto = JsonSerializer.Deserialize<Response<IEnumerable<StudentDto>>>(cachedData);

        // Store the response in the MemoryCache for faster subsequent access
        _memoryCache.Set(cacheKey, StudentDto);

        return studentsDto;
    }
    try
    {
        var sQuery = @"SELECT * FROM students";
        _dbConnection.Open();
        var students = await _dbConnection.QueryAsync<Student>(sQuery);
        var studentsDtos = _mapper.Map<IEnumerable<StudentDto>>(students);

        response.Data = studentsDtos;
        response.Successful = true;

        var cacheOptions = new DistributedCacheEntryOptions
        {
            AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10) // Set cache expiration time
        };

        // Serialize and store the response in Redis cache
        var serializedData = JsonSerializer.Serialize(response);
        await _distributedCache.SetStringAsync(cacheKey, serializedData, cacheOptions);

        // Store the response in the MemoryCache for faster subsequent access
        _memoryCache.Set(cacheKey, response);

        return response;
    }
    catch (Exception ex)
    {
        response.Successful = false;
        response.StatusCode = (int)HttpStatusCode.BadRequest;
        return response;
    }
    finally
    {
        _dbConnection.Close();
    }
}

StudentsService:

public async Task<Response<IEnumerable<StudentDto>>> GetAllStudentsAsync()
{
    return await _studentsRepository.GetAllStudentsAsync();
}

StudentController:

public async Task<ActionResult<Response<IEnumerable<StudentDto>>>> GetAllStudentsAsync()
{
    var result = await _studentsService.GetAllStudentsAsync();
    return Ok(result);
}

appsettings.json:

 "ConnectionStrings": {
    "MyRedisCon": "localhost:3500"
  },

Dependency Injection (DI):

AutoMapper

public static class AutoMapperServiceExtension
{
    public static void ConfigureAutoMappers(this IServiceCollection services)
    {
        services.AddAutoMapper(typeof(StudentProfile));
    }
}

Redis:

public static class CacheExtension
{
    public static void AddCacheInjection(this IServiceCollection services, IConfiguration config)
    {
        services.AddSingleton<IConnectionMultiplexer>(provider =>
        {
            var configuration = ConfigurationOptions.Parse(config.GetConnectionString("MyRedisCon"));
            configuration.AbortOnConnectFail = false; // Allow retrying connection
            configuration.ConnectTimeout = 5000; // Set connection timeout (milliseconds)
            return ConnectionMultiplexer.Connect(configuration);
        });
        services.AddSingleton<IDistributedCache, RedisCache>();
        services.AddMemoryCache();
    }
}

DIServiceExtension:

public static class DIServiceExtension
{
    public static void AddDependencyInjection(this IServiceCollection services)
    {
        // Add Service Injections Here -- HTTP Helpers
        services.AddTransient<IStudentsRepository, StudentsRepository>();
        services.AddTransient<IStudentsService, StudentsService>();
    }
}

Program.cs:

builder.Services.AddDependencyInjection();
builder.Services.ConfigureAutoMappers();
builder.Services.AddCacheInjection(configuration);

However, when I launched the application on Swagger and submitted the HttpGet Request, I got this error:

System.ArgumentNullException: Value cannot be null. (Parameter 'configuration')
at StackExchange.Redis.ConfigurationOptions.DoParse(String configuration, Boolean ignoreUnknown) in /_/src/StackExchange.Redis/ConfigurationOptions.cs:line 810
at Microsoft.Extensions.Caching.StackExchangeRedis.RedisCache.ConnectAsync(CancellationToken token)
at Microsoft.Extensions.Caching.StackExchangeRedis.RedisCache.GetAndRefreshAsync(String key, Boolean getData, CancellationToken token)
at Microsoft.Extensions.Caching.StackExchangeRedis.RedisCache.GetAsync(String key, CancellationToken token)
at Microsoft.Extensions.Caching.Distributed.DistributedCacheExtensions.GetStringAsync(IDistributedCache cache, String key, CancellationToken token)
at StudentsRepository.GetAllStudentsAsync() in C:\StudentsRepository.cs:line 69
at StudentsService.GetAllStudentsAsync() in C:\StudentsService.cs:line 24
at StudentsController.GetAllStudentsAsync() in C:\StudentController.cs:line 31

Note:

C:\StudentsRepository.cs:line 69 is

var cachedData = await _distributedCache.GetStringAsync(cacheKey);

When I put breakpoints, the code below returns null:

if (_memoryCache.TryGetValue(cacheKey, out Response<IEnumerable<StudentDto>> cachedResponse))
{
    return cachedResponse;
}

The problem has to do with Redis. When I commented out all the Redis Cache Code, I got success response

How do I resolve this?

The problem is the way Redis is added to the services. In the current code you didn't set the configuration for the RedisCacheOptions.

Try replacing this code

services.AddSingleton<IDistributedCache, RedisCache>();

with this

services.AddOptions<RedisCacheOptions>().Configure<IServiceProvider>((options, serviceProvider) =>
{
    options.ConnectionMultiplexerFactory = () => Task.FromResult(serviceProvider.GetService<IConnectionMultiplexer>());
});
services.AddStackExchangeRedisCache(_ => { });