public static Coroutine StartCoroutine(this MonoBehaviour behaviour, System.Delegate method, params object[] args) { if (behaviour == null) { throw new System.ArgumentNullException("behaviour"); } if (method == null) { throw new System.ArgumentNullException("method"); } System.Collections.IEnumerator e; if (com.spacepuppy.Utils.TypeUtil.IsType(method.Method.ReturnType, typeof(System.Collections.IEnumerable))) { e = (method.DynamicInvoke(args) as System.Collections.IEnumerable).GetEnumerator(); } else if (com.spacepuppy.Utils.TypeUtil.IsType(method.Method.ReturnType, typeof(System.Collections.IEnumerator))) { e = (method.DynamicInvoke(args) as System.Collections.IEnumerator); } else { throw new System.ArgumentException("Delegate must have a return type of IEnumerable or IEnumerator.", "method"); } return(behaviour.StartCoroutine(e)); }
public static RadicalCoroutine StartRadicalCoroutineAsync(this MonoBehaviour behaviour, System.Delegate method, object[] args = null, RadicalCoroutineDisableMode disableMode = RadicalCoroutineDisableMode.Default) { if (behaviour == null) { throw new System.ArgumentNullException("behaviour"); } if (method == null) { throw new System.ArgumentNullException("method"); } System.Collections.IEnumerator e; if (com.spacepuppy.Utils.TypeUtil.IsType(method.Method.ReturnType, typeof(System.Collections.IEnumerable))) { e = (method.DynamicInvoke(args) as System.Collections.IEnumerable).GetEnumerator(); } else if (com.spacepuppy.Utils.TypeUtil.IsType(method.Method.ReturnType, typeof(System.Collections.IEnumerator))) { e = (method.DynamicInvoke(args) as System.Collections.IEnumerator); } else { throw new System.ArgumentException("Delegate must have a return type of IEnumerable or IEnumerator.", "method"); } var co = new RadicalCoroutine(e); co.StartAsync(behaviour, disableMode); return(co); }
public void ForEach(System.Delegate iterate) { for (int i = 0; i < _size; i++) { iterate.DynamicInvoke(_items[i]); } }
public void TrggerCommand(BaseEventData data) { if (_bindCommand == null) { return; } _bindCommand.DynamicInvoke(data); }
public bool MoveNext() { if (!done_) { func_.DynamicInvoke(args_); done_ = true; } return(false); }
internal virtual int Invoke(int b1, int b2) { object[] args = new object[] { b1, b2 }; int ret = ((int)(d.DynamicInvoke(args))); return(ret); }
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)); } }
// protected delegate string getName_t(); public MyAttribute(System.Type classType, string delegateName) : base() { System.Reflection.MethodInfo mi = classType.GetMethod(delegateName, System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic ); System.Type delegateType = CreateDelegateType(mi); // getName_t getName = (getName_t)System.Delegate.CreateDelegate(delegateType, mi)); System.Delegate getName = System.Delegate.CreateDelegate(delegateType, mi); object name = getName.DynamicInvoke(null); this.m_name = System.Convert.ToString(name); }
/// <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)); } }
public static bool Execute(GameObject gameObject, System.Type handlerType, System.Delegate handlerExecutor, object state) { var handlers = ListPool <object> .Request(); try{ GetHandlers(gameObject, handlerType, handlers); if (handlers.Count == 0) { return(false); } foreach (var handler in handlers) { handlerExecutor.DynamicInvoke(handler, state); } return(true); }finally{ ListPool <object> .Release(handlers); } }
public void CallMemberFunctions <T>(T value) { foreach (ActionEventMethod memberName in methodArray) { if (memberName.parameterType != null) { System.Delegate function = viewModelBinding.model.GetFunctionParam1(memberName.methodName, memberName.parameterType); function.DynamicInvoke(memberName.parameterValue); } else { System.Action <T> function = viewModelBinding.model.GetFunctionParam1 <T>(memberName.methodName); if (function != null) { function(value); } } } }
public void processRequest(API.Request request) { String resquestType = request.GetType().Name; String processorName = resquestType.Substring(0, resquestType.Length - 2); API.Response response = null; string processorName = "Process" + processorName; if (ProcessHandlers.ContainsKey(processorName)) { System.Delegate myDelegate = ProcessHandlers[processorName]; response = (API.Response)myDelegate.DynamicInvoke(request); } else { logger.Warn("Failed to find a processor for " + processorName); response = new ErrorRs(request.id, "Failed to find a processor for " + processorName); } sendResponse(response, request); }
public static void UpdateVariableViaHandle <T> (this Editor editor, ref T var, System.Delegate handleMethod, string undoName, params object[] handleParams) { EditorGUI.BeginChangeCheck(); T value = default(T); try { value = (T)handleMethod.DynamicInvoke(handleParams); } catch (System.Exception e) { Debug.LogErrorFormat("JBirdEditor.UpdateListIndexViaHandle: Method '{0}' does not return type '{1}'. Exception message: {2}", handleMethod.Method.Name, typeof(T).ToString(), e.Message); EditorGUI.EndChangeCheck(); return; } if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(editor.target, string.Format("{0}Change{1}", editor.target.GetType().ToString(), undoName == "" ? handleMethod.Method.Name : undoName)); var = value; EditorUtility.SetDirty(editor.target); SceneView.RepaintAll(); editor.Repaint(); } }