WPF应用中跨窗口传递自定义对象的问题及实现方法咨询

Hey there! Let's break down your problem step by step—this accessibility error is super common when passing custom objects between WPF windows, and fixing it is straightforward once you know the root cause.

先解释报错原因：Inconsistent Accessibility #

That error is telling you one simple thing: your custom object class has a more restrictive access level than the window constructor that's receiving it.

For example:

• If your target window's constructor is public (the default for WPF windows), but your custom class is using the default internal access modifier (since C# classes are internal unless marked public), the compiler throws this error. A public method can't accept a parameter type that's only visible internally—external callers wouldn't know what that type is.

最简实现方式（两种可选） #

方式1：构造函数传递（你已经在用的方式，只需调整访问级别） #

This is the simplest fix since you're already using constructor injection for basic types. Here's how to adapt it for custom objects:

1. Make your custom class public (and ensure its properties are public too, so the target window can access them):

   // 自定义对象类 - 必须标记为public
   public class CustomData
   {
       public string Title { get; set; }
       public int Id { get; set; }
       // 其他需要传递的属性
   }
   

2. Update the target window's constructor to accept the public class:

   // 目标窗口的代码文件（比如SecondWindow.xaml.cs）
   public partial class SecondWindow : Window
   {
       // 公开的构造函数，接收自定义对象
       public SecondWindow(CustomData data)
       {
           InitializeComponent();
           // 直接使用传递过来的对象，比如赋值给控件
           TitleTextBlock.Text = data.Title;
           IdTextBlock.Text = data.Id.ToString();
       }
   }
   

3. Pass the object from the source window:

   // 源窗口的代码文件（比如MainWindow.xaml.cs）
   private void OpenSecondWindowBtn_Click(object sender, RoutedEventArgs e)
   {
       // 创建自定义对象实例
       var myData = new CustomData { Title = "Sample Data", Id = 123 };
       // 传递给目标窗口并打开
       var secondWindow = new SecondWindow(myData);
       secondWindow.Show();
   }
   

方式2：使用DataContext（WPF推荐的方式） #

Your question asks if this relates to DataContext—the short answer is the original error doesn't come from DataContext, but DataContext is a cleaner way to pass data in WPF, especially if you want to use data binding in XAML.

Here's how to do it:

1. Follow step 1 above to make your custom class public.
2. Update the target window's constructor to set the DataContext:

   public SecondWindow(CustomData data)
   {
       InitializeComponent();
       // 将自定义对象设为窗口的DataContext
       this.DataContext = data;
   }
   

3. Bind directly to the object's properties in XAML:

   <!-- SecondWindow.xaml -->
   <TextBlock Text="{Binding Title}" FontSize="16" />
   <TextBlock Text="{Binding Id}" Margin="0,5,0,0" />
   

This way, you don't need to manually assign each control's value—WPF handles the binding automatically.

关键注意事项 #

• Access Modifier Consistency: Always match the access levels of your custom class, window constructor, and any properties you need to access. If your windows are only used within your project, you can use internal instead of public—just make sure everything uses the same level.
• Reference Type Behavior: Custom classes are reference types, so modifying the object in the target window will change the original instance in the source window. If you need an independent copy, implement ICloneable or create a deep copy method.
• Avoid Heavy Logic in Constructors: Don't perform complex operations (like database calls) in the window constructor when receiving the object. Use the Loaded event instead to keep your constructor lightweight.
• MVVM Advanced Tip: If you're using MVVM, consider passing a ViewModel instance instead of a raw model object, or use a message-pattern library (like Prism's EventAggregator) for decoupled communication—but that's an advanced step; the constructor/DataContext method is the simplest for basic scenarios.

内容的提问来源于stack exchange，提问作者PawełZQ