C# Winform implements that the value of static variable attributes changes, triggers events, and is similar to WPF's two-way binding

In C# WinForms, although there is no built-in two-way binding mechanism like WPF, you can implement similar functions through event and property encapsulation. Specifically, you cansetA custom event is triggered in the accessor and then subscribe to the event where it is needed to perform the corresponding action when the property value changes.

Here is a simple example showing how to implement this functionality:

using System;
 using;

 public static class MyStaticClass
 {
     // Define events
     public static event EventHandler<EventArgs> MyPropertyChanged;

     private static string _myProperty;
     public static string MyProperty
     {
         get { return _myProperty; }
         set
         {
             if (_myProperty != value)
             {
                 _myProperty = value;
                 // Trigger event
                 OnMyPropertyChanged();
             }
         }
     }

     // Method to trigger events
     private static void OnMyPropertyChanged()
     {
         MyPropertyChanged?.Invoke(null, );
     }
 }

 public class MyForm : Form
 {
     private Label myLabel;

     public MyForm()
     {
         myLabel = new Label();
          = "Initial Value";
          = new (10, 10);
         (myLabel);

         // Subscribe to events
          += MyStaticClass_MyPropertyChanged;
     }

     // Event handler
     private void MyStaticClass_MyPropertyChanged(object sender, EventArgs e)
     {
         // When the property value changes, update the Label's text
          = ;
     }

     [STAThread]
     public static void Main()
     {
         ();
         (new MyForm());
     }
 }

Example of usage:
You can modify the value elsewhere, for example:

 = "New Value";

Notes:

• Since MyProperty is static, its values ​​are shared throughout the application lifecycle.
• This method works if you need to share state between multiple forms or controls.

In this way, you can achieve a WPF-like two-way binding effect in WinForms.
The one used here isEventHandler<TEventArgs>generic delegate, whereTEventArgsyesEventArgsType (or derived type). This way of defining already implicitly uses delegates, so there is no need to explicitly define a new delegate type.

What are the benefits if the delegate is explicitly defined?
1. Custom event parameters:
If you need to pass more information (not just sender and EventArgs), you can define a custom event parameter class and define a dedicated delegate for it.

public class MyPropertyChangedEventArgs : EventArgs
 {
     public string OldValue { get; }
     public string NewValue { get; }

     public MyPropertyChangedEventArgs(string oldValue, string newValue)
     {
         OldValue = oldValue;
         NewValue = newValue;
     }
 }

 // Define custom delegates
 public delegate void MyPropertyChangedEventHandler(object sender, MyPropertyChangedEventArgs e);

 // Define events with custom delegates
 public static event MyPropertyChangedEventHandler MyPropertyChanged;

This way, the event handler can receive more information (such as old and new values).

2. Improve code readability:
Explicitly defining delegates can make the code more readable, especially when the purpose of the event is very clear.

public delegate void MyPropertyChangedDelegate(string newValue);

public static event MyPropertyChangedDelegate MyPropertyChanged;

This method expresses the purpose of the event more intuitively.

3. Flexibility:
Custom delegates can define more flexible parameter lists, not limited to the standard mode of object sender, EventArgs e.
For example, you can define an event without the sender parameter:

public delegate void MyPropertyChangedDelegate(string newValue);

public static event MyPropertyChangedDelegate MyPropertyChanged;

Explicitly define delegates

Here is a complete example of explicitly defining a delegate:

using System;
 using;

 public static class MyStaticClass
 {
     // Define custom delegates
     public delegate void MyPropertyChangedDelegate(string newValue);

     // Define events
     public static event MyPropertyChangedDelegate MyPropertyChanged;

     private static string _myProperty;
     public static string MyProperty
     {
         get { return _myProperty; }
         set
         {
             if (_myProperty != value)
             {
                 string oldValue = _myProperty;
                 _myProperty = value;
                 // Trigger event
                 OnMyPropertyChanged(value);
             }
         }
     }

     // Method to trigger events
     private static void OnMyPropertyChanged(string newValue)
     {
         MyPropertyChanged?.Invoke(newValue);
     }
 }

 public class MyForm : Form
 {
     private Label myLabel;

     public MyForm()
     {
         myLabel = new Label();
          = "Initial Value";
          = new (10, 10);
         (myLabel);

         // Subscribe to events
          += MyStaticClass_MyPropertyChanged;
     }

     // Event handler
     private void MyStaticClass_MyPropertyChanged(string newValue)
     {
         // When the property value changes, update the Label's text
          = newValue;
     }

     [STAThread]
     public static void Main()
     {
         ();
         (new MyForm());
     }
 }

Summarize
Benefits of using EventHandler:

• Simple, standardized, suitable for most scenarios.
• .NET-compliant event mode (object sender, EventArgs e).

Benefits of explicitly defining delegates:

• More flexible, customize parameter list.
• Improve code readability and expressivity.
• Suitable for scenarios where more information is needed.

In actual development, which method to choose depends on the specific needs. If it's just a simple notification of value change, using EventHandler is enough; if more complex event parameters or greater flexibility are required, the delegate can be explicitly defined.