I have been using Microsoft.Unity as my container and have decided that the approach for a lazy implementation causes too much rework. Each time you decide to swap out to use a lazy you have to go add .Value or a .Resolve() after your variable (which could be called hundreds of times).Suggested lazy implementation by microsoft Deferring the Resolution of ObjectsSo I decided to start from scratch.Firstly I needed an ILazy interface (I did add the Value property so you can get the actual value if it is ever needed)public interface ILazy<out TInterface> where TInterface : class{    TInterface Value { get; }}We then need an interface and a type that is both ILazy<T> and of the interface to be implemented.public interface IContract{    //methods and properties to be implemented    void SomeFunction();}public interface ILazyContract : ILazy<IContract>, IContract{}public class ContractImplementation : IContract{    public void SomeFunction()    {        Console.WriteLine(Doing something);    }}I now need a factory which creates the implementation of the ILazyContract at runtime. This is a long class and has a bit of il generation so it might be difficult to read.public class LazyTypeFactory{    //used to stop the same class being created twice    private readonly object _lock = new object();    private readonly Dictionary<Type, Type> _lazyTypes = new Dictionary<Type, Type>();    private readonly ModuleBuilder _moduleBuilder;    public LazyTypeFactory(string assembly, string module)    {        var an = new AssemblyName(assembly);        var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(an, AssemblyBuilderAccess.Run);        _moduleBuilder = assemblyBuilder.DefineDynamicModule(module);    }    public Type CreateOrGetLazyType<TLazy, TInterface>(string name = null)        where TLazy : ILazy<TInterface>, TInterface        where TInterface : class    {        Type result;        var @interface = typeof (TInterface);        var @container = typeof (IUnityContainer);        var @lazy = typeof (TLazy);        var @func = typeof (Func<IUnityContainer, TInterface>);        name = name ?? @lazy.Name + Impl;        name = @lazy.Namespace + . + name;        if (!@interface.IsInterface)        {            throw new Exception(Expected TInterface to be a type of interface);        }        lock (_lock)        {            if (_lazyTypes.ContainsKey(@lazy))            {                result = _lazyTypes[@lazy];            }            else            {                var typeBuilder = _moduleBuilder.DefineType(name, TypeAttributes.Public | TypeAttributes.Class, null);                typeBuilder.AddInterfaceImplementation(@lazy);                //private field for container                var c = typeBuilder.DefineField(_c, @container, FieldAttributes.Public);                //private field for func                var f = typeBuilder.DefineField(_f, @func, FieldAttributes.Public);                //private field for func result                var v = typeBuilder.DefineField(_v, @interface, FieldAttributes.Public);                //constructor with func                CreateConstructor(typeBuilder, @container, c, @func, f);                //private property to get func result                var propertyBuilder = CreateValueProperty(typeBuilder, @interface, v, @container, c, @func, f);                //interface methods                //call prop then invok method                foreach (var iMethod in @interface.GetMethods())                {                    var mb = CreateOverride(typeBuilder, propertyBuilder, iMethod);                    typeBuilder.DefineMethodOverride(mb, iMethod);                }                foreach (var iProperty in @interface.GetProperties())                {                    var pb = typeBuilder.DefineProperty(iProperty.Name, PropertyAttributes.None, iProperty.PropertyType, Type.EmptyTypes);                    if (iProperty.GetMethod != null)                    {                        var iMethod = iProperty.GetMethod;                        var mb = CreateOverride(typeBuilder, propertyBuilder, iMethod);                        pb.SetGetMethod(mb);                    }                    if (iProperty.SetMethod != null)                    {                        var iMethod = iProperty.SetMethod;                        var mb = CreateOverride(typeBuilder, propertyBuilder, iMethod);                        pb.SetSetMethod(mb);                    }                }                _lazyTypes[@lazy] = result = typeBuilder.CreateType();            }        }        return result;    }    private static void CreateConstructor(TypeBuilder typeBuilder, Type @container, FieldBuilder c, Type @func, FieldBuilder f)    {        var constructor = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new[] { @container, @func });        constructor.DefineParameter(1, ParameterAttributes.None, container);        constructor.DefineParameter(2, ParameterAttributes.None, func);        var cIl = constructor.GetILGenerator();        cIl.Emit(OpCodes.Ldarg_0);        cIl.Emit(OpCodes.Ldarg_1);        cIl.Emit(OpCodes.Stfld, c);        cIl.Emit(OpCodes.Ldarg_0);        cIl.Emit(OpCodes.Ldarg_2);        cIl.Emit(OpCodes.Stfld, f);        cIl.Emit(OpCodes.Ret);    }    private static PropertyBuilder CreateValueProperty(TypeBuilder typeBuilder, Type @interface, FieldBuilder v, Type @container, FieldBuilder c, Type @func, FieldBuilder f)    {        var propertyBuilder = typeBuilder.DefineProperty(Value, PropertyAttributes.None, @interface, Type.EmptyTypes);        var get = typeBuilder.DefineMethod(get_Value, MethodAttributes.Public | MethodAttributes.Virtual, @interface, new Type[0]);        var getIl = get.GetILGenerator();        var skip = getIl.DefineLabel();        getIl.Emit(OpCodes.Ldarg_0);        getIl.Emit(OpCodes.Ldfld, v);        getIl.Emit(OpCodes.Ldnull);        getIl.Emit(OpCodes.Bne_Un, skip);        //call _f and set to _v        getIl.Emit(OpCodes.Ldarg_0);        getIl.Emit(OpCodes.Ldarg_0);        getIl.Emit(OpCodes.Ldfld, f);        getIl.Emit(OpCodes.Ldarg_0);        getIl.Emit(OpCodes.Ldfld, c);        getIl.Emit(OpCodes.Call, @func.GetMethod(Invoke, new[] { @container }));        getIl.Emit(OpCodes.Stfld, v);        getIl.MarkLabel(skip);        getIl.Emit(OpCodes.Ldarg_0);        getIl.Emit(OpCodes.Ldfld, v);        getIl.Emit(OpCodes.Ret);        propertyBuilder.SetGetMethod(get);        return propertyBuilder;    }    private static MethodBuilder CreateOverride(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, MethodInfo iMethod)    {        var mb = typeBuilder.DefineMethod(iMethod.Name, MethodAttributes.Public | MethodAttributes.Virtual,            iMethod.ReturnType, iMethod.GetParameters().Select(x => x.ParameterType).ToArray());        var mIL = mb.GetILGenerator();        mIL.Emit(OpCodes.Ldarg_0);        mIL.Emit(OpCodes.Call, propertyBuilder.GetMethod);        for (var i = 0; i < iMethod.GetParameters().Length; i++)        {            mIL.Emit(OpCodes.Ldarg, i + 1);        }        mIL.Emit(OpCodes.Call, iMethod);        mIL.Emit(OpCodes.Ret);        return mb;    }}To create a Type of ILazyContract at runtime you would do something like this.var factory = new LazyTypeFactory(Assembly.Lazy, Module.Lazy);var type = factory.CreateOrGetLazyType<ILazyContract, IContract>();The implementation of this would look something likepublic class ILazyContractImpl : ILazyContract{    private readonly IUnityContainer _container;    private readonly Func<IUnityContainer, IContract> _func;    private IContract _value;    public ILazyContractImpl(IUnityContainer container, Func<IUnityContainer, IContract> func)    {        _container = container;        _func = func;    }    public IContract Value    {        get        {            if (_value == null)            {                _value = _func(_container);            }            return _value;        }    }    public void SomeFunction()    {        Value.SomeFunction();    }}As for the final part of the puzzle you now have to register this in the unity container. For this we also need to either register a Func<IUnityContainer, IContract> or add it as a parameter in a InjectionConstructor which is what I have done.IUnityContainer container = new UnityContainer();var factory = new LazyTypeFactory(Assembly.Lazy, Module.Lazy);var type = factory.CreateOrGetLazyType<ILazyContract, IContract>();container.RegisterType<IContract, ContractImplementation>();var resolve = new Func<IUnityContainer, IContract>(c => c.Resolve<IContract>());container.RegisterType(typeof(ILazyContract), type, new InjectionConstructor(typeof(IUnityContainer), resolve));var lazy = container.Resolve<ILazyContract>();lazy.SomeFunction();So there is my take on lazy - which wasn't very lazy :(.Any feedback would be greatly appreciated, also if there are any improvements that can be made please let me know.As requested by Heslacher, this is a real implementation where I wanted to cache the UserSettings because they will not change over the life span of a request.  Here you can see that the constructor will make a call to the db, which could take some time.  So instead I would like to only do this when the class is actually used, not when it is created.public interface IUserConfigurationService{    UserSetting[] GetSettings();    UserSetting[] GetSettingsForProduct(Product product);    UserSetting[] GetSettingsOfType(SettingType type);}public class UserConfigurationService : IUserConfigurationService{    private readonly Entities _entities;    private readonly User _currentUser;    //a cache so that we do not have to make the same call many times    private readonly UserSetting[] _userSettings;    public UserConfigurationService(Entities entities, User currentUser)    {        _entities = entities;        _currentUser = currentUser;        _userSettings = Entities.UserSettings.Where(x => x.User == currentUser).ToArray();    }    public UserSetting[] GetSettings()    {        return _userSettings;    }    public UserSetting[] GetSettingsForProduct(Product product)    {        return _userSettings.Where(x => x.Product == product).ToArray();    }    public UserSetting[] GetSettingsOfType(SettingType type)    {        return _userSettings.Where(x => x.SettingType == type).ToArray();    }}
Unity Lazy Resolve Implementation
c#;dependency injection;lazy;unity