Poignée de changement de propriété d'écouteurs d'événement (beaucoup) plus élégamment (dictionnaire?)

bonjour !

Ici, j'ai un simple exemple de classe avec trois champs de type de classe B, et quelques autres trucs.
Comme vous pouvez le voir im écoute sur chaque enfant modification de l'objet.
Depuis que j'ai pu besoin de beaucoup de propriétés de type de classe B, je me demande si il existe un moyen de réduire le code. La création d'un écouteur + une méthode pour chaque semble que je vais avoir BEAUCOUP de code. Comment pourrais-je résoudre ce problème ... à l'aide d'un dictionnaire ou quelque chose de similaire? J'ai dit que le Cio pourrait résoudre ce problème, mais je ne sais pas par où commencer.

public class A : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
public int _id;
public int Id
{
get { return _id; }
set
{
if (_id == value)
{
return;
}
_id = value;
OnPropertyChanged("Id"); 
}
}
public string _name;
public string Name
{
get { return _name; }
set
{
if (_name == value)
{
return;
}
_name = value; 
OnPropertyChanged("Name"); 
}
}
public B _firstB;
public B FirstB
{
get { return _firstB; }
set 
{
if (_firstB == value)
{
return;
}
if (_firstB != null)
{
FirstB.PropertyChanged -= firstObjectB_Listener;
}
_firstB = value;
if (_firstB != null) 
FirstB.PropertyChanged += new PropertyChangedEventHandler(firstObjectB_Listener);
OnPropertyChanged("FirstB"); 
}
}
public B _secondB;
public B SecondB
{
get { return _secondB; }
set
{
if (_secondB == value)
{
return;
}
if (_secondB != null)
{
FirstB.PropertyChanged -= secondObjectB_Listener;
}
_secondB = value;
if (_secondB != null)
SecondB.PropertyChanged += new PropertyChangedEventHandler(secondObjectB_Listener);
OnPropertyChanged("FirstB");
}
}
public B _thirdB;
public B ThirdB
{
get { return _thirdB; }
set
{
if (_thirdB == value)
{
return;
}
if (_thirdB != null)
{
ThirdB.PropertyChanged -= thirdObjectB_Listener;
}
_thirdB = value;
if (_thirdB != null)
ThirdB.PropertyChanged += new PropertyChangedEventHandler(thirdObjectB_Listener);
OnPropertyChanged("ThirdB");
}
}
protected void OnPropertyChanged(string name)
{
PropertyChangedEventHandler handler = PropertyChanged;
if (handler != null)
{
handler(this, new PropertyChangedEventArgs(name));
}
}
void firstObjectB_Listener(object sender, PropertyChangedEventArgs e)
{
Console.WriteLine("Object A has found a change of " + e.PropertyName + " on first object B");
}
void secondObjectB_Listener(object sender, PropertyChangedEventArgs e)
{
Console.WriteLine("Object A has found a change of " + e.PropertyName + " on second object B");
}
void thirdObjectB_Listener(object sender, PropertyChangedEventArgs e)
{
Console.WriteLine("Object A has found a change of " + e.PropertyName + " on third object B");
}
}

OriginalL'auteur no9 | 2010-03-16

c#inotifypropertychanged

2

La façon la plus élégante que je connaisse est d'utiliser la Programmation Orientée Aspects (AOP) avec un outil tel que PostSharp. J'ai trouvé INotifyPropertyChanged la mise en œuvre des exemples ici et ici. Ceux-ci vous permettent de décorer vos propriétés avec un attribut et PostSharp met ensuite en place INotifyPropertyChanged pour vous lorsque le code est construit.

J'ai été à la recherche dans PostSharp beaucoup. Le problème est que je ne peux pas avoir d'enfant changement de propriété de la chaîne de travail. Peut-être il ya une solution pour PostSharp 2.0, mais nous sommes à l'aide de PostSharp 1.5 et les solutions ne fonctionnent pas. Je peux pack INotifyPropertyChange comme un aspect allrite, mais je ne peux pas comprendre comment gérer les modifications de l'enfant (tout niveau). Une idée?
Je n'ai pas réellement utilisé. Ils ont un forum de support (sharpcrafters.com/forum) et j'ai remarqué que de 1,5 est marqué comme "l'héritage" de sorte que vous aurez probablement à la mise à niveau pour le faire fonctionner.

