Есть ли способ "автоматического" уведомления о том, что свойство изменилось?

        public event PropertyChangedEventHandler PropertyChanged;
 
        protected void NotifyPropertyChanged(string name)
        {
            if (null != PropertyChanged)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(name));
            }
        }
 
        private string _host;
        public string Host
        {
            get
            {
                return _host;
            }
            private set
            {
                _host = value;
                NotifyPropertyChanged("Host");
            }
        }

        [Notifitied property]
        public string Host { get; private set; }

public string Host
        {
            get
            {
                return _host;
            }
            private set
            {
                _host = value;
                NotifyPropertyChanged();
            }
        }
...
protected void NotifyPropertyChanged([CallerMemberName] string propertyName = null)
{
...
}

public class NotificationObject : INotifyPropertyChanged
{
        protected bool SetProperty<T>(ref T storage, T value, [CallerMemberName] string propertyName = null)
        {
                return SetProperty(ref storage, value, null, propertyName);
        }
 
        protected virtual bool SetProperty<T>(ref T storage, T value, Action callback, [CallerMemberName] string propertyName = null)
        {
                if (Equals(storage, value))
                        return false;
                storage = value;
                RaisePropertyChanged(propertyName);
                if (callback != null)
                        callback();
                return true;
        }
 
        protected bool SetProperty<T>(ref T? storage, T value, [CallerMemberName] string propertyName = null)
                where T : struct
        {
                return SetProperty(ref storage, value, null, propertyName);
        }
 
        protected virtual bool SetProperty<T>(ref T? storage, T value, Action callback, [CallerMemberName] string propertyName = null)
                where T : struct
        {
                if (Equals(storage, value))
                        return false;
                storage = value;
                RaisePropertyChanged(propertyName);
                if (callback != null)
                        callback();
                return true;
        }
 
        protected virtual T GetProperty<T>(ref T? storage, T defaultValue)
                where T : struct
        {
                if (!storage.HasValue)
                        storage = defaultValue;
                return storage.Value;
        }
 
        protected void RaisePropertyChanged<T>(Expression<Func<T>> action)
        {
                var propertyName = GetPropertyName(action);
                RaisePropertyChanged(propertyName);
        }
 
        private static string GetPropertyName<T>(Expression<Func<T>> action)
        {
                var expression = (MemberExpression)action.Body;
                var propertyName = expression.Member.Name;
                return propertyName;
        }
 
        private void RaisePropertyChanged(string propertyName)
        {
                if (PropertyChanged != null)
                        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
 
        public event PropertyChangedEventHandler PropertyChanged;
}

public class A : NotificationObject
{
        private string _name;
 
        public string Name
        {
                get { return _name; }
                set { SetProperty(ref _name, value); }
        }
}

public class A : NotificationObject
{
        private string _name;
 
        public string Name
        {
                get { return _name; }
                set { SetProperty(ref _name, value, OnNameChanged); }
        }
 
        private void OnNameChanged()
        {
 
        }
}

public abstract class ObservableObject : INotifyPropertyChanged {
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged(string propName) {
Debug.Assert(GetType().GetProperty(propName) != null);
var pc = PropertyChanged;
if(pc != null)
pc(this, new PropertyChangedEventArgs(propName));
}
protected bool SetProperty<T>(ref T field, T value,
string propName) {
if(!EqualityComparer<T>.Default.Equals(field, value)) {
field = value;
OnPropertyChanged(propName);
return true;
}
return false;
}
protected bool SetProperty<T>(ref T field, T value,
Expression<Func<T>> expr) {
if(!EqualityComparer<T>.Default.Equals(field, value)) {
field = value;
var lambda = (LambdaExpression)expr;
MemberExpression memberExpr;
if(lambda.Body is UnaryExpression) {
var unaryExpr = (UnaryExpression)lambda.Body;
memberExpr = (MemberExpression)unaryExpr.Operand;
}
else {
memberExpr = (MemberExpression)lambda.Body;
}
OnPropertyChanged(memberExpr.Member.Name);
return true;
}
return false;
}
}

string _name;
public string Name {
get { return _name; }
set { SetProperty(ref _name, value, () => Name); }
}

/*---------notwendige Namespaces-----------*/
        //using System.Runtime.CompilerServices;
        //using System.ComponentModel;
 
        /*---------Schnittstelle implementieren-----------*/
        //Klassenname : INotifyPropertyChanged
 
        // Aufruf in Set-Methoden der Properties
 
        public event PropertyChangedEventHandler PropertyChanged;
 
        private void OnPropertyChanged([CallerMemberName]string propertyName = "")
        {
            if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }

public string Host
        {
            get
            {
                return _host;
            }
            private set
            {
                _host = value;
                OnPropertyChanged( );
            }
        }

 private float _fat;
        public float Fat
        {
            get
            {
                return _fat;
            }
            set
            {
                if (_fat == value)
                {
                    return;
                }
                _fat = value;
                RaisePropertyChanged(() => Fat);
            }
        }

[ImplementPropertyChanged]
public class Person 
{        
    public string GivenNames { get; set; }
    public string FamilyName { get; set; }
 
    public string FullName
    {
        get
        {
            return string.Format("{0} {1}", GivenNames, FamilyName);
        }
    }
}

public class Person : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;
 
    string givenNames;
    public string GivenNames
    {
        get { return givenNames; }
        set
        {
            if (value != givenNames)
            {
                givenNames = value;
                OnPropertyChanged("GivenNames");
                OnPropertyChanged("FullName");
            }
        }
    }
 
    string familyName;
    public string FamilyName
    {
        get { return familyName; }
        set 
        {
            if (value != familyName)
            {
                familyName = value;
                OnPropertyChanged("FamilyName");
                OnPropertyChanged("FullName");
            }
        }
    }
 
    public string FullName
    {
        get
        {
            return string.Format("{0} {1}", GivenNames, FamilyName);
        }
    }
 
    public virtual void OnPropertyChanged(string propertyName)
    {
        var propertyChanged = PropertyChanged;
        if (propertyChanged != null)
        {
            propertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}