0
votes

Comment récupérer une liste de membres internes à partir d'une liste externe?

J'ai une classe similaire à celle ci-dessous

class AnotherClass
{
    private List<OuterClass> OuterClassList{get;set;}
    private List<InnerClass> InnerClassList{get;set;}

    public void InsertOuterClassObject(OuterClass outerClassObject)
    {
        this.OuterClassList.Add(outerClassObject);
        this.PopulateInnerClassList();
    }

    private void PopulateInnerClassList()
    {
        this.InnerClassList = new List<InnerClass>();
        foreach(var object in this.OuterClassList)
        {
            this.InnerClassList.Add(object.InnerObject);
         }
     }

     ////More operations to be performed on OuterClassList
 }

Maintenant, dans une autre classe, j'ai deux listes, l'une des objets OuterClass et une des InnerClass objets. Et je veux que la liste des objets InnerClass soit remplie à partir de la propriété InnerObject des objets dans la liste OuterClass . Je peux y parvenir en parcourant la liste OuterClass et en remplissant la liste InnerClass . Cependant, cela doit être pris en compte à chaque fois que la liste OuterClass est modifiée.

class OuterClass
{
    public InnerClass InnerObject{get;set;}
    ////Some more properties and methods
}

Existe-t-il un autre moyen de m'assurer que le InnerClassList est correctement synchronisé avec OuterClassList plutôt que d'avoir à itérer et remplir et aussi de s'assurer que la méthode PopulateInnerClassList () est sûrement appelée si nécessaire. P >

c# .net list

0 commentaires

3 Réponses :

1
votes

Essayez de voir s'il répond à vos besoins.

public class AnotherClass
{
    private List<OuterClass> _OuterClassList;
    private List<InnerClass> _InnerClassList;
    private List<OuterClass> OuterClassList {
        get { return _OuterClassList; }
        set
        {
            _OuterClassList = value;
            InnerClassList = value.Select(a => a.InnerObject).ToList();
        }
    }
    private List<InnerClass> InnerClassList { get { return _InnerClassList; } set { InnerClassList = value; } }

    public void InsertOuterClassObject(OuterClass outerClassObject)
    {
        this.OuterClassList.Add(outerClassObject);
        this.PopulateInnerClassList();
    }

    private void PopulateInnerClassList()
    {
        this.InnerClassList = new List<InnerClass>();
        foreach (var item in this.OuterClassList)
        {
            this.InnerClassList.Add(item.InnerObject);
        }
    }
}

0 commentaires

1
votes

Vous n'avez pas besoin d'InnerClassList je pense, regardez ceci:

private List<OuterClass> OuterClassList { get; set; }//initialize in constructor.

internal class OuterClass
{
    public InnerClass InnerObject { get; set; }

    public OuterClass(int num) => InnerObject = new InnerClass(num);
}

internal class InnerClass
{
    public int Value { get; set; }
    public InnerClass(int num) => Value = num;
}

private void button1_Click(object sender, EventArgs e) => OuterClassList.Add(new OuterClass(new Random().Next(0, 1000)));

private void button4_Click(object sender, EventArgs e)
{
    var values = from o in OuterClassList select o.InnerObject.Value;//you always have it, then you don't need InnerClassList I think.
    foreach (var value in values)
        MessageBox.Show(value.ToString());
}

0 commentaires

1
votes

L'exemple de code suggère que la InnerClassList ne doit refléter que l'état de la OuterClassList et ne doit pas être gérée indépendamment. Si tel est le cas, vous pouvez créer la liste interne à la volée:

class AnotherClass
{
    private List<OuterClass> OuterClassList { get; } = new List<OuterClass>();

    private IEnumerable<InnerClass> InnerClassList => OuterClassList.Select(x => x.InnerObject);

    public void InsertOuterClassObject(OuterClass outerClassObject)
    {
        this.OuterClassList.Add(outerClassObject);
    }

    ////More operations to be performed on OuterClassList
}

Et si le modèle d'utilisation de InnerClassList se limite à l'itérer, vous pouvez changez son type en IEnumerable évitant ainsi la dégradation des performances sur les longues listes:

private IEnumerable<InnerClass> InnerClassList => OuterClassList.Select(x => x.InnerObject);

Le code de maintenance de liste résultant peut donc ressembler à ceci:

private List<InnerClass> InnerClassList => OuterClassList.Select(x => x.InnerObject).ToList();

Remarque: J'ai également changé la définition de OuterClassList pour m'assurer qu'elle est toujours instanciée. Certes, c'est une propriété privée, le changer en un objet en lecture seule une fois initialisé ne cassera pas l'API AnotherClass et ne facilitera pas la manipulation interne.

1 commentaires

N'appelez jamais InnerClassList.Add (item) et attendez-vous à ce qu'il fasse quoi que ce soit.