Comment permettre à un parent de la classe de connaître un changement de ses enfants?

Faire ce genre de communication peut être difficile, surtout si vous voulez éviter les fuites de mémoire en raison de l'gestionnaires d'événements que vous vous accrochez. Il y a aussi le cas de la manipulation des éléments qui sont ajoutés /supprimés de la collection.

J'ai vraiment apprécié la puissance et la simplicité de la Continue LINQ projet sur codeplex. Il a quelques fonctionnalités très riche pour la création de "les Objets Réactifs", "Valeurs Continues", et "Continue Collections". Elles vous permettent de définir vos critères d'une expression Linq et de laisser le CLINQ bibliothèque de garder les valeurs sous-jacentes à jour en temps réel.

Dans votre cas, vous pourriez mettre en place le parent avec un ContinuousFirstOrDefault() requête linq qui a regardé pour tout enfant dont la "IsChanged == true". Dès qu'un enfant définit la valeur true et soulève PropertyChanged, la valeur continue permet de détecter le changement et à relever un correspondant PropertyChanged dans le parent.

Les avantages:

1. Références faibles et faible événements sont utilisés pour empêcher les gestionnaires d'événements dans le parent de verrouillage de l'enfant dans la mémoire. Il peut être très salissant à ajouter /supprimer ces gestionnaires de tous les enfants.
2. Vous pouvez déclarer la dépendance du parent qui n'a pas besoin de faire des changements dans l'enfant ou de l'enfant conscient de la mère. Plutôt, l'enfant a juste besoin de bien implémenter INotifyPropertyChanged. Cela met en cause la "logique" près de l'objet qui s'en soucie, plutôt que de diffuser des événements de folie et inter-dépendances partout dans le code.

Voici ce que le code pourrait ressembler à:

public class MyParent : INotifyPropertyChanged
{
private ObservableCollection<MyChild> _MyChildren;
private ContinuousValue<MyChild> _ContinuousIsChanged = null;
public MyParent()
{
_MyChildren = new ObservableCollection<MyChild>();
//Creat the ContinuousFirstOrDefault to watch the MyChildren collection.
//This will monitor for newly added instances, 
//as well as changes to the "IsChanged" property on 
//instances already in the collection.
_ContinuousIsChanged = MyChildren.ContinuousFirstOrDefault(child => child.IsChanged);
_ContinuousIsChanged.PropertyChanged += (s, e) => RaiseChanged("IsChanged");
}
public ObservableCollection<MyChild> MyChildren
{
get { return _MyChildren; }
}
public bool IsChanged
{
get
{
//If there is at least one child that matches the 
//above expression, then something has changed.
if (_ContinuousIsChanged.Value != null)
return true;
return false;
}
}
public event PropertyChangedEventHandler PropertyChanged;
private void RaiseChanged(string propName)
{
if (PropertyChanged != null)
PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propName));
}
}
public class MyChild : INotifyPropertyChanged
{
private int _Value;
public int Value
{
get
{
return _Value;
}
set
{
if (_Value == value)
return;
_Value = value;
RaiseChanged("Value");
RaiseChanged("IsChanged");
}
}
private int _DefaultValue;
public int DefaultValue
{
get
{
return _DefaultValue;
}
set
{
if (_DefaultValue == value)
return;
_DefaultValue = value;
RaiseChanged("DefaultValue");
RaiseChanged("IsChanged");
}
}
public bool IsChanged
{
get
{
return (Value != DefaultValue);
}
}
public event PropertyChangedEventHandler PropertyChanged;
private void RaiseChanged(string propName)
{
if (PropertyChanged != null)
PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propName));
}
}

Le code ci-dessus met en place le ContinuousFirstOrDefault dans le constructeur de sorte qu'il est toujours suivi. Cependant, dans certains cas, vous pouvez optimiser cette par paresseusement l'instanciation de la ContinuousFirstOrDefault uniquement lors de la lecture de "IsChanged" est appelé. De cette façon, vous ne commencez pas à surveiller les modifications jusqu'à ce que vous savez que quelque autre morceau de code se soucie.

OriginalL'auteur NathanAW

Quelque chose que je ne vois pas dans votre exemple de code à fournir est en réalité une référence de parent à enfant. Il ne suffit pas d'avoir une interface pour communiquer à travers, mais vous devez également créer la référence. Quelque chose comme myChild.parent = this; suivie par la liaison des gestionnaires d'événements à travers le canal, dans le "parent" de la propriété de l'objet enfant, il devrait ressembler à:

public INotifyPropertyChanged parent
{
get{return _parent;}
set
{
_parent = value;
this.PropertyChanged += _parent.RaiseChanged();
}
}

Je n'ai pas assez de contexte pour parfaire ce code pour vous, mais cela devrait vous permettre de vous déplacer dans la bonne direction.

OriginalL'auteur Cos Callis