app.xaml.cs与MainViewmodel通讯出现问题

Question

I've following code in my wpf App.xaml.cs file:

 void App_DispatcherUnhandledException(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
        {
            var mainVM = MainWindowViewModel.Instance;
            mainVM.DisplayMessage = string.Format("Something went wrong and it has been logged...If the problem persists, please contact {0}.", mainVM.NotificationsReceiver);
            mainVM.DisplayMessageForegroundColor = "Red";

        e.Handled = true;
    }

MainWindowViewModel.cs

public string DisplayMessage
        {
            get
            {
                return m_displayMessage;
            }
            set
            {
                m_displayMessage = value;
                OnPropertyChanged("DisplayMessage");

            }
        }

        public string DisplayMessageForegroundColor
        {
            get
            {
                return m_displayMessageForegroundColor;
            }
            set
            {
                m_displayMessageForegroundColor = value;
                OnPropertyChanged("DisplayMessageForegroundColor");

            }
        }

MainWindow.xaml

 <Label Content="{Binding DisplayMessage}" Foreground="{Binding DisplayMessageForegroundColor}" Grid.Column="1" HorizontalAlignment="Left" Height="33" Margin="14,660,0,0" Grid.Row="1" 
           VerticalAlignment="Top" Width="693" Grid.ColumnSpan="3"/>

But this does not seem to work.Although the method in app.xaml.cs is getting invoked, I dont see the error getting displayed message on the UI.What could be wrong here please? (I'm able to see the message when I set the DisplayMessage and DisplayMessageForegroundColor properties from within MainWindowViewModel though).

Please advise.

Thanks.

Answer 1

The problem is that you wrote a singleton viewmodel, with a singleton Instance , but then you don't use it. Instead you create a new different instance of the viewmodel in your XAML:

<Window.DataContext>
    <MainViewModel:MainWindowViewModel />
</Window.DataContext>

That creates a new instance of MainWindowViewModel . If your XAML has <TextBox .../> , do you think there's only one TextBox in the world and you're just putting it in a new place? Of course not. You're creating a new TextBox . The same goes for any other XAML element.

The fix is easy: First, remove that Window.DataContext element that I quoted above.

Then assign the static singleton viewmodel to the DataContext instead:

<Window
    ...etc...
    xmlns:MainViewModel="clr-namespace:Whatever.Namespace.YourViewModel.IsIn"
    DataContext="{x:Static MainViewModel:MainWindowViewModel.Instance}"
    ...etc...
    >

Or:

<Window.DataContext>
    <x:StaticExtension 
        Member="MainViewModel:MainWindowViewModel.Instance" />
</Window.DataContext>

<x:StaticExtension ... is the same thing as {x:Static... . System.Windows.Markup.StaticExtension is subclass of MarkupExtension . If one of those has the Extension suffix on the class name, XAML allows you to leave out that part of the name when you use it as a markup extension between curly braces. Try this; it'll work:

DataContext="{x:StaticExtension MainViewModel:MainWindowViewModel.Instance}"

Same thing. Binding ( System.Windows.Data.Binding ) is a MarkupExtension as well. That's why you can create one with curly braces in an attribute value in XAML:

<TextBox Text="{Binding Foo}" />

Text="{Binding Foo}" creates an instance of System.Windows.Data.Binding . But Binding doesn't have the Extension suffix on the class name. That's not a requirement, it's just a convenience XAML offers if you feel like using it.

Take-away: Whenever you see Property="{Identifier ...}" in XAML, Identifier is a class derived from System.Windows.Markup.MarkupExtension . Its actual name may be either Identifier or IdentifierExtension , and that curly brace thing is creating and initializing an instance of it.

OK, back to your bug.

Let's learn from it.

When you try to write a singleton class, you need to prevent other classes from creating instances of it, so you don't end up with stuff like this. The easiest and best way to do that is to make MainWindowViewModel 's constructor private:

public class MainWindowViewModel : ViewModelBaseOrWhatever
{
    //  If MainWindowViewModel has no public constructors, no other class can create an 
    //  instance of it. This is a requirement you need to enforce, so and you can make 
    //  the compiler enforce it for you. If you had done this, the compiler would have 
    //  found this bug for you as soon as you wrote it. 
    private MainWindowViewModel()
    {
        //  ...whatever...
    }

    static MainWindowViewModel()
    {
        Instance = new MainWindowViewModel();
    }

    public static MainWindowViewModel Instance { get; private set; }
}

Singletons

On the subject of singleton classes, it's wise to enforce their singleton nature by making the constructor private, and creating Instance in the static constructor:

private MySingletonViewModel()
{
    //  stuff
}

public static MySingletonViewModel Instance { get; private set; }

//  Static constructor
static MySingletonViewModel()
{
    Instance = new MySingletonViewModel();
}

When you do that, the compiler is in on the plan and it won't let you accidentally create a second instance:

Here, the compiler will complain:

'MySingletonViewModel.MySingletonViewModel()' is inaccessible due to its protection level.

The first time you see that you'll say "huh?!", but that's true of most error messages.

public SomeOtherClass() 
{
    var x = new MySingletonViewModel();
}