C# Propriétés automatiques à chargement paresseux

Question

En C#,

Existe-t-il un moyen de transformer une propriété automatique en une propriété automatique chargée paresseusement avec une valeur par défaut spécifiée ?

Essentiellement, j'essaie de transformer ce...

private string _SomeVariable

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

          return _SomeVariable;
     }
}

en quelque chose de différent, où je peux spécifier le défaut et il gère le reste automatiquement...

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

Answer 1

Non, il n'y en a pas. Les propriétés auto-implémentées ne servent qu'à implémenter les propriétés les plus basiques : champ d'appui avec getter et setter. Elles ne prennent pas en charge ce type de personnalisation.

Cependant, vous pouvez utiliser la version 4.0 Lazy<T> pour créer ce modèle

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

Ce code va calculer paresseusement la valeur de _someVariable la première fois que le Value est appelée. Elle ne sera calculée qu'une seule fois et mettra la valeur en mémoire cache pour les utilisations futures de l'expression Value propriété

Answer 2

La solution la plus concise est probablement d'utiliser l'opérateur de coalescence nul :

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

Answer 3

En revanche, les paramètres des attributs doivent avoir une valeur constante, vous ne pouvez pas appeler de code (même statique).

Il est cependant possible d'implémenter quelque chose avec les aspects de PostSharp.

Regardez-les :

PostSharp

Answer 4

Voici la solution que je propose pour résoudre votre problème. L'idée de base est une propriété qui sera définie par une fonction lors du premier accès et les accès suivants donneront la même valeur de retour que le premier.

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

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

Puis à utiliser :

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

Il y a bien sûr la surcharge liée au passage du pointeur de fonction, mais cela fait l'affaire pour moi et je ne remarque pas trop de surcharge par rapport à l'exécution répétée de la méthode.

Answer 5

Je ne pense pas que cela soit possible en C# pur. Mais vous pourriez le faire en utilisant un réécrivain IL comme PostSharp . Par exemple, il vous permet d'ajouter des gestionnaires avant et après les fonctions en fonction des attributs.