Question

The aim is to create an object that contains a number of WPF windows, which would represent a unit that should always be shown together, each Window retaining its own individual responsibilities – say choosing to be laid out on a screen X …

Now because WPF is a single-window architecture, I would like to wrap this list of Windows in a single Window object, so that it could be set as StartupUri, for instance.

• I know I could manually Show() each Window in Application startup, but that is not the point – I need a collection of windows that stick together and which I can easily call upon anywhere in my codebase, knowing I have one class that has taken care of the linkage.
• Not interested in Multiple Document Interface MDI here

I do not know how to implement such an adapter, I tried to override BeginInit, but that did not get called at all.

How to stop Window initialization

public class MultiWindow : Window
{
    private readonly IList<Window> _windows = new List<Window>();

    public void Register(Window window)
    {
        _windows.Add(window);
    }

    public override void BeginInit()
    {
        foreach (var w in _windows)
            w.Show();
        // base.BeginInit();
    }
}

I do not understand Window lifecycle much, is there anyhow I could cancel the initialization and show the list of registered windows instead?

Answer 1

I found a way to do it, which is by making all my windows subclass BaseWindow, for both normal single Window objects and for Window objects actually containing multiple windows.

• Now when you call .Show() it will either show one window or multiple, depending on what is encapsulated in the subclass.

All Window objects should inherit from BaseWindow

public class BaseWindow : Window
{
    
    // Hide default implementation and call BaseShow instead
    public new void Show()
    {
        BaseShow();
    }

    protected virtual void BaseShow()
    {
        base.Show();
    }

    // ... abstract away any additional Window methods and properties required 
}

Override BaseShow()

public class MultiWindow : BaseWindow
{        
    private readonly IList<Window> _windows = new List<Window>();

    public void Register(Window window)
    {
        _windows.Add(window);
    }

    protected override void BaseShow()
    {
        foreach (var w in _windows)
           w.Show();
    }       
}

Set up MultiWindow in application startup

 // First Window object instantiated becomes WPF MainWindow     
 var multiWindow = new MultiWindow();
 multiWindow.Register(new WindowA());
 multiWindow.Register(new WindowB());

Use MultiWindow, but call overriden members through BaseWindow

// Cast down to BaseWindow in order to call the overriden member
var baseWindow = (BaseWindow)Application.Current.MainWindow;
// Show WindowA and WindowB
baseWindow.Show();

P.S. I wish Microsoft employed interfaces throughout .NET, working with IWindow interface rather than the concrete Window class would provide much more power and in this case, also ease-of-implementation.