多UI线程访问WPF样式资源问题及解决方案咨询

First, let's break down your problems clearly:

Why All Windows Block When a Modal Dialog is Shown #

All your non-modal windows run on the same UI thread. When you call ShowDialog() for a modal confirmation, it blocks the entire thread's message loop—meaning every window on that thread becomes unresponsive until the dialog closes.

Why the Cross-Thread Resource Exception Happens #

WPF UI objects (including styles, templates, and controls) are thread-affine: they belong exclusively to the thread that created them, and can't be accessed directly from another thread. Your shared styles are loaded in the main thread, so trying to use them in a new UI thread triggers that InvalidOperationException.

Fix 1: Make Shared Resources Accessible to Each UI Thread #

To use multiple UI threads safely, each thread needs its own instance of your shared resource dictionary. Here's how to adjust your code:

Step-by-Step Implementation #

1. Load the shared resource dictionary in each new thread:
   Since your styles live in a separate project, load the dictionary directly in the thread's initialization code. This ensures resources are created in the thread's context, avoiding cross-thread access conflicts.

Thread newWindowThread = new Thread(() =>
{
    // Initialize shared resources for this thread
    var sharedResources = new ResourceDictionary();
    // Replace with your actual resource URI (update assembly name and path as needed)
    sharedResources.Source = new Uri("pack://application:,,,/YourResourceProject;component/SharedStyles.xaml");

    // Create your window and attach the resources
    var newWindow = new YourCustomWindow();
    // Add the shared resources to the window's merged dictionaries
    newWindow.Resources.MergedDictionaries.Add(sharedResources);

    // Set DataContext and other properties
    newWindow.DataContext = new YourViewModel();

    // Show the window and start the thread's dispatcher
    newWindow.Show();
    System.Windows.Threading.Dispatcher.Run();
});

newWindowThread.SetApartmentState(ApartmentState.STA);
newWindowThread.IsBackground = true; // Optional: Let thread exit when the app closes
newWindowThread.Start();

Key Notes: #

• Each thread gets its own copy of the resource dictionary, so styles are owned by the thread that uses them.
• If you plan to open multiple windows in the same thread, load the resources once per thread (e.g., add them to a thread-specific Application instance's resources instead of per window).

Fix 2: Higher-Level Alternative (Avoid Multiple UI Threads) #

Using multiple UI threads adds complexity (cross-thread communication, resource duplication, thread management). A simpler approach is to keep all windows on the main thread, but modify your confirmation logic to only block the parent window, not all windows.

Implement Modeless Confirmation with Parent Window Disabling #

Instead of ShowDialog(), use a modeless confirmation window and disable only its parent until the user responds:

// Call this from the parent window that needs confirmation
void ShowConfirmation()
{
    var confirmationWindow = new ConfirmationDialog();
    confirmationWindow.Owner = this; // Bind the dialog to its parent window
    this.IsEnabled = false; // Disable the parent until confirmation is done

    // Handle dialog closure
    confirmationWindow.Closed += (sender, e) =>
    {
        this.IsEnabled = true; // Re-enable the parent
        if (confirmationWindow.DialogResult == true)
        {
            // User confirmed: execute your intended action
            ExecuteConfirmedAction();
        }
        else
        {
            // User canceled: clean up as needed
        }
    };

    confirmationWindow.Show(); // Show as modeless
}

Benefits of This Approach: #

• No cross-thread resource issues—all windows share the same UI thread and resources.
• Easier communication between windows (no need for Dispatcher.Invoke).
• Only the relevant window is blocked; other non-modal windows remain fully interactive.

Which Approach Should You Choose? #

• Use multiple UI threads if you need truly independent windows that can't block each other (e.g., each window runs a heavy UI task that shouldn't impact others).
• Use the modeless confirmation approach if your main goal is to avoid blocking all windows during confirmations, and you want to keep your codebase simpler and easier to maintain.

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