Costumo encontrar-me escrevendo uma propriedade que é avaliada preguiçosamente. Algo como:

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

Não é muito código, mas é repetido muito se você tiver muitas propriedades.

Estou pensando em definir uma classe chamada 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;
    }
}

Isso me permitiria inicializar um campo como este:

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

E então o corpo da propriedade pode ser reduzido para:

public HeavyObject First { get { return first; } }

Isso seria usado pela maioria da empresa, uma vez que entraria em uma biblioteca de classes comum compartilhada pela maioria dos nossos produtos.

Não consigo decidir se é uma boa ideia ou não. Eu acho que as soluções têm alguns profissionais, como:

Menos códigoCódigo mais bonito

Por outro lado, seria mais difícil examinar o código e determinar exatamente o que acontece - especialmente se um desenvolvedor não estiver familiarizado com a classe LazyProperty.

O que você acha ? Esta é uma boa ideia ou devo abandoná-la? Além disso, o operador implícito é uma boa idéia ou você prefere usar a propriedade Value explicitamente se estiver usando esta classe?

Opiniões e sugestões são bem-vindas :-)