Lazy loading for C# auto-implemented properties

Question

I'm trying to do somethings have three things:

• Property is auto setter/getter (required)
• Property is lazy loading (required)

How can I have lazy loading for C# automatic properties?

To make two things above, I think I need to use Reflection (or maybe other). This is what I have tried so far. I have a object test:

public class MyClass
{
    private Lazy<MyObjectClass> lazyObjectClass = new Lazy<MyObjectClass>(() => new MyObjectClass());
    public MyObjectClass MyObject { get { return lazyObjectClass.Value; } }
}

Normally, the MyObjectClass will be initialize when MyObject called.

But, I want to auto-initialize MyObjectClass. So, I change the MyClass to like this:

public class MyClass
{
    public MyClass()
    {
        //Get field
        var field = this.GetType().GetField("lazyObjectClass", BindingFlags.NonPublic | BindingFlags.Instance);
        //Get value of field
        Lazy<MyObjectClass> lazyValue = (Lazy<MyObjectClass>)field.GetValue(this);

        //Get property MyObject
        var property = this.GetType().GetProperty("MyObject");
        //Set value to the MyObject
        property.SetValue(this, lazyValue.Value); // <- when It called, MyObjectClass is ititialize too
    }
    private Lazy<MyObjectClass> lazyObjectClass = new Lazy<MyObjectClass>(() => new MyObjectClass());
    public MyObjectClass MyObject { get; set; }
}

But, when I SetValue to MyObject by Reflection, MyObjectClass is initialize too. How can I fix that or let me know if I should use a totally different solution.

Answer 1

Short Answer

You may not like it, but you cannot have lazy loading for auto-implemented properties u̲n̲l̲e̲s̲s̲:

• You have container/factory which creates a proxy over your class and handle lazy loading by the proxy.
• Or You have some mechanism like using a weaving tool to manipulate the generated IL at build time and add the lazy-loading feature to your class.

I doubt you really need lazy-loading with auto-implemented properties. So my advise is: Change your code and forget about auto-implemented properties and easily use lazy loading using custom getter and setter (with or without using lazy<T>.

Anyway, if you are curious to know more, read the detailed answer.

Note: By doing some research, you may find some posts in stackoverflow which are trying to address similar questions, for example: this post, or this one. I've tried to share more details/options here in this post. You may also find the linked posts useful.

Detailed Answer - Lazy Loading for Auto-Implemented Properties

You want to have Lazy Initialization for Auto-Implemented Property in your class.

As it's already mentioned in the short answer, you cannot have lazy loading for auto-implemented properties unless:

• You have container/factory which creates a proxy over your class and handle lazy loading by the proxy.
• Or You have some mechanism like using a weaving tool to manipulate the generated IL at build time and add the lazy-loading feature to your class.

For example in Entity Framework you can have lazy loading for virtual automatic properties. But the thing is, it's handled by Entity Framework and in this case it creates proxy for the object.

Lazy Loading for Auto-Implemented Properties - Options

To implement one of the above solutions, you can use following options:

To extend the solution you can use the following ideas to generate the proxy and handling lazy-loading in the proxy:

• Implement proxy class yourself: You can create a proxy class derived from your main class and then override the property which you want load lazily. Then you can register the derived class in your DI container and return an instance of the derived class whenever you as instance of the main class requested.

• Implement a Generic Factory to create proxy at run-time using Reflection.Emit: You can create a generic factory method to create the proxy at run-time using Reflection.Emit or other run-time assembly generation mechanisms.

• Implement a Generic Factory to create proxy at run-time using RealProxy You can create a generic factory and use RealProxy and intercept the getter and setter of the property and add lazy loading feature to the property of the proxy.

• Rely on intercepting features of DI frameworks: You can use intercepting features of your DI Framework (if it has such feature) and intercept the get and set and implement lazy loading. For example you may be able to implement the feature using Interceptors in Unity.

• Rely on weaving tools to manipulate the assembly at build time: You can relay on AOP Framework and Weaving tools like Fody or PostSharp to manipulate the IL of your assembly and make the property lazy-loadable at compile time. For example you can find an implementation for PostSharp here.

Answer 2

The problem is related to the get method.

In first case you have:

public class MyClass
{
    private Lazy<MyObjectClass> lazyObjectClass = new Lazy<MyObjectClass>(() => new MyObjectClass());

    public MyObjectClass MyObject { get { return lazyObjectClass.Value;** } }
}

When you access MyObject, in fact you call a get method that reads from your lazyObjectClass, so lazyObjectClass is evalued only when it is called.

In the second case, you use an autoproperty, but real code is like this:

public class MyClass
{
    private Lazy<MyObjectClass> lazyObjectClass = new Lazy<MyObjectClass>(() => new MyObjectClass());

    private MyObjectClass <MyObject>k__BackingField;
    public MyObjectClass MyObject 
    { 
       get 
       {
          return <MyObject>k__BackingField;
       }
       set
       {
          <MyObject>k__BackingField = value;
       }
    }
}

But there is a problem, get method reads directly from hidden autogenerated k__BackingField that must already been evalueted, there is no call to lazy, and you can't change get implementation with reflection.

There is no way to do what you are thinking, but here I suggest this workaround:

public class MyObjectClass
    {

    }

  public class MyClass
    {
        public MyClass()
        {
            var field = this.GetType().GetField("lazyObjectClass", BindingFlags.NonPublic | BindingFlags.Instance);
            //Get value of field
            Lazy<MyObjectClass> lazyValue = (Lazy<MyObjectClass>)field.GetValue(this);

            //Get property MyObject
            var lazyField = this.GetType().GetField("_lazy", BindingFlags.NonPublic | BindingFlags.Instance);
            lazyField.SetValue(this, lazyValue);

        }

        private Lazy<MyObjectClass> _lazy = null;
        private MyObjectClass myValue = null;

        private Lazy<MyObjectClass> lazyObjectClass = new Lazy<MyObjectClass>(() =>
        {
            return new MyObjectClass();
        });
        public MyObjectClass MyObject
        {
            get
            {
                if (myValue == null)
                {
                    return _lazy.Value;
                }
                else
                {
                    return myValue;
                }

            }
            set
            {
                myValue = value;
            }
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            MyClass myClass = new MyClass();

            var a = myClass.MyObject;
        }
    }