INotifyPropertyChanged Implementierung mit IsChanged Events

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Linq.Expressions;

namespace eac.Utilities
{
    /// <summary>
    /// Eine Hilfsklasse, welche Events für Propery-IsChanged generisch bereit stellt
    /// obj.Property(() => obj.PROPERTY).IsChanged += (s,e) => { ... };
    /// </summary>
    public class NotificationObjectWithPropertyIsChangedEvents : Object, INotifyPropertyChanged
    {
        public sealed class NotificationObjectWithPropertyIsChangedEventHolder
        {
            public event EventHandler IsChanged;

            readonly NotificationObjectWithPropertyIsChangedEvents _obj;
            public NotificationObjectWithPropertyIsChangedEventHolder(NotificationObjectWithPropertyIsChangedEvents obj)
            {
                _obj = obj;
            }

            public void RaiseIsChanged()
            {
                var tmp = IsChanged; // in lokale variable kompieren um thread save zu sein
                if (tmp != null) tmp(_obj, EventArgs.Empty);
            }
        }

        public NotificationObjectWithPropertyIsChangedEvents()
        {
            this.PropertyChanged += NotificationObjectWithEvent_PropertyChanged;
        }

        readonly Dictionary<string, NotificationObjectWithPropertyIsChangedEventHolder> _eventHandler = new Dictionary<string, NotificationObjectWithPropertyIsChangedEventHolder>();

        public NotificationObjectWithPropertyIsChangedEventHolder Property<T>(Expression<Func<T>> propertyExpression)
        {
            var propName = ExtractPropertyName(propertyExpression);
            if (_eventHandler.ContainsKey(propName)) return _eventHandler[propName];

            var nh = new NotificationObjectWithPropertyIsChangedEventHolder(this);
            _eventHandler.Add(propName, nh);
            return nh;
        }

        void NotificationObjectWithEvent_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            foreach (var item in _eventHandler.Where(s => s.Key == e.PropertyName))
                item.Value.RaiseIsChanged();
        }

        
        // **************
        // ab hier von Prism 4.0 übernommen (http://compositewpf.codeplex.com/)

        /// <summary>
        /// Raises this object's PropertyChanged event.
        /// </summary>
        /// <param name="propertyName">The property that has a new value.</param>
        protected virtual void RaisePropertyChanged(string propertyName)
        {
            System.ComponentModel.PropertyChangedEventHandler propertyChanged = this.PropertyChanged;
            if (propertyChanged != null)
                propertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName));
        }
        /// <summary>
        /// Raises this object's PropertyChanged event for each of the properties.
        /// </summary>
        /// <param name="propertyNames">The properties that have a new value.</param>
        protected void RaisePropertyChanged(params string[] propertyNames)
        {
            if (propertyNames == null)
                throw new System.ArgumentNullException("propertyNames");
            string[] strArrays = propertyNames;
            foreach (var str in strArrays)
                this.RaisePropertyChanged(str);
        }
        protected void RaisePropertyChanged<T>(System.Linq.Expressions.Expression<System.Func<T>> propertyExpression)
        {
            string str = ExtractPropertyName<T>(propertyExpression);
            this.RaisePropertyChanged(str);
        }
        /// <summary>
        /// Raised when a property on this object has a new value.
        /// </summary>        
        public virtual event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;

        static string ExtractPropertyName<T>(System.Linq.Expressions.Expression<System.Func<T>> propertyExpression)
        {
            if (propertyExpression == null)
            {
                throw new System.ArgumentNullException("propertyExpression");
            }
            System.Linq.Expressions.MemberExpression body = propertyExpression.Body as System.Linq.Expressions.MemberExpression;
            if (body == null)
            {
                throw new System.ArgumentException("The expression is not a member access expression");
            }
            System.Reflection.PropertyInfo member = body.Member as System.Reflection.PropertyInfo;
            if (member == null)
            {
                throw new System.ArgumentException("The member access expression does not access a property");
            }
            System.Reflection.MethodInfo getMethod = member.GetGetMethod(true);
            if (getMethod.IsStatic)
            {
                throw new System.ArgumentException("The referenced property is a static property");
            }
            return body.Member.Name;
        }

    }

}