OriginalL'auteur Jamie Ide

On dirait que vous êtes la configuration d'une chaîne de dépendances. Aucun de l'AOP ou de l'analyse statique des solutions vont gérer cela correctement. Découvrez la mise à Jour des Contrôles, qui utilise le suivi des dépendances à découvrez les chaînes de la dépendance au moment de l'exécution.

Voici ce que votre exemple devient:

public class B
{
private Independent<string> _someProperty = new Independent<string>();
public string SomeProperty
{
get { return _someProperty; }
set { _someProperty.Value = value; }
}
}
public class A
{
private Dependent<string> _dependentProperty;
public A()
{
_dependentProperty = new Dependent<string>(() =>
FirstB.SomeProperty + ", " + SecondB.SomeProperty + ", " + ThirdB.SomeProperty);
}
public string DependentProperty
{
get { return _dependentProperty; }
}
private Independent<int> _id = new Independent<int>();
public int Id
{
get { return _id; }
set { _id.Value = value; }
}
private Independent<string> _name = new Independent<string>();
public string Name
{
get { return _name; }
set { _name.Value = value; }
}
private Independent<B> _firstB = new Independent<B>();
public B FirstB
{
get { return _firstB; }
set { _firstB.Value = value; }
}
private Independent<B> _secondB = new Independent<B>();
public B SecondB
{
get { return _secondB; }
set { _secondB.Value = value; }
}
private Independent<B> _thirdB = new Independent<B>();
public B ThirdB
{
get { return _thirdB; }
set { _thirdB.Value = value; }
}
}

OriginalL'auteur Michael L Perry

0

Une belle façon de simplifier la configuration de vos propriétés peuvent être trouvés ici.

En ce qui concerne votre cascade notifications: je suppose que vous pouvez utiliser l'approche décrite ci-dessus pour gérer la (non-)abonnement d'événements pour les propriétés de mise en œuvre de INotifyPropertyChanged.

OriginalL'auteur Benjamin Podszun
0

De simplifier au peu que vous pouvez faire les deux choses.

Tout d'abord, dans le gestionnaire de la PropertyChanged le premier paramètre, l'expéditeur est l'objet qui a déclenché l'événement, au moins si vous avez mises en œuvre le OnPropertyChanged dans la catégorie B de la même manière que dans la classe A. Cela signifie que vous avez seulement besoin d'un traiteur pour tous les B propriétés.
```
private void BValueListener(object sender, PropertyChangedEventArgs e)
{
Console.WriteLine("Found change of {0} on object {1}", e.PropertyName, sender);
}
```
Si vous avez besoin de le faire savoir exactement quels B propriétés ne l'envoi que vous pourriez faire des vérifications dans le BValueListener méthode.
```
if (sender == FirstB) { /* Do special stuff here */ }
```
Ayant le même port d'écoute pour tous les B propriétés, nous pouvons alors passer à l'écriture de la propriété setter comme:
```
private B _thirdB;
public B ThirdB
{
get { return _thirdB; }
set {
if (UpdateBValue(ref _thirdB, value)) {
OnPropertyChanged("ThirdB");
}
}
}
private bool UpdateBValue(ref B value, B newValue)
{
if (value == newValue)
{
return false;
}
if (value != null)
{
value.PropertyChanged -= BValueListener;
}
value = newValue;
if (value != null)
{
value.PropertyChanged += BValueListener;
}
return true;
}
```
Si vous avez vraiment besoin des gestionnaires différents pour chaque propriété que vous pouvez modifier le code ci-dessus pour quelque chose comme
```
private B _thirdB;
public B ThirdB
{
get { return _thirdB; }
set 
{ 
if (UpdateBValue(ref _thirdB, value, BValueListener))
{
OnPropertyChanged("ThirdB");
}
}
} 
private bool UpdateBValue(ref B value, B newValue, PropertyChangedEventHandler eventHandler)
{
if (value == newValue)
{
return false;
}
if (value != null)
{
value.PropertyChanged -= eventHandler;
}
value = newValue;
if (value != null)
{
value.PropertyChanged += eventHandler;
}
return true;
}
```
où vous pouvez l'envoyer à l'auditeur de la méthode que vous souhaitez utiliser dans chaque cas.

