A menudo me encuentro escribiendo una propiedad que se evalúa perezosamente. Algo como:

if (backingField == null) 
  backingField = SomeOperation();
return backingField;

No es mucho código, pero se repite mucho si tiene muchas propiedades.

Estoy pensando en definir una clase llamada LazyProperty:

public class LazyProperty<T>
    {
    private readonly Func<T> getter;

    public LazyProperty(Func<T> getter)
    {
        this.getter = getter;
    }

    private bool loaded = false;
    private T propertyValue;

    public T Value
    {
        get
        {
            if (!loaded)
            {
                propertyValue = getter();
                loaded = true;
            }
            return propertyValue;
        }
    }

    public static implicit operator T(LazyProperty<T> rhs)
    {
        return rhs.Value;
    }
}

Esto me permitiría inicializar un campo como este:

first = new LazyProperty<HeavyObject>(() => new HeavyObject { MyProperty = Value });

Y luego el cuerpo de la propiedad podría reducirse a:

public HeavyObject First { get { return first; } }

Esto sería utilizado por la mayoría de la compañía, ya que entraría en una biblioteca de clase común compartida por la mayoría de nuestros productos.

No puedo decidir si es una buena idea o no. Creo que las soluciones tienen algunas ventajas, como:

Menos códigoCódigo más bonito

En el lado negativo, sería más difícil mirar el código y determinar exactamente qué sucede, especialmente si un desarrollador no está familiarizado con la clase LazyProperty.

Qué piensas ? ¿Es una buena idea o debería abandonarla? Además, ¿es una buena idea el operador implícito, o preferiría usar la propiedad Value explícitamente si debería usar esta clase?

Las opiniones y sugerencias son bienvenidas :-)