Automatically calling an init function whenever an object is used for the 1st time

Question

I have an object that only initializes itself with barebones data when constructed (fast), and loads itself for real (slow) when first accessed. The idea is that I'm creating a lot of these barebones objects at startup and hash them into a map, then fully load each object whenever it is individually accessed for the first time. The problem is that I cannot guarantee how clients will interact with this object, there are multiple public methods that might be invoked.

Is there a good pattern to support this kind of situation? The obvious (and my current) solution is to track state with an internal bool, check against that bool in every function that might be invoked, and load that way. But that requires code duplication of that behavior across all public functions, and is vulnerable to errors.

I can imagine a single point-of-entry method that then dishes out behaviors based on a client request type etc., but before I go consider going down that road I want to see if there's a commonly accepted approach/pattern that I might not be aware of. I'm doing this in C#, but any insight is appreciated.

Answer 1

Here's an example of dynamic proxy approach.

using System;
using System.Diagnostics;
using Castle.DynamicProxy;  //Remember to include a reference, too.  It's nugettable package is Castle.Core

namespace ConsoleApp
{
    public class ActualClass
    {
        //Have static instances of two below for performance
        private static ProxyGenerator pg = new ProxyGenerator();
        private static ActualClassInterceptor interceptor = new ActualClassInterceptor();

        //This is how we get ActualClass items that are wrapped in the Dynamic Proxy
        public static ActualClass getActualClassInstance()
        {
            ActualClass instance = new ActualClass();
            return pg.CreateClassProxyWithTarget<ActualClass>(instance, interceptor);
        }

        //Tracking whether init has been called
        private bool initialized = false;

        //Will be used as evidence of true initialization, i.e. no longer null
        private int? someValue = null;

        public void Initialize()
        {
            if (!initialized)
            {
                //do some initialization here.
                someValue = -1; //Will only get set to non-null if we've run this line.
                initialized = true;
            }
        }

        //Any methods you want to intercept need to be virtual!
        public virtual int replaceValue(int value) 
        {
            //below will blow up, if someValue has not been set to -1 via Initialize();
            int oldValue = someValue.Value;
            someValue = value;
            return oldValue;
        }

        //block off constructor from public to enforce use of getActualClassInstance
        protected ActualClass() { }
    }

    public class ActualClassInterceptor : ActualClass, IInterceptor
    {
        public void Intercept(IInvocation invocation)
        {
            //Call initialize before proceeding to call the intercepted method
            //Worth noting that this is the only place we actually call Initialize()
            ((ActualClass)invocation.InvocationTarget).Initialize();
            invocation.Proceed();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            ActualClass instance1 = ActualClass.getActualClassInstance();
            ActualClass instance2 = ActualClass.getActualClassInstance();
            int x1 = instance1.replaceValue(41);
            int x2 = instance2.replaceValue(42);

            int y1 = instance1.replaceValue(82);
            Debug.Assert(y1 == 41);

            int y2 = instance2.replaceValue(84);
            Debug.Assert(y2 == 42);

            var read = Console.ReadKey();
        }
    }
}

Answer 2

If I understood what you want to achieve, you are looking for the Proxy Design Pattern, more specifically, a virtual Proxy.

Refer to http://www.dofactory.com/net/proxy-design-pattern

A small example would be something like:

    public abstract class IObjectProvider
    {
        public abstract IObjectProvider Object{get;}
        public abstract void doStuff();
    }

    public class RealObject : IObjectProvider
    {
        public RealObject()
        {
            //Do very complicated and time taking stuff;
        }
        public override IObjectProvider Object
        {
            get { return this; }
        }

        public override void doStuff()
        {
            //do this stuff that these objects normally do 
        }
    }

    public class ObjectProxy : IObjectProvider
    {
        private IObjectProvider objectInstance = null;
        public override IObjectProvider Object
        {
            get 
            {
                if (objectInstance == null)
                    objectInstance = new RealObject();
                return objectInstance; 
            }
        }

        public override void doStuff()
        {
            if(objectInstance!=null)
                objectInstance.doStuff();
        }
    }

    public class SkeletonClass 
    {
        public IObjectProvider Proxy1 = new ObjectProxy();
        public IObjectProvider Proxy2 = new ObjectProxy();
    }
    static void Main(String[] args)
    {
        //Objects Not Loaded
        SkeletonClass skeleton = new SkeletonClass();

        //Proxy1 loads object1 on demand
        skeleton.Proxy1.Object.doStuff();

        //Proxy2 not loaded object2 until someone needs it
    }