防止事件通过删除和恢复的事件处理程序处理

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); 
    } 
}