/// <summary>
/// Initializes a new instance of the <see cref="DelayedInvoke"/> class.
/// </summary>
/// <param name="action">The action to perform.</param>
/// <param name="timeout">The timeout before running.</param>
/// <param name="blocking">if set to <c>true</c> then the delay will block.</param>
/// <param name="args">The arguments to pass to the action.</param>
public DelayedInvoke(Delegate action, int timeout, bool blocking, object[] args = null)
{
if (timeout == 0)
{
action.DynamicInvoke(args);
}
if (blocking)
{
do
{
Restart = false;
Thread.Sleep(timeout);
} while (Restart);
HasReturned = true;
ReturnValue = action.DynamicInvoke(args);
}
else
{
thread = new Thread(delegate()
{
do
{
Restart = false;
Thread.Sleep(timeout);
} while (Restart);
HasReturned = true;
ReturnValue = action.DynamicInvoke(args);
});
thread.Name = "DelayedInvoke: " + action.Method.Name;
thread.Start();
}
}
public void CallFunction()
{
try
{
System.Delegate v_tempFunctionPointer = FunctionToCall;
object[] v_params = Parameters.ToArray();
if (ClearFunctionWhenFinish)
{
FunctionToCall = null;
Parameters.Clear();
}
if (v_tempFunctionPointer != null)
{
if (Parameters.Count == 0)
{
v_tempFunctionPointer.DynamicInvoke(null);
}
else
{
v_tempFunctionPointer.DynamicInvoke(v_params);
}
}
}
catch
{
FunctionToCall = null;
Parameters.Clear();
}
}
public void makeMethodCall(Delegate methodToCall)
{
addArgsTextBox.Text = "Click new constructor or method.";
object[] argObjects = new object[methodArgs.Count];
if (argObjects.Length != methodToCall.Method.GetParameters().Length)
{
System.Windows.Forms.MessageBox.Show("Not enough arguments");
methodArgs.Clear();
enteredArgsLabel.Text = "Entered Args";
return;
}
string stringType = "";
int i = 0;
ParameterInfo[] instancePars = methodToCall.Method.GetParameters();
foreach (object ob in methodArgs)
{
if (ob != null)
{
stringType = instancePars[i].ParameterType.Name;
try
{
argObjects[i] = parseObject(stringType, ob);
}
catch (Exception Exception)
{
System.Windows.Forms.MessageBox.Show("err: " + Exception.Message);
clearArgsButt_Click(null, null);
return;
}
i++;
}
}
object[] returned = null;
object returned_Temp = null;
if (argObjects.Length == 0)
{
returned_Temp = methodToCall.DynamicInvoke();
}
else
{
returned_Temp = methodToCall.DynamicInvoke(argObjects);
}
if (methodToCall.Method.ReturnParameter.ParameterType != typeof(void))
{
returned = new object[1];
returned[0] = returned_Temp;
}
if (returned != null)
{
objectsListBox.Items.Add(returned[0]);
}
enteredArgsLabel.Text = "Entered Args";
methodArgs.Clear();
}
private void datagridHoldInvoice_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
DataGridRow row = ItemsControl.ContainerFromElement((DataGrid)sender, e.OriginalSource as DependencyObject) as DataGridRow;
if (row == null)
{
return;
}
_delegateInvoiceOpen.DynamicInvoke();
}
/// <summary>
/// Forwards the BeginInvoke to the current application's <see cref="Dispatcher"/>.
/// </summary>
/// <param name="method">Method to be invoked.</param>
/// <param name="arg">Arguments to pass to the invoked method.</param>
public Task BeginInvoke(Delegate method, params object[] arg)
{
if (dispatcher != null)
return dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => method.DynamicInvoke(arg)).AsTask();
var coreWindow = CoreApplication.MainView.CoreWindow;
if (coreWindow != null)
{
dispatcher = coreWindow.Dispatcher;
return dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => method.DynamicInvoke(arg)).AsTask();
}
else
return Task.Delay(0);
}
public Object Execute(System.Delegate Method, params object[] Arguments)
{
if (Method == null)
{
throw new InvalidOperationException();
}
else if (!this.Open())
{
throw new InvalidOperationException("Could not open security context.");
}
else
{
try
{
this._Executing = true;
Object ReturnValue = Method.DynamicInvoke(Arguments);
this.Close();
this._Executing = false;
return(ReturnValue);
}
catch (Exception e)
{
return(null);
}
}
}
public void Memorize(string name, object memory, bool is_writable = false)
{
if (memory is System.Delegate && !(memory is System.Func <object>))
{
System.Delegate delegate_ = memory as System.Delegate;
if (delegate_.Method.GetParameters().Count() == 0)
{
memory = (System.Func <object>)(() => delegate_.DynamicInvoke());
}
}
if (is_writable)
{
memories[name] = new WritableVariable(name, memory);
}
else if (memory is System.Func <object> )
{
memories[name] = new FunctionVariable(name, memory as System.Func <object>);
}
else
{
memories[name] = new ReadOnlyVariable(name, memory);
}
memory_names[memories[name]] = name;
}
/////////////////////////////////////////////////////////////////////////////
public static object Invoke( Delegate dg, object [] args )
{
// ******
if( null == dg ) {
throw new ArgumentNullException( "delegate" );
}
// ******
MethodInfo mi = dg.Method;
object [] newArgs = MatchArgs( mi, args );
if( null == newArgs ) {
//
// could not match arguments
//
ThreadContext.MacroError( "could not match the parameters for delegate \"{0}\" with the argument types {1} on the object type \"{2}\"", dg.Method.Name, Arguments.ObjectsTypeNames( args ), GetDeclaringTypeName( dg ) );
}
// ******
try {
return dg.DynamicInvoke( newArgs );
}
catch( Exception ex ) {
//
// never returns
//
//ThreadContext.MacroError( "{0}.DynamicInvoke() failed: {1}", mi.Name, ex.Message );
string msg = ExceptionHelpers.RecursiveMessage( ex, "{0}.DynamicInvoke() failed: {1}", mi.Name, ex.Message );
ThreadContext.MacroError( msg );
return null;
}
}
public virtual Object Execute(System.Delegate Method, params object[] Arguments)
{
if (this.IsExecuting)
{
throw new InvalidOperationException("UserImpersonator cannot Execute while another execution is already in progress.");
}
else if (Method == null)
{
throw new InvalidOperationException("UserImpersonator cannot Execute without a supplied, or stored Method to invoke.");
}
else if (!this.Open())
{
throw new InvalidOperationException("Could not open security context.");
}
else
{
try
{
this._IsExecuting = true;
Object ReturnValue = Method.DynamicInvoke(Arguments);
this.Close();
this._IsExecuting = false;
return(ReturnValue);
}
catch (Exception e)
{
return(null);
}
}
}
public static string Delete(int id, Delegate del, string ItemType)
{
var message = string.Empty;
var sqlError = string.Empty;
var errorMessage = string.Format("Error deleting {0} item (id={1}).", ItemType, id);
try
{
var r = del.DynamicInvoke(id, sqlError);
//Return actual error message, if any
if (!string.IsNullOrEmpty(sqlError))
throw new Exception(errorMessage += " " + sqlError);
else if ((int)r != 0)
throw new Exception(string.Format("{0} {1} returned {2}.", errorMessage, del.Method.Name, r));
}
catch (Exception exc)
{
message = errorMessage;
Global.logger.ErrorException(message, exc);
throw;
}
return message;
}
protected void doComplete()
{
if (_method != null)
{
_method.DynamicInvoke(_parameters);
}
}
public object Invoke(Delegate method, object[] args)
{
//Uses NSObject.InvokeOnMainThread
object result = null;
InvokeOnMainThread (() => result = method.DynamicInvoke (args));
return result;
}
public object Invoke(Delegate method, params object[] args)
{
object result = null;
Exception exception = null;
using (ManualResetEvent waitHandle = new ManualResetEvent(false))
{
_queue._queue.Enqueue(
delegate()
{
try
{
result = method.DynamicInvoke(args);
}
catch (Exception e)
{
exception = e;
}
waitHandle.Set();
});
waitHandle.WaitOne();
}
if (exception != null)
{
throw new ReactorInvocationException("An exception occurred invoking a method " +
"in a reactor thread; check InnerException for the exception.", exception);
}
else
{
return result;
}
}
private object DoInvoke(Guid relatedActivityId, Delegate method, object[] methodArgs)
{
using (_eventCorrelator.StartActivity(relatedActivityId))
{
return method.DynamicInvoke(methodArgs);
}
}
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();
}
}
/// <summary>
/// Forwards the BeginInvoke to the current application's <see cref="Dispatcher"/>.
/// </summary>
/// <param name="method">Method to be invoked.</param>
/// <param name="arg">Arguments to pass to the invoked method.</param>
public void BeginInvoke(Delegate method, object arg)
{
if (Application.Current != null)
{
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Normal, method, arg);
}
else if (SynchronizationContext.Current != null)
{
SendOrPostCallback callback = new SendOrPostCallback(delegate { method.DynamicInvoke(arg); });
SynchronizationContext.Current.Post(callback, null);
}
else
{
method.DynamicInvoke(arg);
}
}
/// <summary>
/// Executes the specified delegate on the UI thread
/// </summary>
/// <param name="del"> </param>
/// <param name="arguments"> </param>
public static void ExecuteDelegate(Delegate del, params object[] arguments) {
if (CheckAccess()) {
del.DynamicInvoke(arguments);
} else {
UserInterfaceDispatcher.BeginInvoke(del, arguments);
}
}
public static void InvokeUntypedDelegate(Delegate d, params object[] args) {
#if SILVERLIGHT
IronPython.Runtime.Operations.PythonCalls.Call(d, args);
#else
d.DynamicInvoke(args);
#endif
}
/// <summary>
/// Invokes a .NET event
/// </summary>
/// <param name="handler">Event to be invoked</param>
/// <param name="args">Paramters to pass to the event</param>
public void InvokeEvent(Delegate handler, params object[] args)
{
if (handler != null)
{
handler.DynamicInvoke(args);
}
}
public void Core_RunInGui(Delegate method, params object[] args)
{
if (method == null)
return;
RunOnUiThread(new Action(() => method.DynamicInvoke(args)));
}
public void FireEvent(object key, EventArgs e)
{
System.Delegate delegateToInvoke = (System.Delegate)Events[key];
if (delegateToInvoke != null)
{
try
{
delegateToInvoke.DynamicInvoke(GetEventSender(), e);
}
catch (Exception ex)
{
// Note: this check is for the debugger, so we can catch exceptions in the debugger instead of
// throwing a thread exception.
if (NativeWindow.WndProcShouldBeDebuggable)
{
throw;
}
else
{
Application.OnThreadException(ex);
}
}
}
}
/// <summary>Invokes the specified delegate with the specified parameters in the specified kind of apartment state.</summary>
/// <param name="d">The delegate to be invoked.</param>
/// <param name="parameters">The parameters to pass to the delegate being invoked.</param>
/// <param name="state">The apartment state to run under.</param>
/// <returns>The result of calling the delegate.</returns>
public static object Execute(
Delegate d, object[] parameters, ApartmentState state)
{
if (d == null) throw new ArgumentNullException("d");
if (state != ApartmentState.MTA && state != ApartmentState.STA)
throw new ArgumentOutOfRangeException("state");
if (Thread.CurrentThread.ApartmentState == state)
{
return d.DynamicInvoke(parameters);
}
else
{
ApartmentStateSwitcher switcher = new ApartmentStateSwitcher();
switcher._delegate = d;
switcher._parameters = parameters;
Thread t = new Thread(new ThreadStart(switcher.Run));
t.ApartmentState = state;
t.IsBackground = true;
t.Start();
t.Join();
if (switcher._exc != null) throw switcher._exc;
return switcher._rv;
}
}
public static void DynamicInvokeSafely(this System.Delegate @delegate, params object[] args)
{
if (@delegate != null)
{
@delegate.DynamicInvoke(args);
}
}
public static object Cache(string key, int cacheTimeMilliseconds, Delegate result, params object[] args)
{
var cache = MemoryCache.Default;
if (cache[key] == null)
{
object cacheValue;
try
{
if (result == null)
return null;
cacheValue = result.DynamicInvoke(args);
}
catch (Exception e)
{
var message = e.InnerException.GetBaseException().Message;
throw new CacheDelegateMethodException(message);
}
if (cacheValue != null)
{
cache.Set(key, cacheValue, DateTimeOffset.Now.AddMilliseconds(cacheTimeMilliseconds));
}
}
return cache[key];
}
public string Call5(Delegate callback)
{
var thisArg = JsValue.Undefined;
var arguments = new JsValue[] { 1, "foo" };
return callback.DynamicInvoke(thisArg, arguments).ToString();
}
// Execute a delegate on the event listening thread.
public static void InvokeOnEventsThread(Delegate method)
{
// There is no event thread, so execute the delegate here.
if(method != null)
{
method.DynamicInvoke(new Object [0]);
}
}
private void label5_Click(object sender, EventArgs e)
{
int indexOfControl = index;
_delPageMethod.DynamicInvoke(indexOfControl);
this.Dispose();
}
private static void ChangeAllLampState(Delegate stateChange)
{
foreach (HueLamp lamp in lamps.Values)
{
stateChange.DynamicInvoke(lamp);
}
messaging.SendMessage(lamps.Values.ToList<HueLamp>());
}
/// <summary>
/// Runs the given delegates with the given arguments in a new thread
/// </summary>
public void LoadScreenContent(Delegate loadMethod, Delegate completeMethod, object[] loadArgs)
{
// Invokes load then close delegates in a new thread.
// TODO: Remove thread sleep once loading testing is complete
loadingThread = new Thread(() => { /* Thread.Sleep(1000); */ loadMethod.DynamicInvoke(loadArgs); completeMethod.DynamicInvoke(); });
loadingThread.Priority = ThreadPriority.Highest;
loadingThread.Start();
}
public static void Invoke(this FrameworkElement element, Delegate action, params object[] values)
{
if (element.InvokeRequired())
{
using (AutoResetEvent are = new AutoResetEvent(false))
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
action.DynamicInvoke(values);
are.Set();
});
are.WaitOne();
}
}
else
action.DynamicInvoke(values);
}
public IAsyncResult BeginInvoke(Delegate method, object[] args)
{
Application.Invoke (delegate {
method.DynamicInvoke (args);
});
return null;
}
private void InvokeDelegate(Delegate handler, object[] e)
{
ISynchronizeInvoke synchronizer = (ISynchronizeInvoke)handler.Target;
if (synchronizer == null)
{
handler.DynamicInvoke(e);
return;
}
if (synchronizer.InvokeRequired == false)
{
handler.DynamicInvoke(e);
return;
}
synchronizer.Invoke(handler, e);
}
public static object SafeInvoke(Delegate delegateToFire, params object[] parameters )
{
ISynchronizeInvoke invoker = delegateToFire.Target as ISynchronizeInvoke;
object retval=null;
if (invoker != null)
{
if (invoker.InvokeRequired)
retval = invoker.Invoke(delegateToFire, parameters);
else
retval = delegateToFire.DynamicInvoke( parameters );
}
else
{
retval = delegateToFire.DynamicInvoke( parameters );
}
return retval;
}
public void ChangeAllLampStates(Delegate stateChange)
{
List<Lamp> lamps = messaging.DownloadLampList();
foreach (Lamp lamp in lamps)
{
stateChange.DynamicInvoke(lamp);
}
messaging.SendMessage(lamps);
}
protected virtual void InvokeEventHandler (Delegate genericHandler, object genericTarget)
{
if (genericHandler == null)
throw new ArgumentNullException ("genericHandler");
if (genericTarget == null)
throw new ArgumentNullException ("genericTarget");
genericHandler.DynamicInvoke (genericTarget, this);
}
/// <summary>
/// Forwards the BeginInvoke to the current deployment's <see cref="System.Windows.Threading.Dispatcher"/>.
/// </summary>
/// <param name="method">Method to be invoked.</param>
/// <param name="arg">Arguments to pass to the invoked method.</param>
public Task BeginInvoke(Delegate method, params object[] arg)
{
if (Deployment.Current != null)
{
return Deployment.Current.Dispatcher.InvokeAsync(() => method.DynamicInvoke(arg));
}
else
return Task.Delay(0);
}
public override void stop()
{
base.stop();
if (m_callback != null)
{
m_callback.DynamicInvoke();
}
}
/// <summary>
/// Executes the specified delegate with the specified arguments synchronously on the thread the Dispatcher is associated with.
/// </summary>
/// <param name="dispatcher">The dispatcher.</param>
/// <param name="method">A delegate to a method that takes parameters specified in args, which is pushed onto the Dispatcher event queue.</param>
/// <param name="args">An array of objects to pass as arguments to the given method. Can be <c>null</c>.</param>
/// <exception cref="ArgumentNullException">The <paramref name="method" /> is <c>null</c>.</exception>
/// <remarks>For target frameworks where the <see cref="Dispatcher" /> class does not contain the <c>Invoke</c> method, the <c>BeginInvoke</c>
/// method will be used instead.</remarks>
public static void Invoke(this Dispatcher dispatcher, Delegate method, params object[] args)
{
Argument.IsNotNull("method", method);
if (dispatcher != null && !dispatcher.CheckAccess())
{
#if NET
dispatcher.Invoke(method, args);
#elif NETFX_CORE
dispatcher.BeginInvoke(() => method.DynamicInvoke(args));
#else
dispatcher.BeginInvoke(method, args);
#endif
}
else
{
method.DynamicInvoke(args);
}
}
public static void Cancel(Delegate networkDel)
{
// stop listening
mic.Stop();
NetworkHelper.CancelSpeech();
networkDel.DynamicInvoke(false, null);
speechOperationInProgress = false;
}
public static object GetInsertCacheItem(System.Web.Caching.Cache cache, string key, Delegate action, object[] args, bool flushCache = false)
{
var cacheItem = cache[key];
if (cacheItem != null && !flushCache) return cacheItem;
cacheItem = action.DynamicInvoke(args);
cache.Insert(key, cacheItem);
return cacheItem;
}
public Task <bool> CanFire(WorkflowContext context)
{
var values = parameters.Select((x, i) => context.GlobalParameters.GetContextProperty(x.ContextPath, typeMap[i]))
.ToArray();
var result = (bool)function.DynamicInvoke(values);
return(Task.FromResult(result));
}
protected object Invoke(Delegate method, params object[] args)
{
var Owner = this.Owner;
if (Owner == null)
return method.DynamicInvoke(args);
else
{
return Owner.Dispatcher.Invoke(method, args);
}
}
private Expression Evaluate(Expression e)
{
if (e.NodeType == ExpressionType.Constant)
{
return(e);
}
LambdaExpression lambda = Expression.Lambda(e);
System.Delegate fn = lambda.Compile();
return(Expression.Constant(fn.DynamicInvoke(null), e.Type));
}
protected bool CallDelegateFunction()
{
try
{
System.Delegate v_tempFunctionPointer = DelegatePointer;
object[] v_params = Params.ToArray();
if (v_tempFunctionPointer != null)
{
if (Params.Count == 0)
{
v_tempFunctionPointer.DynamicInvoke(null);
}
else
{
v_tempFunctionPointer.DynamicInvoke(v_params);
}
return(true);
}
}
catch { }
return(false);
}
/// <summary>
/// Only use the Dispatcher if we are not already on the UI Thread.
/// This avoid WPF exceptions saying the dispatcher is unavailable.
/// </summary>
/// <param name="d">The delegate to invoke</param>
/// <param name="args">Optional parameters</param>
public static object Invoke(System.Delegate d, params object[] args)
{
if (dispatcher != null && System.Threading.Thread.CurrentThread.ManagedThreadId != uiThreadId)
{
// Note: must be careful using this method, it could deadlock the UI, so make sure
// it cannot be interleaved with similar calls.
return(dispatcher.Invoke(d, args));
}
else
{
// we are already on the UI thread so call the delegate directly.
return(d.DynamicInvoke(args));
}
}
private object DynamicInvokeCommand(System.Delegate commandDelegate, object[] agrs)
{
// execute
try
{
object ret = commandDelegate.DynamicInvoke(agrs);
return(ret);
}
catch (Exception exc)
{
// throw inner exception if exists
throw (exc.InnerException != null ? exc.InnerException: exc);
}
}
static public int DynamicInvoke(IntPtr l)
{
try {
System.Delegate self = (System.Delegate)checkSelf(l);
System.Object[] a1;
checkParams(l, 2, out a1);
var ret = self.DynamicInvoke(a1);
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
internal static void Consume <T>(this IEvent @event, T t, System.Reflection.ParameterInfo[] parameterInfo = null)
{
if (IEventExtensions.IsNull(@event))
{
return;
}
System.Reflection.MethodInfo mi = @event.Source.Method;
System.Reflection.ParameterInfo[] methodParams = parameterInfo ?? mi.GetParameters();
System.Delegate @delegate = System.Delegate.CreateDelegate(typeof(T), mi);
@delegate.DynamicInvoke();
}
static int DynamicInvoke(IntPtr L)
{
try
{
int count = LuaDLL.lua_gettop(L);
System.Delegate obj = (System.Delegate)ToLua.CheckObject <System.Delegate>(L, 1);
object[] arg0 = ToLua.ToParamsObject(L, 2, count - 1);
object o = obj.DynamicInvoke(arg0);
ToLua.Push(L, o);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
/// <summary>
/// Only use the Dispatcher if we are not already on the UI Thread.
/// This avoid WPF exceptions saying the dispatcher is unavailable.
/// </summary>
/// <param name="d">The delegate to invoke</param>
/// <param name="args">Optional parameters</param>
public static object BeginInvoke(System.Delegate d, params object[] args)
{
if (dispatcher != null && System.Threading.Thread.CurrentThread.ManagedThreadId != uiThreadId)
{
// Note: we cannot use dispatcher.Invoke because that can lead to deadlocks.
// For example, if this is a background thread with a lock() on a money data object
// (like account.rebalance does) then UI thread might be blocked on trying to get
// that lock and this dispatcher invoke would therefore create a deadlock.
return(dispatcher.BeginInvoke(d, args));
}
else
{
// we are already on the UI thread so call the delegate directly.
return(d.DynamicInvoke(args));
}
}
static int DynamicInvoke(IntPtr L)
{
int count = LuaDLL.lua_gettop(L);
System.Delegate obj = (System.Delegate)ToLua.CheckObject(L, 1, typeof(System.Delegate));
object[] arg0 = ToLua.ToParamsObject(L, 2, count - 1);
object o = null;
try
{
o = obj.DynamicInvoke(arg0);
}
catch (Exception e)
{
return(LuaDLL.luaL_error(L, e.Message));
}
ToLua.Push(L, o);
return(1);
}
public void BeginInvoke(System.Delegate aDelegate, params object[] aArgs)
{
iHandler.Post((Action)(() =>
{
try
{
#if DEBUG || TRACE
Linn.Trace.WriteLine(Linn.Trace.kGui, string.Format("{0} INVOKING {1}", DateTime.Now.ToString(), this.GetCallInfo(aDelegate, aArgs)));
#endif
aDelegate.DynamicInvoke(aArgs);
#if DEBUG || TRACE
Linn.Trace.WriteLine(Linn.Trace.kGui, string.Format("{0} INVOKED {1}", DateTime.Now.ToString(), this.GetCallInfo(aDelegate, aArgs)));
#endif
}
catch (System.Exception ex)
{
UserLog.WriteLine("Exception: " + ex);
UserLog.WriteLine("Invocation details: " + this.GetCallInfo(aDelegate, aArgs));
ThrowException(ex);
}
}));
}
public static void DynamicInvokeAbi(this System.Delegate del, object[] invoke_params)
{
Marshal.ThrowExceptionForHR((int)del.DynamicInvoke(invoke_params));
}
static System.Action Curry <T1, T2, T3, T4>(System.Delegate action, T1 t1, T2 t2, T3 t3, T4 t4)
{
return(() => action.DynamicInvoke(t1, t2, t3, t4));
}
protected void btnCancel_Click(object sender, EventArgs e)
{
_closeParam.DynamicInvoke();
}
static System.Action Curry <T1, T2>(System.Delegate action, T1 t1, T2 t2)
{
return(() => action.DynamicInvoke(t1, t2));
}