Less Boilerplate More Clarity

public class Address : INotifyPropertyChanged
{
    private string _line1;
    private string _line2;
    private string _city;
    private string _remark;

    public string Line1
    {
        get => _line1;
        set
        {
            _line1 = value;
            OnPropertyChanged();
            OnPropertyChanged(nameof(FullAddress));
        }
    }

    public string Line2
    {
        get => _line2;
        set
        {
            _line2 = value;
            OnPropertyChanged();
            OnPropertyChanged(nameof(FullAddress));
        }
    }

    public string City
    {
        get => _city;
        set
        {
            _city = value;
            OnPropertyChanged();
            OnPropertyChanged(nameof(FullAddress));
        }
    }

    public string Remark
    {
        get => _remark;
        set
        {
            _remark = value;
            OnPropertyChanged();
        }
    }

    public string FullAddress => string.Join(Environment.NewLine, Line1, Line2, City);

    public event PropertyChangedEventHandler PropertyChanged;

    // TODO: Weak event.
    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

public class Person : INotifyPropertyChanged
{
    private string _firstName;
    private string _lastName;
    private Address _address;

    public string FirstName
    {
        get => _firstName;
        set
        {
            _firstName = value;
            OnPropertyChanged();
        }
    }

    public string LastName
    {
        get => _lastName;
        set
        {
            _lastName = value;
            OnPropertyChanged();
        }
    }

    public Address Address
    {
        get => _address;
        set
        {
            _address = value;
            OnPropertyChanged();
        }

    }


    public event PropertyChangedEventHandler PropertyChanged;

    // TODO: Weak event.
    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

}

public class PersonViewModel : INotifyPropertyChanged
{
    private Person _person;
    private bool _includeAddressInDetails;

    // TODO: Weak reference (if weak events are implemented).
    private Address _observedAddress;

    public Person Person
    {
        get => _person;
        set
        {

            if (_person != null)
            {
                _person.PropertyChanged -= OnPersonPropertyChanged;
                if (_observedAddress != null)
                {
                    _observedAddress.PropertyChanged -= OnAddressPropertyChanged;
                    _observedAddress = null;
                }
            }
            _person = value;

            if (value != null)
            {
                value.PropertyChanged += OnPersonPropertyChanged;
                _observedAddress = value.Address;
                if (_observedAddress != null)
                {
                    _observedAddress.PropertyChanged += OnAddressPropertyChanged;
                }
            }
            OnPropertyChanged();
            OnPropertyChanged(nameof(FullDetails));


        }
    }


    private void OnAddressPropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        if (e.PropertyName == nameof(Address.FullAddress))
        {
            OnPropertyChanged(nameof(FullDetails));
        }
    }




