What is the Best Practice to configure StackExchange.Redis with Autofac?

Question

In the StackExchange.Redis docs it is recommended to only create one and reuse the connection to Redis.

Azure Redis best practices recommends using the following pattern:

private static Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
{
    return ConnectionMultiplexer.Connect("cachename.redis.cache.windows.net,ssl=true,abortConnect=false,password=password");
});

public static ConnectionMultiplexer Connection
{
    get
    {
        return lazyConnection.Value;
    }
}

but how should I get this working with Autofac where I want the configuration to be set in the web/app config files?

I currently have a RedisCacheProvider:

private readonly ConnectionMultiplexer _connection;

public RedisCacheProvider(string config)
{
    _connection = ConnectionMultiplexer.Connect(config);
}

and in my Autofac config:

builder.RegisterType<RedisCacheProvider>().As<ICacheProvider>().WithParameter("config", "localhost");

My thinking is, I should change my RedisCacheProvider to take in a ConnectionMultiplexer which is passed in via the static variable?

Update: My Solution so far:

My RedisCacheProvider (injecting an interface here allows me to mock the connection in unit tests):

private readonly IConnectionMultiplexer _connection;

public RedisCacheProvider(IConnectionMultiplexer connection)
{
   _connection = connection;
}

RedisConnection class to hold the static property and read config from config file:

public class RedisConnection
{
    private static readonly Lazy<ConnectionMultiplexer> LazyConnection = 
        new Lazy<ConnectionMultiplexer>(
            () => ConnectionMultiplexer.Connect(ConfigurationManager.AppSettings["RedisCache"]));

    public static ConnectionMultiplexer Connection
    {
        get
        {
            return LazyConnection.Value;
        }
    }
}

Registration in an Autofac Module:

builder.RegisterType<RedisCacheProvider>().As<ICacheProvider>()
                    .WithParameter(new TypedParameter(
                                       typeof(IConnectionMultiplexer), 
                                       RedisConnection.Connection));

Answer 1

Autofac supports Implicit Relationship Types and Lazy<> evaluation is supported out of the box. So after you register your RedisCacheProvider as in your example, that is

builder
.RegisterType<RedisCacheProvider>()
.As<ICacheProvider>()
.WithParameter("config", "localhost");

you can resolve it like below:

container.Resolve<Lazy<ICacheProvider>>();

But do not forget that default Autofac lifetime scope is InstancePerDependency(transient). That is, you will get new instance of RedisCacheProvider everytime you resolve it or whenever it is provided to other component as dependency. To fix this you need to specify its lifetime scope explicitly. For instance, to make it singleton you need to change registration as below:

builder
.RegisterType<RedisCacheProvider>()
.As<ICacheProvider>()
.WithParameter("config", "localhost")
.SingleInstance();

Another assumption here is that RedisCacheProvider is the only component where Redis connection is used. If it is not the case then you should better let Autofac manage Redis connection's life scope (which is a better idea anyway) and get the connection as a dependency in RedisCacheProvider. That is:

public RedisCacheProvider(IConnectionMultiplexer connection)
{
    this.connection = connection;
}

....

builder
.Register(cx => ConnectionMultiplexer.Connect("localhost"))
.As<IConnectionMultiplexer>()
.SingleInstance();

builder
.RegisterType<RedisCacheProvider>()
.As<ICacheProvider>();