WPF多窗口交互疑问：子窗口直接交互是否违反设计原则？

好问题！咱们一步步拆解你的疑问，给出更符合设计规范的解决方案：

一、直接让CW1和CW2交互是否违反设计原则？ #

是的，这种直接交互会带来高耦合的问题，违反了几个核心的面向对象设计原则：

• 单一职责原则：ChildWindow1原本只需要处理自身的UI逻辑，现在还要操心ChildWindow2如何使用它的MyClass；同理ChildWindow2也依赖于ChildWindow1的内部实现，职责边界变得模糊。
• 依赖倒置原则：ChildWindow2直接依赖具体的ChildWindow1类，而非抽象的服务接口。后续如果要替换ChildWindow1的实现（比如迭代成ChildWindow1V2），ChildWindow2的代码必须同步修改。
• 可维护性与可测试性下降：测试ChildWindow2时，你必须先实例化ChildWindow1和它的MyClass，大幅增加了测试复杂度；后续修改MyClass的接口，两个窗口都要同步调整。

简单来说，这种做法会让你的窗口之间形成紧密的依赖网，项目规模越大，后续维护成本越高。

二、除了直接调用/订阅，还有哪些交互方式？ #

下面是几种更符合设计原则的WPF常用方案，按复杂度和适用场景排序：

1. 主窗口作为轻量协调者（折中方案） #

如果你不想引入复杂模式或框架，可以让主窗口做中间转发者，但要注意主窗口只负责传递引用或事件，不处理业务逻辑。这种方式比直接交互更清晰，也保持了子窗口的解耦：

// MainWindow中保存共享的MyClass引用
public partial class MainWindow : Window
{
    ChildWindow1 CW1;
    ChildWindow2 CW2;
    private MyClass _sharedMyClass;

    private void btnButton1_Click(object sender, RoutedEventArgs e)
    {
        CW1 = new ChildWindow1();
        CW1.Show();
        CW1.Owner = this;
        // 获取ChildWindow1的MyClass实例
        _sharedMyClass = CW1.MyObject;

        // 把实例传递给ChildWindow2
        CW2 = new ChildWindow2(_sharedMyClass);
        CW2.Show();
        CW2.Owner = this;
    }
}

// ChildWindow2通过构造函数接收MyClass实例
public partial class ChildWindow2 : Window
{
    private MyClass _myClass;

    public ChildWindow2(MyClass myClass)
    {
        InitializeComponent();
        _myClass = myClass;
        // 直接调用方法或订阅事件
        _myClass.DoSomethingCompleted += OnActionCompleted;
    }

    private void OnActionCompleted()
    {
        // 处理MyClass的事件回调
    }
}

2. 中介者模式（Mediator Pattern） #

创建一个专门的中介类作为所有窗口的通信枢纽，窗口之间不直接引用，只通过中介传递信息或请求服务。这种方式彻底解耦子窗口，适合窗口较多、交互复杂的场景：

// 中介类，负责协调窗口间的所有交互
public class WindowMediator
{
    private MyClass _sharedMyClass;

    // 让ChildWindow1注册它的MyClass实例
    public void RegisterMyClass(MyClass myClass)
    {
        _sharedMyClass = myClass;
    }

    // 让ChildWindow2获取共享实例
    public MyClass GetMyClass()
    {
        return _sharedMyClass;
    }

    // 也可以提供事件转发能力，统一管理事件
    public event Action MyClassActionCompleted;

    public void TriggerMyClassActionCompleted()
    {
        MyClassActionCompleted?.Invoke();
    }
}

// MainWindow中实例化中介并传递给子窗口
public partial class MainWindow : Window
{
    private WindowMediator _mediator = new WindowMediator();
    ChildWindow1 CW1;
    ChildWindow2 CW2;

    private void btnButton1_Click(object sender, RoutedEventArgs e)
    {
        CW1 = new ChildWindow1(_mediator);
        CW1.Show();
        CW1.Owner = this;

        CW2 = new ChildWindow2(_mediator);
        CW2.Show();
        CW2.Owner = this;
    }
}

// ChildWindow1通过中介注册MyClass并转发事件
public partial class ChildWindow1 : Window
{
    public MyClass MyObject = new MyClass();
    private WindowMediator _mediator;

