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;}

@Gabe: Note the class will only be called once if it never returns null. — D'Arcy Rittich, Oct 27 '10 at 19:25
I discovered that...it seems to be uses the singleton pattern — ctorx, Oct 28 '10 at 19:50

score 120 · Accepted Answer · edited Jun 13 '18 at 13:24

120

No there is not. Auto-implemented properties only function to implement the most basic of properties: backing field with getter and setter. It doesn't support this type of customization.

However you can use the 4.0 Lazy<T> type to create this pattern

private Lazy<string> _someVariable =new Lazy<string>(SomeClass.IOnlyWantToCallYouOnce);
public string SomeVariable => _someVariable.Value;

This code will lazily calculate the value of _someVariable the first time the Value expression is called. It will only be calculated once and will cache the value for future uses of the Value property

edited Jun 13 '18 at 13:24

Colonel Panic

119,181
74
363
435

answered Oct 27 '10 at 19:20

JaredPar

673,544
139
1,186
1,421

1

Actually, it looks to me like Lazy implements the singleton pattern. That is not my goal...my goal is create a lazy loaded property that is lazily instantiated but disposed along with the instance of the class in which it lives. Lazy does not seem to be performing that way. – ctorx Oct 28 '10 at 19:12
20

@ctorx Lazy has nothing to do with the singleton pattern. It does exactly what you want it to do. – user247702 Feb 20 '13 at 07:15
9

Note, `SomeClass.IOnlyWantToCallYouOnce` in your example must be static to be used with a field initializer. – rory.ap Dec 01 '16 at 14:11
Awesome answer. See my answer for a Visual Studio snippet you can use if you expect to have a many lazy properties. – Zephryl Sep 18 '18 at 18:03

score 41 · Answer 2 · edited Dec 01 '13 at 19:17

41

Probably the most concise you can get is to use the null-coalescing operator:

get { return _SomeVariable ?? (_SomeVariable = SomeClass.IOnlyWantToCallYouOnce()); }

edited Dec 01 '13 at 19:17

redent84

17,763
4
53
83

answered Oct 27 '10 at 19:23

Gabe Moothart

28,997
13
73
98

11

In the case `IOnlyWantToCallYouOnce` returns `null` it will call it more than once. – JaredPar Oct 27 '10 at 19:26
9

When using the null-coalescing operator, the above example will fail. The correct syntax is: `_SomeVariable ?? ( _SomeVariable = SomeClass.IOnlyWantToCallYouOnce() );` - notice the addition of the parenthesis around setting `_SomeVariable` if it is null. – Metro Smurf Oct 22 '12 at 16:49
This is the best option. First I used `Lazy<>`, but for our purposes this worked better. With latest C# it can also be written even more concise `=> _SomeVariable ?? (_SomeVariable = SomeClass.IOnlyWantToCallYouOnce());` What some might not notice from the first look is that operator _evaluates the right-hand operand and returns its result_. – RunninglVlan Oct 04 '19 at 09:20

Alexander Derck · Answer 3 · 2016-08-18T14:56:10.080

15

There is a new feature in C#6 called Expression Bodied Auto-Properties, which allows you to write it a bit cleaner:

public class SomeClass
{ 
   private Lazy<string> _someVariable = new Lazy<string>(SomeClass.IOnlyWantToCallYouOnce);

   public string SomeVariable 
   {
      get { return _someVariable.Value; }
   }
}

Can now be written as:

public class SomeClass
{
   private Lazy<string> _someVariable = new Lazy<string>(SomeClass.IOnlyWantToCallYouOnce);

   public string SomeVariable => _someVariable.Value;
}

edited Aug 18 '16 at 14:56

answered Jun 29 '16 at 07:57

Alexander Derck

11,742
4
43
73

