public void AddHandler_Getter_RemoveHandler_Getter_Roundtrips()
{
var list = new EventHandlerList();
// Create two different delegate instances
Action a1 = () => Assert.True(false);
Action a2 = () => Assert.False(true);
Assert.NotSame(a1, a2);
// Neither entry in the list has a delegate
Assert.Null(list["key1"]);
Assert.Null(list["key2"]);
// Add the first delegate to the first entry
list.AddHandler("key1", a1);
Assert.Same(a1, list["key1"]);
Assert.Null(list["key2"]);
// Add the second delegate to the second entry
list.AddHandler("key2", a2);
Assert.Same(a1, list["key1"]);
Assert.Same(a2, list["key2"]);
// Then remove the first delegate
list.RemoveHandler("key1", a1);
Assert.Null(list["key1"]);
Assert.Same(a2, list["key2"]);
// And remove the second delegate
list.RemoveHandler("key2", a2);
Assert.Null(list["key1"]);
Assert.Null(list["key2"]);
}
public void AddHandler_Getter_RemoveHandler_Getter_Roundtrips()
{
var list = new EventHandlerList();
// Create two different delegate instances
Action a1 = () => Assert.True(false);
Action a2 = () => Assert.False(true);
Assert.NotSame(a1, a2);
// Neither entry in the list has a delegate
Assert.Null(list["key1"]);
Assert.Null(list["key2"]);
// Add the first delegate to the first entry
list.AddHandler("key1", a1);
Assert.Same(a1, list["key1"]);
Assert.Null(list["key2"]);
// Add the second delegate to the second entry
list.AddHandler("key2", a2);
Assert.Same(a1, list["key1"]);
Assert.Same(a2, list["key2"]);
// Then remove the first delegate
list.RemoveHandler("key1", a1);
Assert.Null(list["key1"]);
Assert.Same(a2, list["key2"]);
// And remove the second delegate
list.RemoveHandler("key2", a2);
Assert.Null(list["key1"]);
Assert.Null(list["key2"]);
}
public void Dispose_ClearsList()
{
var list = new EventHandlerList();
// Create two different delegate instances
Action a1 = () => Assert.True(false);
Action a2 = () => Assert.False(true);
Assert.NotSame(a1, a2);
// Neither entry in the list has a delegate
Assert.Null(list["key1"]);
Assert.Null(list["key2"]);
for (int i = 0; i < 2; i++)
{
// Add the delegates
list.AddHandler("key1", a1);
list.AddHandler("key2", a2);
Assert.Same(a1, list["key1"]);
Assert.Same(a2, list["key2"]);
// Dispose to clear the list
list.Dispose();
Assert.Null(list["key1"]);
Assert.Null(list["key2"]);
// List is still usable, though, so loop around to do it again
}
}
public void AddHandler_MultipleInSameKey_Getter_CombinedDelegates()
{
var list = new EventHandlerList();
// Create two delegates that will increase total by different amounts
int total = 0;
Action a1 = () => total += 1;
Action a2 = () => total += 2;
// Add both delegates for the same key and make sure we get them both out of the indexer
list.AddHandler("key1", a1);
list.AddHandler("key1", a2);
list["key1"].DynamicInvoke();
Assert.Equal(3, total);
// Remove the first delegate and make sure the second delegate can still be retrieved
list.RemoveHandler("key1", a1);
list["key1"].DynamicInvoke();
Assert.Equal(5, total);
// Remove a delegate that was never in the list; nop
list.RemoveHandler("key1", new Action(() => { }));
list["key1"].DynamicInvoke();
Assert.Equal(7, total);
// Then remove the second delegate
list.RemoveHandler("key1", a2);
Assert.Null(list["key1"]);
}
public void AddHandler_MultipleInSameKey_Getter_CombinedDelegates()
{
var list = new EventHandlerList();
// Create two delegates that will increase total by different amounts
int total = 0;
Action a1 = () => total += 1;
Action a2 = () => total += 2;
// Add both delegates for the same key and make sure we get them both out of the indexer
list.AddHandler("key1", a1);
list.AddHandler("key1", a2);
list["key1"].DynamicInvoke();
Assert.Equal(3, total);
// Remove the first delegate and make sure the second delegate can still be retrieved
list.RemoveHandler("key1", a1);
list["key1"].DynamicInvoke();
Assert.Equal(5, total);
// Remove a delegate that was never in the list; nop
list.RemoveHandler("key1", new Action(() => { }));
list["key1"].DynamicInvoke();
Assert.Equal(7, total);
// Then remove the second delegate
list.RemoveHandler("key1", a2);
Assert.Null(list["key1"]);
}
public void AddHandler_RemoveHandler_Roundtrips()
{
var list = new EventHandlerList();
Action action1 = () => Assert.True(false);
Action action2 = () => Assert.False(true);
// Add the first delegate to the first entry.
list.AddHandler("key1", action1);
Assert.Same(action1, list["key1"]);
Assert.Null(list["key2"]);
// Add the second delegate to the second entry.
list.AddHandler("key2", action2);
Assert.Same(action1, list["key1"]);
Assert.Same(action2, list["key2"]);
// Then remove the first delegate.
list.RemoveHandler("key1", action1);
Assert.Null(list["key1"]);
Assert.Same(action2, list["key2"]);
// And remove the second delegate.
list.RemoveHandler("key2", action2);
Assert.Null(list["key1"]);
Assert.Null(list["key2"]);
}
public static void BindingEvents(Control src, Control dst)
{
if (src == null)
{
throw new ArgumentNullException(nameof(src));
}
if (dst == null)
{
throw new ArgumentNullException(nameof(dst));
}
Type t = typeof(Control);
EventHandlerList srcEvents = (EventHandlerList)t.GetProperty("Events", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(src);
EventHandlerList dstEvents = (EventHandlerList)t.GetProperty("Events", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(dst);
foreach (EventInfo eventInfo in t.GetEvents(BindingFlags.Public | BindingFlags.Instance))
{
if (eventInfo.Name == "Disposed" || eventInfo.Name == "EventControlAdded")
{
continue;
}
FieldInfo fieldInfo = t.GetField("Event" + eventInfo.Name, BindingFlags.NonPublic | BindingFlags.Static)
?? t.GetField("Event" + _suffixReg.Replace(eventInfo.Name, ""), BindingFlags.NonPublic | BindingFlags.Static); //winforms ♥
object field = fieldInfo.GetValue(null);
HandlerRouter router = new HandlerRouter(field, dstEvents, dst, src, eventInfo.Name);
MethodInfo handlerInfo = router.GetType().GetMethod("Invoke", new Type[] { typeof(object), typeof(EventArgs) });
Delegate deleg = Delegate.CreateDelegate(eventInfo.EventHandlerType, router, handlerInfo, true);
//надо создать делегат задано сигнатуры
//Delegate combine = Delegate.Combine(deleg, dstEvents[field]);
srcEvents.AddHandler(field, deleg);
//eventInfo.AddEventHandler(src, deleg);
}
}
public static void BindingConcreteEvents(this Control src, Control dst)
{
if (src == null)
{
throw new ArgumentNullException(nameof(src));
}
if (dst == null)
{
throw new ArgumentNullException(nameof(dst));
}
Type t = typeof(Control);
EventHandlerList srcEvents = (EventHandlerList)t.GetProperty("Events", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(src);
EventHandlerList dstEvents = (EventHandlerList)t.GetProperty("Events", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(dst);
string[] eventNames = { "MouseMove", "MouseDown", "MouseClick", "MouseUp", "MouseCaptureChanged", "KeyDown", "KeyPress", "KeyUp" };
foreach (EventInfo eventInfo in t.GetEvents(BindingFlags.Public | BindingFlags.Instance).Where(e => eventNames.Contains(e.Name)))
{
FieldInfo fieldInfo = t.GetField("Event" + eventInfo.Name, BindingFlags.NonPublic | BindingFlags.Static)
?? t.GetField("Event" + _suffixReg.Replace(eventInfo.Name, ""), BindingFlags.NonPublic | BindingFlags.Static);
object field = fieldInfo.GetValue(null);
if (src.Parent != null && (srcEvents[field]?.GetInvocationList().Any(d => (d.Target as HandlerRouter)?.Destination == src.Parent) ?? false))
{
return;
}
HandlerRouter router = new HandlerRouter(field, dstEvents, dst, src, eventInfo.Name);
MethodInfo handlerInfo = router.GetType().GetMethod("Invoke", new Type[] { typeof(object), typeof(EventArgs) });
Delegate deleg = Delegate.CreateDelegate(eventInfo.EventHandlerType, router, handlerInfo, true);
srcEvents.AddHandler(field, deleg);
}
}
public void AddSectionChangeHandler(string sectionName, ConfigurationChangedEventHandler handler)
{
lock (eventHandlersLock)
{
eventHandlers.AddHandler(CanonicalizeSectionName(sectionName), handler);
}
}
public IHttpActionResult EventHandlerList()
{
EventHandlerList eventHandlers = new EventHandlerList();
eventHandlers.AddHandler("StringProcessorDelegate", x);
return(Json(eventHandlers));
}
public override void OnInvoke(InvocationContext context)
{
Console.WriteLine(context.Method);
MethodInfo method = context.Method as MethodInfo;
if (method.IsSpecialName)
{
if (method.Name.StartsWith("add_"))
{
string name = method.Name.Replace("add_", "");
object key = GetHandlerKey(name);
handlers.AddHandler(key, context.Arguments[0] as Delegate);
OnAddHandler(context, name, key);
}
else if (method.Name.StartsWith("remove_"))
{
string name = method.Name.Replace("remove_", "");
object key = GetHandlerKey(name);
handlers.RemoveHandler(key, context.Arguments[0] as Delegate);
OnRemoveHandler(context, name, key);
}
}
else
{
OnInvokeMethod(context);
}
}
public void RenderCalendar_RenderLevelIsGreateThenOneAndUserSelectorIsFalse_ReturnsCalenderHtmlContent()
{
// Arrange
_calendar = CreateCalendarObject();
_calendar.SelectedDate = DateTime.MinValue;
_calendar.Enabled = false;
_privateObject = new PrivateObject(_calendar);
var stringWriter = new StringWriter();
var output = new HtmlTextWriter(stringWriter);
_privateObject.SetFieldOrProperty("_autoPostBack", true);
ShimControl.AllInstances.EventsGet = (x) =>
{
var eventHandlerList = new EventHandlerList();
CalculationHandler sumHandler = new CalculationHandler(Sum);
eventHandlerList.AddHandler("click", sumHandler);
return(eventHandlerList);
};
// Act
_privateObject.Invoke(RenderCalendar, output);
// Assert
output.ShouldSatisfyAllConditions(
() => output.ShouldNotBeNull(),
() => output.InnerWriter.ShouldNotBeNull()
);
}
public void Resume(string pMethodName)
{
//if (_handlers == null)
// throw new ApplicationException("Events have not been suppressed.");
Dictionary <object, Delegate[]> toRemove = new Dictionary <object, Delegate[]>();
// goes through all handlers which have been suppressed. If we are resuming,
// all handlers, or if we find the matching handler, add it back to the
// control's event handlers
foreach (KeyValuePair <object, Delegate[]> pair in suppressedHandlers)
{
for (int x = 0; x < pair.Value.Length; x++)
{
string methodName = pair.Value[x].Method.Name;
if (pMethodName == null || methodName.Equals(pMethodName))
{
_sourceEventHandlerList.AddHandler(pair.Key, pair.Value[x]);
toRemove.Add(pair.Key, pair.Value);
}
}
}
// remove all un-suppressed handlers from the list of suppressed handlers
foreach (KeyValuePair <object, Delegate[]> pair in toRemove)
{
for (int x = 0; x < pair.Value.Length; x++)
{
suppressedHandlers.Remove(pair.Key);
}
}
//_handlers = null;
}
void AddEventHandler(object key, EventHandler handler)
{
if (events == null)
{
events = new EventHandlerList();
}
events.AddHandler(key, handler);
}
/// <summary>
/// 增加代理
/// </summary>
/// <param name="value"></param>
public void AddHandler(TResponseType rspType, Delegate value)
{
if (value != null)
{
string key = rspType.ToString();
events.AddHandler(key, value);
}
}
private void AddPropertyChanged(DependencyObjectType type, DependencyPropertyChangedEventHandler handler)
{
if (type != doType && !type.IsSubclassOf(doType))
{
throw new ArgumentException();
}
handlers.AddHandler(type, handler);
}
/// <summary>
/// Raises 'Method' action when SymbolPath value changes
/// </summary>
/// <param name="SymbolName">Path of Symbol to poll for value change</param>
/// <param name="Method">Action / method executed on value change</param>
public void SubscribeOnValueChange(string SymbolPath, Action <object> Method)
{
if (_dynamicEvents[SymbolPath] == null)
{
IValueSymbol symbol = (IValueSymbol)_symbolLoader.Symbols[SymbolPath];
symbol.ValueChanged += Symbol_ValueChanged;
_dynamicEvents.AddHandler(symbol.InstancePath, Method);
}
}
public void AddHandlers_Gettable()
{
var list1 = new EventHandlerList();
var list2 = new EventHandlerList();
int total = 0;
Action a1 = () => total += 1;
Action a2 = () => total += 2;
// Add the delegates to separate keys in the first list
list1.AddHandler("key1", a1);
list1.AddHandler("key2", a2);
// Then add the first list to the second
list2.AddHandlers(list1);
// And make sure they contain the same entries
Assert.Same(list1["key1"], list2["key1"]);
Assert.Same(list1["key2"], list2["key2"]);
}
public static bool Subscribe(string eventName, EventHandler handler)
{
if (m_eventList != null)
{
lock (m_eventList)
{
m_eventList.AddHandler(eventName, handler);
}
return(true);
}
return(false);
}
public static void AddEventDelegates(this Control _Target, string _Event, Delegate[] _Delegates)
{
FieldInfo f1 = typeof(Control).GetField("Event" + _Event, BindingFlags.Static | BindingFlags.NonPublic);
object obj = f1.GetValue(_Target);
PropertyInfo pi = _Target.GetType().GetProperty("Events", BindingFlags.NonPublic | BindingFlags.Instance);
EventHandlerList list = (EventHandlerList)pi.GetValue(_Target, null);
foreach (var currDelegate in _Delegates)
{
list.AddHandler(obj, currDelegate);
}
}
/// <summary>
/// 增加代理
/// </summary>
/// <param name="value"></param>
public void AddHandler(TResponseType rspType, Delegate value)
{
if (value != null)
{
string key = rspType.ToString();
events.AddHandler(key, value);
if (!eventsDataList.ContainsKey(key))
{
eventsDataList.Add(key, value);
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//생성 :
//추가 :
//목적 : 기존 버튼 클릭 이벤트 지우고 시작 이벤트 -> 실제 클릭 이벤트 -> 종료 이벤트로 변경해줌
//설명 :
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private void SetButtonEventChange(Control obj)
{
// 메서드 정보를 가져옴
MethodInfo objMethod = this.GetType().GetMethod("get_Events", BindingFlags.NonPublic | BindingFlags.Instance);
// 메서드 정보와 인스턴스를 통해 이벤트 핸들러 목록을 가져옴
EventHandlerList objEventList = objMethod.Invoke(obj, new object[] { }) as EventHandlerList;
// 해당 버튼 클래스에 Control Type을 가져옴
Type objControlType = GetControlType(obj.GetType());
// 필드 정보를 가져옴
FieldInfo objFieldInfo = objControlType.GetField("EventClick", BindingFlags.NonPublic | BindingFlags.Static);
// 필드 정보에서 해당 컨트롤을 지원하는 필드값을 가져옴
object objClickValue = objFieldInfo.GetValue(obj);
// 등록된 델리게이트 이벤트를 가져옴
Delegate delegateButtonClick = objEventList[objClickValue];
// 기존 클릭 이벤트를 지우고 시작 이벤트 -> 실 구현 이벤트 -> 종료 이벤트로 변경해줌
objEventList.RemoveHandler(objClickValue, delegateButtonClick);
objEventList.AddHandler(objClickValue, new EventHandler(SetButtonStartLog));
objEventList.AddHandler(objClickValue, delegateButtonClick);
objEventList.AddHandler(objClickValue, new EventHandler(SetButtonEndLog));
}
public void NullKey()
{
EventHandlerList list = new EventHandlerList();
EventHandler one = new EventHandler(Deleg1);
list.AddHandler(null, one);
EventHandler d = list [null] as EventHandler;
Assert.IsNotNull(d, "NullKey #01");
list.RemoveHandler(null, one);
d = list [null] as EventHandler;
Assert.IsNull(d, "NullKey #02");
}
public void NullKey()
{
EventHandlerList list = new EventHandlerList();
EventHandler one = new EventHandler(Deleg1);
list.AddHandler(null, one);
EventHandler d = list [null] as EventHandler;
Assertion.Assert("NullKey #01", d != null);
list.RemoveHandler(null, one);
d = list [null] as EventHandler;
Assertion.Assert("NullKey #02", d == null);
}
public void Dispose_ClearsList()
{
var list = new EventHandlerList();
// Create two different delegate instances.
Action action1 = () => Assert.True(false);
Action action2 = () => Assert.False(true);
// The list is still usable after disposal.
for (int i = 0; i < 2; i++)
{
// Add the delegates
list.AddHandler("key1", action1);
list.AddHandler("key2", action2);
Assert.Same(action1, list["key1"]);
Assert.Same(action2, list["key2"]);
// Dispose to clear the list.
list.Dispose();
Assert.Null(list["key1"]);
Assert.Null(list["key2"]);
}
}
public void WatchUnityEvent(UnityEventType type, Action action)
{
if (!eventCallers.ContainsKey(type))
{
var newCaller = new EventHandlerList();
newCaller.AddHandler(action);
eventCallers.Add(type, newCaller);
}
else
{
var caller = eventCallers[type];
caller.AddHandler(action);
}
}
/// <summary>
///
/// </summary>
/// <param name="getParameter"></param>
/// <param name="handler"></param>
public void AddChangeHandler(IConfigParameter getParameter, ConfigChangedEventHandler handler)
{
ConfigChangedEventHandler callback = eventHandles[getParameter.GroupName] as ConfigChangedEventHandler;
if (callback == null)
{
lock (eventHandlersLock)
{
callback = eventHandles[getParameter.GroupName] as ConfigChangedEventHandler;
if (callback == null)
{
eventHandles.AddHandler(getParameter.GroupName, handler);
}
}
}
}
public void Resume()
{
if (_handlers == null)
{
throw new ApplicationException("Events have not been suppressed.");
}
foreach (KeyValuePair <object, Delegate[]> pair in _handlers)
{
for (int x = 0; x < pair.Value.Length; x++)
{
_sourceEventHandlerList.AddHandler(pair.Key, pair.Value[x]);
}
}
_handlers = null;
}
public Form1()
{
InitializeComponent();
button1.Click += new EventHandler(button1_Click);
// Get secret click event key
FieldInfo eventClick = typeof(Control).GetField("EventClick", BindingFlags.NonPublic | BindingFlags.Static);
object secret = eventClick.GetValue(null);
// Retrieve the click event
PropertyInfo eventsProp = typeof(Component).GetProperty("Events", BindingFlags.NonPublic | BindingFlags.Instance);
EventHandlerList events = (EventHandlerList)eventsProp.GetValue(button1, null);
Delegate click = events[secret];
// Remove it from button1, add it to button2
events.RemoveHandler(secret, click);
events = (EventHandlerList)eventsProp.GetValue(button2, null);
events.AddHandler(secret, click);
}
private object DoMethodCallInternal(MethodInfo method, object[] parameters)
{
Type retType = method.ReturnType;
if (retType == typeof(string))
{
return("some string");
}
else if (retType == typeof(int))
{
return(32242);
}
if (method.IsSpecialName)
{
int opId = -1;
string name = null;
string[] specialOperations = new string[] { "add_", "remove_" };
for (int i = 0; i < specialOperations.Length; i++)
{
string prefix = specialOperations[i];
if (method.Name.StartsWith(prefix))
{
name = method.Name.Substring(prefix.Length);
opId = i;
break;
}
}
switch (opId)
{
case 0:
// Add Event Handler
eventHandlerList.AddHandler(name, parameters[0] as Delegate);
return(null);
case 1:
// Remove Event Handler
eventHandlerList.RemoveHandler(name, parameters[0] as Delegate);
return(null);
}
}
// Default operation
return(remoteCaller.Call(this, method, parameters));
}
/// <summary>
/// Adds a handler to the specified event.
/// </summary>
/// <param name="key">
/// The event key.
/// </param>
/// <param name="value">
/// The event handler delegate.
/// </param>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="key"/> is <see langword="null"/></para>
/// <para>-or-</para>
/// <para><paramref name="value"/> is <see langword="null"/></para>
/// </exception>
internal void AddEventHandler(object key, Delegate value)
{
if (null == key)
{
throw new ArgumentNullException("key");
}
if (null == value)
{
throw new ArgumentNullException("value");
}
lock (this)
{
if (null == _events)
{
_events = new EventHandlerList();
}
_events.AddHandler(key, value);
}
}
/// <summary>
/// 订阅事件
/// </summary>
/// <param name="handler"></param>
/// <param name="key"></param>
public void Subscribe(EventHandler <T> handler, string key)
{
Handlers.AddHandler(key, handler);
}
public void AddHandlers_Gettable()
{
var list1 = new EventHandlerList();
var list2 = new EventHandlerList();
int total = 0;
Action a1 = () => total += 1;
Action a2 = () => total += 2;
// Add the delegates to separate keys in the first list
list1.AddHandler("key1", a1);
list1.AddHandler("key2", a2);
// Then add the first list to the second
list2.AddHandlers(list1);
// And make sure they contain the same entries
Assert.Same(list1["key1"], list2["key1"]);
Assert.Same(list1["key2"], list2["key2"]);
}
public void Dispose_ClearsList()
{
var list = new EventHandlerList();
// Create two different delegate instances
Action a1 = () => Assert.True(false);
Action a2 = () => Assert.False(true);
Assert.NotSame(a1, a2);
// Neither entry in the list has a delegate
Assert.Null(list["key1"]);
Assert.Null(list["key2"]);
for (int i = 0; i < 2; i++)
{
// Add the delegates
list.AddHandler("key1", a1);
list.AddHandler("key2", a2);
Assert.Same(a1, list["key1"]);
Assert.Same(a2, list["key2"]);
// Dispose to clear the list
list.Dispose();
Assert.Null(list["key1"]);
Assert.Null(list["key2"]);
// List is still usable, though, so loop around to do it again
}
}