merci pour la réponse de Robert. Mais j'ai besoin d'aller un peu plus loin. J'ai besoin de créer une sorte de "helper" de classe qui permettrait de gérer des événements pour mes cours. Mon but est de garder les classes de nettoyer autant que possible (peut-être même l'interface INotifyPropertyChanged injecté sur demande). J'ai lu à propos de "TypeDescriptor" peut le faire, mais pour être honnête, je suis encore dans le noir...

OriginalL'auteur Robert Höglund

Un outil que vous pourriez envisager est de la T4 (T4 est livré avec VS2010 donc pas de dépendances supplémentaires nécessaires).

T4 est un outil de génération de code qui peut aider à réduire l'entretien de "fastidieux" du code. Pensez ASP/PHP pour le code. C'est également similaire à XML/XSLT.

Pour une excellente introduction à T4 veuillez voir Oleg Sychs blog.

Les avantages de la génération de code dans un cas comme cela, c'est que même si le code généré est superflu le code que vous avez à maintenir (le modèle T4) n'est pas ou, du moins, est moins redondants.

De penser à propos de l'exemple que vous avez fourni, j'ai écrit ce modèle T4:
(Si vous souhaitez essayer ce modèle dans Visual Studio, cliquez sur Ajouter un Nouvel Élément, a choisi le modèle de classe, mais remplacez l'extension .cs .tt, coller la source suivante dans le .tt fichier et de l'enregistrer. Après enregistrez le résultat dans la case correspondante .cs fichier)