In the last section of code, the initialization is not actually lazy. `IOnlyWantToCallYouOnce` would be called during construction every time the class is instantiated. – Tom Blodget Jul 03 '16 at 14:51
So in otherwords this is not lazy loaded? – Zapnologica Jan 30 '17 at 08:40
@Zapnologica My previous answer was a bit wrong but I updated it. `SomeVariable` is lazy loaded. – Alexander Derck Jan 30 '17 at 08:42
This answer reads more like a pitch for Expression Bodied Auto-Properties. – Little Endian Sep 08 '18 at 16:25
@AbleArcher Pointing out a new language feature is a pitch now? – Alexander Derck Sep 26 '18 at 21:29
Well, I like JaredPar's concise answer "No there is not." followed by alternatives. Sorry. – Little Endian Sep 26 '18 at 22:39

score 10 · Answer 4 · answered Jul 25 '20 at 07:39

10

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();

answered Jul 25 '20 at 07:39

Carlos

280
3
10

This is currently the best answer for C#8 and up. – Matt Jenkins Feb 26 '21 at 22:07
1

Nice. Just be aware it's not thread-safe like the original version. With some overheads `Lazy` provides built-in safety if needed. – joe Mar 31 '21 at 03:22

score 5 · Answer 5 · answered Oct 27 '10 at 19:20

5

Not like that, parameters for attributes must be constant in value, you cannot call code (Even static code).

You may however be able to implement something with PostSharp's Aspects.

Check them out:

PostSharp

answered Oct 27 '10 at 19:20

Aren

50,600
8
63
100

score 5 · Answer 6 · edited Jun 02 '15 at 19:50

5

Here's my implementation of a solve to your problem. Basically the idea is a property that will be set by a function at first access and subsequent accesses will yield the same return value as the first.

public class LazyProperty<T>
{
    bool _initialized = false;
    T _result;

    public T Value(Func<T> fn)
    {
        if (!_initialized)
        {
            _result = fn();
            _initialized = true;
        }
        return _result;
    }
 }

Then to use:

LazyProperty<Color> _eyeColor = new LazyProperty<Color>();
public Color EyeColor
{ 
    get 
    {
        return _eyeColor.Value(() => SomeCPUHungryMethod());
    } 
}

There is of course the overhead of passing the function pointer around, but it does the job for me and I don't notice too much overhead compared to running the method over and over again.

edited Jun 02 '15 at 19:50

Daniel Wolf

10,328
9
42
73

answered Jun 26 '11 at 03:13

deepee1

11,640
4
28
43

Wouldn't it make more sense to give the function to the constructor? This way you wouldn't be creating it inline each time, and you could dispose it after you used it the first time. – Mikkel R. Lund Jan 15 '14 at 02:57
@lund.mikkel yeah, that would work too. May be use cases for both approaches. – deepee1 Jan 15 '14 at 17:07
5

If you pass the function to the constructor, much like .Net's Lazy class, then the function passed in will have to be static, I know this hasn't fit my design in many cases. – crunchy May 09 '14 at 18:16
@MikkelR.Lund Sometimes you don't want to execute some code in the constructor but only on demand (and cache the result in form of a backing field) – mamuesstack Mar 23 '17 at 07:03

score 3 · Answer 7 · answered Sep 18 '18 at 18:01

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<int> myProperty = new Lazy<int>(()=>1);
public int MyProperty { get { return myProperty.Value; } }

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

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
    <CodeSnippet Format="1.0.0">
        <Header>
            <Title>proplazy</Title>
            <Shortcut>proplazy</Shortcut>
            <Description>Code snippet for property and backing field</Description>
            <Author>Microsoft Corporation</Author>
            <SnippetTypes>
                <SnippetType>Expansion</SnippetType>
            </SnippetTypes>
        </Header>
        <Snippet>
            <Declarations>
                <Literal>
                    <ID>type</ID>
                    <ToolTip>Property type</ToolTip>
                    <Default>int</Default>
                </Literal>
                <Literal>
                    <ID>field</ID>
                    <ToolTip>The variable backing this property</ToolTip>
                    <Default>myVar</Default>
                </Literal>
                <Literal>
                    <ID>func</ID>
                    <ToolTip>The function providing the lazy value</ToolTip>
                </Literal>
                <Literal>
                    <ID>property</ID>
                    <ToolTip>Property name</ToolTip>
                    <Default>MyProperty</Default>
                </Literal>

            </Declarations>
            <Code Language="csharp"><![CDATA[private Lazy<$type$> $field$ = new Lazy<$type$>($func$);
            public $type$ $property$ { get{ return $field$.Value; } }
            $end$]]>
            </Code>
        </Snippet>
    </CodeSnippet>
