Cached property vs Lazy<T>
C#.Net.Net 4.0Lazy LoadingC# Problem Overview
In .NET 4 the following snippet with a cached property can also be written using the System.Lazy<T>
class. I measured the performance of both approaches and it's pretty much the same. Is there any real benefit or magic for why I should use one over the other?
Cached Property
public static class Brushes
{
private static LinearGradientBrush _myBrush;
public static LinearGradientBrush MyBrush
{
get
{
if (_myBrush == null)
{
var linearGradientBrush = new LinearGradientBrush { ...};
linearGradientBrush.GradientStops.Add( ... );
linearGradientBrush.GradientStops.Add( ... );
_myBrush = linearGradientBrush;
}
return _myBrush;
}
}
}
Lazy<T>
public static class Brushes
{
private static readonly Lazy<LinearGradientBrush> _myBrush =
new Lazy<LinearGradientBrush>(() =>
{
var linearGradientBrush = new LinearGradientBrush { ...};
linearGradientBrush.GradientStops.Add( ... );
linearGradientBrush.GradientStops.Add( ... );
return linearGradientBrush;
}
);
public static LinearGradientBrush MyBrush
{
get { return _myBrush.Value; }
}
}
C# Solutions
Solution 1 - C#
I would use Lazy<T>
in general:
- It's thread-safe (may not be an issue in this case, but would be in others)
- It makes it obvious what's going on just by the name
- It allows null to be a valid value
Note that you don't have to use a lambda expression for the delegate. For example, here's an approach which may be slightly cleaner:
public static class Brushes
{
private static readonly Lazy<LinearGradientBrush> _myBrush =
new Lazy<LinearGradientBrush>(CreateMyBrush);
private static LinearGradientBrush CreateMyBrush()
{
var linearGradientBrush = new LinearGradientBrush { ...};
linearGradientBrush.GradientStops.Add( ... );
linearGradientBrush.GradientStops.Add( ... );
return linearGradientBrush;
}
public static LinearGradientBrush MyBrush
{
get { return _myBrush.Value; }
}
}
This is particularly handy when the creation process gets complicated with loops etc. Note that by the looks of it, you could use a collection initializer for GradientStops
in your creation code.
Another option is not to do this lazily, of course... unless you have several such properties in your class and you only want to create the relevant objects on a one-by-one basis, you could rely on lazy class initialization for many situations.
As noted in DoubleDown's answer, there's no way of resetting this to force recomputation (unless you make the Lazy<T>
field not readonly) - but I've very rarely found that to be important.
Solution 2 - C#
Use Lazy<T>
, as it expresses exactly what you are doing - lazy loading.
In addition, it keeps your property very clean and is thread safe.
Solution 3 - C#
Typically the only reason to not use lazy is to reset the variable to null so the next access causes it to load again. Lazy has no reset and you'd need to recreate the lazy from scratch.
Solution 4 - C#
Lazy<T>
will correctly handel concurrent scenarios (if you pass in the correct LazyThreadSafetyMode ) while your example does not have any thread-safety checks.
Solution 5 - C#
The Lazy<T>
is simpler—it clearly expresses the intent of the code.
It's also thread safe.
Note that if you're actually using this on multiple threads, you need to make it [ThreadStatic]
; GDI+ objects cannot be shared across threads.
Solution 6 - C#
Lazy
From a testability point of view, Lazy
However, it has a very slight overhead, in my opinion, over other option
Solution 7 - C#
Well if your performance is about the same then the only reason to use Lazy<T>
over the cached version would be if you aren't sure if the user is actually going to load the property.
The point of Lazy<T>
is to wait until the user needs the resource and then create it at that instance in time. If they are always going to need to resource then there is no point in using Lazy<T>
, unless you need some of it's other purposes such as it being thread safe.