    public ChildWindow1(WindowMediator mediator)
    {
        InitializeComponent();
        _mediator = mediator;
        _mediator.RegisterMyClass(MyObject);
        // 将MyClass的事件转发到中介
        MyObject.DoSomethingCompleted += () => _mediator.TriggerMyClassActionCompleted();
    }
}

// ChildWindow2通过中介获取实例或订阅事件
public partial class ChildWindow2 : Window
{
    private WindowMediator _mediator;
    private MyClass _myClass;

    public ChildWindow2(WindowMediator mediator)
    {
        InitializeComponent();
        _mediator = mediator;
        _myClass = _mediator.GetMyClass();
        // 订阅中介转发的事件
        _mediator.MyClassActionCompleted += OnActionCompleted;
    }

    private void OnActionCompleted()
    {
        // 处理回调逻辑
    }
}

3. 依赖注入（DI） #

如果你的项目已经使用依赖注入框架（比如Microsoft.Extensions.DependencyInjection、Autofac），可以把MyClass注册为单例服务，让ChildWindow1和ChildWindow2通过构造函数注入获取同一个实例，彻底消除窗口间的依赖：

// 应用启动时注册服务
var services = new ServiceCollection();
// 注册MyClass为单例，确保所有地方拿到同一个实例
services.AddSingleton<MyClass>();
services.AddTransient<ChildWindow1>();
services.AddTransient<ChildWindow2>();
var serviceProvider = services.BuildServiceProvider();

// MainWindow中通过DI获取子窗口
public partial class MainWindow : Window
{
    private IServiceProvider _serviceProvider;
    ChildWindow1 CW1;
    ChildWindow2 CW2;

    public MainWindow(IServiceProvider serviceProvider)
    {
        InitializeComponent();
        _serviceProvider = serviceProvider;
    }

    private void btnButton1_Click(object sender, RoutedEventArgs e)
    {
        CW1 = _serviceProvider.GetRequiredService<ChildWindow1>();
        CW1.Show();
        CW1.Owner = this;

        CW2 = _serviceProvider.GetRequiredService<ChildWindow2>();
        CW2.Show();
        CW2.Owner = this;
    }
}

// ChildWindow1通过构造函数注入MyClass
public partial class ChildWindow1 : Window
{
    public MyClass MyObject { get; }

    public ChildWindow1(MyClass myClass)
    {
        InitializeComponent();
        MyObject = myClass;
    }
}

// ChildWindow2同样注入MyClass直接使用
public partial class ChildWindow2 : Window
{
    private MyClass _myClass;

    public ChildWindow2(MyClass myClass)
    {
        InitializeComponent();
        _myClass = myClass;
        _myClass.DoSomethingCompleted += OnActionCompleted;
    }

    private void OnActionCompleted()
    {
        // 处理事件
    }
}

4. 事件聚合器（Event Aggregator） #

如果你的交互以事件驱动为主，可以使用事件聚合器（比如Prism库中的IEventAggregator）。MyClass或ChildWindow1发布事件，ChildWindow2订阅事件，双方无需直接引用，只依赖事件定义和聚合器：

// 定义事件类
public class MyClassDoSomethingCompletedEvent : PubSubEvent { }

// ChildWindow1中发布事件
public partial class ChildWindow1 : Window
{
    private IEventAggregator _eventAggregator;
    public MyClass MyObject = new MyClass();

    public ChildWindow1(IEventAggregator eventAggregator)
    {
        InitializeComponent();
        _eventAggregator = eventAggregator;
        // 当MyClass完成操作时发布事件
        MyObject.DoSomethingCompleted += () => 
            _eventAggregator.GetEvent<MyClassDoSomethingCompletedEvent>().Publish();
    }
}

// ChildWindow2中订阅事件
public partial class ChildWindow2 : Window
{
    public ChildWindow2(IEventAggregator eventAggregator)
    {
        InitializeComponent();
        // 订阅事件并处理回调
        eventAggregator.GetEvent<MyClassDoSomethingCompletedEvent>().Subscribe(() => 
            MessageBox.Show("MyClass完成了操作！"));
    }
}

内容的提问来源于stack exchange，提问作者Dirty