IT评测·应用市场-qidao123.com

标题: C# Winform 实现静态变量属性的值变了，触发事件，类似WPF的双向绑定 [打印本页]
作者: 北冰洋以北    时间: 2025-2-12 15:20
标题: C# Winform 实现静态变量属性的值变了，触发事件，类似WPF的双向绑定
在C# WinForms中，虽然没有像WPF那样内置的双向绑定机制，但你可以通过事件和属性封装来实现类似的功能。具体来说，你可以在静态属性的set访问器中触发一个自定义事件，然后在必要的地方订阅这个事件，以便在属性值发生变化时执行相应的操纵。
全局状态的隐患
内存泄漏风险
Form 窗体释放后，记得取消订阅
  1. public void MyForm_Closing(object sender, FormClosingEventArgs e)
  2. {
  3.    //显式取消订阅
  4.    GlobalEvents.SomeGlobalEvent -= HandleEvent;
  5. }
  6. //或者
  7. public void Dispose()
  8. {
  9.    //显式取消订阅
  10.    GlobalEvents.SomeGlobalEvent -= HandleEvent;
  11. }
复制代码
以下是一个简单的示例，展示了如何实现这一功能：
  1. using System;
  2. using System.Windows.Forms;
  4. public static class MyStaticClass
  5. {
  6.     // 定义事件
  7.     public static event EventHandler<EventArgs> MyPropertyChanged;
  9.     private static string _myProperty;
  10.     public static string MyProperty
  11.     {
  12.         get { return _myProperty; }
  13.         set
  14.         {
  15.             if (_myProperty != value)
  16.             {
  17.                 _myProperty = value;
  18.                 // 触发事件
  19.                 OnMyPropertyChanged();
  20.             }
  21.         }
  22.     }
  24.     // 触发事件的方法
  25.     private static void OnMyPropertyChanged()
  26.     {
  27.         MyPropertyChanged?.Invoke(null, EventArgs.Empty);
  28.     }
  29. }
  31. public class MyForm : Form
  32. {
  33.     private Label myLabel;
  35.     public MyForm()
  36.     {
  37.         myLabel = new Label();
  38.         myLabel.Text = "Initial Value";
  39.         myLabel.Location = new System.Drawing.Point(10, 10);
  40.         this.Controls.Add(myLabel);
  42.         // 订阅事件
  43.         MyStaticClass.MyPropertyChanged += MyStaticClass_MyPropertyChanged;
  44.     }
  46.     // 事件处理程序
  47.     private void MyStaticClass_MyPropertyChanged(object sender, EventArgs e)
  48.     {
  49.         // 当属性值变化时，更新Label的文本
  50.         myLabel.Text = MyStaticClass.MyProperty;
  51.     }
  53.     [STAThread]
  54.     public static void Main()
  55.     {
  56.         Application.EnableVisualStyles();
  57.         Application.Run(new MyForm());
  58.     }
  59. }
复制代码
使用示例：
你可以在其他地方修改 MyStaticClass.MyProperty 的值，例如：
  1. MyStaticClass.MyProperty = "New Value";
复制代码
注意事项：
通过这种方式，你可以在WinForms中实现类似WPF的双向绑定结果。
这里使用的是 EventHandler 泛型委托，此中 TEventArgs 是 EventArgs 类型（或派生类型）。这种定义方式已经隐式地使用了委托，因此不必要显式地定义一个新的委托类型。
如果显式定义委托，好处是什么？
1. 自定义事件参数：
如果你必要传递更多信息（不但仅是 sender 和 EventArgs），可以定义一个自定义的事件参数类，并为其定义一个专门的委托。
  1. public class MyPropertyChangedEventArgs : EventArgs
  2. {
  3.     public string OldValue { get; }
  4.     public string NewValue { get; }
  6.     public MyPropertyChangedEventArgs(string oldValue, string newValue)
  7.     {
  8.         OldValue = oldValue;
  9.         NewValue = newValue;
  10.     }
  11. }
  13. // 定义自定义委托
  14. public delegate void MyPropertyChangedEventHandler(object sender, MyPropertyChangedEventArgs e);
  16. // 使用自定义委托定义事件
  17. public static event MyPropertyChangedEventHandler MyPropertyChanged;
复制代码
如许，事件处置处罚步伐可以吸收到更多信息（如旧值和新值）。
2. 提高代码可读性：
显式定义委托可以让代码更具可读性，尤其是当事件的用途非常明白时。
  1. public delegate void MyPropertyChangedDelegate(string newValue);
  3. public static event MyPropertyChangedDelegate MyPropertyChanged;
复制代码
这种方式更直观地表达了事件的用途。
3.灵活性：
自定义委托可以定义更灵活的参数列表，而不但限于 object sender, EventArgs e 的标准模式。
例如，你可以定义一个没有 sender 参数的事件：
  1. public delegate void MyPropertyChangedDelegate(string newValue);
  3. public static event MyPropertyChangedDelegate MyPropertyChanged;
复制代码
显式定义委托

以下是显式定义委托的完备示例：
  1. using System;
  2. using System.Windows.Forms;
  4. public static class MyStaticClass
  5. {
  6.     // 定义自定义委托
  7.     public delegate void MyPropertyChangedDelegate(string newValue);
  9.     // 定义事件
  10.     public static event MyPropertyChangedDelegate MyPropertyChanged;
  12.     private static string _myProperty;
  13.     public static string MyProperty
  14.     {
  15.         get { return _myProperty; }
  16.         set
  17.         {
  18.             if (_myProperty != value)
  19.             {
  20.                 string oldValue = _myProperty;
  21.                 _myProperty = value;
  22.                 // 触发事件
  23.                 OnMyPropertyChanged(value);
  24.             }
  25.         }
  26.     }
  28.     // 触发事件的方法
  29.     private static void OnMyPropertyChanged(string newValue)
  30.     {
  31.         MyPropertyChanged?.Invoke(newValue);
  32.     }
  33. }
  35. public class MyForm : Form
  36. {
  37.     private Label myLabel;
  39.     public MyForm()
  40.     {
  41.         myLabel = new Label();
  42.         myLabel.Text = "Initial Value";
  43.         myLabel.Location = new System.Drawing.Point(10, 10);
  44.         this.Controls.Add(myLabel);
  46.         // 订阅事件
  47.         MyStaticClass.MyPropertyChanged += MyStaticClass_MyPropertyChanged;
  48.     }
  50.     // 事件处理程序
  51.     private void MyStaticClass_MyPropertyChanged(string newValue)
  52.     {
  53.         // 当属性值变化时，更新Label的文本
  54.         myLabel.Text = newValue;
  55.     }
  57.     [STAThread]
  58.     public static void Main()
  59.     {
  60.         Application.EnableVisualStyles();
  61.         Application.Run(new MyForm());
  62.     }
  63. }
复制代码
总结
使用 EventHandler 的好处：
显式定义委托的好处：
在现实开发中，选择哪种方式取决于具体需求。如果只是简单的值变化关照，使用 EventHandler 就充足了；如果必要更复杂的事件参数或更高的灵活性，则可以显式定义委托。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/) Powered by Discuz! X3.4