C# Lazy Loaded Automatic Properties

Question

In C#,

Is there a way to turn an automatic property into a lazy loaded automatic property with a specified default value?

Essentially, I am trying to turn this...

private string _SomeVariable

public string SomeVariable
{
     get
     {
          if(_SomeVariable == null)
          {
             _SomeVariable = SomeClass.IOnlyWantToCallYouOnce();
          }

          return _SomeVariable;
     }
}

into something different, where I can specify the default and it handles the rest automatically...

[SetUsing(SomeClass.IOnlyWantToCallYouOnce())]
public string SomeVariable {get; private set;}

user_10413901 · Answer

Operator ??= is available using C# 8.0 and later, so you can now do it even more concise:

private string _someVariable;

public string SomeVariable => _someVariable ??= SomeClass.IOnlyWantToCallYouOnce();

user_5019820 · Answer

I did it like this:

public static class LazyCachableGetter
{
    private static ConditionalWeakTable> Instances = new ConditionalWeakTable>();
    public static R LazyValue(this T obj, Func factory, [CallerMemberName] string prop = "")
    {
        R result = default(R);
        if (!ReferenceEquals(obj, null))
        {
            if (!Instances.TryGetValue(obj, out var cache))
            {
                cache = new ConcurrentDictionary();
                Instances.Add(obj, cache);

            }


            if (!cache.TryGetValue(prop, out var cached))
            {
                cache[prop] = (result = factory());
            }
            else
            {
                result = (R)cached;
            }

        }
        return result;
    }
}

and later you can use it like

       public virtual bool SomeProperty => this.LazyValue(() =>
    {
        return true; 
    });

user_488009 · Answer

I'm a big fan of this idea, and would like to offer up the following C# snippet which I called proplazy.snippet.(you can either import this or paste it into the standard folder which you can get from the Snippet Manager)

Here's a sample of its output:

private Lazy myProperty = new Lazy(()=>1);
public int MyProperty { get { return myProperty.Value; } }

Here's the snippet file contents: (save as proplazy.snippet)



    
        
            proplazy
            proplazy
            Code snippet for property and backing field
            Microsoft Corporation
            
                Expansion
            
        
        
            
                
                    type
                    Property type
                    int
                
                
                    field
                    The variable backing this property
                    myVar
                
                
                    func
                    The function providing the lazy value
                
                
                    property
                    Property name
                    MyProperty
                

            
             $field$ = new Lazy<$type$>($func$);
            public $type$ $property$ { get{ return $field$.Value; } }
            $end$]]>

user_10353570 · Answer

[Serializable]
public class ReportModel
{
    private readonly Func _getReportLayout;
    public ReportModel(Func getReportLayout)
    {
        _getReportLayout = getReportLayout;
    }

    private ReportConfig _getReportLayoutResult;
    public ReportConfig GetReportLayoutResult => _getReportLayoutResult ?? (_getReportLayoutResult = _getReportLayout());


    public string ReportSignatureName => GetReportLayoutResult.ReportSignatureName;
    public string ReportSignatureTitle => GetReportLayoutResult.ReportSignatureTitle;
    public byte[] ReportSignature => GetReportLayoutResult.ReportSignature;
}

user_6627992 · Answer

If you use a constructor during lazy initialization, following extensions may be helpful too

public static partial class New
{
    public static T Lazy(ref T o) where T : class, new() => o ?? (o = new T());
    public static T Lazy(ref T o, params object[] args) where T : class, new() =>
            o ?? (o = (T) Activator.CreateInstance(typeof(T), args));
}

Usage

    private Dictionary _cache;

    public Dictionary Cache => New.Lazy(ref _cache);

                    /* _cache ?? (_cache = new Dictionary()); */

user_19767015 · Answer

Based on some answers here i made my own class for one-liner Lazy properties using c#5 CallerMemberName Attribute.

public class LazyContainer
{
    private Dictionary _LazyObjects = new Dictionary();
    public T Get(Func factory, [CallerMemberName] string name = null) where T: class
    {
        if (string.IsNullOrEmpty(name))
            return default(T);

        if (!_LazyObjects.ContainsKey(name))
            _LazyObjects.Add(name, new Lazy(factory, true));

        return ((Lazy)_LazyObjects[name]).Value;
    }
    public T Get([CallerMemberName] string name = null) where T : class,new()
    {
        return Get(() => new T(), name);
    }
}

It can be used like this:

class PropertyClass
{
    private LazyContainer lc = new LazyContainer();

    public SimpleClass Prop1 => lc.Get();
    public LessSimpleClass Prop2 => lc.Get(()=> new LessSimpleClass(someParametrs...));
}

I added class constraint to restrict use to reference types, for value types i.e. int there is no point as it would return a copy anyway.

public int Prop3 => lc.Get(()=>3);
//Would have the exact same function as this:
public int Prop4 => 3;

C# Lazy Loaded Automatic Properties

13 Answers