public abstract class MultiWindowBaseViewModel : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;
    {
        add
        {
            // add code goes here
        }
        remove
        {
            // remove code goes here
        }
    }
}

public class MultiWindowViewModelBase : INotifyPropertyChanged
{
    private readonly object _lock = new object();
    private readonly Dictionary<SynchronizationContext, PropertyChangedEventHandler> _handlersWithContext = new Dictionary<SynchronizationContext, PropertyChangedEventHandler>();


    public event PropertyChangedEventHandler PropertyChanged
    {
        add
        {
            if (value == null)
            {
                return;
            }


            var synchronizationContext = SynchronizationContext.Current;


            lock (_lock)
            {
                if (_handlersWithContext.TryGetValue(synchronizationContext, out PropertyChangedEventHandler eventHandler))
                {
                    eventHandler += value;


                    _handlersWithContext[synchronizationContext] = eventHandler;
                }
                else
                {
                    _handlersWithContext.Add(synchronizationContext, value);
                }
            }
        }
        remove
        {
            if (value == null)
            {
                return;
            }


            var synchronizationContext = SynchronizationContext.Current;


            lock (_lock)
            {
                if (_handlersWithContext.TryGetValue(synchronizationContext, out PropertyChangedEventHandler eventHandler))
                {
                    eventHandler -= value;


                    if (eventHandler != null)
                    {
                        _handlersWithContext[synchronizationContext] = eventHandler;
                    }
                    else
                    {
                        _handlersWithContext.Remove(synchronizationContext);
                    }
                }
            }
        }
    }


    protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        KeyValuePair<SynchronizationContext, PropertyChangedEventHandler>[] handlersWithContext;


        lock (_lock)
        {
            handlersWithContext = _handlersWithContext.ToArray();
        }


        var eventArgs = new PropertyChangedEventArgs(propertyName);


        foreach (var handlerWithContext in handlersWithContext)
        {
            var synchronizationContext = handlerWithContext.Key;
            var eventHandler = handlerWithContext.Value;


            synchronizationContext.Post(o => eventHandler(this, eventArgs), null);
        }
    }
}

public class MainViewModel : MultiWindowViewModelBase
{
    private string _text;


    public string Text
    {
        get { return _text; }
        set
        {
            if (_text == value) return;


            _text = value;
            OnPropertyChanged();
        }
    }
}

public sealed partial class MainPage : Page
{
    public MainViewModel ViewModel => App.MainViewModel;


    public MainPage()
    {
        DataContext = ViewModel;


        this.InitializeComponent();


        ApplicationView.GetForCurrentView().Consolidated += ApplicationView_OnConsolidated;
    }


    private void ApplicationView_OnConsolidated(ApplicationView s, ApplicationViewConsolidatedEventArgs e)
    {
        if (e.IsAppInitiated || e.IsUserInitiated)
        {
            s.Consolidated -= ApplicationView_OnConsolidated;


            DataContext = null;


            // this is only required if you are using compiled bindings (x:Bind)
            Bindings.StopTracking();
        }
    }
}