//ReSharper disable InconsistentNaming
//ReSharper disable PartialMethodWithSinglePart
//ReSharper disable PartialTypeWithSinglePart
<#
//This is the "model" that is "what" we would like to generate
var classDefs = new []
{
new ClassDefinition
{
Name = "A",
Properties = new []
{
P ("int"    , "Id"      ),
P ("string" , "Name"    ),
P ("B"      , "FirstB"  , listenToChanges:true  ),
P ("B"      , "SecondB" , listenToChanges:true  ),
P ("B"      , "ThirdB"  , listenToChanges:true  ),
},
},
new ClassDefinition
{
Name = "B",
Properties = new []
{
P ("int"    , "Id"      ),
P ("string" , "Name"    ),
},
},
};
#>
namespace SO
{
using System;
using System.ComponentModel;
<#
//This part is the template ie "how" the model will be transformed into code
foreach (var classDef in classDefs)
{
#>        
//------------------------------------------------------------------------
///<summary>
///class <#=classDef.Name#> (implements INotifyPropertyChanged)
///</summary>
public partial class <#=classDef.Name#> : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
void OnPropertyChanged (string name)
{
PropertyChangedEventHandler handler = PropertyChanged;
if (handler != null) 
{
handler (this, new PropertyChangedEventArgs (name));
}
}
<#
foreach (var propertyDef in classDef.Properties)
{
#>
//--------------------------------------------------------------------
///<summary>
///Gets or sets property <#=propertyDef.Name#> (<#=propertyDef.Type#>)
///</summary>
public <#=propertyDef.Type#> <#=propertyDef.Name#>
{ 
get { return <#=propertyDef.FieldName#>; } 
set 
{ 
if (<#=propertyDef.FieldName#> == value) 
{ 
return; 
} 
<#
if (propertyDef.ListenToChanges)
{
#>
if (<#=propertyDef.FieldName#> != null) 
{ 
<#=propertyDef.FieldName#>.PropertyChanged -= <#=propertyDef.ListenerName#>;
} 
<#=propertyDef.FieldName#> = value; 
if (<#=propertyDef.FieldName#> != null)  
{
<#=propertyDef.FieldName#>.PropertyChanged += <#=propertyDef.ListenerName#>; 
}
<#
}
else
{
#>
<#=propertyDef.FieldName#> = value; 
<#
}
#>
<#=propertyDef.EventName#> ();
OnPropertyChanged("<#=propertyDef.Name#>");  
} 
} 
//--------------------------------------------------------------------
<#=propertyDef.Type#> <#=propertyDef.FieldName#>; 
//--------------------------------------------------------------------
partial void <#=propertyDef.EventName#> ();
//--------------------------------------------------------------------
<#
if (propertyDef.ListenToChanges)
{
#>
void <#=propertyDef.ListenerName#> (object sender, PropertyChangedEventArgs e)
{
Console.WriteLine (
"Instance of <#=classDef.Name#> detected a change of <#=propertyDef.Name#>.{0}", 
e.PropertyName
);
<#=propertyDef.EventName#> ();
}
//--------------------------------------------------------------------
<#
}
}
#>
}
//------------------------------------------------------------------------
<#
}
#>
}
<#+
class ClassDefinition
{
public string Name;
public PropertyDefinition[] Properties;
}
class PropertyDefinition
{
public string Type;
public string Name;
public bool ListenToChanges;
public string FieldName 
{
get
{
return "_" + Name;
}
}
public string ListenerName 
{
get
{
return Name + "_Listener";
}
}
public string EventName 
{
get
{
return "Change_" + Name;
}
}
}
PropertyDefinition P (string type, string name, bool listenToChanges = false)
{
return new PropertyDefinition
{
Type = type ?? "<NO_TYPE>",
Name = name ?? "<NO_NAME>",
ListenToChanges = listenToChanges,
};
}
#>

Enfin ce qui produit ce résultat:

//ReSharper disable InconsistentNaming
//ReSharper disable PartialMethodWithSinglePart
//ReSharper disable PartialTypeWithSinglePart
namespace SO
{
using System;
using System.ComponentModel;
//------------------------------------------------------------------------
///<summary>
///class A (implements INotifyPropertyChanged)
///</summary>
public partial class A : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
void OnPropertyChanged (string name)
{
PropertyChangedEventHandler handler = PropertyChanged;
if (handler != null) 
{
handler (this, new PropertyChangedEventArgs (name));
}
}
//--------------------------------------------------------------------
///<summary>
///Gets or sets property Id (int)
///</summary>
public int Id
{ 
get { return _Id; } 
set 
{ 
if (_Id == value) 
{ 
return; 
} 
_Id = value; 
Change_Id ();
OnPropertyChanged("Id");  
} 
} 
//--------------------------------------------------------------------
int _Id; 
//--------------------------------------------------------------------
partial void Change_Id ();
//--------------------------------------------------------------------
//--------------------------------------------------------------------
///<summary>
///Gets or sets property Name (string)
///</summary>
public string Name
{ 
get { return _Name; } 
set 
{ 
if (_Name == value) 
{ 
return; 
} 
_Name = value; 
Change_Name ();
OnPropertyChanged("Name");  
} 
} 
//--------------------------------------------------------------------
string _Name; 
//--------------------------------------------------------------------
partial void Change_Name ();
//--------------------------------------------------------------------
//--------------------------------------------------------------------
///<summary>
///Gets or sets property FirstB (B)
///</summary>
public B FirstB
{ 
get { return _FirstB; } 
set 
{ 
if (_FirstB == value) 
{ 
return; 
} 
if (_FirstB != null) 
{ 
_FirstB.PropertyChanged -= FirstB_Listener;
} 
_FirstB = value; 
if (_FirstB != null)  
{
_FirstB.PropertyChanged += FirstB_Listener; 
}
Change_FirstB ();
OnPropertyChanged("FirstB");  
} 
} 
//--------------------------------------------------------------------
B _FirstB; 
//--------------------------------------------------------------------
partial void Change_FirstB ();
//--------------------------------------------------------------------
void FirstB_Listener (object sender, PropertyChangedEventArgs e)
{
Console.WriteLine (
"Instance of A detected a change of FirstB.{0}", 
e.PropertyName
);
Change_FirstB ();
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
///<summary>
///Gets or sets property SecondB (B)
///</summary>
public B SecondB
{ 
get { return _SecondB; } 
set 
{ 
if (_SecondB == value) 
{ 
return; 
} 
if (_SecondB != null) 
{ 
_SecondB.PropertyChanged -= SecondB_Listener;
} 
_SecondB = value; 
if (_SecondB != null)  
{
_SecondB.PropertyChanged += SecondB_Listener; 
}
Change_SecondB ();
OnPropertyChanged("SecondB");  
} 
} 
//--------------------------------------------------------------------
B _SecondB; 
//--------------------------------------------------------------------
partial void Change_SecondB ();
//--------------------------------------------------------------------
void SecondB_Listener (object sender, PropertyChangedEventArgs e)
{
Console.WriteLine (
"Instance of A detected a change of SecondB.{0}", 
e.PropertyName
);
Change_SecondB ();
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
///<summary>
///Gets or sets property ThirdB (B)
///</summary>
public B ThirdB
{ 
get { return _ThirdB; } 
set 
{ 
if (_ThirdB == value) 
{ 
return; 
} 
if (_ThirdB != null) 
{ 
_ThirdB.PropertyChanged -= ThirdB_Listener;
} 
_ThirdB = value; 
if (_ThirdB != null)  
{
_ThirdB.PropertyChanged += ThirdB_Listener; 
}
Change_ThirdB ();
OnPropertyChanged("ThirdB");  
} 
} 
//--------------------------------------------------------------------
B _ThirdB; 
//--------------------------------------------------------------------
partial void Change_ThirdB ();
//--------------------------------------------------------------------
void ThirdB_Listener (object sender, PropertyChangedEventArgs e)
{
Console.WriteLine (
"Instance of A detected a change of ThirdB.{0}", 
e.PropertyName
);
Change_ThirdB ();
}
//--------------------------------------------------------------------
}
//------------------------------------------------------------------------
//------------------------------------------------------------------------
///<summary>
///class B (implements INotifyPropertyChanged)
///</summary>
public partial class B : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
void OnPropertyChanged (string name)
{
PropertyChangedEventHandler handler = PropertyChanged;
if (handler != null) 
{
handler (this, new PropertyChangedEventArgs (name));
}
}
//--------------------------------------------------------------------
///<summary>
///Gets or sets property Id (int)
///</summary>
public int Id
{ 
get { return _Id; } 
set 
{ 
if (_Id == value) 
{ 
return; 
} 
_Id = value; 
Change_Id ();
OnPropertyChanged("Id");  
} 
} 
//--------------------------------------------------------------------
int _Id; 
//--------------------------------------------------------------------
partial void Change_Id ();
//--------------------------------------------------------------------
//--------------------------------------------------------------------
///<summary>
///Gets or sets property Name (string)
///</summary>
public string Name
{ 
get { return _Name; } 
set 
{ 
if (_Name == value) 
{ 
return; 
} 
_Name = value; 
Change_Name ();
OnPropertyChanged("Name");  
} 
} 
//--------------------------------------------------------------------
string _Name; 
//--------------------------------------------------------------------
partial void Change_Name ();
//--------------------------------------------------------------------
}
//------------------------------------------------------------------------
}

Si vous aimez le T4 pour récupérer le code C# et de générer du code à partir de ce que ce mec a exploré certaines des possibilités de le faire dans VS: danielvaughan.orpius.com/post/...

OriginalL'auteur Just another metaprogrammer

Vous devez vous connecter pour publier un commentaire.