public static bool Contains(this System.Delegate del, System.Type type, string methodName)
{
bool contains = false;
if (del != null && del.GetInvocationList() != null)
{
contains = !System.Array.TrueForAll(del.GetInvocationList(), invoker => invoker.Method.DeclaringType != type && invoker.Method.Name != methodName);
}
return(contains);
}
static internal void ExecuteAndSendResult(Binder binder, System.Delegate callback, object[] arguments, double id, bool execute, bool isDynamic)
{
object result = null;
if (execute)
{
if (!isDynamic)
{
foreach (var invocation in callback.GetInvocationList())
{
result = invocation.Method.Invoke(invocation.Target, arguments);
}
}
else
{
result = callback.DynamicInvoke(arguments);
}
if (result != null && id != 0)
{
binder.Return(id, result);
}
}
else
{
binder.SendError();
}
}
// Token: 0x06001860 RID: 6240
// RVA: 0x00014E5C File Offset: 0x0001305C
private static void ValidateCallback(Delegate delegate_0)
{
if (delegate_0 != null && delegate_0.GetInvocationList().Length > 1)
{
throw new NotSupportedException("SmartThreadPool doesn't support delegates chains");
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <param name="event"></param>
internal static void OnEvent(object sender, EventArgs e, System.Delegate @event)
{
bool eventFired = false;
if (@event != null)
{
foreach (System.Delegate singleCast in @event.GetInvocationList())
{
eventFired = false;
try {
ISynchronizeInvoke syncInvoke = (ISynchronizeInvoke)singleCast.Target;
if (syncInvoke != null && syncInvoke.InvokeRequired)
{
eventFired = true;
syncInvoke.BeginInvoke(singleCast, new object[] { sender, e });
}
else
{
eventFired = true;
singleCast.DynamicInvoke(new object[] { sender, e });
}
}
catch (System.Reflection.TargetInvocationException ex) {
if (!eventFired)
{
singleCast.DynamicInvoke(new object[] { sender, e });
}
Debug.Print("OnEvent: " + ex.InnerException.Message);
}
}
}
}
public void Dump(MainLoopEvent mainloopevent)
{
#if UNITY_EDITOR
var en = this.callbackMap.GetEnumerator();
while (en.MoveNext())
{
Action <object, int> act = en.Current.Value;
if (act != null && callbackListMap[en.Current.Key].Count > 0)
{
System.Delegate d = act as System.Delegate;
Delegate[] delegates = d.GetInvocationList();
for (int i = 0; i < delegates.Length; ++i)
{
LogMgr.LogWarningFormat(" InstanceCacheDelegate {0} in {1} not clear at {2}", delegates[i].Method.Name, delegates[i].Method.DeclaringType, mainloopevent);
}
}
}
var listen = this.callbackListMap.GetEnumerator();
while (listen.MoveNext())
{
List <object> list = listen.Current.Value;
if (list != null && list.Count > 0)
{
for (int i = 0; i < list.Count; ++i)
{
object o = list[i];
LogMgr.LogWarningFormat("InstanceCacheDelegate {0} not clear at {1}", o, mainloopevent);
}
}
}
#endif
}
/// <summary>
/// Invokes a method delegate asynchrounously and thread safe.
/// </summary>
/// <param name="method">The delegate method to invoke</param>
/// <param name="args">The arguments passed to the delegate.</param>
public static void Invoke(Delegate method, object[] args)
{
if (method != null)
{
foreach (Delegate handler in method.GetInvocationList())
{
if (handler.Target is Control)
{
Control target = handler.Target as Control;
if (target.IsHandleCreated)
{
target.BeginInvoke(handler, args);
}
}
else if (handler.Target is ISynchronizeInvoke)
{
ISynchronizeInvoke target = handler.Target as ISynchronizeInvoke;
target.BeginInvoke(handler, args);
}
else
{
handler.DynamicInvoke(args);
}
}
}
}
private static void AddTaskDelay(Delegate ev, object[] paramArray, int time)
{
System.Threading.Thread.Sleep(time);
bool bFired;
if (ev != null)
{
foreach (Delegate singleCast in ev.GetInvocationList())
{
bFired = false;
try
{
ISynchronizeInvoke syncInvoke = (ISynchronizeInvoke)singleCast.Target;
if (syncInvoke != null && syncInvoke.InvokeRequired)
{
bFired = true;
syncInvoke.BeginInvoke(singleCast, paramArray);
}
else
{
bFired = true;
singleCast.DynamicInvoke(paramArray);
}
}
catch (Exception)
{
if (!bFired)
singleCast.DynamicInvoke(paramArray);
}
}
}
}
public static void DispatchEvent(object source, string eventName, EventArgs eventArgs)
{
EventInfo eventObject = source.GetType().GetEvent(eventName);
if (eventObject != null)
{
IEnumerable <FieldInfo> fis = source.GetType().GetRuntimeFields();
foreach (FieldInfo fi in fis)
{
if (fi.Name == eventName + "Event")
{
System.Delegate del = fi.GetValue(source) as System.Delegate;
List <System.Delegate> invocationList = del.GetInvocationList().ToList();
foreach (System.Delegate invItem in invocationList)
{
invItem.DynamicInvoke(source, eventArgs);
}
}
}
}
}
static void DisplayDelegateInfo(Delegate delObj)
{
foreach (Delegate d in delObj.GetInvocationList())
{
Console.WriteLine("Method name: {0}", d.Method);
Console.WriteLine("Type name: {0}", d.Target);
}
}
private void ReadDelegate( Delegate delObj )
{
foreach (Delegate del in delObj.GetInvocationList())
{
Console.WriteLine("Method {0}", del.Method);
Console.WriteLine("Target {0}", del.Target);
}
}
public static void DisplayDelegateInfo(Delegate del)
{
foreach (var item in del.GetInvocationList())
{
Console.WriteLine("Method Name {0}", del.Method);
Console.WriteLine("Type Name {0}", del.Target);
}
}
public static Delegate[] GetDelegateList(Delegate del)
{
if(del == null) {
throw new ArgumentNullException("del");
}
return del.GetInvocationList();
}
static void DisplayDelegateInfo(Delegate delObj)
{
//print the names of each member in the delegates invocation list
foreach (Delegate d in delObj.GetInvocationList())
{
Console.WriteLine("Method Name: {0}", d.Method);
Console.WriteLine("Type Name: {0}", d.Target);
}
}
public static void GetDelegateDetails(Delegate d)
{
foreach (Delegate dg in d.GetInvocationList())
{
Console.WriteLine("Type is {0}",dg.GetType());
Console.WriteLine("Method is {0}",dg.Method);
Console.WriteLine("target is {0}",dg.Target);
}
}
private static void Handle(Delegate del, PacketHandlerEventArgs args, params object[] parameters)
{
if (del != null)
foreach (Delegate d in del.GetInvocationList())
{
bool? result = (bool?)d.Method.Invoke(d.Target, parameters);
if (result.HasValue)
args.Block = result.Value;
}
}
public int CountTotalEmployee()
{
int total = 0;
foreach (System.Delegate i in allDelegates.GetInvocationList())
{
total += (int)i.DynamicInvoke();
}
return(total);
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="d">The delegate the info object should be created for.</param>
public DelegateMetadata(Delegate d)
{
Requires.NotNull(d, nameof(d));
_delegate = d;
_delegateType = d.GetType();
var list = d.GetInvocationList();
_targets = list.Select(info => info.Target).ToArray();
_methods = list.Select(info => info.Method).ToArray();
}
public int CountTotalEmployees()
{
int totalEmployees = 0;
foreach (System.Delegate calculate in allDelegate.GetInvocationList())
{
totalEmployees += (int)calculate.DynamicInvoke();
}
return(totalEmployees);
}
private static dynamic Cast(Delegate source, Type type)
{
Delegate[] delegates = source.GetInvocationList();
if (delegates.Length == 1)
return Delegate.CreateDelegate(type,
delegates[0].Target, delegates[0].Method);
Delegate[] delegatesDest = new Delegate[delegates.Length];
for (int nDelegate = 0; nDelegate < delegates.Length; nDelegate++)
delegatesDest[nDelegate] = Delegate.CreateDelegate(type,
delegates[nDelegate].Target, delegates[nDelegate].Method);
return Delegate.Combine(delegatesDest);
}
static public int GetInvocationList(IntPtr l)
{
try {
System.Delegate self = (System.Delegate)checkSelf(l);
var ret = self.GetInvocationList();
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
//////// - Nguyễn Việt Dũng : Anh em chú ý nhé. (BỎ COMMENT RA KHI MUỐN BIẾT SỰ KIỆN PHÁT SINH TỪ ĐÂU) - ////////////
string LogEvent(System.Delegate _event)
{
if (_event == null)
{
return("");
}
string strDebug = "Event: " + _event.ToString() + " ->\n";
foreach (System.Delegate _delegate in _event.GetInvocationList())
{
strDebug += "" + _delegate.Method.ReflectedType.Name + " : " + _delegate.Method.Name + "\n";
}
return(strDebug);
}
/// <summary>
/// Invokes every delegate method in new thread (except synchronized handlers).
/// </summary>
/// <param name="handler"></param>
/// <param name="parameters"></param>
public static void InvokeAsync(Delegate handler, params object[] parameters)
{
if (handler != null) {
foreach (Delegate d in handler.GetInvocationList()) {
ISynchronizeInvoke sync = d.Target as ISynchronizeInvoke;
if (sync != null) {
sync.BeginInvoke(d, parameters);
}
else {
ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncInvokeProc), new AsyncInvokeArgs(d.Method, d.Target, parameters));
}
}
}
}
public static void RaiseEventOnUIThread(Delegate theEvent, object[] args)
{
foreach (Delegate d in theEvent.GetInvocationList())
{
ISynchronizeInvoke syncer = d.Target as ISynchronizeInvoke;
if (syncer == null)
{
d.DynamicInvoke(args);
}
else
{
syncer.BeginInvoke(d, args); // cleanup omitted
}
}
}
static int GetInvocationList(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 1);
System.Delegate obj = (System.Delegate)ToLua.CheckObject <System.Delegate>(L, 1);
System.Delegate[] o = obj.GetInvocationList();
ToLua.Push(L, o);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
public static MethodInfo[] GetMethodList(Delegate del)
{
if(del == null) {
throw new ArgumentNullException("del");
}
Delegate[] delegates = del.GetInvocationList();
MethodInfo[] methods = new MethodInfo[delegates.Length];
for(int i = 0; i < delegates.Length; i++) {
methods[i] = delegates[i].Method;
}
return methods;
}
public static void Invoke(Delegate handler, params object[] parameters)
{
if (handler != null) {
foreach (Delegate d in handler.GetInvocationList()) {
ISynchronizeInvoke sync = d.Target as ISynchronizeInvoke;
if (sync != null && sync.InvokeRequired) {
// I need to call this asynchrounously because it caused deadlocks
sync.BeginInvoke(d, parameters);
}
else {
d.Method.Invoke(d.Target, parameters);
}
}
}
}
public static void CallAsyncMethod(Delegate eventDelegate, params object[] args)
{
if (eventDelegate != null)
{
Delegate[] delegates = eventDelegate.GetInvocationList();
AsyncInvokeDelegate invoker = new AsyncInvokeDelegate(InvokeDelegate);
AsyncCallback cleanUp = new AsyncCallback(AsyncDelegateCleanup);
foreach (Delegate sink in delegates)
{
invoker.BeginInvoke(sink, args, cleanUp, null);
}
}
}
public static void InvokeDelegateAsync(Delegate del, params object[] args)
{
if (del == null)
{ return; }
AsyncCallback cleanUp = delegate(IAsyncResult asyncResult)
{
asyncResult.AsyncWaitHandle.Close();
};
AsyncFire asyncFire = new AsyncFire(InvokeDelegate);
foreach (Delegate sink in del.GetInvocationList())
{
asyncFire.BeginInvoke(sink, args, cleanUp, null);
}
}
public static bool IsDelegateSubscribers(Delegate _delegate)
{
bool result = false;
if (_delegate != null)
{
lock (_delegate)
{
if (_delegate != null)
{
Delegate[] list = _delegate.GetInvocationList();
result = ((list != null) && (list.Length != 0));
}
}
}
return result;
}
static void DelegateReport(System.Delegate d, string name)
{
if (d == null) return;
IFormatProvider fp = System.Globalization.CultureInfo.InvariantCulture;
string title = string.Format(fp, "{0} Event\n", name);
UnsafeNativeMethods.CRhinoEventWatcher_LogState(title);
Delegate[] list = d.GetInvocationList();
if (list != null && list.Length > 0)
{
for (int i = 0; i < list.Length; i++)
{
Delegate subD = list[i];
Type t = subD.Target.GetType();
string msg = string.Format(fp, "- Plug-In = {0}\n", t.Assembly.GetName().Name);
UnsafeNativeMethods.CRhinoEventWatcher_LogState(msg);
}
}
}
static int GetInvocationList(IntPtr L)
{
ToLua.CheckArgsCount(L, 1);
System.Delegate obj = (System.Delegate)ToLua.CheckObject(L, 1, typeof(System.Delegate));
System.Delegate[] o = null;
try
{
o = obj.GetInvocationList();
}
catch (Exception e)
{
return(LuaDLL.luaL_error(L, e.Message));
}
ToLua.Push(L, o);
return(1);
}
public static void CallSafe(Delegate e, params object[] param)
{
try
{
foreach (Delegate d in e.GetInvocationList())
{
ISynchronizeInvoke syncer = d.Target as ISynchronizeInvoke;
if (syncer == null)
{
d.DynamicInvoke(param);
}
else
{
syncer.BeginInvoke(d, param);
}
}
}
catch { }
}
public void Dump(MainLoopEvent mainloopevent)
{
#if UNITY_EDITOR
var en = this.cachesMap.GetEnumerator();
while (en.MoveNext())
{
Action <int> act = en.Current.Value;
if (act != null)
{
System.Delegate d = act as System.Delegate;
Delegate[] delegates = d.GetInvocationList();
for (int i = 0; i < delegates.Length; ++i)
{
LogMgr.LogWarningFormat(" StaticDelegate {0} in {1} not clear at:{2}", delegates[i].Method.Name, delegates[i].Method.DeclaringType, mainloopevent);
}
}
}
#endif
}
/// <summary>
/// Invokes all nonsynchronized handlers on new thread (all on one).
/// </summary>
/// <param name="handler"></param>
/// <param name="parameters"></param>
public static void BeginInvoke(Delegate handler, params object[] parameters)
{
if (handler != null) {
List<Delegate> list = new List<Delegate>();
foreach (Delegate d in handler.GetInvocationList()) {
ISynchronizeInvoke sync = d.Target as ISynchronizeInvoke;
if (sync != null) {
sync.BeginInvoke(d, parameters);
}
else {
list.Add(d);
}
}
if (list.Count > 0) {
ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncInvokeListProc), new AsyncInvokeArgs(list, parameters));
}
}
}
/// <summary>
/// Helper method for raising events safely.
/// </summary>
/// <param name="del">Delegate to invoke.</param>
/// <param name="sender">The sender of the event.</param>
/// <param name="e">The <see cref="EventArgs"/>.</param>
/// <remarks>
/// Use this method to invoke user code via delegates.
/// This method will log any exceptions thrown in user code and immediately rethrow it.
/// The typical usage is shown below.
/// </remarks>
/// <example>
/// <code>
/// [C#]
/// public class PresentationImage
/// {
/// private event EventHandler _imageDrawingEvent;
///
/// public void Draw()
/// {
/// EventsHelper.Fire(_imageDrawingEvent, this, new DrawImageEventArgs());
/// }
/// }
/// </code>
/// </example>
public static void Fire(Delegate del, object sender, EventArgs e)
{
if (del == null)
return;
Delegate[] delegates = del.GetInvocationList();
foreach(Delegate sink in delegates)
{
try
{
sink.DynamicInvoke(sender, e);
}
catch (Exception ex)
{
Platform.Log(LogLevel.Error, ex);
throw;
}
}
}
public static Thread raiseRegistedCallbacks(Delegate delegatesToInvoke, object[] parameters)
{
return O2Kernel_O2Thread.mtaThread(() =>
{
if (delegatesToInvoke != null)
foreach (
Delegate registerCallback in
delegatesToInvoke.GetInvocationList())
try
{
registerCallback.DynamicInvoke(parameters);
}
catch (Exception ex)
{
log.error(
"in raiseRegistedCallbacks, while invoking {0} : ",
registerCallback.Method.Name,
ex.Message);
}
});
}
/// <summary>
/// Indicates if a method with name, methodName is subscribed to a delegate, del, on object, invokingObject
/// </summary>
public static bool isSubscribed(this System.Delegate del, object invokingObject, string methodName)
{
bool isSubscribed = false;
if (del != null) //Delegate has methods subscribed
{
System.Delegate[] invocationList = del.GetInvocationList();
int i = 0;
while (i < invocationList.Length && !isSubscribed)
{
System.Delegate subscribedDelegate = invocationList[i];
if (del.Method.Name == methodName && subscribedDelegate.Target.Equals(invokingObject))
{
isSubscribed = true;
}
i++;
}
}
return(isSubscribed);
}
// From http://code.logos.com/blog/2008/07/casting_delegates.html
public static System.Delegate Cast(this System.Delegate source, Type type)
{
if (source == null)
{
return(null);
}
System.Delegate[] delegates = source.GetInvocationList();
if (delegates.Length == 1)
{
return(System.Delegate.CreateDelegate(type,
delegates[0].Target, delegates[0].Method));
}
System.Delegate[] delegatesDest = new System.Delegate[delegates.Length];
for (int nDelegate = 0; nDelegate < delegates.Length; nDelegate++)
{
delegatesDest[nDelegate] = System.Delegate.CreateDelegate(type,
delegates[nDelegate].Target, delegates[nDelegate].Method);
}
return(System.Delegate.Combine(delegatesDest));
}
/// <summary>
/// Helper method for raising events safely.
/// </summary>
/// <param name="del">Delegate to invoke.</param>
/// <param name="sender">The sender of the event.</param>
/// <param name="e">The <see cref="EventArgs"/>.</param>
/// <remarks>
/// Use this method to invoke user code via delegates.
/// This method will log any exceptions thrown in user code and immediately rethrow it.
/// The typical usage is shown below.
/// </remarks>
/// <example>
/// <code>
/// [C#]
/// public class PresentationImage
/// {
/// private event EventHandler _imageDrawingEvent;
///
/// public void Draw()
/// {
/// EventsHelper.Fire(_imageDrawingEvent, this, new DrawImageEventArgs());
/// }
/// }
/// </code>
/// </example>
public static void Fire(Delegate del, object sender, EventArgs e)
{
// TODO CR (Apr 13): del should really be EventHandler (and an overload added for EventHandler<T>) since this method won't work with any other kind of delegate
// and a strongly typed API would help programmers from putting in the wrong arguments
if (del == null)
return;
var delegates = del.GetInvocationList();
foreach (var sink in delegates)
{
try
{
sink.DynamicInvoke(sender, e);
}
catch (Exception ex)
{
Platform.Log(LogLevel.Error, ex);
throw;
}
}
}
public static object FireEvent(Delegate eventDelegate, params object[] paramValues)
{
if (eventDelegate == null) return null;
if (eventDelegate is MulticastDelegate)
{
Delegate[] delegates = eventDelegate.GetInvocationList();
if (delegates.Length > 1)
{
foreach (Delegate eventSink in delegates)
{
FireEvent(eventSink, paramValues);
}
return null;
}
else
{
return FireSingleEvent(eventDelegate, paramValues);
}
}else
{
return FireSingleEvent(eventDelegate, paramValues);
}
}
public static void TraceMethodAndDelegate(object sender, System.Delegate eventHandler)
{
if (!_enabled)
{
return;
}
try
{
StackFrame f = new StackFrame(1);
Delegate[] eventHandlers = (eventHandler != null ? eventHandler.GetInvocationList() : new Delegate[] {});
// string target = (eventHandler != null ? eventHandlers[0].Target.GetType().Name : <
string message = string.Format("{0}.{1} called, preparing to call {3} delegates.", f.GetMethod().DeclaringType.Name, f.GetMethod().Name, DateTime.Now.ToLongTimeString(), eventHandlers.Length.ToString());
System.Diagnostics.Trace.WriteLine(message);
// eventHandler.Target.GetType().Name
}
catch (System.Exception systemException)
{
System.Diagnostics.Trace.WriteLine(systemException);
}
}
/// <summary>
/// Fires the specified event on the correct thread and passes
/// in the specified arguments.
/// </summary>
/// <param name="eventToFire">The event to fire.</param>
/// <param name="args">The arguments to pass to the event.</param>
private static void fireEvent(Delegate eventToFire, params object[] args)
{
if (eventToFire == null)
return;
foreach (Delegate d in eventToFire.GetInvocationList())
{
ISynchronizeInvoke target = d.Target as ISynchronizeInvoke;
if (target != null && target.InvokeRequired)
{
target.Invoke(d, args);
}
else
{
d.DynamicInvoke(args);
}
}
}
/// <summary>
/// Removes non-public method targets from a delegate so that they
/// can be safely serialized.
/// </summary>
/// <param name="d">The multicast or singlecast delegate to process</param>
/// <returns>A delegate with only the public methods or null if all methods are non-public</returns>
public static Delegate MakeSerializable(Delegate d)
{
if (d == null)
return null;
Delegate[] children = d.GetInvocationList();
if (children.Length == 0)
return null;
else if (children.Length == 1 && d == children[0])
{
// Non-combined delegate
if (d.Method.IsPublic)
return d;
else
return null;
}
else
{
ArrayList publicChildren = new ArrayList(children.Length);
foreach (Delegate child in children)
{
Delegate publicChild = MakeSerializable(child);
if (publicChild != null)
publicChildren.Add(publicChild);
}
if (publicChildren.Count == 0)
return null;
else if (publicChildren.Count == 1)
return (Delegate)publicChildren[0];
else
{
Delegate[] publicChildrenArray = new Delegate[publicChildren.Count];
for (int i = 0; i < publicChildren.Count; ++i)
publicChildrenArray[i] = (Delegate)publicChildren[i];
return Delegate.Combine(publicChildrenArray);
}
}
}
/// <summary>
/// This method is used to actually fire an event
///
/// It returns true if it called any delegates, false otherwise (event wasn't hooked)
/// </summary>
/// <param name="method"></param>
/// <param name="args"></param>
/// <returns></returns>
internal static bool FireEvent(Delegate del, object[] args)
{
bool ret = false;
if(del != null)
{
// Invoke the delegates 1 by 1 instead of in linked list
// this gives them each a chance to execute
Delegate[] sinks = del.GetInvocationList();
foreach(Delegate sink in sinks)
{
try
{
sink.DynamicInvoke(args);
}
catch(Exception e)
{
eventLog.WriteEntry(string.Format(CultureInfo.CurrentCulture,
Strings.ErrorCallingAnEventDelegate, e.ToString()), EventLogEntryType.Error,
(int)RtpEL.ID.Error);
}
}
ret = true;
}
return ret;
}
private static object InternalSafeInvoke(Delegate deleg, object[] arguments)
{
var dynamicInvoker = GetDynamicInvoker(deleg);
var invocationList = deleg.GetInvocationList();
if (invocationList.Length < 2)
{
// nothing to worry about, invoke as is
return dynamicInvoker(deleg, arguments);
}
// run all delegates and gather exceptions being thrown
var exceptions = new List<Exception>();
var result = default(object);
foreach (var d in invocationList)
{
try
{
result = dynamicInvoker(d, arguments);
}
catch (Exception ex)
{
exceptions.Add(ex.PreserveStackTrace());
}
}
// return the last result or rethrow exceptions
if (!exceptions.Any())
{
return result;
}
#if !FX3
if (exceptions.Count == 1)
{
throw exceptions.First();
}
// .NET 4.0 only
throw new AggregateException(exceptions);
#else
throw exceptions.First();
#endif
}
/// <summary>
/// Raises the event encapsulated by the supplied
/// <paramref name="source"/>, passing the supplied <paramref name="arguments"/>
/// to the event.
/// </summary>
/// <param name="source">The event to be raised.</param>
/// <param name="arguments">The arguments to the event.</param>
/// <returns>a map of sink/exception entries that occurred during event raising</returns>
public virtual IEventExceptionsCollector Raise(Delegate source, params object[] arguments)
{
EventExceptionsCollector exceptions = new EventExceptionsCollector();
if (source != null)
{
Delegate [] delegates = source.GetInvocationList ();
foreach (Delegate sink in delegates)
{
Invoke (sink, arguments, exceptions);
}
}
return exceptions;
}
public static bool Contains(this System.Delegate del, string methodName)
{
return(!System.Array.TrueForAll(del.GetInvocationList(), invoker => invoker.Method.Name != methodName));
}
