public void UploadAsync(string path, string token, string message) { var worker = new UpdateDelegate(UploadInternal); var asyncOp = AsyncOperationManager.CreateOperation(null); worker.BeginInvoke(path, token, message, asyncOp, null, null); }
///////////////////////////////////////////////////////////// /// #region Implementation // <snippet3> // This method starts an asynchronous calculation. // First, it checks the supplied task ID for uniqueness. // If taskId is unique, it creates a new WorkerEventHandler // and calls its BeginInvoke method to start the calculation. public virtual void CalculatePrimeAsync( int numberToTest, object taskId) { // Create an AsyncOperation for taskId. AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(taskId); // Multiple threads will access the task dictionary, // so it must be locked to serialize access. lock (userStateToLifetime.SyncRoot) { if (userStateToLifetime.Contains(taskId)) { throw new ArgumentException( "Task ID parameter must be unique", "taskId"); } userStateToLifetime[taskId] = asyncOp; } // Start the asynchronous operation. WorkerEventHandler workerDelegate = new WorkerEventHandler(CalculateWorker); workerDelegate.BeginInvoke( numberToTest, asyncOp, null, null); }
/// <summary> /// Initializes the Members with their default values /// </summary> protected void SetDefaults() { _context = SynchronizationContext.Current; _contextOperation = AsyncOperationManager.CreateOperation(null); CreateAndAttachAnalysis(); }
public void UploadBlobAsync(CloudBlockBlob blob, string localFile, object state) { TransferType = TransferTypeEnum.Upload; //attempt to open the file first so that we throw an exception before getting into the async work using (FileStream fs = new FileStream(localFile, FileMode.Open, FileAccess.Read)) { } m_Blob = blob; m_FileName = localFile; BlobTransferWorkerDelegate worker = new BlobTransferWorkerDelegate(UploadBlobWorker); AsyncCallback completedCallback = new AsyncCallback(TaskCompletedCallback); lock (_sync) { if (TaskIsRunning) { throw new InvalidOperationException("The control is currently busy."); } AsyncOperation async = AsyncOperationManager.CreateOperation(state); MyAsyncContext context = new MyAsyncContext(); bool cancelled; worker.BeginInvoke(context, out cancelled, async, completedCallback, async); TaskIsRunning = true; TaskContext = context; } }
public void ExtractEmailsAsync() { while (!isTerminating) { // Check if the folder exists and contains atleast 1 text file if (TotalFiles(Scrapers.Pastebin.SaveLocation) == 0) { return; } // Create a worker and a call back MergeWorkerDelegate worker = new MergeWorkerDelegate(ExtractEmailWorker); AsyncCallback completedCallback = new AsyncCallback(MergeCompletedCallBack); // Lock the operation and fire up the worker lock (_sync) { if (isMergeRunning) { throw new InvalidOperationException("Merge is already running, please wait till current merge completes"); } AsyncOperation async = AsyncOperationManager.CreateOperation(null); worker.BeginInvoke(completedCallback, async); isMergeRunning = true; } break; } }
public void DownloadBlobAsync(ICloudBlob blob, string LocalFile) { // The class currently stores state in class level variables so calling UploadBlobAsync or DownloadBlobAsync a second time will cause problems. // A better long term solution would be to better encapsulate the state, but the current solution works for the needs of my primary client. // Throw an exception if UploadBlobAsync or DownloadBlobAsync has already been called. lock (WorkingLock) { if (!Working) { Working = true; } else { throw new Exception("BlobTransfer already initiated. Create new BlobTransfer object to initiate a new file transfer."); } } // Create an async op in order to raise the events back to the client on the correct thread. asyncOp = AsyncOperationManager.CreateOperation(blob); TransferType = TransferTypeEnum.Download; m_Blob = blob; m_FileName = LocalFile; m_Blob.FetchAttributes(); FileStream fs = new FileStream(m_FileName, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read); ProgressStream pstream = new ProgressStream(fs); pstream.ProgressChanged += pstream_ProgressChanged; pstream.SetLength(m_Blob.Properties.Length); m_Blob.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 10; asyncresult = m_Blob.BeginDownloadToStream(pstream, BlobTransferCompletedCallback, new BlobTransferAsyncState(m_Blob, pstream)); }
/// <include file='doc\SoundPlayer.uex' path='docs/doc[@for="SoundPlayer.LoadAsync"]/*' /> public void LoadAsync() { // if we have a file there is nothing to load - we just pass the file to the PlaySound function // if we have a stream, then we start loading the stream async // if (uri != null && uri.IsFile) { Debug.Assert(stream == null, "we can't have a stream and a path at the same time"); isLoadCompleted = true; FileInfo fi = new FileInfo(uri.LocalPath); if (!fi.Exists) { throw new FileNotFoundException(SR.GetString(SR.SoundAPIFileDoesNotExist), this.soundLocation); } OnLoadCompleted(new AsyncCompletedEventArgs(null, false, null)); return; } // if we are actively loading, keep it running if (copyThread != null && copyThread.ThreadState == System.Threading.ThreadState.Running) { return; } isLoadCompleted = false; streamData = null; currentPos = 0; asyncOperation = AsyncOperationManager.CreateOperation(null); LoadStream(false); }
public virtual bool Run(bool threaded) { AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(this.taskIdentifier); this._waitEvent = new AutoResetEvent(false); object syncRoot = this.userStateToLifetime.SyncRoot; ObjectFlowControl.CheckForSyncLockOnValueType(syncRoot); lock (syncRoot) { if (this.userStateToLifetime.Contains(this.taskIdentifier)) { Interaction.MsgBox("There is an operation still pending.\r\n\r\nPlease disconnect then reconnect your phone and then try again.", MsgBoxStyle.Exclamation, null); return(false); } this.userStateToLifetime[this.taskIdentifier] = asyncOp; } if (threaded) { new WorkerEventHandler(this.ProcessCommandQueue).BeginInvoke(asyncOp, null, null); } else { this.ProcessCommandQueue(asyncOp); } return(true); }
public DirectoryView(string dir, ArrayList myArrayList, Icon plusIcon, Icon minusIcon, ref List <ExtensionIcon> smallImageList, Methods pmyActions) { _myArrayList = myArrayList; _plusIcon = plusIcon; _minusIcon = minusIcon; _smallImageList = smallImageList; // Setup Async _oper = AsyncOperationManager.CreateOperation(null); myActions = pmyActions; // Fill Fill(dir, true, myActions); // Setup the FileSystemWatcher FileSystemWatcher fsw = new FileSystemWatcher(dir); fsw.EnableRaisingEvents = true; fsw.NotifyFilter = NotifyFilters.DirectoryName | NotifyFilters.FileName | NotifyFilters.LastWrite | NotifyFilters.LastAccess; fsw.Changed += new FileSystemEventHandler(FileSystem_Changed); fsw.Created += new FileSystemEventHandler(FileSystem_Created); fsw.Deleted += new FileSystemEventHandler(FileSystem_Deleted); fsw.Renamed += new RenamedEventHandler(FileSystem_Renamed); // Debug info WriteDebugThreadInfo("DirectoryView"); }
private void NotCompleted(OperationCompletedTracker tracker) { // This is in a helper method to ensure the JIT doesn't artifically extend the lifetime of the operation. AsyncOperationManager.SynchronizationContext = tracker; AsyncOperation operation = AsyncOperationManager.CreateOperation(new object()); Assert.False(tracker.OperationDidComplete); }
public override void SubscribeAsync(object userToken) { // // My Contact is always subscribed. So this is no op. Just call the callback // if (m_Disposed) { throw new ObjectDisposedException(this.GetType().FullName); } if (userToken == null) { throw new ArgumentNullException("userToken"); } Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Entering SubscribeAsync() with user token {0}.", userToken); lock (AsyncLock){ if (AsyncOp != null) { throw new PeerToPeerException(SR.GetString(SR.Collab_DuplicateSubscribeAsync)); } AsyncOp = AsyncOperationManager.CreateOperation(userToken); } this.PrepareToRaiseSubscribeCompletedEvent(AsyncOp, new SubscribeCompletedEventArgs(null, this, null, false, userToken)); Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Leaving SubscribeAsync()."); }
/// <summary> /// Downloads a blob to a local file asynchronously. /// </summary> /// <param name="localFile">The local file.</param> /// <exception cref="System.Exception">BlobTransfer already initiated. Create new BlobTransfer object to initiate a new file transfer.</exception> public ICancellableAsyncResult DownloadBlobAsync(string localFile) { lock (workingLock) { if (!working) { working = true; } else { throw new Exception("BlobTransfer already initiated. Create new BlobTransfer object to initiate a new file transfer."); } } // Create an async op in order to raise the events back to the client on the correct thread. asyncOp = AsyncOperationManager.CreateOperation(blob); TransferType = TransferTypeEnum.Download; fileName = localFile; this.blob.FetchAttributes(); FileStream fs = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read); ProgressStream pstream = new ProgressStream(fs); pstream.ProgressChanged += pstream_ProgressChanged; pstream.SetLength(this.blob.Properties.Length); this.blob.ServiceClient.ParallelOperationThreadCount = 10; asyncresult = this.blob.BeginDownloadToStream(pstream, BlobTransferCompletedCallback, new BlobTransferAsyncState(this.blob, pstream)); return(asyncresult); }
/// <summary> /// Uploads a file to an Azure blob asynchronously. /// </summary> /// <param name="localFile">The local file.</param> /// <exception cref="System.Exception">BlobTransfer already initiated. Create new BlobTransfer object to initiate a new file transfer.</exception> public ICancellableAsyncResult UploadBlobAsync(string localFile) { lock (workingLock) { if (!working) { working = true; } else { throw new Exception("BlobTransfer already initiated. Create new BlobTransfer object to initiate a new file transfer."); } } // Attempt to open the file first so that we throw an exception before getting into the async work using (var fstemp = new FileStream(localFile, FileMode.Open, FileAccess.Read)) { } // Create an async op in order to raise the events back to the client on the correct thread. asyncOp = AsyncOperationManager.CreateOperation(this.blob); TransferType = TransferTypeEnum.Upload; fileName = localFile; var file = new FileInfo(fileName); long fileSize = file.Length; FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read); ProgressStream pstream = new ProgressStream(fs); pstream.ProgressChanged += pstream_ProgressChanged; pstream.SetLength(fileSize); this.blob.ServiceClient.ParallelOperationThreadCount = 10; asyncresult = this.blob.BeginUploadFromStream(pstream, BlobTransferCompletedCallback, new BlobTransferAsyncState(this.blob, pstream)); return(asyncresult); }
public virtual void MatMulAsync(double[,] mat1, double[,] mat2, int size, object taskId) { AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(taskId); lock (userStateToLifetime.SyncRoot) { if (userStateToLifetime.Contains(taskId)) { throw new ArgumentException( "Task ID parameter must be unique", "taskId"); } userStateToLifetime[taskId] = asyncOp; } // Start the asynchronous operation. WorkerEventHandler workerDelegate = new WorkerEventHandler(CalculateWorker); workerDelegate.BeginInvoke( mat1, mat2, size, asyncOp, null, null); }
protected override YahooManaged.Base.DownloadCompletedEventArgs <MarketResult> ConvertDownloadCompletedEventArgs(YahooManaged.Base.DefaultDownloadCompletedEventArgs <MarketResult> e) { MarketDownloadSettings set = (MarketDownloadSettings)e.Settings; if (set.Sectors != null) { SectorsDownloadCompletedEventArgs args = new SectorsDownloadCompletedEventArgs(e.UserArgs, (SectorResponse)e.Response, set); if (AsyncSectorsDownloadCompleted != null) { AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(this); asyncOp.Post(new SendOrPostCallback(delegate(object obj) { AsyncSectorsDownloadCompleted(this, (SectorsDownloadCompletedEventArgs)obj); }), args); } return(args); } else if (set.Industries != null) { IndustryDownloadCompletedEventArgs args = new IndustryDownloadCompletedEventArgs(e.UserArgs, (IndustryResponse)e.Response, set); if (AsyncIndustriesDownloadCompleted != null) { AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(this); asyncOp.Post(new SendOrPostCallback(delegate(object obj) { AsyncIndustriesDownloadCompleted(this, (IndustryDownloadCompletedEventArgs)obj); }), args); } return(args); } else { return(null); } }
public void Open(string uri, string protocol, ClientAccessPolicyProtocol policyProtocol, bool enableAutoSendPing, int autoSendPingInterval) { m_AsyncOper = AsyncOperationManager.CreateOperation(null); //pass in Origin var hostName = HtmlPage.Document.DocumentUri.Host; var port = HtmlPage.Document.DocumentUri.Port; string origin = hostName; if (port != 80) { origin += ":" + port; } m_WebSocket = new WebSocket(uri, protocol, cookies: HtmlPage.Document.Cookies, origin: origin); m_WebSocket.Opened += new EventHandler(m_WebSocket_Opened); m_WebSocket.Closed += new EventHandler(m_WebSocket_Closed); m_WebSocket.MessageReceived += new EventHandler <MessageReceivedEventArgs>(m_WebSocket_MessageReceived); m_WebSocket.Error += new EventHandler <ErrorEventArgs>(m_WebSocket_Error); m_WebSocket.ClientAccessPolicyProtocol = (policyProtocol == ClientAccessPolicyProtocol.Http) ? SocketClientAccessPolicyProtocol.Http : SocketClientAccessPolicyProtocol.Tcp; m_WebSocket.EnableAutoSendPing = enableAutoSendPing; m_WebSocket.AutoSendPingInterval = autoSendPingInterval; m_WebSocket.Open(); }
void SendAsyncCore(HttpRequestMessage request, object userState) { if (userState != null) { CancelManager.EnableCancel(request); lock (pendingAsync) { HttpStageProcessingAsyncResult pend; if (pendingAsync.TryGetValue(userState, out pend)) { if (pend == null) { throw new ArgumentException("userState is not unique", "userState"); } else { throw new ArgumentException("userState is already being used for " + pend.HttpAsyncState.request, "userState"); } } pendingAsync.Add(userState, null); } } var operation = AsyncOperationManager.CreateOperation(userState); var state = new SendAsyncState(this, operation); var result = this.BeginSendCore(request, SendCompletedCallback, state); if (userState != null && !result.IsCompleted) { lock (pendingAsync) { Debug.Assert(pendingAsync[userState] == null); pendingAsync[userState] = result; } } }
public WaitHandle RunAsync() { if (isRunning) { throw new InvalidOperationException("Import is already running"); } try { /* must be set (as soon as possible) in a function that is _not_ called asynchronously * (i.e. dont call it in ImportThread()) */ isRunning = true; importSucceeded = false; cancellationRequested = false; asyncOperation = AsyncOperationManager.CreateOperation(null); Reset(); /* invoke the import function on a new thread and return a waithandle */ Action <string, VolumeDatabase, string, int> it = ImportThread; IAsyncResult ar = it.BeginInvoke(sourceDbPath, targetDb, dbDataPath, bufferSize, null, null); return(ar.AsyncWaitHandle); } catch (Exception) { isRunning = false; if (asyncOperation != null) { asyncOperation.OperationCompleted(); } throw; } }
/// <summary> /// Constructor Engine /// </summary> /// <param name="rootPath"></param> /// <param name="srvType"></param> /// <param name="srvIp"></param> /// <param name="srvLogin"></param> /// <param name="srvPwd"></param> public Engine(string rootPath, bool srvType, string srvName, string srvLogin, string srvPwd) { this.op = AsyncOperationManager.CreateOperation(null); _finfo = new List <InputSorage>(); _rootPath = rootPath; _isInit = __InitEngine(srvType, srvName, srvLogin, srvPwd); }
public void DownloadHtmlAsync(Uri address) { AsyncOperation asyncOperation = AsyncOperationManager.CreateOperation(null); DownloadHtmlCallback callBack = new DownloadHtmlCallback(InternalDownloadHtmlAsync); callBack.BeginInvoke(address, asyncOperation, null, null); }
/// <summary> /// Creates an instance of the HttpDownloader class /// </summary> /// <param name="url">Url source string</param> /// <param name="destPath">Target file path</param> public HttpDownloader(string url, string destPath) { this.Reset(); fileURL = url; this.destPath = destPath; oprtor = AsyncOperationManager.CreateOperation(null); }
public FileNodeExportViewModel() { CancelOrCloseCommand = new RelayCommand(DoCancelOrCloseCommand); OpenPathCommand = new RelayCommand(DoOpenPathCommand); AsyncOperation = AsyncOperationManager.CreateOperation(this); }
public void Reload() { if (_operation != null) { return; } _operation = AsyncOperationManager.CreateOperation(null); Reset(); Show(); ThreadPool.QueueUserWorkItem(obj => { try { OnRequestLoad(new GeneralEventArgs <Action <Action> >(_ => OnAction(_))); OnAction(OnLoadSuccess, true); } catch (Exception ex) { Exception = ex; OnAction(OnLoadFailed, true); } finally { _operation = null; } }); }
/// <summary> /// Upload file and start recognition asynchronously /// Performs callbacks: /// UploadFileCompleted /// TaskProcessingCompleted /// </summary> private void processFileAsync(string filePath, IProcessingSettings settings, object taskId) { // Create an AsyncOperation for taskId. AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(taskId); // Multiple threads will access the task dictionary, // so it must be locked to serialize access. lock (processJobs.SyncRoot) { if (processJobs.Contains(taskId)) { throw new ArgumentException( "Task ID parameter must be unique", "taskId"); } processJobs[taskId] = asyncOp; } // Start the asynchronous operation. processFileWorkerEventHandler workerDelegate = new processFileWorkerEventHandler(processFileWorker); workerDelegate.BeginInvoke( filePath, settings, asyncOp, null, null); }
private void InitBeforeRun(int threadCount, bool needCreateBarrierForReps = true) { _repeatCount = 0; _notImplementedReset = false; _currentThreadCount = threadCount; if (needCreateBarrierForReps) { _barrierForReps = new Barrier(threadCount, (b) => { if (!Canceling) { OnRepeatCompleted( new MultiThreadingRepeatEventArgs(++_repeatCount)); } }); } _canceling = false; _asyncOperation = AsyncOperationManager.CreateOperation(new object()); Working = true; OnBeginningWork(EventArgs.Empty); }
public void LoadAsync() { if ((this.imageLocation == null) || (this.imageLocation.Length == 0)) { throw new InvalidOperationException(System.Windows.Forms.SR.GetString("PictureBoxNoImageLocation")); } if (!this.pictureBoxState[1]) { this.pictureBoxState[1] = true; if (((this.Image == null) || (this.imageInstallationType == ImageInstallationType.ErrorOrInitial)) && (this.InitialImage != null)) { this.InstallNewImage(this.InitialImage, ImageInstallationType.ErrorOrInitial); } this.currentAsyncLoadOperation = AsyncOperationManager.CreateOperation(null); if (this.loadCompletedDelegate == null) { this.loadCompletedDelegate = new SendOrPostCallback(this.LoadCompletedDelegate); this.loadProgressDelegate = new SendOrPostCallback(this.LoadProgressDelegate); this.readBuffer = new byte[0x1000]; } this.pictureBoxState[0x20] = false; this.pictureBoxState[2] = false; this.contentLength = -1; this.tempDownloadStream = new MemoryStream(); WebRequest state = WebRequest.Create(this.CalculateUri(this.imageLocation)); new WaitCallback(this.BeginGetResponseDelegate).BeginInvoke(state, null, null); } }
///////////////////////////////////////////////////////////// /// #region 实现 // 这个方法开始一个异步的计算 // 首先,它检查提供的taskId是否为unique的,如果是,就创建一个新的 WorkerEventHandler,并调用BeginInvoke方法开始计算 public virtual void ValidateAsync( ref List <ProxyInfo> proxyList, object taskId) { // 为taskId创建一个AsyncOperation对象 AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(taskId); // Multiple threads will access the task dictionary, // so it must be locked to serialize access. lock (userStateToLifetime.SyncRoot) { if (userStateToLifetime.Contains(taskId)) { throw new ArgumentException( "Task ID parameter must be unique", "taskId"); } userStateToLifetime[taskId] = asyncOp; } // 开始异步操作 WorkerEventHandler workerDelegate = new WorkerEventHandler(CalculateWorker); workerDelegate.BeginInvoke( ref proxyList, asyncOp, null, null); }
//public event EventHandler<TEventArgs<List<>>> ModChatRoomMemberListComplete; #endregion public Client() { baseRequest = new BaseRequest(); asyncOperation = AsyncOperationManager.CreateOperation(null); source = new CancellationTokenSource(); factory = new TaskFactory(source.Token); }
/// <summary> /// Retrieves the Profile URI for a given entity asynchronously. /// </summary> /// <param name="command"></param> /// <param name="taskId"></param> /// <remarks> /// This method starts an asynchronous command. /// First, it checks the supplied task ID for uniqueness. /// If taskId is unique, it creates a new WorkerEventHandler /// and calls its BeginInvoke method to start the calculation. /// </remarks> public virtual void GetProfileAsync( string entity, int timeout = DEFAULT_TIMEOUT, object taskId = null) { if (taskId == null) { taskId = System.Guid.NewGuid(); } // Create an AsyncOperation for taskId. AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(taskId); // Multiple threads will access the task dictionary, // so it must be locked to serialize access. lock (userStateToLifetime.SyncRoot) { if (userStateToLifetime.Contains(taskId)) { throw new ArgumentException( "Task ID parameter must be unique", "taskId"); } userStateToLifetime[taskId] = asyncOp; } // Start the asynchronous operation. GetProfileWorkerEventHandler workerDelegate = new GetProfileWorkerEventHandler(CalculateGetProfileWorker); workerDelegate.BeginInvoke(entity, timeout, asyncOp, null, null); }
public void MovieSearchAsync(string title, object userState) { AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(null); MovieSearchDelegate worker = new MovieSearchDelegate(MovieSearchWorker); worker.BeginInvoke(title, userState, asyncOp, null, null); }