public TextCommand( CanExecuteCallback canExecute, ExecuteCallback execute) { this.CanExecute = canExecute; this.Execute = execute; }
/// <summary> /// Adds component command builder to <see cref="ComponentCommands"/>. /// </summary> /// <param name="name">Name of the command.</param> /// <param name="callback">Command callback to be executed.</param> /// <param name="configure"><see cref="ComponentCommandBuilder"/> factory.</param> /// <returns> /// The builder instance. /// </returns> public ModuleBuilder AddComponentCommand(string name, ExecuteCallback callback, Action <ComponentCommandBuilder> configure) { var command = new ComponentCommandBuilder(this, name, callback); configure(command); _componentCommands.Add(command); return(this); }
/// <summary> /// Adds autocomplete command builder to <see cref="AutocompleteCommands"/>. /// </summary> /// <param name="name">Name of the command.</param> /// <param name="callback">Command callback to be executed.</param> /// <param name="configure"><see cref="AutocompleteCommandBuilder"/> factory.</param> /// <returns> /// The builder instance. /// </returns> public ModuleBuilder AddSlashCommand(string name, ExecuteCallback callback, Action <AutocompleteCommandBuilder> configure) { var command = new AutocompleteCommandBuilder(this, name, callback); configure(command); _autocompleteCommands.Add(command); return(this); }
public CommandRegistrationBuilder Add <TBag>([NotNull] Identifier id, [NotNull] ExecuteCallback <TBag> execute) where TBag : ICommandParameter, new() { return(Add <Lambda <TBag> >(r => { r.Id = id; r.Execute = execute; })); }
public void DropViewModel(string key) { CommandQueue.Enqueue(new DeleteCachCommand { Key = key }); ExecuteCallback pollCallback = ExecuteCommands; pollCallback.BeginInvoke(null, null); }
public void DropViewModelByModel(Guid modelId) { CommandQueue.Enqueue(new DeleteCachByModelCommand { ModelId = modelId }); ExecuteCallback pollCallback = ExecuteCommands; pollCallback.BeginInvoke(null, null); }
public void AddNewViewModel(ICachedViewModel startModel) { CommandQueue.Enqueue(new AddCachCommand { ViewModel = startModel }); ExecuteCallback pollCallback = ExecuteCommands; pollCallback.BeginInvoke(null, null); }
public virtual void ExecuteTableAsync(IDbCommand command, ExecuteCallback <DataTable> callback, object state) { if (command == null) { throw new ArgumentNullException("command"); } if (callback == null) { throw new ArgumentNullException("callback"); } AsyncExecuteState <DataTable> internalState = new AsyncExecuteState <DataTable> (command, callback, state); ThreadPool.QueueUserWorkItem(new WaitCallback(ExecuteTableThreaded), internalState); }
internal CommandInfo(Builders.ICommandBuilder builder, ModuleInfo module, InteractionService commandService) { CommandService = commandService; Module = module; Name = builder.Name; MethodName = builder.MethodName; IgnoreGroupNames = builder.IgnoreGroupNames; RunMode = builder.RunMode != RunMode.Default ? builder.RunMode : commandService._runMode; Attributes = builder.Attributes.ToImmutableArray(); Preconditions = builder.Preconditions.ToImmutableArray(); _action = builder.Callback; _groupedPreconditions = builder.Preconditions.ToLookup(x => x.Group, x => x, StringComparer.Ordinal); }
public ReadEvalPrintLoop(AutoCompleteCallback autoCompleteCallback, ExecuteCallback executeCallback, string prompt = "$>", string historyFile = null) { AutoCompleteHook = autoCompleteCallback; ExecuteHook = executeCallback; Prompt = prompt; if (historyFile != null) { History = File.ReadAllText(historyFile) .Split(Environment.NewLine) .ToList(); } }
public void ShowProgressBar(ExecuteCallback callback) { this._executeCallback = callback; this.progressBar.Maximum = 50; this.btnCancel.Enabled = false; this._timer = new System.Windows.Forms.Timer(); this._timer.Interval = 100; this._timer.Tick += new EventHandler(timer_Tick); this._thread = new Thread(ExecuteOnce); this._thread.Name = "ProgressForm ExecuteOnce Thread"; this.ShowDialog(); this.CloseThread(); }
public void ClearOldCach() { var oldDate = DateTime.Now.AddHours(-6); var item = Cach.SingleOrDefault(x => x.Value.CachLastAccess <= oldDate); while (item.Key != null) { CommandQueue.Enqueue(new DeleteCachCommand { Key = item.Key }); item = Cach.SingleOrDefault(x => x.Value.CachLastAccess <= oldDate); } ExecuteCallback pollCallback = ExecuteCommands; pollCallback.BeginInvoke(null, null); }
//////////////////////////////////////////////////////////////////////// #region IExecute Members public override ReturnCode Execute( Interpreter interpreter, IClientData clientData, ArgumentList arguments, ref Result result ) { ExecuteCallback callback = this.Callback; if (callback != null) { return(callback(interpreter, clientData, arguments, ref result)); } else { return(ReturnCode.Error); } }
public VoxelQuery(Vector3 position, int width, int height, int depth, bool[] mask, ExecuteCallback executeCallback) { if (width < 1 || height < 1 || depth < 1) { throw new Exception ("width < 1 || height < 1 || depth < 1"); } int size = width * height * depth; if (mask.Length != size) { throw new Exception ("mask.Length != size"); } if (executeCallback == null) { throw new Exception ("executeCallback == null"); } _position = position; _width = width; _height = height; _depth = depth; _mask = mask; _executeCallback = executeCallback; }
public CLIBase(ExecuteCallback cb) { Callback = cb; }
protected CommandBuilder(ModuleBuilder module, string name, ExecuteCallback callback) : this(module) { Name = name; Callback = callback; }
/// <summary> /// Initializes a new <see cref="ComponentBuilder"/>. /// </summary> /// <param name="module">Parent module of this command.</param> /// <param name="name">Name of this command.</param> /// <param name="callback">Execution callback of this command.</param> public ComponentCommandBuilder(ModuleBuilder module, string name, ExecuteCallback callback) : base(module, name, callback) { }
public virtual void Execute(ExecuteCallback callback) { this.callback = callback; Context.ClientPage.Start(this, "Pipeline"); }
public Lambda(CommandServiceProvider <Lambda <TBag> > serviceProvider, [NotNull] Identifier id, [NotNull] ExecuteCallback <TBag> execute) : base(serviceProvider, id) { _execute = execute ?? throw new ArgumentNullException(nameof(execute)); }
public VoxelQuery(int width, int height, int depth, bool[] mask, ExecuteCallback executeCallback) : this(Vector3.zero, width, height, depth, mask, executeCallback) { }
public CreateItem(ExecuteCallback callback) { this.callback = callback; }
/// <summary> /// Initializes a new <see cref="AutocompleteCommandBuilder"/>. /// </summary> /// <param name="module">Parent module of this command.</param> /// <param name="name">Name of this command.</param> /// <param name="callback">Execution callback of this command.</param> public AutocompleteCommandBuilder(ModuleBuilder module, string name, ExecuteCallback callback) : base(module, name, callback) { }
public RelayCommand(ExecuteCallback execute, CanExecuteCallback canExecute) { this._execute = execute; this._canExecute = canExecute; }
/// /// * <param name="_callback"> the ExecuteCallback to set </param> /// public virtual void setExecuteCallback(ExecuteCallback _callback) { this.executeCallback = _callback; }
public RelayCommand(ExecuteCallback execute) : this(execute, RelayCommand.CanExecuteDefault) { }
public void ShowProgressBar(ExecuteCallback callback) { this._executeCallback = callback; this.progressBar.Maximum = 50; this.btnCancel.Enabled = false; this._timer = new System.Windows.Forms.Timer (); this._timer.Interval = 100; this._timer.Tick += new EventHandler (timer_Tick); this._thread = new Thread (ExecuteOnce); this._thread.Name = "ProgressForm ExecuteOnce Thread"; this.ShowDialog (); this.CloseThread (); }
public AsyncExecuteState(IDbCommand command, ExecuteCallback <T> callback, object state) { Command = command; Callback = callback; State = state; }
public CallbackAction(String name, ExecuteCallback execute = null) : base(name) { this.executeCallback = execute; }
public static IEnumerable ExecuteQuery(DataServiceContext context, DataServiceRequest query, QueryMode queryMode) { bool isQuery = (null != (query as DataServiceQuery)); object result = null; switch (queryMode) { case QueryMode.GetEnumerator: // IEnumerable.GetEnumerator { if (isQuery) { result = query; } else { goto case QueryMode.ExecuteMethod; } break; } case QueryMode.ExecuteMethod: // DataServiceQuery<T>.Execute { if (isQuery) { result = UnitTestCodeGen.InvokeMethod(query.GetType(), "Execute", null, null, query, null); } else { result = UnitTestCodeGen.InvokeMethod(typeof(DataServiceContext), "Execute", TypesUri, new Type[] { query.ElementType }, context, query.RequestUri); } break; } case QueryMode.AsyncExecute: // DataServiceQuery<T>.BeginExecute and wait { if (isQuery) { IAsyncResult async = (IAsyncResult)UnitTestCodeGen.InvokeMethod(query.GetType(), "BeginExecute", TypesAsyncCallbackObject, null, query, new object[] { null, null }); if (!async.CompletedSynchronously) { Assert.IsTrue(async.AsyncWaitHandle.WaitOne(new TimeSpan(0, 0, TestConstants.MaxTestTimeout), false), "BeginExecute timeout"); } result = UnitTestCodeGen.InvokeMethod(query.GetType(), "EndExecute", TypesIAsyncResult, null, query, new object[] { async }); } else { IAsyncResult async = UnitTestCodeGen.InvokeMethod <DataServiceContext, IAsyncResult>("BeginExecute", TypesUriAsyncCallbackObject, new Type[] { query.ElementType }, context, query.RequestUri, null, null); if (!async.CompletedSynchronously) { Assert.IsTrue(async.AsyncWaitHandle.WaitOne(new TimeSpan(0, 0, TestConstants.MaxTestTimeout), false), "BeginExecute timeout"); } result = UnitTestCodeGen.InvokeMethod(typeof(DataServiceContext), "EndExecute", TypesIAsyncResult, new Type[] { query.ElementType }, context, async); } break; } case QueryMode.AsyncExecuteWithCallback: // DataServiceQuery<T>.BeginExecute with callback { ExecuteCallback callback = new ExecuteCallback(); IAsyncResult async; if (isQuery) { async = (IAsyncResult)UnitTestCodeGen.InvokeMethod(query.GetType(), "BeginExecute", TypesAsyncCallbackObject, null, query, new object[] { (AsyncCallback)callback.CallbackMethod, new object[] { query, context } }); } else { async = UnitTestCodeGen.InvokeMethod <DataServiceContext, IAsyncResult>("BeginExecute", TypesUriAsyncCallbackObject, new Type[] { query.ElementType }, context, new object[] { query.RequestUri, (AsyncCallback)callback.CallbackMethod, new object[] { query, context } }); } Assert.IsTrue(callback.Finished.WaitOne(new TimeSpan(0, 0, TestConstants.MaxTestTimeout), false), "Asyncallback timeout"); Assert.IsTrue(async.IsCompleted); if (null != callback.CallbackFailure) { Assert.IsNull(callback.CallbackResult, callback.CallbackFailure.ToString()); throw new Exception("failure in callback", callback.CallbackFailure); } result = callback.CallbackResult; Assert.IsNotNull(result); break; } case QueryMode.BatchExecute: // DataServiceContext.ExecuteBatch { LastUriRequest = query.RequestUri; int countBefore = context.Entities.Count + context.Links.Count; DataServiceResponse response = context.ExecuteBatch(query); int countAfter = context.Entities.Count + context.Links.Count; Assert.AreEqual(countBefore, countAfter, "should not materialize during ExecuteBatch"); result = HandleQueryResponse(response, query, context); } break; case QueryMode.BatchAsyncExecute: // DataServiceContext.BeginExecuteBatch and wait { int count = context.Entities.Count + context.Links.Count; LastUriRequest = query.RequestUri; IAsyncResult async = context.BeginExecuteBatch(null, null, query); if (!async.CompletedSynchronously) { Assert.IsTrue(async.AsyncWaitHandle.WaitOne(new TimeSpan(0, 0, TestConstants.MaxTestTimeout), false), "BeginExecuteBatch timeout"); } Assert.AreEqual(count, context.Entities.Count + context.Links.Count, "should not materialize until EndExecuteBatch"); DataServiceResponse response = context.EndExecuteBatch(async); result = HandleQueryResponse(response, query, context); break; } case QueryMode.BatchAsyncExecuteWithCallback: // DataServiceContext.BeginExecuteBatch with callback { ExecuteBatchCallback callback = new ExecuteBatchCallback(); LastUriRequest = query.RequestUri; IAsyncResult async = context.BeginExecuteBatch(callback.CallbackMethod, new object[] { query, context }, query); Assert.IsTrue(callback.Finished.WaitOne(new TimeSpan(0, 0, TestConstants.MaxTestTimeout), false), "Asyncallback timeout {0}", LastUriRequest); Assert.IsTrue(async.IsCompleted); if (null != callback.CallbackFailure) { Assert.IsNull(callback.CallbackResult, callback.CallbackFailure.ToString()); throw new Exception("failure in callback", callback.CallbackFailure); } result = callback.CallbackResult; Assert.IsNotNull(result); break; } default: Assert.Fail("shouldn't be here"); break; } return((IEnumerable)result); }
private static void Fire <DelegateType>(this Subscriptions collection, Type dataType, ExecuteCallback <DelegateType> runner) where DelegateType : class { Verify.ArgumentNotNull(collection, "collection"); Verify.ArgumentNotNull(dataType, "dataType"); Verify.ArgumentNotNull(runner, "runner"); if (SuppressEventScope.IsEnabled) { return; } List <Type> types = GetTypesToFire(dataType); foreach (Type type in types) { Pair <Delegate, bool>[] subscriptions = null; if (collection.ContainsKey(type)) { lock (_collectionAccesslock) { if (collection.ContainsKey(type)) { subscriptions = collection[type].ToArray(); } } } if (subscriptions == null) { continue; } foreach (Pair <Delegate, bool> subscription in subscriptions) { var callback = subscription.First as DelegateType; Verify.That(callback != null, "Wrong delegate type"); runner(callback); } } }
//2 public BotCommand(ExecuteCallback executeMethod, string name) { Execute = executeMethod; commandName = name; }
public static void YesNoCancelMessage(string message, string width, string height, ExecuteCallback callback) { new YesNoCancelMessage(message, width, height).Execute(callback); }