Feedback

C# - Einfache PropertyChanged-Properties

Veröffentlicht von am 04.11.2015
(0 Bewertungen)
Mit dieser Klasse lassen sich Notify-Changed-Properties sehr einfach implementieren, ohne dass für jede property ein entsprechendes private field benötigt wird. Dieses snippet funktioniert bereits mit dem .net-Framework 3.5.

Eine ähnliche Implementierung dieser Klasse befindet sich hinter dem nachfolgenden Link. Der Unterschied dabei ist, dass dafür mindestens das .net-Framework 4.5 (oder höher) erforderlich ist.
http://dotnet-snippets.de/snippet/einfache-propertychanged-properties-net-4-5/11017

Die Verwendung ist sehr einfach. Die ViewModel-Klasse wird einfach von NotifyBase abgleitet und properties können dann wie folgt definiert werden:

        public string MyProperty
{
get { return Get(() => MyProperty); }
set { Set(() => MyProperty, value); }
}

GFU-Schulungen  [Anzeige]

C# 2017/2015/2013 Grundlagen

Nach Abschluss des Kurses sind Ihnen die Datentypen und Klassenbibliotheken von C# bekannt. Außerdem sind Sie in der Lage, mit Variablen umzugehen und deren Typen zu konvertieren. Sie definieren Namespaces und setzen diese ein, Sie erstellen eigene Klassen  und bauen Trouble Shooting ein.

ASP.NET 2.0 und 3.5

Dieser Kurs vermittelt Ihnen alle Erweiterungen von Microsoft ASP.NET 2.0. Zu diesen zählen u. a. Data Bindung, Master Pages, und Security.

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

namespace NameSpace
{
    public abstract class NotifyBase : INotifyPropertyChanged
    {
        private readonly Dictionary<string, object> propertyValues;

        protected NotifyBase()
        {
            propertyValues = new Dictionary<string, object>();
        }

        public event PropertyChangedEventHandler PropertyChanged;

        protected void Set<T>(Expression<Func<T>> expression, T value)
        {
            string propertyName = GetPropertyNameFromExpression(expression);
            Set(propertyName, value);
        }

        public static string GetPropertyNameFromExpression<T>(Expression<Func<T>> expression)
        {
            MemberExpression memberExpression = (MemberExpression)expression.Body; 
            return memberExpression.Member.Name;
        }

        protected void Set<T>(string name,
            T value)
        {
            if (propertyValues.ContainsKey(name))
            {
                propertyValues[name] = value;
                OnPropertyChanged(name);
            }
            else
            {
                propertyValues.Add(name, value);
                OnPropertyChanged(name);
            }
        }

        protected T Get<T>(string name)
        {
            if (propertyValues.ContainsKey(name))
            {
                return (T)propertyValues[name];
            }
            return default(T);
        }

        protected T Get<T>(Expression<Func<T>> expression)
        {
            string propertyName = GetPropertyNameFromExpression(expression);
            return Get<T>(propertyName);
        }

        protected void OnPropertyChanged(string propertyName)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null)
            {
                handler(this, new PropertyChangedEventArgs(propertyName));
            }
        }

        protected void OnPropertyChanged<T>(Expression<Func<T>> expression)
        {
            string propertyName = GetPropertyNameFromExpression(expression);
            OnPropertyChanged(propertyName);
        }
    }
}
Abgelegt unter c#, WPF, INotifyPropertyChanged.

Kommentare zum Snippet

 

Logge dich ein, um hier zu kommentieren!