property - properties in c# with example

C#Lazy Loaded Automatic Properties

Question

Cª#,

¿Hay alguna manera de convertir una propiedad automática en una propiedad automática con carga lenta y un valor predeterminado específico?

Esencialmente, estoy tratando de convertir esto ...

private string _SomeVariable
public string SomeVariable
{
get
{
if(_SomeVariable == null)
{
_SomeVariable = SomeClass.IOnlyWantToCallYouOnce();
}
return _SomeVariable;
}
}

en algo diferente, donde puedo especificar el valor predeterminado y maneja el resto automáticamente ...

[SetUsing(SomeClass.IOnlyWantToCallYouOnce())]
public string SomeVariable {get; private set;}

Answer 1

Aquí está mi implementación de una solución a su problema. Básicamente, la idea es una propiedad que será configurada por una función en el primer acceso y los accesos posteriores arrojarán el mismo valor de retorno que el primero.

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

Entonces para usar:

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

Por supuesto, la sobrecarga de pasar el puntero a la función, pero hace el trabajo por mí y no noto demasiada sobrecarga en comparación con ejecutar el método una y otra vez.

Answer 2

Hay una nueva característica en C # 6 llamada Expression Bodied Auto-Properties , que le permite escribirla un poco más limpia:

public class SomeClass
{
private Lazy<string> _someVariable = new Lazy<string>(SomeClass.IOnlyWantToCallYouOnce);
public string SomeVariable
{
get { return _someVariable.Value; }
}
}

Ahora se puede escribir como:

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

Answer 3

No así, los parámetros para los atributos deben tener un valor constante, no se puede llamar al código (incluso el código estático).

Sin embargo, puede ser capaz de implementar algo con Aspectos de PostSharp.

Échales un vistazo:

PostSharp

Answer 4

No creo que esto sea posible con C # puro. Pero podrías hacerlo usando un PostSharp IL como PostSharp . Por ejemplo, le permite agregar manejadores antes y después de las funciones dependiendo de los atributos.

Answer 5

No no hay. Las propiedades implementadas automáticamente solo funcionan para implementar las propiedades más básicas: campo de respaldo con getter y setter. No es compatible con este tipo de personalización.

Sin embargo, puede usar el tipo 4.0 Lazy<T> para crear este patrón

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

Este código calculará de forma _someVariable el valor de _someVariable la primera vez que se llame a la expresión Value . Solo se calculará una vez y almacenará en caché el valor para usos futuros de la propiedad Value

Answer 6

Probablemente lo más conciso que puede obtener es usar el operador nulo-coalescente:

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

Answer 7

https://github.com/bcuff/AutoLazy usa Fody para darte algo como esto

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