C# caricato in modo pigro Proprietà automatici

Question

In C#,

C'è un modo per trasformare una proprietà automatica in un pigro caricato immobile automatico con un valore predefinito specificato?

In sostanza, sto cercando di trasformare questo ...

private string _SomeVariable 

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

      return _SomeVariable; 
    } 
} 

in qualcosa di diverso, dove posso specificare il difetto ed in cui gestisce il resto automaticamente ...

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

Answer 1

No, non c'è. Le proprietà implementate automaticamente funzionano solo per implementare le proprietà più basilari: il backing field con getter e setter. Non supporta questo tipo di personalizzazione.

Tuttavia è possibile utilizzare il tipo di 4.0 Lazy<T> per creare questo schema

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

Questo codice sarà pigramente calcolare il valore della _someVariable la prima volta l'espressione Value si chiama. Verrà calcolato una sola volta e memorizzerà il valore per gli usi futuri della proprietà Value

Answer 2

I don Penso che questo sia possibile con il puro C#. Ma potresti farlo usando un rewriter IL come PostSharp. Ad esempio, consente di aggiungere gestori prima e dopo le funzioni a seconda degli attributi.

Answer 3

Non è così, i parametri per gli attributi devono essere di valore costante, non è possibile chiamare il codice (anche codice statico).

Potrebbe tuttavia essere possibile implementare qualcosa con gli Aspetti di PostSharp.

Dateci un'occhiata:

PostSharp

Answer 4

Probabilmente il più conciso si può ottenere è quello di utilizzare l'operatore null coalescenza:

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

Answer 5

Ecco la mia implementazione di una soluzione al vostro problema. Fondamentalmente l'idea è una proprietà che verrà impostata da una funzione al primo accesso e gli accessi successivi produrranno lo stesso valore di ritorno del primo.

public class LazyProperty<T> 
{ 
    bool _initialized = false; 
    T _result; 

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

quindi di utilizzare:

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

C'è naturalmente l'overhead di passare il puntatore a funzione in giro, ma fa il lavoro per me e non si nota troppo in alto rispetto alla corsa il metodo più e più volte.

Answer 6

C'è una nuova funzionalità in C# 6 chiamato Expression Bodied Auto-Properties, che permette di scrivere un po 'più pulito:

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

    public string SomeVariable 
    { 
     get { return _someVariable.Value; } 
    } 
} 

ora può essere scritta come:

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

    public string SomeVariable => _someVariable.Value; 
} 

Answer 7

https://github.com/bcuff/AutoLazy utilizza Fody a darti una cosa del genere

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