Définition manuelle de la valeur de Lazy <T>

Question

J'ai un objet que je crée à partir de la réponse d'un service Web. Si je reçois une liste de ces objets, ils ont une quantité minimale d'informations (dans l'exemple ci-dessous, ID, Prop1 et Prop2 sont retournés dans la réponse de la liste). Si j'obtiens l'objet par ID, l'ensemble complet d'informations est renvoyé, y compris les objets enfants dans Prop3 et Prop4.

public class Foo 
{ 
    public Guid ID { get; set; } 
    public string Prop1 { get; set; } 
    public string Prop2 { get; set; } 

    public Lazy<IEnumerable<Bar>> Prop3 { get; } 
    public Lazy<IEnumerable<Bar2>> Prop4 { get; } 
} 

Ce que je veux être en mesure de faire est d'utiliser cet objet lorsqu'il est partiellement construit, mais si prop3 ou Prop4 sont accessibles, faire un appel à la webservice pour télécharger les données plus détaillées définies et remplir les deux prop3 et Prop4 . Si j'utilise Lazy, je ne peux remplir chaque propriété individuellement qu'en y accédant. Cela entraînerait des appels de service Web identiques, juste pour analyser une petite partie de la réponse à chaque fois. Ce que je veux être en mesure de faire est de créer chaque Lazy comme ceci:

Prop3 = new Lazy<IEnumerable<Foo>>(() => LoadDetailedInformation()); 

private void LoadDetailedInformation() 
{ 
    // Get info from web service 
    Prop3.Value = ParseProp3(response); 
    Prop4.Value = ParseProp4(response); 
} 

Donc, dans ce semblant de mise en œuvre Lazy, la fonction sera appelée lorsque l'objet paresseux est accessible, mais ne retournerait pas réellement les données . Il effectuerait des calculs et initialiserait toutes les valeurs paresseuses à la fois. Est-ce que je ferais mieux de rouler ma propre paresseuse, ou y a-t-il une autre façon de le faire sans écrire une tonne de code d'emballage pour chaque propriété? Une des classes pour laquelle je fais cela a environ 20 objets qui doivent être emballés comme ça, donc je ne veux pas avoir à écrire des getters et des setters réels si je peux m'en sortir.

Answer 1

On dirait que vous voulez un simpleLazy<T> qui construit un objet composé avec les deux valeurs dans une Tuple<Bar, Bar2> volonté au travail.

public Bar Prop3 { get { return lazy.Value.Item1; } } 
public Bar2 Prop4 { get { return lazy.Value.Item2; } } 

private readonly Lazy<Tuple<Bar, Bar2>> lazy = 
    new Lazy<Tuple<Bar, Bar2>>(LoadDetailedInformation); 

private Tuple<Bar, Bar2> LoadDetailedInformation() 
{ 
    ... 
} 

Bien sûr, au lieu de Tuple vous pourriez avoir un type DetailedResponse - Je recommande que si vous vous retrouvez avec plus de quelques propriétés. Effectivement, vous voulez paresseusement obtenir la réponse détaillée, puis fournir un accès simplifié aux propriétés individuelles en son sein.

Answer 2

Lazy obtient seulement ce que vous demandez, alors demandez-les ensemble ...

public class Foo 
{ 
    public Guid ID { get; set; } 
    public string Prop1 { get; set; } 
    public string Prop2 { get; set; } 
    public Lazy<SubFoo> SubFoo{ get; } 
} 

public class SubFoo 
{ 
    public IEnumerable<Bar> Prop3 { get; } 
    public IEnumerable<Bar2> Prop4 { get; } 
}