/// <summary> /// Bluetooth transport constructor /// </summary> public BluetoothTransport() { _showAsConnected = false; _lazyReconnect = true; _worker = new AsyncWorker(Poll); _worker.Name = "Bluetooth Transport"; }
public void FindOrganisationList() { DataTable dt = new DataTable(); dt.Columns.Add("Organisation"); dt.Columns.Add("Description"); this.ug_organisationlist.DataSource = dt; this.lbl_recordCount.Text = this.ug_organisationlist.Rows.Count.ToString(); using (AsyncWorker<IOrganisationMaintenance> worker = new AsyncWorker<IOrganisationMaintenance>(_presenter, this.ug_organisationlist, new Control[] { btn_search, btn_reset })) { worker.DoWork += delegate(object oDoWork, DoWorkEventArgs eDoWork) { eDoWork.Result = _presenter.FindeOrganisationsByConditions(this.txt_organisationName.Text, this.txt_organisationDescription.Text); }; worker.RunWorkerCompleted += delegate(object oCompleted, RunWorkerCompletedEventArgs eCompleted) { List<OrganisationEntity> orgEntities = eCompleted.Result as List<OrganisationEntity>; if (orgEntities != null) { foreach (OrganisationEntity entity in orgEntities) { dt.Rows.Add(entity.OrganisationName, entity.OrganisationDescription); } } this.ug_organisationlist.DataSource = dt; this.lbl_recordCount.Text = this.ug_organisationlist.Rows.Count.ToString(); }; worker.Run(); } }
public void ExceptionViewModelConstructorNewAsyncWorker() { IAsyncWorker asyncWorker = new AsyncWorker(); ExceptionViewModel vm = new ExceptionViewModel(asyncWorker); Assert.IsNotNull(vm.AsyncWorker); Assert.AreSame(asyncWorker, vm.AsyncWorker); }
/// <summary> Gets or sets the current serial port settings. </summary> /// <value> The current serial settings. </value> public FileTransport() { _arduino2pc = System.IO.File.Open(@"c:\temp\serial2pc.txt", FileMode.OpenOrCreate, FileAccess.Read, FileShare.ReadWrite); _pc2arduino = System.IO.File.Open(@"c:\temp\serial2arduino.txt", FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite); _arduino2pc.Seek(0, SeekOrigin.End); _worker = new AsyncWorker(Poll); _worker.Name = "FileTransport"; }
private void LogOperationCompletedWithException(AsyncWorker asyncWorker, DoWorkEventHandler worker, Exception exception) { this.log.Debug(string.Format( CultureInfo.InvariantCulture, "{0} completes asynchronous operation {1}.{2}() with exception = {3}", asyncWorker, worker.Method.DeclaringType.FullName, worker.Method.Name, exception)); }
public void Start(AsyncWorker <T> work) { try { _results.Add(work()); } catch (Exception error) { _results.Add(new AsyncWorkResult <T>(error)); } }
/// <summary> /// Called when an operation is cancelled. /// </summary> /// <param name="asyncWorker">The async worker.</param> /// <param name="worker">The worker.</param> public void CancellingExecution(AsyncWorker asyncWorker, DoWorkEventHandler worker) { if (this.log.IsDebugEnabled) { this.log.Debug(string.Format( CultureInfo.InvariantCulture, "{0} cancels asynchronous operation {1}.{2}()", asyncWorker, worker.Method.DeclaringType.FullName, worker.Method.Name)); } }
/// <summary> /// Called when an operation reports progress. /// </summary> /// <param name="asyncWorker">The async worker.</param> /// <param name="worker">The worker.</param> /// <param name="progress">The progress.</param> /// <param name="userState">State of the user.</param> public void ReportProgress(AsyncWorker asyncWorker, DoWorkEventHandler worker, ProgressChangedEventHandler progress, object userState) { if (this.log.IsDebugEnabled) { this.log.Debug(string.Format( CultureInfo.InvariantCulture, "{0} reports progress for operation {1}.{2}()", asyncWorker, worker.Method.DeclaringType.FullName, worker.Method.Name)); } }
/// <summary> /// Called when an operation is cancelled. /// </summary> /// <param name="asyncWorker">The async worker.</param> /// <param name="worker">The worker.</param> public void CancellingExecution(AsyncWorker asyncWorker, DoWorkEventHandler worker) { if (this.log.IsInfoEnabled) { this.log.Info(string.Format( CultureInfo.InvariantCulture, "{0} cancels asynchronous operation {1}.{2}()", asyncWorker, worker.Method.DeclaringType.FullName, worker.Method.Name)); } }
private void btnLogin_Click(object sender, RoutedEventArgs e) { bool isApplySuccess = false; string strpwd = pbPwd.Password; string strPrinterName = ((MainWindow)App.Current.MainWindow).statusPanelPage.m_selectedPrinter; string strDrvName = ""; if (false == common.GetPrinterDrvName(strPrinterName, ref strDrvName)) { MessageBoxEx_Simple messageBox = new MessageBoxEx_Simple((string)this.TryFindResource("ResStr_can_not_be_carried_out_due_to_software_has_error__please_try__again_after_reinstall_the_Driver_and_Virtual_Operation_Panel_"), (string)this.FindResource("ResStr_Error")); messageBox.Owner = App.Current.MainWindow; messageBox.ShowDialog(); return; } if (strpwd.Length > 0) { PasswordRecord m_rec = new PasswordRecord(strPrinterName, strpwd); AsyncWorker worker = new AsyncWorker(this); if (worker.InvokeMethod <PasswordRecord>(strPrinterName, ref m_rec, DllMethodType.ConfirmPassword, this)) { if (null != m_rec && m_rec.CmdResult == EnumCmdResult._ACK) { ((MainWindow)App.Current.MainWindow).m_strPassword = strpwd; isApplySuccess = true; } } if (!isApplySuccess) { ((MainWindow)App.Current.MainWindow).m_strPassword = ""; pbPwd.Focus(); pbPwd.SelectAll(); tbkErrorInfo.Foreground = new SolidColorBrush(Colors.Red); tbkErrorInfo.Text = (string)this.FindResource("ResStr_Authentication_error__please_enter_the_password_again_"); } else { this.DialogResult = true; this.Close(); } } else { tbkErrorInfo.Foreground = new SolidColorBrush(Colors.Red); tbkErrorInfo.Text = (string)this.FindResource("ResStr_The_new_password_can_not_be_empty_"); } }
/// <summary> /// Called when an operation is started. /// </summary> /// <param name="asyncWorker">The async worker.</param> /// <param name="worker">The worker.</param> /// <param name="argument">The argument.</param> public void StartedExecution(AsyncWorker asyncWorker, DoWorkEventHandler worker, object argument) { if (this.log.IsDebugEnabled) { this.log.Debug(string.Format( CultureInfo.InvariantCulture, "{0} executes asynchronous operation {1}.{2}({3})", asyncWorker, worker.Method.DeclaringType.FullName, worker.Method.Name, argument)); } }
public void SetEventLoop(bool active) { if (_active == active) { return; } _active = active; if (_active) { AsyncWorker.Run(EventLoop); } }
private async Task SomeAsyncFunction() { Log("Starting async function"); Log("Waiting for coroutine"); await AsyncWorker.RunAsync(SomeCoroutine); Log("Waiting for deferred"); await SomeExternalAsyncFunction(); Log("Woo! All async stuff worked"); Completed(); }
public ApplicationWatcher(Logger logger) { //ProcessHandlers= new List<ProcessHandler>(); ApplicationHandlers = new List <ApplicationHandler>(); _sleepStopwatch = new Stopwatch(); var asyncWorkerMonitor = new AsyncWorker(MonitorJob) { Name = "ApplicationWatcher" }; asyncWorkerMonitor.Start(); _logger = logger; }
public AsyncTest() { InitializeComponent(); var taskId = Guid.NewGuid(); AsyncWorker.Execute(() => DateTime.Now.ToString(), time => display.Text += time + "\r\n", new TimeSpan(0, 0, 0, 5), processId: taskId); AsyncWorker.Execute(() => "Hello! " + Environment.TickCount.ToString(), time => display.Text += time + "\r\n", new TimeSpan(0, 0, 0, 2)); AsyncWorker.PauseContinuousProcess(taskId); AsyncWorker.ResumeContinuousProcess(taskId); AsyncWorker.StopContinuousProcess(taskId); }
/// <summary> /// Called when an operation is started. /// </summary> /// <param name="asyncWorker">The async worker.</param> /// <param name="worker">The worker.</param> /// <param name="argument">The argument.</param> public void StartedExecution(AsyncWorker asyncWorker, DoWorkEventHandler worker, object argument) { if (this.log.IsInfoEnabled) { this.log.Info(string.Format( CultureInfo.InvariantCulture, "{0} executes asynchronous operation {1}.{2}({3})", asyncWorker, worker.Method.DeclaringType.FullName, worker.Method.Name, argument)); } }
public bool apply() { bool isApplySuccess = false; // soft ap config string str_ssid = tbSSID.Text; string str_pwd = tbPWD.Text; bool isEnableSoftAp = (chkbtn_wifi_enable.IsChecked == true); if (is_InputVailible()) { SoftApRecord m_rec = new SoftApRecord(((MainWindow)App.Current.MainWindow).statusPanelPage.m_selectedPrinter, str_ssid, str_pwd, isEnableSoftAp); AsyncWorker worker = new AsyncWorker(Application.Current.MainWindow); if (worker.InvokeMethod <SoftApRecord>(((MainWindow)App.Current.MainWindow).statusPanelPage.m_selectedPrinter, ref m_rec, DllMethodType.SetSoftAp, this)) { if (null != m_rec && m_rec.CmdResult == EnumCmdResult._ACK) { softAPSettingInit.m_ssid = softAPSetting.m_ssid = str_ssid; softAPSettingInit.m_pwd = softAPSetting.m_pwd = str_pwd; softAPSettingInit.m_bEnableSoftAp = softAPSetting.m_bEnableSoftAp = isEnableSoftAp; isApplySuccess = true; } } //if (null != event_config_dirty) // event_config_dirty(is_dirty()); } else { if (str_ssid.Length <= 0) { VOP.Controls.MessageBoxEx.Show(VOP.Controls.MessageBoxExStyle.Simple, Application.Current.MainWindow, (string)this.FindResource("ResStr_Msg_10"), (string)this.FindResource("ResStr_Warning")); } else if (str_pwd.Length < 8 || str_pwd.Length >= 64) { VOP.Controls.MessageBoxEx.Show(VOP.Controls.MessageBoxExStyle.Simple, Application.Current.MainWindow, (string)this.FindResource("ResStr_Msg_3"), (string)this.FindResource("ResStr_Warning")); } } if (isApplySuccess) { ((MainWindow)App.Current.MainWindow).statusPanelPage.ShowMessage((string)this.FindResource("ResStr_Msg_1"), Brushes.Black); } else { ((MainWindow)App.Current.MainWindow).statusPanelPage.ShowMessage((string)this.FindResource("ResStr_Setting_Fail"), Brushes.Red); } return(isApplySuccess); }
public bool apply() { bool isApplySuccess = false; string strPWD = pbnewPWD.Password; string strCfPWD = pbConfirmPWD.Password; if (strPWD.Length > 0 && strPWD == strCfPWD) { if (strPWD.Length > 0) { string strPrinterName = ((MainWindow)App.Current.MainWindow).statusPanelPage.m_selectedPrinter; PasswordRecord m_rec = new PasswordRecord(strPrinterName, strPWD); AsyncWorker worker = new AsyncWorker(Application.Current.MainWindow); if (worker.InvokeMethod <PasswordRecord>(strPrinterName, ref m_rec, DllMethodType.SetPassword, this)) { if (null != m_rec && m_rec.CmdResult == EnumCmdResult._ACK) { ((MainWindow)App.Current.MainWindow).m_strPassword = strCfPWD; isApplySuccess = true; } } } if (isApplySuccess) { ((MainWindow)App.Current.MainWindow).statusPanelPage.ShowMessage((string)this.FindResource("ResStr_Setting_Successfully_"), Brushes.Black); } else { ((MainWindow)App.Current.MainWindow).statusPanelPage.ShowMessage((string)this.FindResource("ResStr_Setting_Fail"), Brushes.Red); } } else { if (strPWD.Length == 0) { pbnewPWD.Focus(); VOP.Controls.MessageBoxEx.Show(VOP.Controls.MessageBoxExStyle.Simple, Application.Current.MainWindow, (string)this.FindResource("ResStr_The_new_password_can_not_be_empty_"), (string)this.FindResource("ResStr_Error")); } else if (strPWD != strCfPWD) { pbnewPWD.Focus(); pbnewPWD.SelectAll(); VOP.Controls.MessageBoxEx.Show(VOP.Controls.MessageBoxExStyle.Simple, Application.Current.MainWindow, (string)this.FindResource("ResStr_The_passwords_you_entered__are_different__please_try_again_"), (string)this.FindResource("ResStr_Error")); } } return(isApplySuccess); }
private void OnLoadedIPV6View(object sender, RoutedEventArgs e) { InitFontSize(); AsyncWorker worker = new AsyncWorker(this); worker.InvokeMethod <IPV6InfoRecord>(((MainWindow)App.Current.MainWindow).statusPanelPage.m_selectedPrinter, ref m_rec, DllMethodType.GetIpv6Info, this); if (null != m_rec) { if (1 == m_rec.DHCPv6) { btnDHCP.IsChecked = true; } else { btnDHCP.IsChecked = false; } if (1 == m_rec.UseManualAddress) { btnManual.IsChecked = true; } else { btnManual.IsChecked = false; } if (1 == m_rec.UseManualAddress) { tb_ip.Text = m_rec.IPManualAddress; tb_PreSubMask.Text = String.Format("{0}", m_rec.ManualMask); } else { tb_ip.Text = "::"; tb_PreSubMask.Text = String.Format("{0}", 1); } if (1 == m_rec.UseManualAddress) { tb_Gateway.Text = m_rec.IPv6ManualGatewayAddress; // tb_GatewayPreSubMask.Text = String.Format("{0}", m_rec.ManualGatewayAddressMask); } else { tb_Gateway.Text = "::"; // tb_GatewayPreSubMask.Text = String.Format("{0}", 0); } } }
public override void SetUp() { base.SetUp(); AsyncWorker worker = new AsyncWorker(); worker.QueueUserWorkItem = delegate(WaitCallback function) { function(null); return(true); }; tracker = new TrailTracker(persister); tracker.Start(); }
public ConsumingMessageService(Consumer consumer) { _consumer = consumer; _logger = ObjectContainer.Resolve <ILoggerFactory>().Create(GetType().FullName); _scheduleService = ObjectContainer.Resolve <IScheduleService>(); if (_isSequentialConsume) { _consumeWaitingQueue = new BlockingCollection <ConsumeResult <Ignore, string> >(); _consumeMessageWorker = new AsyncWorker("ConsumeMessage", async() => await HandleMessageAsync(_consumeWaitingQueue.Take())); } _consumingQueues = new ConcurrentDictionary <string, TopicPartitionProcessQueue <Ignore, string> >(); _retryQueue = new BlockingCollection <ConsumeResult <Ignore, string> >(); }
void analog_AnalogChanged(object sender, AnalogChangeEventArgs e) { { double v = Convert.ToDouble(e.Channels[0]); result.Enqueue(v); if (result.Count > 22) { AsyncWorker.ReportProgress(-1, null); result.Dequeue(); } } }
/// <summary> /// Called when an operation was completed. /// </summary> /// <param name="asyncWorker">The async worker.</param> /// <param name="worker">The worker.</param> /// <param name="completed">The completed handler.</param> /// <param name="runWorkerCompletedEventArgs">The <see cref="System.ComponentModel.RunWorkerCompletedEventArgs"/> instance containing the event data.</param> public void CompletedExecution(AsyncWorker asyncWorker, DoWorkEventHandler worker, RunWorkerCompletedEventHandler completed, RunWorkerCompletedEventArgs runWorkerCompletedEventArgs) { if (this.log.IsDebugEnabled) { if (runWorkerCompletedEventArgs.Error == null) { this.LogOperationCompletedWithoutException(asyncWorker, worker); } else { this.LogOperationCompletedWithException(asyncWorker, worker, runWorkerCompletedEventArgs.Error); } } }
static void Main(string[] args) { Console.WriteLine("App start!"); IEnumerable <string> m_oEnum = new List <string>() { "1", "2", "3" }; AsyncWorker.LoopAsync(m_oEnum); Console.WriteLine("App completed!"); Console.Read(); }
/// <summary> /// Checks if specified process is currently running. /// </summary> /// <param name="process">Async process to check its status</param> private bool ProcessIsRunning(AsyncWorker process) { switch (process.Status) { // Process not running statuses case AsyncWorkerStatusEnum.Unknown: case AsyncWorkerStatusEnum.Stopped: case AsyncWorkerStatusEnum.Finished: case AsyncWorkerStatusEnum.Error: return(false); default: return(true); } }
public ElasticsearchSourceViewModel(IElasticsearchSourceModel elasticsearchSourceModel, IEventAggregator aggregator, IElasticsearchSourceDefinition elasticsearchServiceSource, IAsyncWorker asyncWorker, IExternalProcessExecutor executor, IServer currentEnvironment) : this(elasticsearchSourceModel, aggregator, asyncWorker, executor, currentEnvironment) { VerifyArgument.IsNotNull(nameof(elasticsearchServiceSource), elasticsearchServiceSource); AsyncWorker.Start(() => elasticsearchSourceModel.FetchSource(elasticsearchServiceSource.Id), source => { _elasticsearchServiceSource = source; _elasticsearchServiceSource.Path = elasticsearchServiceSource.Path; FromModel(_elasticsearchServiceSource); Item = ToSource(); SetupHeaderTextFromExisting(); }); }
public ManageWebserviceSourceViewModel(IManageWebServiceSourceModel updateManager, IEventAggregator aggregator, IWebServiceSource webServiceSource, IAsyncWorker asyncWorker, IExternalProcessExecutor executor) : this(updateManager, aggregator, asyncWorker, executor) { VerifyArgument.IsNotNull("webServiceSource", webServiceSource); _warewolfserverName = updateManager.ServerName; AsyncWorker.Start(() => updateManager.FetchSource(webServiceSource.Id), source => { _webServiceSource = source; _webServiceSource.Path = webServiceSource.Path; FromModel(_webServiceSource); Item = ToSource(); SetupHeaderTextFromExisting(); }); }
public RedisSourceViewModel(IRedisSourceModel redisSourceModel, IEventAggregator aggregator, IRedisServiceSource redisServiceSource, IAsyncWorker asyncWorker, IExternalProcessExecutor executor) : this(redisSourceModel, aggregator, asyncWorker, executor) { VerifyArgument.IsNotNull(nameof(redisServiceSource), redisServiceSource); _warewolfserverName = redisSourceModel.ServerName; AsyncWorker.Start(() => redisSourceModel.FetchSource(redisServiceSource.Id), source => { _redisServiceSource = source; _redisServiceSource.Path = redisServiceSource.Path; FromModel(_redisServiceSource); Item = ToSource(); SetupHeaderTextFromExisting(); }); }
private void backgroundEntryWorker_DoWork(object sender, DoWorkEventArgs e) { BeginInvoke(new MethodInvoker(delegate { progressBar.Visible = true; progressBar.Value = 5; pageIndex = 0; button_search.Enabled = false; })); animeEntries = GetAnimes(); pages = (int)Math.Ceiling(animeEntries.Count() * 1.0 / entriesPerPage); AsyncWorker.ReportProgress(10); LoadPage.RunWorkerAsync(); }
public override void SetUp() { base.SetUp(); var definitions = TestSupport.SetupDefinitions(typeof(PersistableItem), typeof(PersistableItem2), typeof(PersistablePart)); accessor = new LuceneAccesor(new ThreadContext(), new DatabaseSection()); indexer = new ContentIndexer(new LuceneIndexer(accessor), new TextExtractor(new IndexableDefinitionExtractor(definitions))); searcher = new LuceneContentSearcher(accessor, persister); worker = new AsyncWorker(); asyncIndexer = new AsyncIndexer(indexer, persister, worker, Rhino.Mocks.MockRepository.GenerateStub <IErrorNotifier>(), new DatabaseSection()); tracker = new ContentChangeTracker(asyncIndexer, persister, new N2.Plugin.ConnectionMonitor(), new DatabaseSection()); accessor.LockTimeout = 1L; indexer.Clear(); root = CreateOneItem <PersistableItem>(1, "The Root Page", null); }
/// <summary> /// Starts this EnityPoller. /// </summary> /// <exception cref="System.InvalidOperationException">Already polling</exception> public void Start() { var worker = new AsyncWorker(Poll); var completed = new AsyncCallback(PollComplete); var onCompleted = new AsyncComplete(OnEntity); lock (_sync) { if (_polling) { throw new InvalidOperationException("Already polling"); } var operation = AsyncOperationManager.CreateOperation(onCompleted); worker.BeginInvoke(completed, operation); _polling = true; } }
void GetLoadComputerNamesTask(Action additionalUiAction) { AsyncWorker.Start(() => _updateManager.GetComputerNames().Select(name => new ComputerName { Name = name }).ToList(), names => { ComputerNames = names; additionalUiAction?.Invoke(); }, exception => { FailedTesting(); if (exception.InnerException != null) { exception = exception.InnerException; } TestMessage = exception.Message; }); }
static void Main(string[] args) { intList = Enumerable.Range(0, N); int[] arr = new int[N]; Console.WriteLine("Starting with {0} items", N); Stopwatch sw = new Stopwatch(); sw.Start(); AsyncWorker<int> worker = new AsyncWorker<int>(Method2, arr, TC); worker.Wait(); sw.Stop(); Console.WriteLine("Worker finished in {0}s", sw.Elapsed.TotalSeconds); Console.ReadLine(); }
void TestConnection() { _token = new CancellationTokenSource(); AsyncWorker.Start(SetupProgressSpinner, () => { TestMessage = "Passed"; TestFailed = false; TestPassed = true; Testing = false; }, _token, exception => { TestFailed = true; TestPassed = false; Testing = false; TestMessage = GetExceptionMessage(exception); }); }
private void OnLoadedIPV6View(object sender, RoutedEventArgs e) { InitFontSize(); AsyncWorker worker = new AsyncWorker(this); worker.InvokeMethod <IPV6InfoRecord>(((MainWindow)App.Current.MainWindow).statusPanelPage.m_selectedPrinter, ref m_rec, DllMethodType.GetIpv6Info, this); if (null != m_rec) { tbStatelessAddress1.Text = m_rec.StatelessAddress1; tbStatelessAddress2.Text = m_rec.StatelessAddress2; tbStatelessAddress3.Text = m_rec.StatelessAddress3; tbAutoStatefullAddress.Text = m_rec.AutoStatefulAddress; tbLinkLocalAddress.Text = m_rec.IPLinkLocalAddress; tbAutoConfigureGatewayAddress.Text = m_rec.AutoGatewayAddress; } }
protected DatabaseSourceViewModelBase(IManageDatabaseSourceModel updateManager, IEventAggregator aggregator, IDbSource dbSource, IAsyncWorker asyncWorker, string dbSourceImage) : this(asyncWorker, dbSourceImage) { VerifyArgument.IsNotNull("dbSource", dbSource); PerformInitialise(updateManager, aggregator); _warewolfserverName = updateManager.ServerName ?? ""; AsyncWorker.Start(() => updateManager.FetchDbSource(dbSource.Id), source => { DbSource = source; DbSource.Path = dbSource.Path; Item = ToSourceDefinition(); GetLoadComputerNamesTask(() => { FromModel(DbSource); SetupHeaderTextFromExisting(); }); }); }
public void FindRoleList() { DataTable dt = new DataTable(); dt.Columns.Add("Role Name"); dt.Columns.Add("Description"); dt.Columns.Add("Status"); this.ug_rolelist.DataSource = dt; this.lbl_rolecount.Text = this.ug_rolelist.Rows.Count.ToString(); this.ug_rolelist.Focus(); var argus = new object[] { this.txt_rolename.Text, this.txt_description.Text }; using (AsyncWorker<IRoleMaintenance> worker = new AsyncWorker<IRoleMaintenance>(_presenter, this.ug_rolelist, new Control[] { btn_search, btn_reset })) { worker.DoWork += delegate(object oDoWork, DoWorkEventArgs eDoWork) { var tempArgus = eDoWork.Argument as object[]; if (tempArgus == null || tempArgus.Length <= 1) { return; } eDoWork.Result = _presenter.FindRoleListByConditions(tempArgus[0] as string,tempArgus[1] as string); }; worker.RunWorkerCompleted += delegate(object oCompleted, RunWorkerCompletedEventArgs eCompleted) { RoleEntity[] roleEntitys = eCompleted.Result as RoleEntity[]; if (roleEntitys != null) { if (roleEntitys.Length > 0) { foreach (RoleEntity entity in roleEntitys) { dt.Rows.Add(entity.RoleName, entity.Description, entity.Status); } } this.ug_rolelist.DataSource = dt; this.lbl_rolecount.Text = this.ug_rolelist.Rows.Count.ToString(); } }; worker.Run(argus); } }
private void wzdExport_NextButtonClick(object sender, WizardNavigationEventArgs e) { switch (e.CurrentStepIndex) { case 0: // Apply settings if (!configExport.ApplySettings()) { e.Cancel = true; return; } // Update settings ExportSettings = configExport.Settings; if (!configExport.ExportHistory) { ltlScriptAfter.Text = ScriptHelper.GetScript( "var actDiv = document.getElementById('actDiv'); \n" + "if (actDiv != null) { actDiv.style.display='block'; } \n" + "var buttonsDiv = document.getElementById('buttonsDiv'); if (buttonsDiv != null) { buttonsDiv.disabled=true; } \n" + "BTN_Disable('" + NextButton.ClientID + "'); \n" + "StartSelectionTimer();" ); // Select objects asynchronously ctrlAsync.RunAsync(SelectObjects, WindowsIdentity.GetCurrent()); e.Cancel = true; } else { pnlExport.Settings = ExportSettings; pnlExport.ReloadData(); } break; case 1: // Apply settings if (!pnlExport.ApplySettings()) { e.Cancel = true; return; } ExportSettings = pnlExport.Settings; // Delete temporary files try { ExportProvider.DeleteTemporaryFiles(ExportSettings, true); } catch (Exception ex) { lblError.Text = ex.Message; e.Cancel = true; return; } try { // Save export history ExportHistoryInfo history = new ExportHistoryInfo(); history.ExportDateTime = DateTime.Now; history.ExportFileName = ExportSettings.TargetFileName; history.ExportSettings = ExportSettings.GetXML(); history.ExportSiteID = ExportSettings.SiteId; history.ExportUserID = CMSContext.CurrentUser.UserID; ExportHistoryInfoProvider.SetExportHistoryInfo(history); } catch (Exception ex) { lblError.Text = ex.Message; lblError.ToolTip = EventLogProvider.GetExceptionLogMessage(ex); e.Cancel = true; return; } // Init the Mimetype helper (required for the export) MimeTypeHelper.LoadMimeTypes(); if (ExportSettings.SiteId > 0) { ExportSettings.EventLogSource = string.Format(ExportSettings.GetAPIString("ExportSite.EventLogSiteSource", "Export '{0}' site"), ResHelper.LocalizeString(ExportSettings.SiteInfo.DisplayName)); } // Start asynchronnous export ExportManager.Settings = ExportSettings; AsyncWorker worker = new AsyncWorker(); worker.OnFinished += worker_OnFinished; worker.OnError += worker_OnError; worker.RunAsync(ExportManager.Export, WindowsIdentity.GetCurrent()); lblProgress.Text = GetString("SiteExport.PreparingExport"); break; } ReloadSteps(); wzdExport.ActiveStepIndex = e.NextStepIndex; }
private SerialPort _serialPort; // The serial port #endregion Fields #region Constructors public SerialTransport() { _worker = new AsyncWorker(Poll, "SerialTransport"); }
public void ShowSessionList(SessionCriteria sessionCriteria) { this.ug_sessionlist.Focus(); using (AsyncWorker<ISessionManagementView> worker = new AsyncWorker<ISessionManagementView>(_presenter, this.ug_sessionlist, new Control[] { refreshButton })) { worker.DoWork += delegate(object oDoWork, DoWorkEventArgs eDoWork) { eDoWork.Result = _presenter.GetActiveSessions(sessionCriteria); }; worker.RunWorkerCompleted += delegate(object oCompleted, RunWorkerCompletedEventArgs eCompleted) { SessionInfo[] sessions = eCompleted.Result as SessionInfo[]; if (sessions == null) { return; } this._sessionList.Clear(); foreach (SessionInfo sessionInfo in sessions) { this._sessionList.Add(sessionInfo.SessionID, sessionInfo); } this.ug_sessionlist.DataSource = sessions; this.ug_sessionlist.DataBind(); this.lbl_totalsessionnumber.Text = this.ug_sessionlist.Rows.Count.ToString(); }; worker.Run(); } }
private void LogOperationCompletedWithException(AsyncWorker asyncWorker, DoWorkEventHandler worker, Exception exception) { this.log.Info(string.Format( CultureInfo.InvariantCulture, "{0} completes asynchronous operation {1}.{2}() with exception = {3}", asyncWorker, worker.Method.DeclaringType.FullName, worker.Method.Name, exception)); }
/// <summary> /// Starts import process with given settings. Returns true if import was started successfully, false otherwise (error label is set in this case). /// </summary> /// <param name="importSettings">Import settings</param> /// <returns>Returns true if import was started successfully, false otherwise.</returns> private bool StartImport(SiteImportSettings importSettings) { // Check licences string error = ImportExportControl.CheckLicenses(importSettings); if (!string.IsNullOrEmpty(error)) { SetErrorLabel(error); return false; } // Init the Mimetype helper (required for the Import) MimeTypeHelper.LoadMimeTypes(); // Start asynchronnous Import if (importSettings.SiteIsIncluded) { importSettings.EventLogSource = string.Format(importSettings.GetAPIString("ImportSite.EventLogSiteSource", "Import '{0}' site"), ResHelper.LocalizeString(importSettings.SiteDisplayName)); } ImportManager.Settings = importSettings; AsyncWorker worker = new AsyncWorker(); worker.OnFinished += worker_OnFinished; worker.OnError += worker_OnError; worker.RunAsync(ImportManager.Import, WindowsIdentity.GetCurrent()); return true; }
protected void wzdImport_NextButtonClick(object sender, WizardNavigationEventArgs e) { switch (e.CurrentStepIndex) { case 0: // Apply settings if (!stpConfigImport.ApplySettings()) { e.Cancel = true; return; } // Update settings ImportSettings = stpConfigImport.Settings; ltlScriptAfter.Text = ScriptHelper.GetScript( "var actDiv = document.getElementById('actDiv'); \n" + "if (actDiv != null) { actDiv.style.display='block'; } \n" + "var buttonsDiv = document.getElementById('buttonsDiv'); if (buttonsDiv != null) { buttonsDiv.disabled=true; } \n" + "BTN_Disable('" + NextButton.ClientID + "'); \n" + "StartUnzipTimer();" ); // Create temporary files asynchronously ctrlAsync.RunAsync(CreateTemporaryFiles, WindowsIdentity.GetCurrent()); e.Cancel = true; break; case 1: // Apply settings if (!stpSiteDetails.ApplySettings()) { e.Cancel = true; return; } // Update settings ImportSettings = stpSiteDetails.Settings; //stpImport.SelectedNodeValue = CMSObjectHelper.GROUP_OBJECTS; stpImport.ReloadData(true); wzdImport.ActiveStepIndex++; break; case 2: // Apply settings if (!stpImport.ApplySettings()) { e.Cancel = true; return; } // Check licences string error = ImportExportControl.CheckLicenses(ImportSettings); if (!string.IsNullOrEmpty(error)) { SetErrorLabel(error); e.Cancel = true; return; } ImportSettings = stpImport.Settings; // Init the Mimetype helper (required for the Import) MimeTypeHelper.LoadMimeTypes(); // Start asynchronnous Import ImportSettings.DefaultProcessObjectType = ProcessObjectEnum.Selected; if (ImportSettings.SiteIsIncluded) { ImportSettings.EventLogSource = string.Format(ImportSettings.GetAPIString("ImportSite.EventLogSiteSource", "Import '{0}' site"), ResHelper.LocalizeString(ImportSettings.SiteDisplayName)); } ImportManager.Settings = ImportSettings; AsyncWorker worker = new AsyncWorker(); worker.OnFinished += worker_OnFinished; worker.OnError += worker_OnError; worker.RunAsync(ImportManager.Import, WindowsIdentity.GetCurrent()); wzdImport.ActiveStepIndex++; break; } ReloadSteps(); }
protected CommandQueue() { _worker = new AsyncWorker(ProcessQueue); _worker.Name = "CommandQueue"; }
private void LoadOrganisationList() { this.ultraGridOrganisational.Focus(); var argus = txt_Orgenisation.Text ; using (AsyncWorker<IMaintainOrganisationName> worker = new AsyncWorker<IMaintainOrganisationName>(_presenter, this.ultraGridOrganisational, new Control[] { ultraBtnSearch, ultraBtnReset })) { worker.DoWork += delegate(object oDoWork, DoWorkEventArgs eDoWork) { var lookup = _presenter.GetOrganisationLookup(); var tempArgu = eDoWork.Argument as string; eDoWork.Result = RetriveOrgData(lookup, tempArgu); }; worker.RunWorkerCompleted += delegate(object oCompleted, RunWorkerCompletedEventArgs eCompleted) { this.ultraGridOrganisational.DataSource = eCompleted.Result; ultraLabTotalNum.Text = HiiP.Framework.Messaging.Messages.General.GEI001.Format(this.ultraGridOrganisational.Rows.Count.ToString()); }; worker.Run(argus); } }
private void ButtonSearchForCount_Click(object sender, EventArgs e) { try { this.Cursor = Cursors.WaitCursor; DisableValidationProvider(); this.validationProvider7.Enabled = true; if (this.ValidateChildren()) { DateTimeCompare timeEntity = new DateTimeCompare( DateTimeStartDateForCount.DateTime.Date, DateTimeEndDateForCount.DateTime.Date); using (AsyncWorker<IUsageLogView> worker = new AsyncWorker<IUsageLogView>(_presenter, this.ultraChart7, new Control[] { ButtonSearchForCount })) { #region worker defini worker.DoWork += delegate(object oDoWork, DoWorkEventArgs eDoWork) { var tempEntity = eDoWork.Argument as DateTimeCompare; if (tempEntity == null) { return; } eDoWork.Result = _presenter.GetAllCountOfUsers(tempEntity); }; worker.RunWorkerCompleted += delegate(object oCompleted, RunWorkerCompletedEventArgs eCompleted) { LoggingUsageDataSet dataset = eCompleted.Result as LoggingUsageDataSet; if (dataset != null && dataset.T_IC_LOGGING_USAGE.Rows.Count > 0) { int rowCount = dataset.T_IC_LOGGING_USAGE.Rows.Count - 1; this.ultraChart7.Height = CHART_BASE_HEIGHT + rowCount * INCREMENT_FEED; this.usageByUserCountExpandableGroupBox.Height = EXPANDABLE_GROUP_BOX_BASE_HEIGHT + rowCount * INCREMENT_FEED; SetChartStype(this.ultraChart7, "USER_COUNT", dataset); this.ultraChart7.DataSource = dataset.T_IC_LOGGING_USAGE.Select( data => new { emptyname = String.Empty, usercount = Convert.ToInt32(data["USER_COUNT"]) } ).ToList(); this.ultraChart7.Visible = true; } else { this.ultraChart7.Visible = false; this.usageByUserCountExpandableGroupBox.Height = EXPANDABLE_GROUP_BOX_BASE_HEIGHT - CHART_BASE_HEIGHT; } }; #endregion worker.Run(timeEntity); } } } catch (Exception ex) { if (ExceptionManager.Handle(ex)) { throw; } } finally { this.Cursor = Cursors.Default; } }
private void ButtonSearchForUser_Click(object sender, EventArgs e) { try { this.Cursor = Cursors.WaitCursor; DisableValidationProvider(); this.validationProvider1.Enabled = true; if (this.ValidateChildren()) { DateTimeCompare timeEntity = new DateTimeCompare(DateTimeStartDateForUser.DateTime.Date, DateTimeEndDateForUser.DateTime.Date); var argus = new object[] {timeEntity, TextBoxUserName.Text}; using (AsyncWorker<IUsageLogView> worker = new AsyncWorker<IUsageLogView>(_presenter, this.ultraChart1, new Control[] { ButtonSearchForUser })) { #region worker definition worker.DoWork += delegate(object oDoWork, DoWorkEventArgs eDoWork) { var tempArgus = eDoWork.Argument as object[]; if (tempArgus==null || tempArgus.Length<=1) { return; } eDoWork.Result = _presenter.GetUsageForUserData( tempArgus[0] as DateTimeCompare,tempArgus[1] as string ); }; worker.RunWorkerCompleted += delegate(object oCompleted, RunWorkerCompletedEventArgs eCompleted) { LoggingUsageDataSet dataset = eCompleted.Result as LoggingUsageDataSet; if (dataset != null && dataset.T_IC_LOGGING_USAGE.Rows.Count > 0) { int rowCount = dataset.T_IC_LOGGING_USAGE.Rows.Count - 1; this.ultraChart1.Height = CHART_BASE_HEIGHT + rowCount * INCREMENT_FEED; this.usageByUserExpandableGroupBox.Height = EXPANDABLE_GROUP_BOX_BASE_HEIGHT + rowCount * INCREMENT_FEED; SetChartStype(this.ultraChart1, "FREQUENCY", dataset); this.ultraChart1.DataSource = dataset.T_IC_LOGGING_USAGE.Select( data => new { username = data["USER_NAME"].ToString(), logintimes = Convert.ToInt32(data["FREQUENCY"]) } ).ToList(); this.ultraChart1.Visible = true; } else { this.ultraChart1.Visible = false; this.usageByUserExpandableGroupBox.Height = EXPANDABLE_GROUP_BOX_BASE_HEIGHT - CHART_BASE_HEIGHT; } }; #endregion worker.Run(argus); } } } catch (Exception ex) { if (ExceptionManager.Handle(ex)) throw; } finally { this.Cursor = Cursors.Default; } }
public void Test() { Parallel.For(0, 100, i => { DateTime dt = SysTimeRecord.Get(i.ToString()); SysTimeRecord.Set(i.ToString(), dt == DateTime.MinValue ? DateTime.Now.AddDays(-i) : dt.AddHours(1)); }); for (int i = 0; i < 100; i++) { DateTime dt = SysTimeRecord.Get(i.ToString()); SysTimeRecord.Set(i.ToString(), dt == DateTime.MinValue ? DateTime.Now.AddDays(i) : dt.AddHours(-1)); } RedisTest.Test(); AsyncWorker<int> aw = new AsyncWorker<int>(3, Console.WriteLine); for (int i = 0; i < 100; i++) { aw.AddItem(i); } aw.StopAndWait(); Thread.Sleep(10000000); Parallel.Invoke( () => ExecCrawler(1), () => ExecCrawler(2), () => ExecCrawler(3), () => ExecCrawler(4), () => ExecCrawler(5) ); HttpCore hc = new HttpCore(); hc.SetUrl("http://ac168.info/bt/thread.php?fid=16&page={0}", 2); var res = hc.GetHtml(); var tres = res.SelectNodes("//*[@id='ajaxtable']/tbody[1]/tr[@class='tr3 t_one']"); HtmlNode node = tres[10]; var an = node.SelectSingleNode("/td[2]/h3/a"); string aHref = "http://ac168.info/bt/" + an.Attributes["href"].Value; string aText = an.InnerHtml; hc.SetUrl(aHref); res = hc.GetHtml(); tres = res.SelectNodes("//*[@id='read_tpc']/img"); string imgUrl = tres[0].Attributes["src"].Value; HttpCore hcImg = new HttpCore(); hcImg.SetUrl(imgUrl); hcImg.CurrentHttpItem.ResultType = ResultType.Byte; //得到HTML代码 HttpResult result = hcImg.CurrentHttpHelper.GetHtml(hcImg.CurrentHttpItem); if (result.StatusCode == System.Net.HttpStatusCode.OK) { //表示访问成功,具体的大家就参考HttpStatusCode类 } //表示StatusCode的文字说明与描述 string statusCodeDescription = result.StatusDescription; //把得到的Byte转成图片 Image img = result.ResultByte.ByteArrayToImage(); img.Save("f://imgs/" + imgUrl.Split('/').Last()); Console.WriteLine(tres); Console.ReadLine(); RequestBase rb = new RequestBase(); rb.BindLocalCache("intc", s => GetSourceCacheInt(s[0].TryChangeType(0)), 3); rb.BindLocalCache("person", s => GetSourceCachePerson(), null); Stopwatch st0 = new Stopwatch(); st0.Start(); rb.BindLocalCache("ps", s => GetSourceCacheListPerson(), null); st0.Stop(); Console.WriteLine("实例化1千万个对象,耗时【{0}】毫秒", st0.ElapsedMilliseconds); Stopwatch st1 = new Stopwatch(); st1.Start(); for (int i = 0; i < 10000000; i++) { rb.BindLocalCache("ps", s => GetSourceCacheListPerson(), null); } st1.Stop(); Console.WriteLine("绑定1千万次本地缓存,耗时【{0}】毫秒", st1.ElapsedMilliseconds); var t1 = rb.GetLocalCache("intc"); var t2 = rb.GetLocalCache("person"); var t3 = rb.GetLocalCache<Person>("person"); var t4 = rb.LocalCache.person; var t5 = rb.LocalCache.intc; Stopwatch st = new Stopwatch(); st.Start(); for (int i = 0; i < 10000000; i++) { var t = rb.LocalCache.ps; var tt = rb.GetLocalCache<List<Person>>("ps"); } st.Stop(); Console.WriteLine("读取2千万次本地缓存,耗时【{0}】毫秒", st.ElapsedMilliseconds); }
/// <summary> /// Checks if specified process is currently running. /// </summary> /// <param name="process">Async process to check its status</param> private bool ProcessIsRunning(AsyncWorker process) { switch (process.Status) { // Process not running statuses case AsyncWorkerStatusEnum.Unknown: case AsyncWorkerStatusEnum.Stopped: case AsyncWorkerStatusEnum.Finished: case AsyncWorkerStatusEnum.Error: return false; default: return true; } }
public void ShowUserList() { this.btn_disable.Enabled = false; this.btn_assignroles.Enabled = false; DataTable dt = new DataTable(); dt.Columns.Add("User ID", Type.GetType("System.String")); dt.Columns.Add("Status", Type.GetType("System.String")); dt.Columns.Add("Created On", Type.GetType("System.DateTime")); dt.Columns.Add("User Name", Type.GetType("System.String")); dt.Columns.Add("Gender", Type.GetType("System.String")); dt.Columns.Add("Title", Type.GetType("System.String")); dt.Columns.Add("Email", Type.GetType("System.String")); dt.Columns.Add("Telephone No", Type.GetType("System.String")); //dt.Columns.Add("Organisation", Type.GetType("System.String")); dt.Columns.Add("Master Office", Type.GetType("System.String")); dt.Columns.Add("Office", Type.GetType("System.String")); dt.Columns.Add("AllOffices", Type.GetType("System.String")); dt.Columns.Add("First Name", Type.GetType("System.String")); dt.Columns.Add("Last Name", Type.GetType("System.String")); dt.Columns.Add("Mobile", Type.GetType("System.String")); this.ug_userlist.DataSource = dt; this.ug_userlist.Focus(); this.lbl_recordCount.Text = "0"; var criteria = GetSearchCriteria(); using (AsyncWorker<IUserMaintenance> worker = new AsyncWorker<IUserMaintenance>(_presenter, this.ug_userlist, new Control[] { btn_search })) { worker.DoWork += delegate(object oDoWork, DoWorkEventArgs eDoWork) { var tempCriteria = eDoWork.Argument as UserInfoSearchCriteria; if (tempCriteria == null) { return; } eDoWork.Result = _presenter.GetUserInfoArrayEntity(tempCriteria); }; worker.RunWorkerCompleted += delegate(object oCompleted, RunWorkerCompletedEventArgs eCompleted) { UserInfoEntity[] userInfoEntitys = eCompleted.Result as UserInfoEntity[]; if (userInfoEntitys != null && userInfoEntitys.Length > 0) { foreach (UserInfoEntity entity in userInfoEntitys) { dt.Rows.Add( entity.UserName, entity.UserStatus, entity.CreatedOn, entity.Display, entity.Gender, entity.Title, entity.Email, entity.TelephoneNo, //entity.Organisation, entity.IsMaster, entity.Office, entity.AllOffices, entity.FirstName, entity.LastName, entity.MobileNo ); } } this.ug_userlist.DataSource = dt; this.lbl_recordCount.Text = this.ug_userlist.Rows.Count.ToString(); }; worker.Run(criteria); } }
void btnYes_Click(object sender, EventArgs e) { pnlConfirmation.Visible = false; pnlDeleteSite.Visible = true; // Start the timer for the callbacks ltlScript.Text = ScriptHelper.GetScript("StartStateTimer();"); // Initilaize web root path AttachmentHelper.WebRootFullPath = HttpContext.Current.Server.MapPath("~/"); // Deletion info initialization DeletionInfo.DeleteAttachments = chkDeleteDocumentAttachments.Checked; DeletionInfo.DeleteMediaFiles = chkDeleteMediaFiles.Checked; DeletionInfo.DeleteMetaFiles = chkDeleteMetaFiles.Checked; DeletionInfo.SiteName = siteName; DeletionInfo.SiteDisplayName = siteDisplayName; DeletionManager.CurrentUser = CMSContext.CurrentUser; DeletionManager.DeletionInfo = DeletionInfo; AsyncWorker worker = new AsyncWorker(); worker.RunAsync(DeletionManager.DeleteSite, WindowsIdentity.GetCurrent()); }
public ScanResult Execute(object markerAsynchrone) { _log.Info("======================================= SCAN COMMAND ========================================"); _log.Info(string.Format("Start execute with scan params: " + "source={0}, sourceFeed={1}, dpi={2}, colorMode={3}, compressionFormat={4}, format={5}, " + "isPackage={6}, saveAs={7}", _command.Source, _command.DocumentHandlingCap, _command.DPI, _command.ColorMode, _command.CompressionFormat.ImgFormat, _command.Format.Name, _command.IsPackage, _command.SaveAs)); ScanResult scanResult; try { var scannedImages = new List<Image>(); lock (markerAsynchrone) { if (_scannerManager.CurrentSourceIndex != _command.Source) { new AsyncWorker<int>().RunWorkAsync(_command.Source, _scannerManager.ChangeSource, WaitTimeForChangeSource); if (_scannerManager.CurrentSourceIndex != _command.Source) { return new SingleScanResult("Не удается изменить источник данных"); } } var settingAcquire = new SettingsAcquire { Format = _command.Format, Resolution = _command.DPI, PixelType = _command.ColorMode, ScanSource = _command.DocumentHandlingCap }; var images = new AsyncWorker<SettingsAcquire, List<Image>>().RunWorkAsync(settingAcquire, _scannerManager.CurrentSource.Scan, WaitTimaeForScan); if (images != null) { foreach (var image in images) { var clonedImage = (Image) image.Clone(); image.Dispose(); ((Bitmap) clonedImage).SetResolution(_command.DPI, _command.DPI); scannedImages.Add(clonedImage); } } } if (scannedImages.Count == 0) { return new SingleScanResult( "Сканирование завершилось неудачей! Попробуйте переподключить сканер либо повторить сканирование с помощью другого устройства."); } if (scannedImages.Count == 1) { var image = scannedImages[0]; var downloadFile = SaveImage(image); var singleScanResult = new SingleScanResult(); singleScanResult.FillContent(downloadFile); scanResult = singleScanResult; image.Dispose(); } else { var downloadFiles = new List<DownloadFile>(); int counter; try { counter = int.Parse(_command.FileCounter); } catch (Exception) { counter = 1; } foreach (var scannedImage in scannedImages) { var downloadFile = SaveImage(scannedImage, counter++); downloadFiles.Add(downloadFile); scannedImage.Dispose(); } var multipleScanResult = new MultipleScanResult(); multipleScanResult.FillContent(downloadFiles); scanResult = multipleScanResult; } } catch (TwainException ex) { return new SingleScanResult(ex.Message); } _log.Info("Scan command executed"); return scanResult; }
private void ultraBtnSearch_Click(object sender, EventArgs e) { try { this.Cursor = Cursors.WaitCursor; this.ultraGridDelegation.Focus(); var criteria = GetDelegationSearchCriteria(); using (AsyncWorker<IMaintainDelegation> worker = new AsyncWorker<IMaintainDelegation>(_presenter, this.ultraGridDelegation,true)) { worker.DoWork += delegate(object senderobj, DoWorkEventArgs ev) { var tempCriteria = ev.Argument as DelegationSearchCriteria; if (tempCriteria == null) { return; } ev.Result = _presenter.FindDelegationDetailEntity(tempCriteria); }; worker.RunWorkerCompleted += delegate(object senderobj, RunWorkerCompletedEventArgs ev) { List<DelegationValueEntity> lstResults = ev.Result as List<DelegationValueEntity>; ultraGridDelegation.DataSource = lstResults; ultraGridDelegation.DataBind(); ultraLabTotalNum.Text = string.Format("Total record(s) : {0}", ultraGridDelegation.Rows.Count.ToString()); }; worker.Run(criteria); } } catch (Exception ex) { if (ExceptionManager.Handle(ex)) throw; } finally { this.Cursor = Cursors.Default; } }
private SerialPort _serialPort; // The serial port #endregion Fields #region Constructors public SerialTransport() { _worker = new AsyncWorker(Poll); _worker.Name = "SerialTransport"; }
/// <summary> /// Called when an operation was completed. /// </summary> /// <param name="asyncWorker">The async worker.</param> /// <param name="worker">The worker.</param> /// <param name="completed">The completed handler.</param> /// <param name="runWorkerCompletedEventArgs">The <see cref="System.ComponentModel.RunWorkerCompletedEventArgs"/> instance containing the event data.</param> public void CompletedExecution(AsyncWorker asyncWorker, DoWorkEventHandler worker, RunWorkerCompletedEventHandler completed, RunWorkerCompletedEventArgs runWorkerCompletedEventArgs) { if (this.log.IsInfoEnabled) { if (runWorkerCompletedEventArgs.Error == null) { this.LogOperationCompletedWithoutException(asyncWorker, worker); } else { this.LogOperationCompletedWithException(asyncWorker, worker, runWorkerCompletedEventArgs.Error); } } }
protected CommandQueue() { _worker = new AsyncWorker(ProcessQueue, "CommandQueue"); }
private ScannerSettings GetScannerSettings(int sourceIndex) { _logger.Debug("Searching scanner settings in cache..."); var searchSetting = _cacheSettings.Search(_scannerManager, sourceIndex); if (searchSetting != null) { _logger.Debug("Scanner settings was found"); return searchSetting; } else { _logger.Debug("Scanner settings was not found"); } var needOfChangeSource = _sourceIndex.HasValue && _sourceIndex != _scannerManager.CurrentSourceIndex; if (needOfChangeSource) new AsyncWorker<int>().RunWorkAsync(sourceIndex, _scannerManager.ChangeSource, ChangeSourceWaitTime); if (_scannerManager.CurrentSource == null) throw new Exception("Не удалось выбрать источник"); if (sourceIndex == _scannerManager.CurrentSource.Index) searchSetting = new AsyncWorker<IScannerManager, ScannerSettings>() .RunWorkAsync(_scannerManager, _cacheSettings.PushCurrentSource, PushSettingsWaitTime); return searchSetting; }
private void btnYes_Click(object sender, EventArgs e) { pnlConfirmation.Visible = false; pnlDeleteSite.Visible = true; // Start the timer for the callbacks ltlScript.Text = ScriptHelper.GetScript("StartStateTimer();"); // Deletion info initialization DeletionInfo.DeleteAttachments = chkDeleteDocumentAttachments.Checked; DeletionInfo.DeleteMediaFiles = chkDeleteMediaFiles.Checked; DeletionInfo.DeleteMetaFiles = chkDeleteMetaFiles.Checked; DeletionInfo.SiteName = siteName; DeletionInfo.SiteDisplayName = siteDisplayName; DeletionManager.CurrentUser = MembershipContext.AuthenticatedUser; DeletionManager.DeletionInfo = DeletionInfo; AsyncWorker worker = new AsyncWorker(); worker.RunAsync(DeletionManager.DeleteSite, WindowsIdentity.GetCurrent()); }
/// <summary> /// Called when an operation reports progress. /// </summary> /// <param name="asyncWorker">The async worker.</param> /// <param name="worker">The worker.</param> /// <param name="progress">The progress.</param> /// <param name="userState">State of the user.</param> public void ReportProgress(AsyncWorker asyncWorker, DoWorkEventHandler worker, ProgressChangedEventHandler progress, object userState) { if (this.log.IsInfoEnabled) { this.log.Info(string.Format( CultureInfo.InvariantCulture, "{0} reports progress for operation {1}.{2}()", asyncWorker, worker.Method.DeclaringType.FullName, worker.Method.Name)); } }
/// <summary> /// Next button click. /// </summary> /// <param name="sender">Sender</param> /// <param name="e">Arguments</param> void wzdImport_NextButtonClick(object sender, WizardNavigationEventArgs e) { switch (wzdImport.ActiveStepIndex) { case 0: if (!string.IsNullOrEmpty(lstImports.SelectedValue)) { // Create asynchronous process worker = new AsyncWorker(); worker.OnError += new EventHandler(worker_OnError); worker.RunAsync(ImportLicenses, WindowsIdentity.GetCurrent()); wzdImport.ActiveStepIndex++; PrepareSteps(); } else { e.Cancel = true; lblErrorFirstStep.Visible = true; } break; } }