Question

I’m switching over from structure map to Autofac. I’ve use a caching pattern from Scott Millett’s book ASP.net Design Patterns which implements an interface for both Cache and the Repository and switches in the appropriate object depending on the constructor parameter name

The interface looks like this

public interface ISchemeRepository
{
        List<Scheme> GetSchemes();
}

The cache object looks like this

public class SchemeRepository : BaseRepository, ISchemeRepository
{
/***************************************************************
 *  Properties
 ***************************************************************/

private readonly ISchemeRepository schemeRepository;

/***************************************************************
 *  Constructors
 ***************************************************************/
public SchemeRepository()
    : this(ObjectFactory.GetInstance<ISchemeRepository>(), ObjectFactory.GetInstance<IConfigurationSetting>())
{
}

public SchemeRepository(ISchemeRepository realSchemeRepository, IConfigurationSetting configurationSetting)
{
    schemeRepository = realSchemeRepository;
    this.configurationSetting = configurationSetting;
}

/**************************************************************
 *  Methods
 ***************************************************************/
public List<Scheme> GetSchemes()
{
    string key = Prefix + "Schemes";

    if (!MemoryCache.Default.Contains(key))
    {
        MemoryCache.Default.Add(key, schemeRepository.GetSchemes(), new CacheItemPolicy());
    }

    return (List<Scheme>)MemoryCache.Default.Get(key);
}

}

The repository looks like this

 public class SchemeRepository : BaseLocalRepository, ISchemeRepository
    {
        /***************************************************************
         *  Properties
         ***************************************************************/
        private readonly IConnectionSetting connectionSetting;

        /***************************************************************
         *  Constructors
         ***************************************************************/
        public SchemeRepository()
            : this(ObjectFactory.GetInstance<IConnectionSetting>())
        {
        }

        public SchemeRepository(IConnectionSetting connectionSetting)
        {
            this.connectionSetting = connectionSetting;
        }

        /**************************************************************
         *  Methods
         ***************************************************************/
        public List<Scheme> GetSchemes()
        {
            var response = new List<Scheme>();

            var conn = new SqlConnection(connectionSetting.CQBConnectionString);
            var command = new SqlCommand("proc_GetSchemes", conn) { CommandType = CommandType.StoredProcedure };

            conn.Open();
            var reader = command.ExecuteReader();
            while (reader.Read())
            {
                response.Add(
                        new Scheme
                        {
                            SchemeId = reader["Scheme_Id"].ToString().Trim(),
                            GuaranteeText = reader["Guarantee_Text"].ToString().Trim()
                        }
                    );
            }
            conn.Close();

            return response;         
        }


    }

The structure map call is below

 InstanceOf<Repository.Local.Contract.IProviderRepository>().Is.OfConcreteType<Repository.Local.Core.ProviderRepository>().WithName("RealProviderRepository");

ForRequestedType<Repository.Local.Contract.IProviderRepository>().TheDefault.Is.OfConcreteType<Repository.Local.Cache.ProviderRepository>().CtorDependency<Repository.Local.Contract.IProviderRepository>().Is(x => x.TheInstanceNamed("RealProviderRepository"));

Structure map looks at the constructor and if it contains a parameter called “realSchemeRepository” then it implements the object that connect to the database, if not it implements the cache object that checks the cache and calls the database if nothing is in the cache and populates the cache.

How do I do this in Autofac? Is there a better way of doing this in Autofac?

Answer 1

I believe what you’re asking how to do is set up a decorator between your two repository classes. I’m gonna pretend the two class names are CacheSchemeRepository and RealSchemeRepository because naming them exactly the same is confusing and terrible. Anyways…

builder.Register(c => new RealSchemeRepository(c.Resolve<IConnectionSetting>())
       .Named<ISchemeRepository>("real");

builder.RegisterDecorator<ISchemeRepository>(
    (c, inner) => new CacheSchemeRepository(inner, c.Resolve<IConfigurationSetting>()),
    "real");