构造函数异常后引用不为空

Question

I have the following line of code.

Application.Current.MainWindow = new MainWindow();

Placing the constructor on the line the debugger tells me Application.Current.MainWindow is null. The constructor then throws an exception. In the catch block Application.Current.MainWindow is no longer null. The value of Application.Current.MainWindow should not be modified, but it is.

If I instead do:

Window w = new MainWindow();

w is null after the exception is thrown as expected.

What am I missing?

Update

Just calling the constructor for a class that subclasses Window causes Application.Current.MainWindow to change to point to that instance. This occurs even if the constructor throws an exception. This leaves the application in an inconsistent state.

For example, it will then let me call Application.Current.MainWindow.Show, which creates all sorts of issues, because the state of that Window is invalid.

Answer 1

Check out the source of the Application.MainWindow property

Source: http://referencesource.microsoft.com/#PresentationFramework/Framework/System/Windows/Application.cs,cf9c51e402f97b05

public Window MainWindow
{
    get
    {
        VerifyAccess();
        return _mainWindow;
    }

    set
    {
        VerifyAccess();

        //
        // Throw if an attempt is made to change RBW.
        // or we are browser hosted, main window is null, and attempt is made to change RBW.
        //
        if ( ( _mainWindow is RootBrowserWindow )
                ||
            ((BrowserCallbackServices != null ) &&
                ( _mainWindow == null ) &&
                ( !( value is RootBrowserWindow ))) )
        {
            throw new InvalidOperationException( SR.Get( SRID.CannotChangeMainWindowInBrowser ) ) ;
        }

        if (value != _mainWindow)
        {
            _mainWindow = value;
        }
    }
}

This is one point of concern. The other point is that other thread or the framework itself can set it in some other place. Check this comment

By default - MainWindow will be set to the first window opened in the application. However the MainWindow may be set programmatically to indicate "this is my main window". It is a recommended programming style to refer to MainWindow in code instead of Windows[0].

There is no way that runtime can set a reference to a allocated memory before constructor finished. It maybe done as an optimization, but only with a classes that are specific to framework, like System.String .

Edit: Look at Window.Initialize method

private void Initialize()
{
    // AVTempUIPermission avtUIPermission = new AVTempUIPermission(AVTUIPermissionNewWindow.LaunchNewWindows);
    // CASRemoval:avtUIPermission.Demand();

    //  this makes MeasureCore / ArrangeCore to defer to direct MeasureOverride and ArrangeOverride calls
    //  without reading Width / Height properties and modifying input constraint size parameter...
    BypassLayoutPolicies = true;

    // check if within an app && on the same thread
    if (IsInsideApp == true)
    {
        if (Application.Current.Dispatcher.Thread == Dispatcher.CurrentDispatcher.Thread)
        {
            // add to window collection
            // use internal version since we want to update the underlying collection
            App.WindowsInternal.Add(this);
            if (App.MainWindow == null)
            {
                App.MainWindow = this;
            }
        }
        else
        {
            App.NonAppWindowsInternal.Add(this);
        }
    }
}

Specifically at lines:

App.WindowsInternal.Add(this);
if (App.MainWindow == null)
{
    App.MainWindow = this;
}

This is where Window property gets set. And because your MainWindow is derived from Window , this happens before you get to throwing your exception.