///<summary> /// Uses the action pipeline to invoke the method. ///</summary> ///<param name="target"> The object instance to invoke the method on. </param> ///<param name="methodName"> The name of the method to invoke. </param> ///<param name="view"> The view. </param> ///<param name="source"> The source of the invocation. </param> ///<param name="eventArgs"> The event args. </param> ///<param name="parameters"> The method parameters. </param> public static void Invoke(object target, string methodName, DependencyObject view = null, FrameworkElement source = null, object eventArgs = null, object[] parameters = null) { var context = new ActionExecutionContext { Target = target, Method = target.GetType().GetMethod(methodName), #if WINFORMS || WEBGUI Message = new ActionMessage(source, null, methodName), #else Message = new ActionMessage { MethodName = methodName }, #endif View = view, Source = source, EventArgs = eventArgs }; if (parameters != null) { parameters.Apply(x => context.Message.Parameters.Add(x as Parameter ?? new Parameter { Value = x })); } ActionMessage.InvokeAction(context); }
/// <summary> /// Called by the bootstrapper's constructor at runtime to start the framework. /// </summary> protected virtual void StartRuntime() { #if WEBGUI Execute.ResetWithoutDispatcher(); #else Execute.InitializeWithDispatcher(); #endif EventAggregator.DefaultPublicationThreadMarshaller = Execute.OnUIThread; EventAggregator.HandlerResultProcessing = (target, result) => { var coroutine = result as IEnumerable <IResult>; if (coroutine != null) { var viewAware = target as IViewAware; var view = viewAware != null?viewAware.GetView() : null; var context = new ActionExecutionContext { Target = target, View = (DependencyObject)view }; Coroutine.BeginExecute(coroutine.GetEnumerator(), context); } }; #if WEBGUI var selectedAssemblies = SelectAssemblies(); foreach (var selectedAssembly in selectedAssemblies) { if (!AssemblySource.Instance.Contains(selectedAssembly)) { AssemblySource.Instance.AddRange(new[] { selectedAssembly }); } } #else AssemblySource.Instance.AddRange(SelectAssemblies()); #endif if (useApplication) { #if WINFORMS || WEBGUI //Application = System.Windows.Forms.Application; #else Application = Application.Current; #endif PrepareApplication(); } Configure(); IoC.GetInstance = GetInstance; IoC.GetAllInstances = GetAllInstances; IoC.BuildUp = BuildUp; }
private void UpdateContext() { if (context != null) { context.Dispose(); } context = new ActionExecutionContext { Message = this, Source = AssociatedObject }; PrepareContext(context); UpdateAvailabilityCore(); }
/// <summary> /// Executes a coroutine. /// </summary> /// <param name="coroutine">The coroutine to execute.</param> /// <param name="context">The context to execute the coroutine within.</param> /// /// <param name="callback">The completion callback for the coroutine.</param> public static void BeginExecute(IEnumerator <IResult> coroutine, ActionExecutionContext context = null, EventHandler <ResultCompletionEventArgs> callback = null) { Log.Info("Executing coroutine."); var enumerator = CreateParentEnumerator(coroutine); IoC.BuildUp(enumerator); if (callback != null) { ExecuteOnCompleted(enumerator, callback); } ExecuteOnCompleted(enumerator, Completed); enumerator.Execute(context ?? new ActionExecutionContext()); }
public void Execute(ActionExecutionContext context) { var view = context.View.Object as Control; while (view != null) { var indicator = view as IHaveBusyIndicator; if (indicator != null) { indicator.Indicator.IsBusy = !_hide; indicator.Indicator.BusyContent = _message; break; } view = view.Parent; } if (view == null) { var queue = new Queue<Control>(); #if WINFORMS queue.Enqueue(Form.ActiveForm); #else queue.Enqueue(ApplicationContext.WebGUIActiveForm); #endif while (queue.Count > 0) { var current = queue.Dequeue(); if (current == null) continue; var indicator = current as BusyIndicator; if (indicator != null) { indicator.IsBusy = !_hide; break; } var count = current.Controls.Count; for (var i = 0; i < count; i++) { queue.Enqueue(current.Controls[i]); } } } Completed(this, new ResultCompletionEventArgs()); }
/// <summary> /// Determines the parameters that a method should be invoked with. /// </summary> /// <param name="context">The action execution context.</param> /// <param name="requiredParameters">The parameters required to complete the invocation.</param> /// <returns>The actual parameter values.</returns> public static object[] DetermineParameters(ActionExecutionContext context, ParameterInfo[] requiredParameters) { var providedValues = context.Message.Parameters.Select(x => x.Value).ToArray(); var finalValues = new object[requiredParameters.Length]; for (int i = 0; i < requiredParameters.Length; i++) { var parameterType = requiredParameters[i].ParameterType; var parameterValue = providedValues[i]; var parameterAsString = parameterValue as string; if (parameterAsString != null) finalValues[i] = CoerceValue(parameterType, EvaluateParameter(parameterAsString, parameterType, context), context); else finalValues[i] = CoerceValue(parameterType, parameterValue, context); } return finalValues; }
/// <summary> /// Try to find a candidate for guard function, having: /// - a name in the form "CanXXX" /// - no generic parameters /// - a bool return type /// - no parameters or a set of parameters corresponding to the action method /// </summary> /// <param name="context">The execution context</param> /// <returns>A MethodInfo, if found; null otherwise</returns> private static MethodInfo TryFindGuardMethod(ActionExecutionContext context) { var guardName = "Can" + context.Method.Name; var targetType = context.Target.GetType(); var guard = targetType.GetMethod(guardName); if (guard == null) { return(null); } if (guard.ContainsGenericParameters) { return(null); } if (typeof(bool) != guard.ReturnType) { return(null); } var guardPars = guard.GetParameters(); var actionPars = context.Method.GetParameters(); if (guardPars.Length == 0) { return(guard); } if (guardPars.Length != actionPars.Length) { return(null); } var comparisons = guardPars.Zip( context.Method.GetParameters(), (x, y) => x.ParameterType == y.ParameterType ); if (comparisons.Any(x => !x)) { return(null); } return(guard); }
/// <summary> /// Determines the parameters that a method should be invoked with. /// </summary> /// <param name="context">The action execution context.</param> /// <param name="requiredParameters">The parameters required to complete the invocation.</param> /// <returns>The actual parameter values.</returns> public static object[] DetermineParameters(ActionExecutionContext context, ParameterInfo[] requiredParameters) { var providedParameters = context.Message.Parameters.Select(x => x).ToArray(); var finalValues = new object[requiredParameters.Length]; for (int i = 0; i < requiredParameters.Length; i++) { var parameterType = requiredParameters[i].ParameterType; var parameterValue = providedParameters[i].Value; var parameterAsString = parameterValue as string; if (parameterAsString != null) { if (providedParameters[i].MustEvaluate) { var parameterMembers = Parser.SplitParameter(parameterAsString); var sourceControl = EvaluateParameter(parameterMembers[0], parameterType, context); if (parameterMembers[1] == null) { finalValues[i] = CoerceValue(parameterType, sourceControl, context); } else { var sourceProperty = sourceControl.GetType().GetProperty(parameterMembers[1]); var propertyValue = sourceProperty.GetValue(sourceControl, null); finalValues[i] = CoerceValue(parameterType, propertyValue, context); } } else { finalValues[i] = CoerceValue(parameterType, EvaluateParameter(parameterAsString, parameterType, context), context); } } else { finalValues[i] = CoerceValue(parameterType, parameterValue, context); } } return finalValues; }
/// <summary> /// Determines the parameters that a method should be invoked with. /// </summary> /// <param name="context">The action execution context.</param> /// <param name="requiredParameters">The parameters required to complete the invocation.</param> /// <returns>The actual parameter values.</returns> public static object[] DetermineParameters(ActionExecutionContext context, ParameterInfo[] requiredParameters) { var providedParameters = context.Message.Parameters.Select(x => x).ToArray(); var finalValues = new object[requiredParameters.Length]; for (int i = 0; i < requiredParameters.Length; i++) { var parameterType = requiredParameters[i].ParameterType; var parameterValue = providedParameters[i].Value; var parameterAsString = parameterValue as string; if (parameterAsString != null) { if (providedParameters[i].MustEvaluate) { var parameterMembers = Parser.SplitParameter(parameterAsString); var sourceControl = EvaluateParameter(parameterMembers[0], parameterType, context); if (parameterMembers[1] == null) { finalValues[i] = CoerceValue(parameterType, sourceControl, context); } else { var sourceProperty = sourceControl.GetType().GetProperty(parameterMembers[1]); var propertyValue = sourceProperty.GetValue(sourceControl, null); finalValues[i] = CoerceValue(parameterType, propertyValue, context); } } else { finalValues[i] = CoerceValue(parameterType, EvaluateParameter(parameterAsString, parameterType, context), context); } } else { finalValues[i] = CoerceValue(parameterType, parameterValue, context); } } return(finalValues); }
/// <summary> /// Determines the parameters that a method should be invoked with. /// </summary> /// <param name="context">The action execution context.</param> /// <param name="requiredParameters">The parameters required to complete the invocation.</param> /// <returns>The actual parameter values.</returns> public static object[] DetermineParameters(ActionExecutionContext context, ParameterInfo[] requiredParameters) { var providedValues = context.Message.Parameters.Select(x => x.Value).ToArray(); var finalValues = new object[requiredParameters.Length]; for (int i = 0; i < requiredParameters.Length; i++) { var parameterType = requiredParameters[i].ParameterType; var parameterValue = providedValues[i]; var parameterAsString = parameterValue as string; if (parameterAsString != null) { finalValues[i] = CoerceValue(parameterType, EvaluateParameter(parameterAsString, parameterType, context), context); } else { finalValues[i] = CoerceValue(parameterType, parameterValue, context); } } return(finalValues); }
/// <summary> /// Executes the result using the specified context. /// </summary> /// <param name = "context">The context.</param> public void Execute(ActionExecutionContext context) { this.context = context; ChildCompleted(null, new ResultCompletionEventArgs()); }
///<summary> /// Uses the action pipeline to invoke the method. ///</summary> ///<param name="target"> The object instance to invoke the method on. </param> ///<param name="methodName"> The name of the method to invoke. </param> ///<param name="view"> The view. </param> ///<param name="source"> The source of the invocation. </param> ///<param name="eventArgs"> The event args. </param> ///<param name="parameters"> The method parameters. </param> public static void Invoke(object target, string methodName, DependencyObject view = null, FrameworkElement source = null, object eventArgs = null, object[] parameters = null) { var context = new ActionExecutionContext { Target = target, Method = target.GetType().GetMethod(methodName), #if WINFORMS || WEBGUI Message = new ActionMessage(source, null, methodName), #else Message = new ActionMessage { MethodName = methodName }, #endif View = view, Source = source, EventArgs = eventArgs }; if (parameters != null) { parameters.Apply(x => context.Message.Parameters.Add(x as Parameter ?? new Parameter {Value = x})); } ActionMessage.InvokeAction(context); }
/// <summary> /// Try to find a candidate for guard function, having: /// - a name in the form "CanXXX" /// - no generic parameters /// - a bool return type /// - no parameters or a set of parameters corresponding to the action method /// </summary> /// <param name="context">The execution context</param> /// <returns>A MethodInfo, if found; null otherwise</returns> private static MethodInfo TryFindGuardMethod(ActionExecutionContext context) { var guardName = "Can" + context.Method.Name; var targetType = context.Target.GetType(); var guard = targetType.GetMethod(guardName); if (guard == null) return null; if (guard.ContainsGenericParameters) return null; if (typeof (bool) != guard.ReturnType) return null; var guardPars = guard.GetParameters(); var actionPars = context.Method.GetParameters(); if (guardPars.Length == 0) return guard; if (guardPars.Length != actionPars.Length) return null; var comparisons = guardPars.Zip( context.Method.GetParameters(), (x, y) => x.ParameterType == y.ParameterType ); if (comparisons.Any(x => !x)) { return null; } return guard; }
private void UpdateContext() { if (context != null) context.Dispose(); context = new ActionExecutionContext { Message = this, Source = AssociatedObject }; PrepareContext(context); UpdateAvailabilityCore(); }
public void Execute(ActionExecutionContext context) { System.Threading.ThreadPool.QueueUserWorkItem(state => { System.Threading.Thread.Sleep(2000); Response = Guid.NewGuid(); Completed(this, new ResultCompletionEventArgs()); }); }