public override bool Equals(object obj) { ActionWrapper wrapper = obj as ActionWrapper; if (wrapper == null) { return(false); } if (this.ParameterType != wrapper.ParameterType) { return(false); } if (this._object == null && wrapper._object == null) { return(true); } else if (this._object != null && wrapper._object != null) { if (this._object.Target != wrapper._object.Target) { return(false); } } else { return(false); } if (this._method != wrapper._method) { return(false); } return(true); }
private static ParameterContext[] GetContextParms(ActionWrapper action, NakedObject target) { NakedObjectActionParameter[] parms = action.GetParameters(target); return(parms.Select(p => new ParameterContext { Action = action, Parameter = p }).ToArray()); }
protected void InitializeServiceApi(Type interfaceType) { ConcurrentDictionary <string, ActionWrapper> wrapper; if (cache.TryGetValue(interfaceType, out wrapper)) { return; } var newWrapper = new ConcurrentDictionary <string, ActionWrapper>(); foreach (var methodInfo in interfaceType.GetMethods()) { var template = ExtensionsFactory.GetServiceTemplate(methodInfo); var actionName = GetActionName(methodInfo); var action = new ActionWrapper { Name = actionName, ReturnType = methodInfo.ReturnType, RouteTemplate = template, Parameters = new List <ParameterWrapper>() }; var actions = methodInfo.GetCustomAttributes(true).OfType <IActionHttpMethodProvider>(); var methods = ExtensionsFactory.GetHttpMethods(actions.ToList(), methodInfo); var handlers = ExtensionsFactory.GetHeaderInspectors(methodInfo); action.CustomHandlers = handlers; action.Actions = methods; BuildParameterInfo(methodInfo, action); newWrapper.TryAdd(action.Name, action); } if (cache.TryGetValue(interfaceType, out wrapper)) { return; } cache.TryAdd(interfaceType, newWrapper); }
public static NakedObjectActionParameter[] GetParameters(this ActionWrapper action) { NakedObjectSpecification[] parameterTypes = action.getParameterTypes(); int index = 0; return(parameterTypes.Select(nakedObjectSpecification => new NakedObjectActionParameter(GetShortName(nakedObjectSpecification), index++, nakedObjectSpecification, action, null, null)).ToArray()); }
private static Tuple <ActionContext, NakedObjectSpecification> GetActionTypeInternal(string typeName, string actionName) { if (string.IsNullOrEmpty(typeName.Trim()) || string.IsNullOrWhiteSpace(actionName.Trim())) { throw new BadRequestNOSException(); } NakedObjectSpecification spec = [email protected]().loadSpecification(typeName); if (spec is NoMemberSpecification) { throw new TypeResourceNotFoundNOSException(typeName); } ActionWrapper action = spec.GetActionLeafNodes().SingleOrDefault(p => p.getId() == actionName); if (action == null) { throw new ActionResourceNotFoundNOSException(actionName); } var actionContext = new ActionContext { Action = action }; return(new Tuple <ActionContext, NakedObjectSpecification>(actionContext, spec)); }
private void Process(List <ActionWrapper> myWrappedActions) { try { acutPrintf("Process Started!!\n"); acutPrintf(myWrappedActions[0].Parameter + "\n"); for (int i = 0; i < myWrappedActions.Count; i++) { ActionWrapper myActions = myWrappedActions[i]; if (myActions == null) { throw new ArgumentNullException(); } acutPrintf(myActions.Type.ToString() + "\n"); myWrappedActions[i] = _BricsCadEntityInjector.Dispatcher(myActions); myWrappedActions[i].Status = ActionWrapper.StatusEnum.Ok; } } catch (System.Exception ex) { string Error = string.Format("\nError: {0}\nStackTrace: {1}", ex.Message, ex.StackTrace); acutPrintf(Error); } }
public void Act(EventAction action, List <Dependency> deps = null) { //Debug.Log("Act " + action.GetType().Name, gameObject); //Debug.Log(action.State); ActionWrapper wrapper = new ActionWrapper(); wrapper.Action = action; bool canDo = true; if (deps == null) { wrapper.Deps = action.GetDependencies(); //Here it should ask the action to get its dependencies canDo = Traverse(wrapper.Deps); //Here it should traverse those and answer whether it's possible to achieve this action at all, //while also marking external dependencies } else { wrapper.Deps = deps; } if (!canDo) { action.State = EventAction.ActionState.Failed; } else { //Debug.Log("Put as current action"); PutAsCurrentAction(wrapper); } }
private Tuple <ActionWrapper, NakedObjectSpecification, NakedObjectActionParameter> GetActionParameterTypeInternal(string typeName, string actionName, string parmName) { if (string.IsNullOrEmpty(typeName.Trim()) || string.IsNullOrWhiteSpace(actionName.Trim()) || string.IsNullOrWhiteSpace(parmName.Trim())) { throw new BadRequestNOSException(); } NakedObjectSpecification spec = [email protected]().loadSpecification(typeName); if (spec is NoMemberSpecification) { throw new TypeResourceNotFoundNOSException(typeName); } ActionWrapper action = spec.GetActionLeafNodes().SingleOrDefault(p => p.getId() == actionName); if (action == null) { throw new ActionResourceNotFoundNOSException(actionName); } NakedObjectActionParameter parm = action.GetParameters().SingleOrDefault(p => p.getId() == parmName); if (parm == null) { throw new ActionResourceNotFoundNOSException(parmName); } return(new Tuple <ActionWrapper, NakedObjectSpecification, NakedObjectActionParameter>(action, spec, parm)); }
private async Task <ResultWrapper> CreateResult( ActionWrapper action, HttpResponseMessage response) { Type type = typeof(Task).IsAssignableFrom(action.ReturnType) ? ((IEnumerable <Type>)action.ReturnType.GetGenericArguments()).FirstOrDefault <Type>() : action.ReturnType; if (type == typeof(void) || type == (Type)null) { return new ResultWrapper() { Type = typeof(void), IsVoid = true, Value = (object)null, Status = response.StatusCode, StatusMessage = response.ReasonPhrase, ActionId = response.ActionId() } } ; object resultFromResponse = await this.GetResultFromResponse(action, response, type); return(new ResultWrapper() { Type = type, IsVoid = false, Value = resultFromResponse, Status = response.StatusCode, StatusMessage = response.ReasonPhrase, ActionId = response.ActionId() }); }
private static void BuildParameterInfo(MethodInfo methodInfo, ActionWrapper action) { foreach (var parameterInfo in methodInfo.GetParameters()) { var @in = parameterInfo.GetCustomAttribute <InAttribute>(true); if (@in == null) { var fromBody = parameterInfo.GetCustomAttribute <FromBodyAttribute>(true); if (fromBody != null) { @in = new InAttribute(InclutionTypes.Body); } if (@in == null) { var fromUri = parameterInfo.GetCustomAttribute <FromUriAttribute>(true); if (fromUri != null) { @in = new InAttribute(InclutionTypes.Path); } } } action.Parameters.Add(new ParameterWrapper { Name = parameterInfo.Name, Type = parameterInfo.ParameterType, In = @in?.InclutionType ?? InclutionTypes.Body }); } }
public void Unsubscribe <T>(Action <T> action, string key = null) { lock (this._locker) { ActionWrapper wrapper = new ActionWrapper(action); this.Remove(key, wrapper); } }
private void Resync() { FileSyncData sync = this.Project.GetSyncData() as FileSyncData; this.Text = sync.Text; this.ImageKey = sync.ImageKey; this.ContextMenu = ActionWrapper.GetContextMenu(this.Project.ContextActions); }
private ResultWrapper InvokeAction( string name, ParameterWrapper[] parameters, ActionWrapper action, string path) { return(Task.Run <ResultWrapper>((Func <Task <ResultWrapper> >)(async() => await this.InvokeActionAsync(parameters, action, path))).Result); }
public NakedObjectActionParameter(string id, int number, NakedObjectSpecification spec, ActionWrapper action, object[] choices, object dflt) { this.id = id; this.number = number; this.spec = spec; this.action = action; this.choices = choices; this.dflt = dflt; }
private void Resync() { FileSyncData sync = this.File.GetSyncData() as FileSyncData; this.Text = sync.Text; this.ImageKey = sync.ImageKey; this.SelectedImageKey = sync.ImageKey; this.ContextMenuStrip = ActionWrapper.GetContextMenu(this.File.ContextActions); }
public static IAsyncResult BeginInvoke(Func <object> proc, AsyncCallback callback) { ActionWrapper wrap = new ActionWrapper { RunFunc = proc, Callback = callback, }; System.Threading.ThreadPool.QueueUserWorkItem(wrap.DoRun); return(wrap); }
private ActionWrapper Find(string key, ActionWrapper wrapper) { ActionWrapper found = null; if (this._actions.ContainsKey(key)) { found = this._actions[key].SingleOrDefault(x => x.Equals(wrapper)); } return(found); }
static HttpExtensions() { // 使用这个内部方法写HTTP头会比较方便, // 因为有些头不允许直接添加,需要通过属性来设置,那样就需要一大堆的判断,写起来很麻烦。 MethodInfo method = typeof(WebHeaderCollection).GetMethod( "AddWithoutValidate", BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[] { typeof(string), typeof(string) }, null); s_AddWithoutValidateInvoker = new ActionWrapper<WebHeaderCollection, string, string>(); s_AddWithoutValidateInvoker.BindMethod(method); }
static HttpExtensions() { // 使用这个内部方法写HTTP头会比较方便, // 因为有些头不允许直接添加,需要通过属性来设置,那样就需要一大堆的判断,写起来很麻烦。 MethodInfo method = typeof(WebHeaderCollection).GetMethod( "AddWithoutValidate", BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[] { typeof(string), typeof(string) }, null); s_AddWithoutValidateInvoker = new ActionWrapper <WebHeaderCollection, string, string>(); s_AddWithoutValidateInvoker.BindMethod(method); }
public List <ActionWrapper> GetAllAsWrapper(List <Model.Action> myActionList, string filename) { List <ActionWrapper> returnList = new List <ActionWrapper>(); returnList.Add(new ActionWrapper() { Name = nameof(ActionWrapper.TypeEnum.ReadDwgFile), Type = ActionWrapper.TypeEnum.ReadDwgFile, FileName = filename }); foreach (Model.Action item in myActionList) { ActionWrapper myActionWrapper = new ActionWrapper() { FileName = filename }; switch (Enum.Parse(typeof(ActionWrapper.TypeEnum), item.Name)) { case ActionWrapper.TypeEnum.AddCircle: myActionWrapper.Type = ActionWrapper.TypeEnum.AddCircle; break; case ActionWrapper.TypeEnum.AddLayer: myActionWrapper.Type = ActionWrapper.TypeEnum.AddLayer; break; case ActionWrapper.TypeEnum.AddLine: myActionWrapper.Type = ActionWrapper.TypeEnum.AddLine; break; case ActionWrapper.TypeEnum.AddPolyLine: myActionWrapper.Type = ActionWrapper.TypeEnum.AddPolyLine; break; case ActionWrapper.TypeEnum.CreateTable: myActionWrapper.Type = ActionWrapper.TypeEnum.CreateTable; break; case ActionWrapper.TypeEnum.PerfomranceTest: myActionWrapper.Type = ActionWrapper.TypeEnum.PerfomranceTest; break; default: throw new ArgumentException("Unrecognized action type!!"); } returnList.Add(myActionWrapper); } returnList.Add(new ActionWrapper() { Name = nameof(ActionWrapper.TypeEnum.SaveDwgFile), Type = ActionWrapper.TypeEnum.SaveDwgFile, FileName = filename }); return(returnList); }
public static ActionWrapper <T> WithSubscriptionDetails <T>(this ActionWrapper <T> baseAction, ActionSubscriptionDetails details) { return(new ActionWrapper <T> { RuleId = baseAction.RuleId, FlightName = baseAction.FlightName, ActionPath = baseAction.ActionPath, Precedence = baseAction.Precedence, Action = baseAction.Action, Subscription = details }); }
/// <summary>When overridden in a derived class, returns a <see cref="T:System.Windows.DataTemplate"/> based on custom logic.</summary> /// <returns>Returns a <see cref="T:System.Windows.DataTemplate"/> or null. The default value is null.</returns> /// <param name="item">The data object for which to select the template.</param> /// <param name="container">The data-bound object.</param> public override DataTemplate SelectTemplate(object item, DependencyObject container) { ActionWrapper wrapper = (ActionWrapper)item; FrameworkElement element = (FrameworkElement)container; // when the action is a Call use a different data template which will pase the call amount on the button if (wrapper.Action == GuiActions.Call) { return((DataTemplate)element.TryFindResource("CallButtonTemplate")); } // in all other cases use the default template return((DataTemplate)element.TryFindResource("ActionButtonTemplate")); }
private static async Task <string> TryGetErrorBody( ActionWrapper action, HttpResponseMessage resp) { try { return(await resp.Content.ReadAsStringAsync()); } catch { } return((string)null); }
private void Remove(string key, ActionWrapper wrapper) { if (key == null) { key = string.Empty; } ActionWrapper found = this.Find(key, wrapper); if (found != null) { this._actions[key].Remove(wrapper); } }
public ResultWrapper Execute(string name, ParameterWrapper[] parameters) { ActionWrapper action = this.GetAction(name); string path = RestWrapper.BuildActionUrl(parameters, action); int num = 0; int interval = action.Interval; while (num <= action.NumberOfRetries) { ++num; try { ResultWrapper result = CircuitBreakerContainer.GetCircuitBreaker(this.interfaceType).Execute(this.baseUri + path, (Func <ResultWrapper>)(() => this.InvokeAction(name, parameters, action, path)), this._serviceLocator); if (result.Error != null) { if (result.Error is SuspendedDependencyException || !action.Retry || num > action.NumberOfRetries || !this.IsTransient(action, result.Error)) { return(result); } this._serviceLocator.GetService <ILogger>()?.Error(result.Error); this._serviceLocator.GetService <ILogger>()?.Message(string.Format("Retrying action {0}, retry count {1}", (object)action.Name, (object)num)); interval *= action.IncrementalRetry ? num : 1; result.EndState(); Thread.Sleep(interval); } else { if (num > 1) { result.GetState().Extras.Add("retryCount", (object)num); } return(result); } } catch (Exception ex) { this._logger?.Error(ex); if (!action.Retry || num > action.NumberOfRetries || !this.IsTransient(action, ex)) { throw; } else { Thread.Sleep(action.IncrementalRetry ? num : action.Interval); } } } throw new Exception("Should not get here!?!"); }
public IAction this[T key] { get { if (this._actionContainer.TryGetValue(key, out IAction actionwrapper)) { return(actionwrapper); } ActionWrapper <T> wrapper = new ActionWrapper <T>(key, this.Action, this.ActionCanExecute); this._actionContainer.Add(key, wrapper); return(wrapper); } }
public void InvokeAction(string actorName, string operationType) { ActionWrapper action; ActorBase actor; try { actor = _actors[actorName]; } catch { Console.WriteLine("Invalid Actor Name"); return; } switch ((OperationType)int.Parse(operationType)) { case OperationType.Increment: action = new ActionWrapper(this, actorName, actor.Increment); break; case OperationType.Decrement: action = new ActionWrapper(this, actorName, actor.Decrement); break; default: throw new InvalidOperationException(); } var actorState = false; actorState = _actorRunningState[actorName]; if (actorState) //running { _actorsActions[actorName].Enqueue(action.DoPendingAction); } else { _actorRunningState[actorName] = true; var thread = new Thread(() => action.DoAction()); thread.Start(); _threads.Add(thread); } Console.WriteLine($"Added {(OperationType)int.Parse(operationType)} to actor {actorName}"); }
private void GetHeaderValues(ActionWrapper action, HttpResponseMessage response) { if (response == null) { return; } List <IHeaderHandler> source = new List <IHeaderHandler>(); foreach (IHeaderInspector customHandler in action.CustomHandlers) { source.AddRange((IEnumerable <IHeaderHandler>)customHandler.GetHandlers(this._serviceLocator)); } foreach (IHeaderHandler headerHandler in (IEnumerable <IHeaderHandler>)source.OrderBy <IHeaderHandler, int>((Func <IHeaderHandler, int>)(f => f.ProcessingOrder))) { headerHandler.GetHeader(response); } }
private void Add(string key, ActionWrapper wrapper) { if (key == null) { key = string.Empty; } ActionWrapper found = this.Find(key, wrapper); if (found == null) { if (!this._actions.ContainsKey(key)) { this._actions.Add(key, new List <ActionWrapper>()); } this._actions[key].Add(wrapper); } }
public ActionWrapper Dispatcher(ActionWrapper myActionWrapper) { currentActionWrapper = myActionWrapper; switch (myActionWrapper.Type) { case ActionWrapper.TypeEnum.AddCircle: addCircle(); break; case ActionWrapper.TypeEnum.AddLayer: addLayer(); break; case ActionWrapper.TypeEnum.AddLine: addLine(); break; case ActionWrapper.TypeEnum.AddPolyLine: addPolyLine(); break; case ActionWrapper.TypeEnum.CreateTable: createTable(); break; case ActionWrapper.TypeEnum.PerfomranceTest: performanceTest(); break; case ActionWrapper.TypeEnum.ReadDwgFile: readDwgFile(_FileService.GetPath(myActionWrapper.FileName)); break; case ActionWrapper.TypeEnum.SaveDwgFile: saveDwgFile(_FileService.GetPath(myActionWrapper.FileName)); break; default: myActionWrapper.Status = ActionWrapper.StatusEnum.DataError; break; } return(currentActionWrapper); }
protected override async Task DoLogAsync(string message, Exception exception, LogType logType, bool sync) { Tuple <string, Exception, Task> result; result = ActionWrapper.Execute(() => logRepository.Add(GetLogModel(message, logType, exception))); if (WebUtils.WithoutErrors(result.Item1)) { result = sync ? ActionWrapper.Execute(() => logRepository.Commit()) : await ActionWrapper.ExecuteAsync(logRepository.CommitAsync); } if (!WebUtils.WithoutErrors(result.Item1)) { message = $"{message}; {result}"; fileLogger.Value.Log(message, exception, logType); } }
public ActionFacade(ActionWrapper action, Naked target, IFrameworkFacade frameworkFacade) { this.action = action; this.target = target; FrameworkFacade = frameworkFacade; }
private async void HardwareButtons_BackPressed(object sender, BackPressedEventArgs e) { var backArgs = e; var wrapper = new ActionWrapper { WrappedAction = () => { backArgs.Handled = true; } }; await GoToPreviousState(wrapper); }
/// <summary> /// Invoke all the given actions in parallel in their own thread. /// <para> /// A memory barrier is used to line up all actions in an attempt to ensure they are all invoked at the same time. The idea is /// to cause maximum contention. However this is very much up to the OS, number or cores, whether true threading is used etc. /// </para> /// <para> /// If you are performing multiple operations inside your action, it is suggested to to add a Thread.Yield() in suitable /// places to increase the chance you will get out of order execution between threads (rather than one thread executing all the /// way through without being switched out partway through operation) /// </para> /// </summary> /// <param name="parallelActions">actions to complete in parallel</param> /// <param name="timeout">timeout period after which to abort</param> /// <param name="priority">priority with which to run threads</param> public static void InvokeAllWaitingForCompletion(IEnumerable<Action> parallelActions, TimeSpan timeout, ThreadPriority priority = ThreadPriority.Normal) { var actionList = new List<Action>(parallelActions); // allow multiple iteration var barrierToCauseContention = new Barrier(actionList.Count()); var wrappedActions = new List<ActionWrapper>(actionList.Count()); var threads = new List<Thread>(actionList.Count); // wrap passed in actions so we can monitor the state of their execution and collect any exceptions thrown // the wrapped actions will wait on the barrier foreach (var action in actionList) { var wrapper = new ActionWrapper(barrierToCauseContention, action); var thread = new Thread(wrapper.Invoke) { Priority = priority }; threads.Add(thread); wrappedActions.Add(wrapper); thread.Start(); } // wait till all actions complete var timeoutInMs = timeout.TotalMilliseconds; var stopWatch = Stopwatch.StartNew(); var allComplete = false; while (!allComplete) { // if we timed out if (stopWatch.ElapsedMilliseconds > timeoutInMs) { // kill all the threads still running foreach (var t in threads) { TerminateThreadQuietly(t); } TestFirstAssert.Fail(string.Format("Timed out waiting for all actions to complete. Waitied for {0} milliseonds (TimeSpan {1}). Aborted remaining threads", timeoutInMs, timeout)); } // determine if all actions complete var complete = true; foreach (var wrapper in wrappedActions) { if (!wrapper.IsComplete) { complete = false; break; } } allComplete = complete; if (!allComplete) { Thread.Sleep(100); // give actions a bit of time to complete } } // fail if any of the actions threw an exception var exceptions = new List<string>(); foreach (var wrapper in wrappedActions) { if (wrapper.HasFailed) { exceptions.Add("thread[" + wrapper.ThreadId + "] : " + wrapper.Exception); } } if (exceptions.Count > 0) { var msg = "===============Action Error===========\r\n" + string.Join("\r\n===============Action Error===========", exceptions); TestFirstAssert.Fail(msg); } }
protected async void BackRequested(object sender, BackRequestedEventArgs e) { var backArgs = e; var wrapper = new ActionWrapper { WrappedAction = () => { backArgs.Handled = true; } }; await GoToPreviousState(wrapper); }
private async Task GoToPreviousState(ActionWrapper onsuccess) { Debug.WriteLine("Going back"); var reg = RegionForCurrentWindow as IHasStates; //var win = Window.Current.CoreWindow; //var regId = (from r in RegionWindows // where r.Value == win // select r.Key).FirstOrDefault(); //if (regId != null) //{ // var reg = RegionManager.RegionById(regId) as IHasStates; if (reg?.StateManager.PreviousStateExists ?? false) { onsuccess.InvokeAction(); if (!(reg?.StateManager.GoToPreviousStateIsBlocked ?? false)) { await reg.StateManager.GoBackToPreviousState(); } return; } //} //var gb = GoBackViewModel; //if (gb != null) //{ // var cancel = new CancelEventArgs(); // await GoBackViewModel.GoingBack(cancel); // if (cancel.Cancel) // { // e.Handled = true; // return; // } //} //e.Handled = true; //if (Frame.CanGoBack) //{ // Frame.GoBack(); //} }