</CodeSnippets>

I would set `myProperty` to be `readonly`, just to be safe – PLopes Oct 15 '20 at 12:12 — PLopes, Oct 15 '20 at 12:12

score 2 · Answer 8 · answered Oct 27 '10 at 19:19

2

I don't think this is possible with pure C#. But you could do it using an IL rewriter like PostSharp. For example it allows you to add handlers before and after functions depending on attributes.

answered Oct 27 '10 at 19:19

CodesInChaos

100,017
20
197
251

score 2 · Answer 9 · answered Oct 24 '18 at 16:05

I did it like this:

public static class LazyCachableGetter
{
    private static ConditionalWeakTable<object, IDictionary<string, object>> Instances = new ConditionalWeakTable<object, IDictionary<string, object>>();
    public static R LazyValue<T, R>(this T obj, Func<R> factory, [CallerMemberName] string prop = "")
    {
        R result = default(R);
        if (!ReferenceEquals(obj, null))
        {
            if (!Instances.TryGetValue(obj, out var cache))
            {
                cache = new ConcurrentDictionary<string, object>();
                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; 
    });

@Riera what do you mean? Just like regular property. E.g. `public ISet RegularProperty {get;set} public string CalculatedProperty => this.LazyValue(() => { return string.Join(",", RegularProperty.ToArray()); });` — Alexander Zuban, Oct 05 '19 at 02:16

score 0 · Answer 10 · answered Jun 22 '17 at 06:38

https://github.com/bcuff/AutoLazy uses Fody to give you something like this

public class MyClass
{
    // This would work as a method, e.g. GetSettings(), as well.
    [Lazy]
    public static Settings Settings
    {
        get
        {
            using (var fs = File.Open("settings.xml", FileMode.Open))
            {
                var serializer = new XmlSerializer(typeof(Settings));
                return (Settings)serializer.Deserialize(fs);
            }
        }
    }

    [Lazy]
    public static Settings GetSettingsFile(string fileName)
    {
        using (var fs = File.Open(fileName, FileMode.Open))
        {
            var serializer = new XmlSerializer(typeof(Settings));
            return (Settings)serializer.Deserialize(fs);
        }
    }
}

score 0 · Answer 11 · edited Sep 12 '18 at 13:56

[Serializable]
public class RaporImza
{
    private readonly Func<ReportConfig> _getReportLayout;
    public RaporImza(Func<ReportConfig> getReportLayout)
    {
        _getReportLayout = getReportLayout;
    }

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

    public string ImzaAtanKisiAdi => GetReportLayoutResult.ReportSignatureName;

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

and i call like bellow

result.RaporBilgisi = new ExchangeProgramPersonAllDataModel.RaporImza(() => _reportConfigService.GetReportLayout(documentTypeId));

While this might answer the authors question, it lacks some explaining words and links to documentation. Raw code snippets are not very helpful without some phrases around it. You may also find [how to write a good answer](https://stackoverflow.com/help/how-to-answer) very helpful. Please edit your answer. — hellow, Sep 12 '18 at 13:56

score 0 · Answer 12 · answered Oct 28 '18 at 03:02

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

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

Usage

    private Dictionary<string, object> _cache;

    public Dictionary<string, object> Cache => New.Lazy(ref _cache);

                    /* _cache ?? (_cache = new Dictionary<string, object>()); */

Is there an advantage to using your helper over `LazyInitializer.EnsureInitialized()`? Because from what I can tell, in addition to the functionality above, `LazyInitializer` provides error handling as well as sync functionality. [LazyInitializer source code](https://referencesource.microsoft.com/#mscorlib/system/threading/LazyInitializer.cs). — semaj1919, Jan 03 '19 at 20:24

C# Lazy Loaded Automatic Properties

12 Answers12

Linked

Related