防止事件通過刪除和恢復的事件處理程序處理

Question

常常有必要防止一些控件的事件設置時的處理是一樣的複選框或單選按鈕等。爲了實現這一目標代碼的特性，我用的是下面的幫助：

public static class PropertySetter 
{ 
    private static readonly object locker = new object(); 

    public static object CurrentObject { get; private set; } 

    public static string CurrentPropertyName { get; private set; } 

    public static void SetValueFor(this object obj, string propertyName, object value) 
    { 
     if (obj == null) { throw new ArgumentNullException("obj"); } 
     if (string.IsNullOrEmpty(propertyName) == true) { throw new ArgumentNullException("'propertyName"); } 

     PropertyInfo propertyInfo = obj.GetType().GetProperty(propertyName); 

     if (propertyInfo == null) 
     { 
      throw new ArgumentOutOfRangeException("propertyName", "Property not found."); 
     } 

     lock (locker) 
     { 
      CurrentObject = obj; 
      CurrentPropertyName = propertyName; 
      try 
      { 
       propertyInfo.SetValue(obj, value, null); 
      } 
      catch (Exception) 
      { 
       throw; 
      } 
      finally 
      { 
       CurrentObject = null; 
       CurrentPropertyName = null; 
      } 
     } 
    } 

    public static bool CanHandleEventFor(this object obj, string propertyName) 
    { 
     return object.ReferenceEquals(obj, CurrentObject) == false && CurrentPropertyName.Equals(propertyName) == false; 
    } 
} 

用法：

checkBox.SetValueFor("Checked", false); 

void checkBox_Checked(object sender, EventArgs e) 
{ 
    if (sender.CanHandleEventFor("Checked")) return; 

    // ... 
} 

但是我thougt或許有不寫if事件處理程序中，而是由要麼分離爲一些事件的所有事件處理程序傳遞給它的名字作爲additinal參數或者更好的辦法事件字段本身和屬性設置後重新附加它們。這甚至可能嗎？

Answer 1

我終於設法解決這個問題：

class Program 
{ 
    static void Main(string[] args) 
    { 
     var fc = new TestCheckbox(); 
     fc.CheckedChanged += (sender, e) => 
     { 
      int i = 0; 
     }; 

     // 'CheckedChanged' event is not raised. 
     fc.SetValueFor(x => x.Checked = true, "CheckedChanged"); 

     // 'CheckedChanged' event it raised. 
     fc.Checked = false; 
    } 
} 

class TestCheckbox 
{ 
    private bool _checked; 

    public event EventHandler CheckedChanged; 

    public bool Checked 
    { 
     get { return _checked; } 
     set 
     { 
      _checked = value; 
      if (CheckedChanged != null) 
      { 
       CheckedChanged(this, EventArgs.Empty); 
      } 
     } 
    } 
} 

public static class PropertySetter 
{ 
    private static readonly object locker = new object(); 

    public static void SetValueFor<T>(this T obj, Action<T> action, string eventName) 
    { 
     lock (locker) 
     { 
      try 
      { 
       // Get event handlers. 
       Type type = obj.GetType(); 
       var eventInfo = type.GetEvent(eventName); 
       var fieldInfo = type.GetField(eventName, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic); 
       var multicastDelegate = fieldInfo.GetValue(obj) as MulticastDelegate; 
       Delegate[] delegates = multicastDelegate.GetInvocationList(); 

       // Remove event handlers. 
       foreach (var item in delegates) 
       { 
        eventInfo.RemoveEventHandler(obj, item); 
       } 

       try 
       { 
        action(obj); 
       } 
       catch (Exception) 
       { 
        throw; 
       } 
       finally 
       { 
        // Restore event handlers. 
        foreach (var item in delegates) 
        { 
         eventInfo.AddEventHandler(obj, item); 
        } 
       } 
      } 
      catch (Exception) 
      { 
       throw; 
      } 
     } 
    } 
} 

不幸的是這隻能在理論和因爲每個事件沒有專屬領域根本不是那麼容易.NET，它需要一些hacking所以我我會堅持最簡單的解決方案，這是我認爲的：

class Program 
{ 
    static void Main(string[] args) 
    { 
     CheckBox checkBox = new CheckBox(); 
     checkBox.CheckedChanged += (sender, e) => 
     { 
      if (!sender.CanHandleEvent("CheckedChanged")) return; 
      int i = 0; 
     }; 

     checkBox.SetValueFor(x => x.Checked = true, "CheckedChanged"); 
     checkBox.Checked = false; 
    } 
}  

public static class PropertySetter 
{ 
    private static readonly object locker = new object(); 

    public static object CurrentObject { get; private set; } 

    public static string CurrentEventName { get; private set; } 

    public static void SetValueFor<T>(this T obj, Action<T> action, string eventName) 
    { 
     lock (locker) 
     { 
      CurrentObject = obj; 
      CurrentEventName = eventName; 
      try 
      { 
       action(obj); 
      } 
      catch (Exception) 
      { 
       throw; 
      } 
      finally 
      { 
       CurrentObject = null; 
       CurrentEventName = null; 
      } 
     } 
    } 

    public static bool CanHandleEvent(this object obj, string eventName) 
    { 
     return !(object.ReferenceEquals(obj, CurrentObject) == true && CurrentEventName.Equals(eventName) == true); 
    } 
}