    private void OnPersonPropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        switch (e.PropertyName)
        {
            case nameof(Person.FirstName):
            case nameof(Person.LastName):
                OnPropertyChanged(nameof(FullDetails));
                break;

            case nameof(Person.Address):
                if (_observedAddress != null)
                {
                    _observedAddress.PropertyChanged -= OnAddressPropertyChanged;
                    _observedAddress = null;
                }

                _observedAddress = _person.Address;
                if (_observedAddress != null)
                {
                    _observedAddress.PropertyChanged += OnAddressPropertyChanged;
                }

                break;
        }
    }

    public bool IncludeAddressInDetails
    {
        get => _includeAddressInDetails;
        set
        {
            _includeAddressInDetails = value;
            OnPropertyChanged();
            OnPropertyChanged(nameof(FullDetails));
        }
    }

    public string FullDetails
    {
        get
        {
            // We don't handle the nulls for simplicity of the argument.
            if (IncludeAddressInDetails)
            {
                return string.Join(this.Person.FirstName + " " + this.Person.LastName,
                    this.Person.Address.FullAddress);
            }
            else
            {
                return this.Person.FirstName + " " + this.Person.LastName;
            }
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    // TODO: Weak events.
    [NotifyPropertyChangedInvocator]
    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

public partial class MainWindow : Window
{
    private MainViewModel _mainViewModel = new MainViewModel();

    public MainWindow()
    {
        InitializeComponent();
        this.OpenFile = new OpenFileCommand(_mainViewModel);
        this.CloseFile = new CloseFileCommand(_mainViewModel);
    }

    public ICommand OpenFile { get; }

    public ICommand CloseFile { get; }

    class OpenFileCommand : ICommand
    {
        private MainViewModel _mainViewModel;

        public OpenFileCommand(MainViewModel mainViewModel)
        {
            _mainViewModel = mainViewModel;
        }

        public bool CanExecute(object parameter) => true;

        public void Execute(object parameter) => _mainViewModel.OpenFile();

        public event EventHandler CanExecuteChanged;
    }

    class CloseFileCommand : ICommand
    {
        private MainViewModel _mainViewModel;

        public CloseFileCommand(MainViewModel mainViewModel)
        {
            _mainViewModel = mainViewModel;

            _mainViewModel.PropertyChanged += delegate (object o, PropertyChangedEventArgs args)
                {
                    if (args.PropertyName == nameof(MainViewModel.IsFileOpen))
                    {
                        this.CanExecuteChanged?.Invoke(this, EventArgs.Empty);
                    }
                };
        }

        public bool CanExecute(object parameter) => _mainViewModel.IsFileOpen;

        public void Execute(object parameter) => _mainViewModel.CloseFile();

        public event EventHandler CanExecuteChanged;
    }
}

public partial class FancyTextBlock : UserControl
{
    public static DependencyProperty TextProperty = DependencyProperty.Register(
      "Text", typeof(string), typeof(FancyTextBlock), null,
      value => !string.IsNullOrEmpty(value as string));

    public string Text
    {
        get => (string)this.GetValue(TextProperty);
        set => this.SetValue(TextProperty, value);
    }
}

public class Icecream : IFreezable
{
    private double _temperature;
    public FreezableList<Ingredient> Ingredients { get; } = new FreezableList<Ingredient>();

    public double Temperature
    {
        get => _temperature;
        set
        {
            if (this.IsFrozen) throw new ObjectReadOnlyException();
            _temperature = value;
        }

        // Hello, world.
    }

    public void Freeze()
    {
        this.IsFrozen = true;
        this.Ingredients.Freeze();
    }

    public bool IsFrozen { get; private set; }
}


public class Ingredient : IFreezable
{
    private string _name;
    private double _quantity;

    public string Name
    {
        get => _name;

        set
        {
            if (this.IsFrozen) throw new ObjectReadOnlyException();

            _name = value;
        }
    }

    public double Quantity
    {
        get => _quantity;

        set
        {
            if (this.IsFrozen) throw new ObjectReadOnlyException();

            _quantity = value;
        }
    }

    public void Freeze()
    {
        this.IsFrozen = true;
    }

    public bool IsFrozen { get; private set; }
}

public class UserNameService
{
    private Logger logger;
    private Db db;

    // It's just one method, but you should do this for thousands.
    public string GetUserName(int userId)
    {
        var methodLogger = logger.Start("UserNameService.GetUserName({userId})");

        try
        {

            string userName = db.Context.Users.Single(u => u.Id == userId).Name;
            methodLogger.Success(userName);

            return userName;
        }
        catch (Exception e)
        {
            methodLogger.Exception(e);
            throw;
        }
    }
}

public interface IBananaFactory
{
    Banana GetBanana(string kind, double length, double diameter);
}

public class BananaFactory : IBananaFactory
{
    public Banana GetBanana(string kind, double length, double diameter)
    {
        if (string.IsNullOrEmpty(kind)) throw new ArgumentNullException(nameof(kind));
        if (length < 0) throw new ArgumentOutOfRangeException(nameof(length));
        // Yep copy-pase error again.
        if (length < 0 || diameter > 5) throw new ArgumentOutOfRangeException(nameof(length));

        return new Banana(kind, length, diameter);
    }
}

public class Banana
{
    private string _kind;
    private double _length;
    private double _diameter;

    public Banana(string kind, double length, double diameter)
    {
        Kind = kind;
        Length = length;
        Diameter = diameter;
    }

    public string Kind
    {
        get => _kind;
        set
        {
            if (string.IsNullOrEmpty(value)) throw new ArgumentNullException(nameof(value));
            _kind = value;
        }
    }

    public double Length
    {
        get => _length;
        set
        {
            if (value < 0) throw new ArgumentOutOfRangeException(nameof(value));
            _length = value;
        }
    }

    public double Diameter
    {
        get => _diameter;
        set
        {
            if (value < 0 || value > 5) throw new ArgumentOutOfRangeException(nameof(value));
            _diameter = value;
        }
    }
}