WPF: Close a secondary window when application shutdown without "programmer" intervention

Question

It's quite hard to explain this in the title, if someone would like to change it it's ok.

I have a situation where, in WPF, I create an "hidden" window which is transparent to the programmer. What I mean is that this window is created in static constructor, hidden and moved outside of the screen and it's width and height are 0. This because I'm using this window to do some interop operations and to allow a sort of handlers for all WndProcs override that someone could require (there is a list of delegates which handles methods that should override WndProc).

In hope that you understand what I've said (it's not easy), my problem is that when I create a WPF project and start it, if I close the Main Window (which is not the one created transparently to the programmer), I want that my application shutdown. However with the code I created this doesn't happen except if I use Application.Current.Shutdown();

Are there any way to fix this without calling that method? I want a transparent way, that other programmers shouldn't even notice (it's a lib, shouldn't change the behaviour of working programs in this way).

Thanks for any suggestion, here you can see some code snippets:

The window created by the lib

public class InteropWindow : Window
{
    public HwndSource Source { get; protected set; }

    private static InteropWindow _Instance;

    static InteropWindow()
    {
        _WndProcs = new LinkedList<WndProcHandler>();
        _Instance = new InteropWindow();
    }

    private static WindowInteropHelper _InteropHelper;
    public static WindowInteropHelper InteropHelper
    {
        get
        {
            if (_InteropHelper == null)
            {
                _InteropHelper = new WindowInteropHelper(_Instance);
                _InteropHelper.EnsureHandle();
            }
            return _InteropHelper;
        }
    }

    public static IntPtr Handle { get { return InteropHelper.Handle; } }

    private InteropWindow()
    {
        Opacity = 0.0;
        //We have to "show" the window in order to obtain hwnd to process WndProc messages in WPF
        Top = -10;
        Left = -10;
        Width = 0;
        Height = 0;
        WindowStyle = WindowStyle.None;
        ShowInTaskbar = false;
        ShowActivated = false;
        Show();
        Hide();
    }

    private static LinkedList<WndProcHandler> _WndProcs;
    public static void AddWndProcHandler(WndProcHandler handler)
    {
        _WndProcs.AddLast(handler);
    }
    public static void RemoveWndProcHandler(WndProcHandler handler)
    {
        _WndProcs.Remove(handler);
    }

    private static IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
    {
        IntPtr result = IntPtr.Zero;
        foreach (WndProcHandler handler in _WndProcs)
        {
            IntPtr tmp = handler(hwnd, msg, wParam, lParam, ref handled);
            if (tmp != IntPtr.Zero)
            {
                if (result != IntPtr.Zero)
                    throw new InvalidOperationException(string.Format("result should be zero if tmp is non-zero:\nresult: {0}\ntmp: {1}", result.ToInt64().ToString(), tmp.ToInt64().ToString()));
                result = tmp;
            }
        }
        return result;
    }

    protected override void OnSourceInitialized(EventArgs e)
    {
        base.OnSourceInitialized(e);
        Source = PresentationSource.FromVisual(this) as HwndSource;
        Source.AddHook(WndProc);
        OnWindowInitialized(null, e);
    }

    protected override void OnClosed(EventArgs e)
    {
        base.OnClosed(e);
        if (Source != null)
            Source.RemoveHook(WndProc);
        OnWindowClosed(null, e);
    }

    private static void OnWindowInitialized(object sender, EventArgs e)
    {
        if (WindowInitialized != null) WindowInitialized(sender, e);
    }

    private static void OnWindowClosed(object sender, EventArgs e)
    {
        if (WindowClosed != null) WindowClosed(sender, e);
    }

    public static event EventHandler WindowInitialized;

    public static event EventHandler WindowClosed;
}

A normal window created with wpf (base window created from project)

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        ExClipboard.ClipboardUpdate += new RoutedEventHandler(ExClipboard_ClipboardUpdate);
        Closed += new EventHandler(MainWindow_Closed);
    }

    private void MainWindow_Closed(object sender, EventArgs e)
    {
        //InteropWindow.Dispose();
        App.Current.Shutdown(0);
    }
}

Update 1:

To answer to your answers, No I would like to avoid any intervetion by programmer using my library, so the ideal solution is that in my lib I subscribe to some Application.Exit event and close my window, obviusly I can't use Application.Exit because the application doesn't close due of my window not closing

Maybe there is a way to calculate all windows that belongs to an application? I can do something with that too

score 3 · Answer 1 · answered Jul 16 '11 at 23:09

3

If you have a main window, can't you set Application.ShutdownMode to OnMainWindowClose ?

The default value is OnLastWindowClose, which is most likely why you're seeing this behaviour.

answered Jul 16 '11 at 23:09

Chris Bednarski

3,364
25
33

score 2 · Accepted Answer · answered Jul 17 '11 at 20:55

2

It's a cheap hack, but I think this may achieve what you're after..

In your lib you will need to reference the xaml dependencies (PresentationCore, PresentationFramework, System.Xaml and WindowsBase)

In the static constructor for your lib, you can then add something like

Application.Current.MainWindow.Closed += new EventHandler(MainWindow_Closed);

static void MainWindow_Closed(object sender, EventArgs e)
{
    Dispose();
}

Where dispose closes your window (_Instance.Close()) and handles any other clean-up calls

answered Jul 17 '11 at 20:55

fatty

2,453
2
25
24

Good job mate, your hack worked greatly, was exactly what I was looking for :) – Francesco Belladonna Jul 18 '11 at 01:10
Set the ShutDownMode in the App.xaml to OnMainWindowClose. – Jesse Seger Sep 27 '12 at 11:21
@JesseSeger The idea (for this case) was to have it handled within the lib, and not rely on end developer intervention. The other answers provided for this question would be the best way to do it normally, but not for this specific case. – fatty Sep 28 '12 at 04:26
Based on the restrictions set out by the asker, where would you trigger that call from? It's been a while since I've thought in .Net - so I would be curious to see if I am something simple. – fatty Sep 28 '12 at 11:21
You can call it from anywhere. In this case, in the MainWindow_Closed. It kills the entire application including all other open windows. – Jesse Seger Oct 02 '12 at 10:55
@JesseSeger - Where would you call it without the MainWindow_Closed, though? The point of this question was how to know when the main application closed from within his library. The only reason I have `Dispose` here (as noted in the answer) is so he can clean stuff up, and only used as an example. Sure, from within the event handler, any method can be used to close stuff on his side - but that's not the point here. I guess I just don't understand the downvote..? – fatty Oct 03 '12 at 07:37

score 1 · Answer 3 · answered Jul 16 '11 at 21:27

Conceptually speaking, the only thing that comes to mind is an event message notification service, in which, the second window is listening or awaiting a message to close and the first window sends a message for it to be closed. This also requires using the MVVM pattern. I'm not sure about this entirely, and I am also not sure if this falls into your idea of not letting other programmers know.

Here is a blog article on it: Sending notifications in WPF MVVM applications

WPF: Close a secondary window when application shutdown without "programmer" intervention

3 Answers3