Griff-Eigenschaft change-Ereignis-Listener (viel) mehr aus (Wörterbuch?)

Hallo !

Hier habe ich eine einfache Klasse Beispiel mit drei Feldern vom Typ Klasse B und einige andere Sachen.
Wie Sie sehen können, im hören auf jedes child-Objekt ändern.
Da könnte ich brauchen eine Menge Eigenschaften, die vom Typ der Klasse B, ich Frage mich, ob es einen Weg gibt, schrumpft der code. Erstellen eines Listeners + eine Methode für den einzelnen scheint, wie ich haben eine Menge von code. Wie würde ich dieses Problem beheben ... mit einem Wörterbuch oder ähnliches? Mir wurde gesagt, dass IoC dieses Problem beheben könnte, aber im nicht sicher, wo zu beginnen.

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");
    }
}

InformationsquelleAutor no9 | 2010-03-16

c#inotifypropertychanged

2

Die eleganteste Möglichkeit, die ich kenne ist die Verwendung von Aspekt-Orientierte Programmierung (AOP) mit einem tool wie PostSharp. Ich fand die INotifyPropertyChanged Implementierung Beispiele hier und hier. Diese können Sie schmücken Sie Ihre Eigenschaften mit einem Attribut und PostSharp dann INotifyPropertyChanged implementiert für Sie, wenn der code aufgebaut ist.

Ich habe auf der Suche in PostSharp eine Menge. Das problem ist, dass ich kann nicht get-child-Eigenschaft ändern-Kette zu arbeiten. Vielleicht gibt es eine Lösung für PostSharp 2.0, aber wir sind mit PostSharp 1.5 und die Lösungen, die nicht dort arbeiten. Ich kann das pack INotifyPropertyChange als ein Aspekt allrite, aber ich kann nicht herausfinden, wie zu handhaben untergeordnete änderungen (jeder Ebene). Irgendeine Idee?
Ich habe nicht wirklich verwendet. Sie haben ein support-forum (sharpcrafters.com/forum) und mir ist aufgefallen, dass 1,5 ist markiert als "legacy" so werden Sie wahrscheinlich haben, zu aktualisieren, um es arbeiten.

InformationsquelleAutor Jamie Ide

Sieht es aus wie Sie eine Abhängigkeit Kette. Keine AOP oder statische Analyse-Lösungen behandeln Sie diese ordnungsgemäß. Check-out Update-Steuerelemente, die verwendet dependency-tracking entdecken Sie Ketten Abhängigkeit zur Laufzeit.

Hier ist, was dein Beispiel wird zu:

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; }
    }
}

InformationsquelleAutor Michael L Perry

0

Einer schönen Art und Weise zu vereinfachen, die Einrichtung Ihrer Eigenschaften finden Sie hier.

Bezug auf Ihre kaskadierende Benachrichtigungen: ich denke, man könnte den Ansatz oben beschrieben zu behandeln, die (un-)Abonnement von Veranstaltungen für die Eigenschaften der Umsetzung INotifyPropertyChanged es.

InformationsquelleAutor Benjamin Podszun

Zu vereinfachen, zu wenig können Sie die folgenden zwei Dinge.

Erste, in der handler das PropertyChanged-der erste parameter sender ist das Objekt, das ausgelöst das Ereignis, zumindest wenn man implmented die OnPropertyChanged in der Klasse B die gleiche Weise wie in der Klasse A. Dies bedeutet, dass benötigen Sie nur einen einzigen handler für alle B-Eigenschaften.

private void BValueListener(object sender, PropertyChangedEventArgs e)
{
  Console.WriteLine("Found change of {0} on object {1}", e.PropertyName, sender);
}

Wenn Sie genau wissen, welche von den B-Eigenschaften haben, die senden, die Sie tun könnten Prüfungen in der BValueListener Methode.

if (sender == FirstB) { /* Do special stuff here */ }

Haben Sie die gleichen Hörer für alle B-Eigenschaften können wir uns dann bewegen, um zu schreiben, die Eigenschaft setter wie:

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;
}

Wenn Sie wirklich brauchen verschiedene Handler für jede Eigenschaft, die Sie ändern können Sie den code oben, um so etwas wie

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;
}

wo können Sie in den listener-Methode, die Sie verwenden möchten, in jedem Fall.

danke für die anwser Robert. Aber ich muss einen Schritt weiter gehen. Ich muss eine Art "helper" - Klasse, würde behandeln von Ereignissen für meine Klassen. Mein Ziel ist es, die Klassen reinigen Sie so viel wie möglich (vielleicht sogar die INotifyPropertyChanged-Schnittstelle injiziert-on-demand). Ich lese über "TypeDescriptor" dies tun können, aber um ehrlich zu sein, ich bin immer noch im dunklen...

InformationsquelleAutor Robert Höglund

Einem Werkzeug, das Sie in Betracht ziehen könnte, ist T4 (T4 geliefert wird mit VS2010, so dass keine zusätzlichen Abhängigkeiten benötigt).

T4 ist eine code-generation-tool, das helfen kann, reduzieren die Wartung der "langweilige" code. Denken ASP - /PHP-code. Es ist auch ähnlich zu XML/XSLT.

Für eine hervorragende Einführung zu T4 finden Sie Oleg Sychs blog.

Die Vorteile der code-Generierung in einem Fall wie diesem ist, dass, obwohl der generierte code ist redundant der code, den Sie erhalten (die T4-Vorlage) nicht oder zumindest weniger überflüssig.

Also ein nachdenken über die Probe, die Sie zur Verfügung gestellt, die ich schrieb dieser T4-Vorlage:
(Wenn Sie möchten, um zu versuchen, diese Vorlage in Visual Studio, klicken Sie auf Neues Element Hinzufügen, wählte die Klasse Vorlage, aber ändern Sie die Erweiterung aus .cs .tt, fügen Sie den folgenden Quelltext in die .tt-Datei und speichern Sie. Nach dem speichern sollte das Ergebnis in der entsprechenden .cs-Datei)

//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,
            };
    }
#>

Schließlich erzeugt diese Ausgabe:

//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 ();
        //--------------------------------------------------------------------
    }
    //------------------------------------------------------------------------
}

Wenn Sie wie die T4 pickup der C# - code und generieren Sie code aus, dass dieser Kerl untersucht einige Möglichkeiten, dies zu tun in VS: danielvaughan.orpius.com/post/...

InformationsquelleAutor Just another metaprogrammer

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.