A menudo me encuentro escribiendo una propiedad que se evalúa perezosamente. Algo así como:Implementar una clase "LazyProperty": ¿es esta una buena idea?
if (backingField == null)
backingField = SomeOperation();
return backingField;
No es mucho código, pero sí se repiten mucho si usted tiene una gran cantidad de propiedades.
estoy pensando en la definición de 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 entonces 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 un biblioteca de clases común compartida por la mayoría de nuestros productos.
No puedo decidir si esta es una buena idea o no. Creo que las soluciones tienen algunas ventajas, como:
- menos código
- Prettier código
En el lado negativo, sería más difícil de mirar el código y determinar exactamente lo que sucede - especialmente si una el desarrollador no está familiarizado con la clase LazyProperty.
¿Qué opinas? ¿Es esta una buena idea o debería abandonarla? Además, ¿el operador implícito es una buena idea, o preferiría usar la propiedad Value explícitamente si debería usar esta clase?
Las opiniones y sugerencias son bienvenidas :-)
Se señala su punto sobre el operador implícito. Es una de esas cosas sobre las que necesitaba opiniones. – driis
Es bueno ser pedante. +1. – dalle