protected DownloadFileTask(Account account, string accountName, int priority, AsyncTask[] parent, string destFolder, AccountFile file) : base(account, accountName, priority, parent) { DestFolder = destFolder; File = file; }
private void EnumerateFilesRecursiveAsync(DirectoryInfo folder, AccountFile destDirectory, AsyncTask task, CancellationToken token) { foreach (var file in folder.EnumerateFiles()) { if (token.IsCancellationRequested) return; //var newTask = task == null // ? new UploadFileTask(Account, AccountName, 0, null, file.FullName, destDirectory) // : new UploadFileTask(Account, AccountName, 0, new[] { task }, file.FullName, null); var newTask = new UploadFileTask(Account, AccountName, 0, new[] { task }, file.FullName, null); AddTask(newTask); lastTask.AddParent(newTask); } foreach (var dir in folder.EnumerateDirectories()) { if (token.IsCancellationRequested) return; //var newTask = task == null // ? new CreateFolderTask(Account, AccountName, 0, null, dir.Name, destDirectory) // : new CreateFolderTask(Account, AccountName, 0, new[] { task }, dir.Name, null); var newTask = new CreateFolderTask(Account, AccountName, 0, new[] { task }, dir.Name, null); AddTask(newTask); lastTask.AddParent(newTask); EnumerateFilesRecursiveAsync(dir, destDirectory, newTask, token); } OnProgress(new AsyncTaskProgressEventArgs(0, null)); }
public void SimpleTest() { var Result = new AsyncTask<String>(delegate() { return "Hello"; }); Assert.AreEqual("Hello", Result.Result); }
public void Complex2Test() { var Result = new AsyncTask<String>(delegate() { Thread.Yield(); return "Test"; }); Assert.AreEqual("Test", Result.Result); Assert.IsTrue(Result.Ready); }
public void Complex1Test() { var Result = new AsyncTask<String>(delegate() { Thread.Yield(); return "Test"; }); Assert.IsFalse(Result.Ready); Thread.Sleep(2); Assert.IsTrue(Result.Ready); }
/// <summary> /// Runs <paramref name="method"/> on the worker thread. /// </summary> /// <param name="method">The method to run.</param> /// <returns>IAsyncResult that gets completed when the action has executed.</returns> public IAsyncResult Enqueue(Action method) { if (method == null) throw new ArgumentNullException("method"); AsyncTask task = new AsyncTask(method); lock (lockObject) { taskQueue.Enqueue(task); Monitor.Pulse(lockObject); } return task; }
private void btnTruncateSelected_Click(object sender, EventArgs e) { AsyncTask<string,string, string> task = new AsyncTask<string,string,string>(this); TextBox LogTxt = null; Trunc.OnProgress += new TableTruncator.TableItemTruncateEventHandler( delegate(string TableName, string Operation) { task.PublishProgress(string.Format("{0} -> {1}", Operation, TableName)); } ); task.doInBackground = delegate(string[] param) { task.PublishProgress("Truncating tables..."); Trunc.TruncateTable(param); return "Done"; }; task.onProgressUpdate = delegate(string[] param) { lblStatus.Text = param[0]; LogTxt.AppendText(param[0] + "\r\n"); LogTxt.SelectionStart = LogTxt.Text.Length; }; task.onPostExecute = delegate(string result) { lblStatus.Text = result; LogTxt.AppendText(result + "\r\n"); LogTxt.SelectionStart = LogTxt.Text.Length; LogTxt.AppendText("Disconnecting\r\n"); if (chkShowScript.Checked) { frmScriptViewer ScriptViewDlg = new frmScriptViewer(Trunc.ToString()); ScriptViewDlg.ShowDialog(); } Trunc.Release(); }; Trunc.OnlyGenerateSQLScript = chkOnlyGenScript.Checked; LogTxt = PassProgressMode(); task.Execute(GetCheckedTables()); }
private void NotifyTaskStateChanged(AsyncTask task, TaskStateChangedEventArgs.State state) { var stateChangedHandler = TaskStateChanged; if (stateChangedHandler == null) return; // No event handler, bail. var e = new TaskStateChangedEventArgs(task, state); stateChangedHandler(this, e); if (state == TaskStateChangedEventArgs.State.Discarded) { task.HandleTaskDiscarded(); } }
protected override TaskMergeInstruction CanMergeWithCore(AsyncTask otherTask) { var theOtherTask = otherTask as NotifyRenderPackagesReadyAsyncTask; if (theOtherTask == null) return base.CanMergeWithCore(otherTask); // Comparing to another NotifyRenderPackagesReadyAsyncTask, the one // that gets scheduled more recently stay, while the earlier one // gets dropped. If this task has a higher tick count, keep this. // if (ScheduledTime.TickCount > theOtherTask.ScheduledTime.TickCount) return TaskMergeInstruction.KeepThis; return TaskMergeInstruction.KeepOther; // Otherwise, keep the other. }
protected override async Task OnStartAsync() { lastTask = new EmptyTask(Account, AccountName, Priority, null); var folder = new DirectoryInfo(Path); OnProgress(new AsyncTaskProgressEventArgs(0, null)); var createFolderTask = new CreateFolderTask(Account, AccountName, 0, null, FolderName, DestFolder); AddTask(createFolderTask); lastTask.AddParent(createFolderTask); //CreatedFolder = await Account.CreateFolderAsync(System.IO.Path.GetFileName(Path), DestFolder, CancellationTokenSource.Token); EnumerateFilesRecursiveAsync(folder, CreatedFolder, createFolderTask, CancellationTokenSource.Token); AddTask(lastTask); await Task.Run(async () => { while (lastTask.State == AsyncTaskState.Running || lastTask.State == AsyncTaskState.Waiting) { await Task.Delay(500); } }); }
/// <summary> /// Creates tasks percentage. /// </summary> /// <param name="asyncTaskUId">The task UId to be updated</param> /// <param name="currentActivity">The current activity</param> /// <param name="pct">The current percentage</param> public void CreateTask(string asyncTaskUId, string type, string requiredRole, string currentActivity, string description, string fileName, string contentType, string mimeType) { AsyncTask asyncTask = new AsyncTask(); asyncTask.AsyncTaskUId = asyncTaskUId; asyncTask.Type = type; asyncTask.CurrentAtivity = currentActivity; asyncTask.RequiredRole = requiredRole; asyncTask.Description = description; asyncTask.CurrentPercentage = 0; asyncTask.StartDate = DateTime.Now.ToUniversalTime(); asyncTask.FileName = fileName; asyncTask.ResultContentType = contentType; asyncTask.ResultMimeType = mimeType; using (Data.CoreContext context = new Data.CoreContext()) { context.AsyncTasks.Add(asyncTask); context.SaveChanges(); } }
public static void LogUnhandledException(this AsyncTask task, string prefix, Exception ex) { LogUnhandledException((code, message) => task.LogCodedError(code, message), prefix, ex); }
public void Login() { if (log.IsDebugEnabled) { log.DebugFormat("login start. username:{0} password:{1}", this.username, this.password); } this.account = null; this.loginCommand.Enabled = false;/*by databinding, auto set button.interactable = false. */ AsyncTask <Account> task; if (!(this.ValidateUsername() && this.ValidatePassword())) { task = new AsyncTask <Account>(() => { return(null); }); } else { task = new AsyncTask <Account>(() => { IAsyncResult <Account> result = this.accountService.Login(this.username, this.password); Account account = result.Synchronized().WaitForResult(); if (account != null) { Context.GetApplicationContext().GetMainLoopExcutor().RunOnMainThread(() => { globalPreferences.SetString(LAST_USERNAME_KEY, this.username); globalPreferences.Save(); }); } return(account); }); } task.OnPostExecute(account => { if (account != null) { /* login success */ this.account = account; this.interactionFinished.Raise();/* Interaction completed, request to close the login window */ } else { /* Login failure */ var tipContent = this.localization.GetText("login.failure.tip", "Login failure."); this.toastRequest.Raise(new Notification(tipContent));/* show toast */ } }).OnError(e => { if (log.IsErrorEnabled) { log.ErrorFormat("OnError:{0}", e); } var tipContent = this.localization.GetText("login.exception.tip", "Login exception."); this.toastRequest.Raise(new Notification(tipContent));/* show toast */ }).OnFinish(() => { this.loginCommand.Enabled = true;/*by databinding, auto set button.interactable = true. */ }).Start(); }
public _Runnable_381(AsyncTask function, Database database) { this.function = function; this.database = database; }
public IEnumerator LoadLevelCoroutine(Package.Asset asset, string playerScene, string uiScene, SimulationMetaData ngs) { string scene; int i; yield return(null); Util.InvokeVoid(LoadingManager.instance, "PreLoadLevel"); if (!LoadingManager.instance.LoadingAnimationComponent.AnimationLoaded) { LoadingManager.instance.m_loadingProfilerScenes.BeginLoading("LoadingAnimation"); yield return(SceneManager.LoadSceneAsync("LoadingAnimation", LoadSceneMode.Additive)); LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } AsyncTask task = Singleton <SimulationManager> .instance.AddAction("Loading", (IEnumerator)Util.Invoke(LoadingManager.instance, "LoadSimulationData", asset, ngs)); LoadSaveStatus.activeTask = task; if (LoadingManager.instance.m_loadedEnvironment == null) // loading from main menu { knownFailedAssets.Clear(); fastLoad = false; } else // loading from in-game (the pause menu) { while (!LoadingManager.instance.m_metaDataLoaded && !task.completedOrFailed) // IL_139 { yield return(null); } if (SimulationManager.instance.m_metaData == null) { SimulationManager.instance.m_metaData = new SimulationMetaData(); SimulationManager.instance.m_metaData.m_environment = "Sunny"; SimulationManager.instance.m_metaData.Merge(ngs); } Util.InvokeVoid(LoadingManager.instance, "MetaDataLoaded"); // No OnCreated string mapThemeName = SimulationManager.instance.m_metaData.m_MapThemeMetaData?.name; fastLoad = SimulationManager.instance.m_metaData.m_environment == LoadingManager.instance.m_loadedEnvironment && mapThemeName == LoadingManager.instance.m_loadedMapTheme; // The game is nicely optimized when loading from the pause menu. We must specifically address the following situation: // - environment (biome) stays the same // - map theme stays the same // - 'load used assets' is enabled // - not all assets used in the save being loaded are currently in memory. if (fastLoad) { if (Settings.settings.loadUsed && !IsKnownFastLoad(asset)) { i = Profiling.Millis; while (Profiling.Millis - i < 5000 && !IsSaveDeserialized()) { yield return(null); } fastLoad = AllAssetsAvailable(); } if (fastLoad) // optimized load { LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "EssentialScenesLoaded")); LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "RenderDataReady")); Util.DebugPrint("fast load at", Profiling.Millis); } else // fallback to full load { DestroyLoadedPrefabs(); LoadingManager.instance.m_loadedEnvironment = null; LoadingManager.instance.m_loadedMapTheme = null; Util.DebugPrint("not fast load at", Profiling.Millis); } } else // full load { // Notice that there is a race condition in the base game at this point: DestroyAllPrefabs ruins the simulation // if its deserialization has progressed far enough. Typically there is no problem. Util.InvokeVoid(LoadingManager.instance, "DestroyAllPrefabs"); LoadingManager.instance.m_loadedEnvironment = null; LoadingManager.instance.m_loadedMapTheme = null; Util.DebugPrint("full load at", Profiling.Millis); } } if (LoadingManager.instance.m_loadedEnvironment == null) // IL_27C { AsyncOperation op; knownFastLoads.Clear(); fullLoadTime = DateTime.Now; loadingLock = Util.Get(LoadingManager.instance, "m_loadingLock"); if (!string.IsNullOrEmpty(playerScene)) { LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(playerScene); op = SceneManager.LoadSceneAsync(playerScene, LoadSceneMode.Single); while (!op.isDone) // IL_2FF { LoadingManager.instance.SetSceneProgress(op.progress * 0.01f); yield return(null); } LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } while (!LoadingManager.instance.m_metaDataLoaded && !task.completedOrFailed) // IL_33C { yield return(null); } if (SimulationManager.instance.m_metaData == null) { SimulationManager.instance.m_metaData = new SimulationMetaData(); SimulationManager.instance.m_metaData.m_environment = "Sunny"; SimulationManager.instance.m_metaData.Merge(ngs); } Util.InvokeVoid(LoadingManager.instance, "MetaDataLoaded"); // OnCreated if loading from the main manu KeyValuePair <string, float>[] levels = SetLevels(); float currentProgress = 0.10f; for (i = 0; i < levels.Length; i++) { scene = levels[i].Key; LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene); op = SceneManager.LoadSceneAsync(scene, LoadSceneMode.Additive); while (!op.isDone) { LoadingManager.instance.SetSceneProgress(currentProgress + op.progress * (levels[i].Value - currentProgress)); yield return(null); } LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); currentProgress = levels[i].Value; } Queue <IEnumerator> mainThreadQueue; // Some major mods (Network Extensions 1 & 2, Single Train Track, Metro Overhaul) have a race condition issue // in their NetInfo Installer. Everything goes fine if LoadCustomContent() below is NOT queued before the // said Installers have finished. This is just a workaround for the issue. The actual fix should be in // the Installers. Notice that the built-in loader of the game is also affected. do { yield return(null); yield return(null); lock (loadingLock) { mainThreadQueue = (Queue <IEnumerator>)queueField.GetValue(LoadingManager.instance); i = mainThreadQueue.Count; } }while (i > 0); LoadingManager.instance.QueueLoadingAction(AssetLoader.instance.LoadCustomContent()); RenderManager.Managers_CheckReferences(); LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "EssentialScenesLoaded")); RenderManager.Managers_InitRenderData(); LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "RenderDataReady")); simulationFailed = HasFailed(task); // Performance optimization: do not load scenes while custom assets are loading. while (!AssetLoader.instance.hasFinished) { yield return(null); } scene = SimulationManager.instance.m_metaData.m_environment + "Properties"; if (!string.IsNullOrEmpty(scene)) { LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene); op = SceneManager.LoadSceneAsync(scene, LoadSceneMode.Additive); while (!op.isDone) // IL_C47 { LoadingManager.instance.SetSceneProgress(0.85f + op.progress * 0.05f); yield return(null); } LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } if (!simulationFailed) { simulationFailed = HasFailed(task); } if (!string.IsNullOrEmpty(uiScene)) // IL_C67 { LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(uiScene); op = SceneManager.LoadSceneAsync(uiScene, LoadSceneMode.Additive); while (!op.isDone) // IL_CDE { LoadingManager.instance.SetSceneProgress(0.90f + op.progress * 0.08f); yield return(null); } LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } LoadingManager.instance.m_loadedEnvironment = SimulationManager.instance.m_metaData.m_environment; // IL_CFE LoadingManager.instance.m_loadedMapTheme = SimulationManager.instance.m_metaData.m_MapThemeMetaData?.name; } else { scene = (string)Util.Invoke(LoadingManager.instance, "GetLoadingScene"); if (!string.IsNullOrEmpty(scene)) { LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene); yield return(SceneManager.LoadSceneAsync(scene, LoadSceneMode.Additive)); LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } } LoadingManager.instance.SetSceneProgress(1f); // IL_DBF if (!simulationFailed) { simulationFailed = HasFailed(task); } while (!task.completedOrFailed) // IL_DED { yield return(null); } LoadingManager.instance.m_simulationDataLoaded = LoadingManager.instance.m_metaDataLoaded; LoadingManager.SimulationDataReadyHandler SimDataReady = Util.Get(LoadingManager.instance, "m_simulationDataReady") as LoadingManager.SimulationDataReadyHandler; SimDataReady?.Invoke(); SimulationManager.UpdateMode mode = SimulationManager.UpdateMode.Undefined; if (ngs != null) { mode = ngs.m_updateMode; } LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "LoadLevelComplete", mode)); // OnLevelLoaded if (Singleton <TelemetryManager> .exists) { Singleton <TelemetryManager> .instance.StartSession(asset?.name, playerScene, mode, SimulationManager.instance.m_metaData); } LoadingManager.instance.QueueLoadingAction(LoadingComplete()); knownFastLoads.Add(asset.fullName); AssetLoader.instance.PrintMem(); }
/// <summary> /// Checks if all parts of the craft are installed. /// </summary> /// <param name="partList">The list of installed parts.</param> private static void Parts_ScanComplete(List <PartNode> partList) { View.ShowProcessingIcon = true; EventDistributor.InvokeAsyncTaskStarted(Instance); AsyncTask <bool> .DoWork(() => { Messenger.AddInfo(Messages.MSG_CRAFT_VALIDATION_STARTED); View.InvokeIfRequired(() => model.Nodes.Clear()); foreach (CraftNode craft in allCrafts) { Messenger.AddInfo(string.Format(Messages.MSG_VALIDATING_CRAFT_0, craft.Name)); Dictionary <string, CraftNode> alreadyCheckedParts = new Dictionary <string, CraftNode>(); foreach (CraftNode part in craft.Nodes) { string partName = part.Name.Substring(0, part.Name.IndexOf(" (")); string count = part.Name.Substring(partName.Length); if (alreadyCheckedParts.ContainsKey(part.Name)) { if (alreadyCheckedParts[part.Name] != null) { part.RelatedPart = alreadyCheckedParts[part.Name].RelatedPart; part.Name = part.RelatedPart.Title + count; craft.AddMod(part.RelatedPart.Mod); } continue; } else { bool found = false; foreach (PartNode instPart in partList) { if (instPart.Name.Replace("_", ".") == partName) { if (!alreadyCheckedParts.ContainsKey(instPart.Name)) { alreadyCheckedParts.Add(instPart.Name, part); } part.Name = instPart.Title + count; part.RelatedPart = instPart; part.AddMod(instPart.Mod); View.InvokeIfRequired(() => part.RelatedPart.AddRelatedCraft(craft)); craft.AddMod(instPart.Mod); found = true; break; } } if (!found) { alreadyCheckedParts.Add(part.Name, null); } } } if (craft.IsInvalidOrHasInvalidChilds) { Messenger.AddInfo(string.Format(Messages.MSG_VALIDATING_CRAFT_0_FAILED, craft.Name)); } else { Messenger.AddInfo(string.Format(Messages.MSG_VALIDATING_CRAFT_0_SUCCESSFUL, craft.Name)); } ////craft.SortPartsByDisplayText(); } return(true); }, (result, ex) => { View.ShowProcessingIcon = false; EventDistributor.InvokeAsyncTaskDone(Instance); PartsTabViewController.ScanComplete -= Parts_ScanComplete; if (ex != null) { MessageBox.Show(View.ParentForm, string.Format(Messages.MSG_ERROR_DURING_CRAFT_VALIDATION_0, ex.Message)); } else { RefreshTreeView(); } Messenger.AddInfo(Messages.MSG_CRAFT_VALIDATION_DONE); }); }
public SynchronizeDriveEmptyFolderTask(Account account, string accountName, int priority, AsyncTask[] parents, AccountFile folder) : base(account, accountName, priority, parents) { Folder = folder; }
private void Update() { //Permission Module Depende On This AsyncTask.OnUpdate(); }
// creates new user and adds it to the user group private IEnumerator AddUserToGroup(Face face, string userName, string userInfo) { CloudUserManager userManager = CloudUserManager.Instance; if (texCamShot && userManager && face != null && userName != null && userName.Trim() != string.Empty) { SetHintText("Wait..."); yield return(null); FaceRectangle faceRect = face.faceRectangle; byte[] imageBytes = texCamShot.EncodeToJPG(); yield return(null); AsyncTask <Person> task = new AsyncTask <Person>(() => { return(userManager.AddUserToGroup(userName.Trim(), userInfo, imageBytes, faceRect)); }); task.Start(); yield return(null); while (task.State == TaskState.Running) { yield return(null); } // get the resulting person Person person = task.Result; if (!string.IsNullOrEmpty(task.ErrorMessage)) { SetHintText(task.ErrorMessage); Debug.LogError(task.ErrorMessage); } else if (person != null && person.persistedFaceIds != null && person.persistedFaceIds.Length > 0) { string faceId = face.faceId; bool bFaceFound = false; for (int i = 0; i < faces.Length; i++) { if (faces[i].faceId == faceId) { if (faces[i].candidate == null || faces[i].candidate.person == null) { faces[i].candidate = new Candidate(); faces[i].candidate.personId = person.personId; faces[i].candidate.confidence = 1f; faces[i].candidate.person = person; } bFaceFound = true; break; } } if (!bFaceFound) { Debug.Log(string.Format("Face {0} not found.", faceId)); } SetHintText(string.Format("'{0}' created successfully.", userName.Trim())); ShowIdentityResult(); } else { SetHintText("User could not be created."); } } yield return(null); }
public void SimpleTest() { var Result = new AsyncTask <string>(delegate() { return("Hello"); }); Assert.Equal("Hello", Result.Result); }
public SynchronizeFileTask(Account account, string accountName, int priority, AsyncTask[] parent, AccountFile sourceFile) : base(account, accountName, priority, parent) { SourceFile = sourceFile; }
public async AsyncTask StartMonitor(string taskName) { await AsyncTask.Run(() => { }); }
void Application_End() { _hostClient.Dispose(); AsyncTask.Shutdown(); DependencyResolver.GlobalDispose(); }
/// <summary> /// Starts a asynchrony download. /// </summary> /// <param name="url">Download link</param> /// <param name="downloadPath">Path and filename to download to.</param> /// <param name="finished">The finished callback function. (A function with the signature "void FunctionName<bool>(bool result, Exception ex)")</param> /// <param name="progressChanged">The progress change callback function. (A function with the signature "void FunctionName(int percentage)")</param> public static void RunDownload(string url, string downloadPath, AsyncResultHandler <bool> finished = null, AsyncProgressChangedHandler progressChanged = null) { AsyncTask <bool> asyncTask = new AsyncTask <bool>(url, downloadPath, finished, progressChanged); asyncTask.RunDownload(); }
public override void Update() { if (m_SessionManager == null) { return; } AsyncTask.OnUpdate(); if (Frame.TrackingState != TrackingState.Tracking) { return; } if (m_ARCoreSessionConfig.EnablePlaneFinding) { Frame.GetPlanes(m_TrackedPlaneBuffer); foreach (var trackedPlane in m_TrackedPlaneBuffer) { BoundedPlane boundedPlane; if (m_TrackedPlanes.TryGetValue(trackedPlane, out boundedPlane)) { // remove any subsumed planes if (trackedPlane.SubsumedBy != null) { OnPlaneRemoved(boundedPlane); m_TrackedPlanes.Remove(trackedPlane); } // update any planes with changed extents else if (PlaneUpdated(trackedPlane, boundedPlane)) { boundedPlane.center = trackedPlane.Position; boundedPlane.rotation = trackedPlane.Rotation; boundedPlane.extents.x = trackedPlane.ExtentX; boundedPlane.extents.y = trackedPlane.ExtentZ; m_TrackedPlanes[trackedPlane] = boundedPlane; OnPlaneUpdated(boundedPlane); } } // add any new planes else { boundedPlane = new BoundedPlane() { id = Guid.NewGuid().ToString(), center = trackedPlane.Position, rotation = trackedPlane.Rotation, extents = new Vector2(trackedPlane.ExtentX, trackedPlane.ExtentZ) }; m_TrackedPlanes.Add(trackedPlane, boundedPlane); OnPlaneAdded(boundedPlane); } } // Check for planes that were removed from the tracked plane list List <TrackedPlane> planesToRemove = new List <TrackedPlane>(); foreach (var kvp in m_TrackedPlanes) { var trackedPlane = kvp.Key; if (!m_TrackedPlaneBuffer.Exists(x => x == trackedPlane)) { OnPlaneRemoved(kvp.Value); planesToRemove.Add(trackedPlane); } } foreach (var plane in planesToRemove) { m_TrackedPlanes.Remove(plane); } } //Update Anchors foreach (var anchor in m_Anchors) { anchor.Key.transform.position = anchor.Value.transform.position; anchor.Key.transform.rotation = anchor.Value.transform.rotation; } }
public DeleteFolderTask(Account account, string accountName, int priority, AsyncTask[] parent, AccountFile folder) : base(account, accountName, priority, parent, folder) { }
public _Runnable_639(Database _enclosing, AsyncTask asyncTask) { this._enclosing = _enclosing; this.asyncTask = asyncTask; }
public DeleteFileTask(Account account, string accountName, int priority, AsyncTask[] parents, AccountFile file) : base(account, accountName, priority, parents, file, false) { }
private void OnPreviewGraphCompleted(AsyncTask asyncTask) { var updateTask = asyncTask as PreviewGraphAsyncTask; if (updateTask != null) { var nodeGuids = updateTask.previewGraphData; var deltaComputeStateArgs = new DeltaComputeStateEventArgs(nodeGuids,graphExecuted); OnSetNodeDeltaState(deltaComputeStateArgs); } }
/// <summary> /// This callback method is invoked in the context of ISchedulerThread /// when UpdateGraphAsyncTask is completed. /// </summary> /// <param name="task">The original UpdateGraphAsyncTask instance.</param> private void OnUpdateGraphCompleted(AsyncTask task) { var updateTask = (UpdateGraphAsyncTask)task; var messages = new Dictionary <Guid, string>(); // Runtime warnings take precedence over build warnings. foreach (var warning in updateTask.RuntimeWarnings) { var message = string.Join(Environment.NewLine, warning.Value.Select(w => w.Message)); messages.Add(warning.Key, message); } foreach (var warning in updateTask.BuildWarnings) { // If there is already runtime warnings for // this node, then ignore the build warnings. // But for cyclic dependency warnings, it is // easier to understand to report a build warning. string message = string.Empty; if (messages.ContainsKey(warning.Key)) { if (!warning.Value.Any(w => w.ID == ProtoCore.BuildData.WarningID.InvalidStaticCyclicDependency)) { continue; } messages.Remove(warning.Key); message = string.Join("\n", warning.Value. Where(w => w.ID == ProtoCore.BuildData.WarningID.InvalidStaticCyclicDependency). Select(w => w.Message)); } else { message = string.Join("\n", warning.Value.Select(w => w.Message)); } if (!string.IsNullOrEmpty(message)) { messages.Add(warning.Key, message); } } var workspace = updateTask.TargetedWorkspace; foreach (var message in messages) { var guid = message.Key; var node = workspace.Nodes.FirstOrDefault(n => n.GUID == guid); if (node == null) { continue; } using (node.PropertyChangeManager.SetPropsToSuppress(nameof(NodeModel.ToolTipText), nameof(NodeModel.State))) { node.Warning(message.Value); // Update node warning message. } } // Notify listeners (optional) of completion. RunSettings.RunEnabled = true; // Re-enable 'Run' button. executingTask = false; // setting back to false //set the node execution preview to false; OnSetNodeDeltaState(new DeltaComputeStateEventArgs(new List <Guid>(), graphExecuted)); // This method is guaranteed to be called in the context of // ISchedulerThread (for Revit's case, it is the idle thread). // Dispatch the failure message display for execution on UI thread. // EvaluationCompletedEventArgs e = task.Exception == null || IsTestMode ? new EvaluationCompletedEventArgs(true, messages.Keys, null) : new EvaluationCompletedEventArgs(true, messages.Keys, task.Exception); EvaluationCount++; OnEvaluationCompleted(e); if (EngineController.IsDisposed) { return; } EngineController.ReconcileTraceDataAndNotify(); // Refresh values of nodes that took part in update. var nodes = new HashSet <NodeModel>(updateTask.ExecutedNodes.Concat(updateTask.ModifiedNodes)); foreach (var executedNode in nodes) { executedNode.RequestValueUpdate(EngineController); } scheduler.Tasks.AllComplete(_ => { OnRefreshCompleted(e); }); }
public EmptyTask(Account account, string accountName, int priority, AsyncTask[] parents, AsyncTaskParentsMode parentsMode = AsyncTaskParentsMode.CancelIfAnyErrorOrCanceled) : base(account, accountName, priority, parents, parentsMode) { }
public static void Issue(AsyncTask task) { AsyncTaskRunner(task); }
public virtual Stream ProcessAsynchronously(Stream requestStream) { DateTime now = DateTime.Now; string asyncToken = now.Ticks.ToString(CultureInfo.InvariantCulture); AsyncTask asyncTask = null; if (requestStream == null) { asyncTask = new AsyncTask(this, this.CreateRequestMessage(null), now.AddSeconds(AsyncTask.DefaultDuration)); } else { StreamPipe requestPipe = new StreamPipe(); using (requestPipe.WriteStream) { requestStream.CopyTo(requestPipe.WriteStream); // read the input stream to memory } var requestMessage = this.CreateRequestMessage(requestPipe.ReadStream); asyncTask = new AsyncTask(this, requestMessage, now.AddSeconds(AsyncTask.DefaultDuration)); } AsyncTask.AddTask(asyncToken, asyncTask); StreamPipe responsePipe = new StreamPipe(); var responseMessage = new ODataResponseMessage(responsePipe.WriteStream, 202); //202 Accepted responseMessage.PreferenceAppliedHeader().RespondAsync = true; ResponseWriter.WriteAsyncPendingResponse(responseMessage, asyncToken); return responsePipe.ReadStream; }
/// <summary> /// Scans the KSP install directory and sub directories for *.craft files. /// </summary> private static void ScanDir() { allModFilter.Clear(); allModFilter.Add(All); allModFilter.Add(Squad); View.SelectedModFilter = All; model.Nodes.Clear(); View.ShowProcessingIcon = true; EventDistributor.InvokeAsyncTaskStarted(Instance); AsyncTask <bool> .DoWork(() => { Messenger.AddInfo(Messages.MSG_PART_SCAN_STARTED); // Get part.cfg files from GameData folder. string gameDatePath = KSPPathHelper.GetPath(KSPPaths.GameData); string[] files = Directory.GetFiles(gameDatePath, EXTENSION_CFG, SearchOption.AllDirectories); // Get part.cfg files from additional folders. string partsPath = KSPPathHelper.GetPath(KSPPaths.Parts); string[] addPaths = new[] { partsPath }; foreach (var path in addPaths) { string[] files2 = Directory.GetFiles(path, EXTENSION_CFG, SearchOption.AllDirectories); int oldLength = files.Length; Array.Resize <string>(ref files, oldLength + files2.Length); Array.Copy(files2, 0, files, oldLength, files2.Length); } // Create PartNodes from each file. var nodes = new List <PartNode>(); if (files.Length > 0) { foreach (string file in files) { Messenger.AddInfo(string.Format(Messages.MSG_SCAN_FILE_0_FOR_PARTS, file)); var newNodes = CreatePartNodes(file); foreach (var newNode in newNodes) { if (newNode != null && !string.IsNullOrEmpty(newNode.Name) && !nodes.Contains(newNode)) { nodes.Add(newNode); } } } } else { Messenger.AddInfo(string.Format(Messages.MSG_NO_PARTCFG_FOUND_0, gameDatePath)); } allNodes.Clear(); foreach (PartNode node in nodes) { allNodes.Add(node); } Messenger.AddInfo(Messages.MSG_PART_SCAN_DONE); return(true); }, (result, ex) => { View.ShowProcessingIcon = false; EventDistributor.InvokeAsyncTaskDone(Instance); if (ex != null) { Messenger.AddError(string.Format(Messages.MSG_ERROR_DURING_PART_READING_0, ex.Message), ex); } else { RefreshTreeView(); } if (ScanComplete != null) { ScanComplete(Parts); } }); }
/// <summary> /// This function calls the passed task function asynchronously. /// </summary> /// <param name="task">The task function to execute asynchrony. (A function with the signature "T_RETURN_VALUE FunctionName<T_RETURN_VALUE>()")</param> /// <param name="finished">The finished callback function. (A function with the signature "void FunctionName<T_RETURN_VALUE>(T_RETURN_VALUE result, Exception ex)")</param> /// <param name="progressChanged">The progress change callback function. (A function with the signature "void FunctionName(int percentage)")</param> public static void DoWork(AsyncHandler <T_RETURN_VALUE> task, AsyncResultHandler <T_RETURN_VALUE> finished = null, AsyncProgressChangedHandler progressChanged = null) { AsyncTask <T_RETURN_VALUE> asyncTask = new AsyncTask <T_RETURN_VALUE>(task, finished, progressChanged); asyncTask.Run(); }
private void test() { Debug.Log("begin test"); /* AStarPathFinder pathFinder = new AStarPathFinder(mapData, new GameMoveCost(), new AStarHCostHuffman() //new AStarHCostEuclidean() //new AStarHCostChebyshev() ); IList<Vec2<short>> path = new List<Vec2<short>>(); Vec2<short> startPos = new Vec2<short>(3, 55), endPos = new Vec2<short>(70, 25); int err = (int)pathFinder.findPath(0, ref startPos, ref endPos, path); Debug.Log("found path with err=" + err); if (err == 0) printPath(path); //*/ //* _num = 10000; for (int i = 0; i < _num; ++i) { AStarPathFinder pathFinder = new AStarPathFinder(mapData, new GameMoveCost(), new AStarHCostHuffman() //new AStarHCostEuclidean() //new AStarHCostChebyshev() ); AsyncTask task = new AsyncTask(i + 1); task.getParamDict().Add(0, pathFinder); task.getParamDict().Add(1, i); task.onHandleTask = new OnHandleTask(onHandleTestTask); task.onCompleteTask = new OnCompleteTask(onCompleteTestTask); _dispatcher.dispatch(task); } //*/ Debug.Log("end test"); }
protected override TaskMergeInstruction CanMergeWithCore(AsyncTask otherTask) { var theOtherTask = otherTask as UpdateRenderPackageAsyncTask; if (theOtherTask == null) return base.CanMergeWithCore(otherTask); // If the two UpdateRenderPackageAsyncTask are for different nodes, // then there is no comparison to be made, keep both the tasks. // if (nodeGuid != theOtherTask.nodeGuid) return TaskMergeInstruction.KeepBoth; // Comparing to another NotifyRenderPackagesReadyAsyncTask, the one // that gets scheduled more recently stay, while the earlier one // gets dropped. If this task has a higher tick count, keep this. // if (ScheduledTime.TickCount > theOtherTask.ScheduledTime.TickCount) return TaskMergeInstruction.KeepThis; return TaskMergeInstruction.KeepOther; // Otherwise, keep the other. }
public override void Update() { if (m_ARCoreSession == null) { return; } AsyncTask.OnUpdate(); if (Session.Status != SessionStatus.Tracking) { return; } if (m_ARCoreSessionConfig.EnablePlaneFinding) { Session.GetTrackables <DetectedPlane>(m_DetectedPlaneBuffer, TrackableQueryFilter.All); foreach (var detectedPlane in m_DetectedPlaneBuffer) { BoundedPlane boundedPlane; if (m_DetectedPlanes.TryGetValue(detectedPlane, out boundedPlane)) { // remove any subsumed planes if (detectedPlane.SubsumedBy != null) { OnPlaneRemoved(boundedPlane); m_DetectedPlanes.Remove(detectedPlane); } // update any planes with changed extents else if (PlaneUpdated(detectedPlane, boundedPlane)) { boundedPlane.center = detectedPlane.CenterPose.position; boundedPlane.rotation = detectedPlane.CenterPose.rotation; boundedPlane.extents.x = detectedPlane.ExtentX; boundedPlane.extents.y = detectedPlane.ExtentZ; m_DetectedPlanes[detectedPlane] = boundedPlane; OnPlaneUpdated(boundedPlane); } } // add any new planes else { boundedPlane = new BoundedPlane() { id = Guid.NewGuid().ToString(), center = detectedPlane.CenterPose.position, rotation = detectedPlane.CenterPose.rotation, extents = new Vector2(detectedPlane.ExtentX, detectedPlane.ExtentZ) }; m_DetectedPlanes.Add(detectedPlane, boundedPlane); OnPlaneAdded(boundedPlane); } } // Check for planes that were removed from the detected plane list List <DetectedPlane> planesToRemove = new List <DetectedPlane>(); foreach (var kvp in m_DetectedPlanes) { var detectedPlane = kvp.Key; if (!m_DetectedPlaneBuffer.Exists(x => x == detectedPlane)) { OnPlaneRemoved(kvp.Value); planesToRemove.Add(detectedPlane); } } foreach (var plane in planesToRemove) { m_DetectedPlanes.Remove(plane); } } //Update Anchors foreach (var anchor in m_Anchors) { anchor.Key.transform.position = anchor.Value.transform.position; anchor.Key.transform.rotation = anchor.Value.transform.rotation; } }
// performs face detection private IEnumerator DoFaceDetection() { // get the image to detect Face[] faces = null; Texture2D texCamShot = null; if (cameraShot) { texCamShot = (Texture2D)cameraShot.texture; SetHintText("Wait..."); } // get the face manager instance CloudFaceManager faceManager = CloudFaceManager.Instance; if (!faceManager) { SetHintText("Check if the FaceManager component exists in the scene."); } else if (texCamShot) { byte[] imageBytes = texCamShot.EncodeToJPG(); yield return(null); //faces = faceManager.DetectFaces(texCamShot); AsyncTask <Face[]> taskFace = new AsyncTask <Face[]>(() => { return(faceManager.DetectFaces(imageBytes)); }); taskFace.Start(); yield return(null); while (taskFace.State == TaskState.Running) { yield return(null); } if (string.IsNullOrEmpty(taskFace.ErrorMessage)) { faces = taskFace.Result; if (faces != null && faces.Length > 0) { // stick to detected face rectangles FaceRectangle[] faceRects = new FaceRectangle[faces.Length]; for (int i = 0; i < faces.Length; i++) { faceRects[i] = faces[i].faceRectangle; } yield return(null); // get the emotions of the faces if (recognizeEmotions) { //Emotion[] emotions = faceManager.RecognizeEmotions(texCamShot, faceRects); AsyncTask <Emotion[]> taskEmot = new AsyncTask <Emotion[]>(() => { return(faceManager.RecognizeEmotions(imageBytes, faceRects)); }); taskEmot.Start(); yield return(null); while (taskEmot.State == TaskState.Running) { yield return(null); } if (string.IsNullOrEmpty(taskEmot.ErrorMessage)) { Emotion[] emotions = taskEmot.Result; int matched = faceManager.MatchEmotionsToFaces(ref faces, ref emotions); if (matched != faces.Length) { Debug.Log(string.Format("Matched {0}/{1} emotions to {2} faces.", matched, emotions.Length, faces.Length)); } } else { SetHintText(taskEmot.ErrorMessage); } } CloudFaceManager.DrawFaceRects(texCamShot, faces, FaceDetectionUtils.FaceColors); //SetHintText("Click on the camera image to make a shot"); SetHintText(hintMessage); SetResultText(faces); } else { SetHintText("No face(s) detected."); } } else { SetHintText(taskFace.ErrorMessage); } } yield return(null); }
//网络初始化 public override void fullfillByNetwork(BaseResponse response) { if (response != null && response.status != BaseResponse.ERROR) { LoginResponse loginResp = response as LoginResponse; if (loginResp != null && loginResp.data != null && loginResp.data.floor != null) { InitData(); lastFloorId = loginResp.data.floor.end; if (lastFloorId == 0) { lastFloorId = startFloorID; } DungeonsInfo dungeonse = loginResp.data.floor; if (dungeonse != null && dungeonse.pro != null) { foreach (int[] oneFloor in dungeonse.pro) { int floorId = oneFloor[0]; int star = oneFloor[1]; NewFloor floor = null; if (FloorList.TryGetValue(floorId, out floor)) { floor.star = star; } } } //设置各个小关卡的状态 NewFloor floordata = null; int floorid = startFloorID; for (; floorid <= lastFloorId; floorid++) { if (FloorList.TryGetValue(floorid, out floordata)) { floordata.state = NewFloorState.Pass; } } Debug.Log("CurrentID=" + floorid.ToString()); //设置开启的下一关<当前关卡> if (FloorList.TryGetValue(floorid, out floordata)) { floordata.state = NewFloorState.Current; } //开启PVE副本倒计时 if (loginResp.data.explorDoors != null) { explorDoors = loginResp.data.explorDoors; AsyncTask.QueueOnMainThread(() => { JCPVETimerManager.Instance.AutoOpenPVESystemTimer(); }); } Analysis(); // AnaylizeFloor(); } //挑战次数和重置次数 if (loginResp != null && loginResp.data != null && loginResp.data.doorDayStatus != null) { for (int i = 0; i < loginResp.data.doorDayStatus.Length; i++) { DoorDayStatus doorStatus = loginResp.data.doorDayStatus [i]; NewFloor newflr = GetFloorData(doorStatus.doorId); if (newflr != null) { newflr.passTimes = doorStatus.passCount; newflr.resetTimes = doorStatus.resetCount; } else { RED.LogWarning(doorStatus.doorId + "not find floor data"); } } } } //更新招募和位置2是否解锁 PlayerManager playerMgr = Core.Data.playerManager; if (playerMgr.RTData != null && playerMgr.RTData.curTeam != null) { Core.Data.BuildingManager.ZhaoMuUnlock = (playerMgr.RTData.curTeam.getMember(1) != null); //|| lastFloorId >= 60104); } }
public WaitForAsynTaskCompletionYieldInstruction(AsyncTask <T> task) { m_task = task; }
/// <summary> /// This callback method is invoked in the context of ISchedulerThread /// when UpdateGraphAsyncTask is completed. /// </summary> /// <param name="task">The original UpdateGraphAsyncTask instance.</param> private void OnUpdateGraphCompleted(AsyncTask task) { var updateTask = (UpdateGraphAsyncTask)task; var messages = new Dictionary <Guid, string>(); // Runtime warnings take precedence over build warnings. foreach (var warning in updateTask.RuntimeWarnings) { var message = string.Join("\n", warning.Value.Select(w => w.Message)); messages.Add(warning.Key, message); } foreach (var warning in updateTask.BuildWarnings) { // If there is already runtime warnings for // this node, then ignore the build warnings. if (messages.ContainsKey(warning.Key)) { continue; } var message = string.Join("\n", warning.Value.Select(w => w.Message)); messages.Add(warning.Key, message); } var workspace = updateTask.TargetedWorkspace; foreach (var message in messages) { var guid = message.Key; var node = workspace.Nodes.FirstOrDefault(n => n.GUID == guid); if (node == null) { continue; } node.Warning(message.Value); // Update node warning message. } // Refresh values of nodes that took part in update. foreach (var modifiedNode in updateTask.ModifiedNodes) { modifiedNode.RequestValueUpdateAsync(scheduler, EngineController); } foreach (var node in Nodes) { node.ClearDirtyFlag(); } // Notify listeners (optional) of completion. RunSettings.RunEnabled = true; // Re-enable 'Run' button. //set the node execution preview to false; OnSetNodeDeltaState(new DeltaComputeStateEventArgs(new List <Guid>(), graphExecuted)); // This method is guaranteed to be called in the context of // ISchedulerThread (for Revit's case, it is the idle thread). // Dispatch the failure message display for execution on UI thread. // EvaluationCompletedEventArgs e = task.Exception == null || IsTestMode ? new EvaluationCompletedEventArgs(true) : new EvaluationCompletedEventArgs(true, task.Exception); EvaluationCount++; OnEvaluationCompleted(e); }
public Future RunAsync(AsyncTask asyncTask) { return GetManager().RunAsync(new _Runnable_639(this, asyncTask)); }
private void frmApplication_Shown(object sender, EventArgs e) { lblName.Text = lblRelatedColumn.Text = lblRelatedTo.Text = lblRelationState.Text = ""; Trunc = new TableTruncator(Connection); AsyncTask<string, string, string> task = new AsyncTask<string, string, string>(this); task.doInBackground = delegate(string[] param) { task.PublishProgress("Connecting to the SQL Server"); Connection.Connect(); task.PublishProgress("Gathering & inspecting tables..."); Trunc.Initialize(); return "Ready"; }; task.onProgressUpdate = delegate(string[] param) { lblStatus.Text = param[0]; }; task.onPostExecute = delegate(string result) { lblStatus.Text = result; List<string> Tables = Trunc.GetTables(); TreeNode Root = tvTables.Nodes.Add(Setting.Database); foreach (string table in Tables) { Root.Nodes.Add(table); } }; task.Execute(); }
// performs user recognition private IEnumerator DoUserRecognition() { // get the image to detect faces = null; texCamShot = null; if (cameraShot) { texCamShot = (Texture2D)cameraShot.texture; SetHintText("Wait..."); } // get the user manager instance CloudUserManager userManager = CloudUserManager.Instance; if (!userManager) { if (hintText) { hintText.text = "Check if the CloudFaceManager and CloudUserManager components exist in the scene."; } } else if (texCamShot) { byte[] imageBytes = texCamShot.EncodeToJPG(); yield return(null); AsyncTask <bool> taskIdentify = new AsyncTask <bool>(() => { bool bSuccess = userManager.IdentifyUsers(imageBytes, ref faces, ref results); return(bSuccess); }); taskIdentify.Start(); yield return(null); while (taskIdentify.State == TaskState.Running) { yield return(null); } if (string.IsNullOrEmpty(taskIdentify.ErrorMessage)) { if (taskIdentify.Result) { CloudFaceManager.DrawFaceRects(texCamShot, faces, FaceDetectionUtils.FaceColors); yield return(null); SetHintText("Select user to login:"******"No users detected."); } // show the identified users ShowIdentityResult(); } else { SetHintText(taskIdentify.ErrorMessage); } } yield return(null); }
/// <inheritdoc /> public void EndProcessRequest(IAsyncResult result) { AsyncTask task = (AsyncTask)result; task.EndTask(); }
/// <summary> /// This callback method is invoked in the context of ISchedulerThread /// when UpdateGraphAsyncTask is completed. /// </summary> /// <param name="task">The original UpdateGraphAsyncTask instance.</param> private void OnUpdateGraphCompleted(AsyncTask task) { var updateTask = (UpdateGraphAsyncTask)task; var messages = new Dictionary<Guid, string>(); // Runtime warnings take precedence over build warnings. foreach (var warning in updateTask.RuntimeWarnings) { var message = string.Join("\n", warning.Value.Select(w => w.Message)); messages.Add(warning.Key, message); } foreach (var warning in updateTask.BuildWarnings) { // If there is already runtime warnings for // this node, then ignore the build warnings. // But for cyclic dependency warnings, it is // easier to understand to report a build warning. string message = string.Empty; if (messages.ContainsKey(warning.Key)) { if (!warning.Value.Any(w => w.ID == ProtoCore.BuildData.WarningID.kInvalidStaticCyclicDependency)) continue; messages.Remove(warning.Key); message = string.Join("\n", warning.Value. Where(w => w.ID == ProtoCore.BuildData.WarningID.kInvalidStaticCyclicDependency). Select(w => w.Message)); } else { message = string.Join("\n", warning.Value.Select(w => w.Message)); } if (!string.IsNullOrEmpty(message)) { messages.Add(warning.Key, message); } } var workspace = updateTask.TargetedWorkspace; foreach (var message in messages) { var guid = message.Key; var node = workspace.Nodes.FirstOrDefault(n => n.GUID == guid); if (node == null) continue; node.Warning(message.Value); // Update node warning message. } // Notify listeners (optional) of completion. RunSettings.RunEnabled = true; // Re-enable 'Run' button. //set the node execution preview to false; OnSetNodeDeltaState(new DeltaComputeStateEventArgs(new List<Guid>(), graphExecuted)); // This method is guaranteed to be called in the context of // ISchedulerThread (for Revit's case, it is the idle thread). // Dispatch the failure message display for execution on UI thread. // EvaluationCompletedEventArgs e = task.Exception == null || IsTestMode ? new EvaluationCompletedEventArgs(true) : new EvaluationCompletedEventArgs(true, task.Exception); EvaluationCount ++; OnEvaluationCompleted(e); if (EngineController.IsDisposed) return; EngineController.ReconcileTraceDataAndNotify(); // Refresh values of nodes that took part in update. foreach (var modifiedNode in updateTask.ModifiedNodes) { modifiedNode.RequestValueUpdateAsync(scheduler, EngineController); } scheduler.Tasks.AllComplete(_ => { OnRefreshCompleted(e); }); }
public IEnumerator LoadLevelCoroutine(Package.Asset asset, string playerScene, string uiScene, SimulationMetaData ngs) { string scene; yield return(null); LoadingManager.instance.SetSceneProgress(0f); Util.InvokeVoid(LoadingManager.instance, "PreLoadLevel"); AsyncTask task = Singleton <SimulationManager> .instance.AddAction("Loading", (IEnumerator)Util.Invoke(LoadingManager.instance, "LoadSimulationData", asset, ngs)); LoadSaveStatus.activeTask = task; if (!LoadingManager.instance.LoadingAnimationComponent.AnimationLoaded) { LoadingManager.instance.m_loadingProfilerScenes.BeginLoading("LoadingAnimation"); yield return(Application.LoadLevelAdditiveAsync("LoadingAnimation")); LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } if (LoadingManager.instance.m_loadedEnvironment != null) // loading from in-game { while (!LoadingManager.instance.m_metaDataLoaded && !task.completedOrFailed) // IL_158 { yield return(null); } if (Singleton <SimulationManager> .instance.m_metaData == null) { Singleton <SimulationManager> .instance.m_metaData = new SimulationMetaData(); Singleton <SimulationManager> .instance.m_metaData.m_environment = "Sunny"; Singleton <SimulationManager> .instance.m_metaData.Merge(ngs); } string mapThemeName = Singleton <SimulationManager> .instance.m_metaData.m_MapThemeMetaData?.name; if (Singleton <SimulationManager> .instance.m_metaData.m_environment == LoadingManager.instance.m_loadedEnvironment && mapThemeName == LoadingManager.instance.m_loadedMapTheme) { LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "EssentialScenesLoaded")); LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "RenderDataReady")); } else { Util.InvokeVoid(LoadingManager.instance, "DestroyAllPrefabs"); LoadingManager.instance.m_loadedEnvironment = null; LoadingManager.instance.m_loadedMapTheme = null; } } if (LoadingManager.instance.m_loadedEnvironment == null) // IL_290 { AsyncOperation op; if (!string.IsNullOrEmpty(playerScene)) { LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(playerScene); op = Application.LoadLevelAsync(playerScene); while (!op.isDone) // IL_312 { LoadingManager.instance.SetSceneProgress(op.progress * 0.1f); yield return(null); } LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } while (!LoadingManager.instance.m_metaDataLoaded && !task.completedOrFailed) // IL_34F { yield return(null); } if (Singleton <SimulationManager> .instance.m_metaData == null) { Singleton <SimulationManager> .instance.m_metaData = new SimulationMetaData(); Singleton <SimulationManager> .instance.m_metaData.m_environment = "Sunny"; Singleton <SimulationManager> .instance.m_metaData.Merge(ngs); } LoadingManager.instance.m_supportsExpansion[0] = (bool)Util.Invoke(LoadingManager.instance, "DLC", 369150u); LoadingManager.instance.m_supportsExpansion[1] = (bool)Util.Invoke(LoadingManager.instance, "DLC", 420610u); bool isWinter = Singleton <SimulationManager> .instance.m_metaData.m_environment == "Winter"; if (isWinter && !LoadingManager.instance.m_supportsExpansion[1]) { Singleton <SimulationManager> .instance.m_metaData.m_environment = "Sunny"; isWinter = false; } scene = (string)Util.Invoke(LoadingManager.instance, "GetLoadingScene"); if (!string.IsNullOrEmpty(scene)) { LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene); op = Application.LoadLevelAdditiveAsync(scene); while (!op.isDone) // IL_4D0 { LoadingManager.instance.SetSceneProgress(0.1f + op.progress * 0.03f); yield return(null); } LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } scene = Singleton <SimulationManager> .instance.m_metaData.m_environment + "Prefabs"; // IL_4F0 if (!string.IsNullOrEmpty(scene)) { LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene); op = Application.LoadLevelAdditiveAsync(scene); while (!op.isDone) // IL_585 { LoadingManager.instance.SetSceneProgress(0.13f + op.progress * 0.5f); yield return(null); } LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } if ((bool)Util.Invoke(LoadingManager.instance, "DLC", 1u)) // IL_5A5 { scene = isWinter ? "WinterLoginPackPrefabs" : "LoginPackPrefabs"; LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene); op = Application.LoadLevelAdditiveAsync(scene); while (!op.isDone) // IL_63C { LoadingManager.instance.SetSceneProgress(0.63f + op.progress * 0.02f); yield return(null); } LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } if ((bool)Util.Invoke(LoadingManager.instance, "DLC", 340160u)) // IL_65C { scene = isWinter ? "WinterPreorderPackPrefabs" : "PreorderPackPrefabs"; LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene); op = Application.LoadLevelAdditiveAsync(scene); while (!op.isDone) // IL_6F8 { LoadingManager.instance.SetSceneProgress(0.65f + op.progress * 0.02f); yield return(null); } LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } scene = isWinter ? "WinterSignupPackPrefabs" : "SignupPackPrefabs"; // IL_718 LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene); op = Application.LoadLevelAdditiveAsync(scene); while (!op.isDone) // IL_79F { LoadingManager.instance.SetSceneProgress(0.67f + op.progress * 0.01f); yield return(null); } LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); if ((bool)Util.Invoke(LoadingManager.instance, "DLC", 346791u)) { scene = "DeluxePackPrefabs"; LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene); op = Application.LoadLevelAdditiveAsync(scene); while (!op.isDone) // IL_846 { LoadingManager.instance.SetSceneProgress(0.68f + op.progress * 0.02f); yield return(null); } LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } if (Steam.IsAppOwned(238370u)) // IL_866 { scene = "MagickaPackPrefabs"; LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene); op = Application.LoadLevelAdditiveAsync(scene); while (!op.isDone) // IL_8ED { LoadingManager.instance.SetSceneProgress(0.7f + op.progress * 0.01f); yield return(null); } LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } if (LoadingManager.instance.m_supportsExpansion[0]) // IL_90D { scene = isWinter ? "WinterExpansion1Prefabs" : "Expansion1Prefabs"; LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene); op = Application.LoadLevelAdditiveAsync(scene); while (!op.isDone) // IL_9A6 { LoadingManager.instance.SetSceneProgress(0.71f + op.progress * 0.02f); yield return(null); } LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } if (LoadingManager.instance.m_supportsExpansion[1]) // IL_9C6 { scene = "Expansion2Prefabs"; LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene); op = Application.LoadLevelAdditiveAsync(scene); while (!op.isDone) // IL_A4A { LoadingManager.instance.SetSceneProgress(0.73f + op.progress * 0.02f); yield return(null); } LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } Package.Asset europeanStyles = PackageManager.FindAssetByName("System." + DistrictStyle.kEuropeanStyleName); // IL_A6A if (europeanStyles != null && europeanStyles.isEnabled) { if (Singleton <SimulationManager> .instance.m_metaData.m_environment.Equals("Europe")) { scene = "EuropeNormalPrefabs"; } else { scene = "EuropeStylePrefabs"; } LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene); op = Application.LoadLevelAdditiveAsync(scene); while (!op.isDone) // IL_B45 { LoadingManager.instance.SetSceneProgress(0.75f + op.progress * 0.02f); yield return(null); } LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } // LoadingManager.instance.QueueLoadingAction((IEnumerator) Util.Invoke(LoadingManager.instance, "LoadCustomContent")); // IL_B65 LoadingManager.instance.QueueLoadingAction(AssetLoader.instance.LoadCustomContent()); RenderManager.Managers_CheckReferences(); LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "EssentialScenesLoaded")); RenderManager.Managers_InitRenderData(); LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "RenderDataReady")); simulationFailed = HasFailed(task); // Performance optimization: do not load scenes while custom assets are loading. while (!AssetLoader.instance.hasFinished) { yield return(null); } scene = Singleton <SimulationManager> .instance.m_metaData.m_environment + "Properties"; if (!string.IsNullOrEmpty(scene)) { LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene); op = Application.LoadLevelAdditiveAsync(scene); while (!op.isDone) // IL_C47 { LoadingManager.instance.SetSceneProgress(0.77f + op.progress * 0.11f); yield return(null); } LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } if (!simulationFailed) { simulationFailed = HasFailed(task); } if (!string.IsNullOrEmpty(uiScene)) // IL_C67 { LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(uiScene); op = Application.LoadLevelAdditiveAsync(uiScene); while (!op.isDone) // IL_CDE { LoadingManager.instance.SetSceneProgress(0.88f + op.progress * 0.11f); yield return(null); } LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } LoadingManager.instance.m_loadedEnvironment = Singleton <SimulationManager> .instance.m_metaData.m_environment; // IL_CFE LoadingManager.instance.m_loadedMapTheme = Singleton <SimulationManager> .instance.m_metaData.m_MapThemeMetaData?.name; } else { scene = (string)Util.Invoke(LoadingManager.instance, "GetLoadingScene"); if (!string.IsNullOrEmpty(scene)) { LoadingManager.instance.m_loadingProfilerScenes.BeginLoading(scene); yield return(Application.LoadLevelAdditiveAsync(scene)); LoadingManager.instance.m_loadingProfilerScenes.EndLoading(); } } LoadingManager.instance.SetSceneProgress(1f); // IL_DBF if (!simulationFailed) { simulationFailed = HasFailed(task); } while (!task.completedOrFailed) // IL_DED { yield return(null); } LoadingManager.instance.m_simulationDataLoaded = LoadingManager.instance.m_metaDataLoaded; LoadingManager.SimulationDataReadyHandler SimDataReady = Util.Get(LoadingManager.instance, "m_simulationDataReady") as LoadingManager.SimulationDataReadyHandler; SimDataReady?.Invoke(); SimulationManager.UpdateMode mode = SimulationManager.UpdateMode.Undefined; if (ngs != null) { mode = ngs.m_updateMode; } LoadingManager.instance.QueueLoadingAction((IEnumerator)Util.Invoke(LoadingManager.instance, "LoadLevelComplete", mode)); if (Singleton <TelemetryManager> .exists) { Singleton <TelemetryManager> .instance.StartSession(asset?.name, playerScene, mode, Singleton <SimulationManager> .instance.m_metaData); } }
/// <summary> /// Scans the KSP install directory and sub directories for *.craft files. /// </summary> private static void ScanDir() { View.ShowProcessingIcon = true; EventDistributor.InvokeAsyncTaskStarted(Instance); ResetView(); AsyncTask <bool> .DoWork(() => { Messenger.AddInfo(Messages.MSG_CRAFT_SCAN_STARTED); // Get *.craft files from GameData folder. string gameDatePath = KSPPathHelper.GetPath(KSPPaths.GameData); string[] files = Directory.GetFiles(gameDatePath, EXTENSION_CRAFT, SearchOption.AllDirectories); // Get *.craft files from additional folders. string path1 = KSPPathHelper.GetPath(KSPPaths.VAB); string path2 = KSPPathHelper.GetPath(KSPPaths.SPH); string[] addPaths = new[] { path1, path2 }; foreach (var path in addPaths) { string[] files2 = Directory.GetFiles(path, EXTENSION_CRAFT, SearchOption.AllDirectories); int oldLength = files.Length; Array.Resize <string>(ref files, oldLength + files2.Length); Array.Copy(files2, 0, files, oldLength, files2.Length); } // Create CraftNodes from each file. var nodes = new List <CraftNode>(); if (files.Length > 0) { foreach (string file in files) { Messenger.AddInfo(string.Format(Messages.MSG_SCAN_FILE_0_FOR_CRAFTS, file)); var newNodes = CreateCraftEntry(file); foreach (var newNode in newNodes) { if (newNode != null && !string.IsNullOrEmpty(newNode.Name) && !nodes.Contains(newNode)) { nodes.Add(newNode); } } } } else { Messenger.AddInfo(string.Format(Messages.MSG_NO_CRAFTCFG_FOUND_0, gameDatePath)); } allCrafts.Clear(); foreach (CraftNode node in nodes) { allCrafts.Add(node); } Messenger.AddInfo(Messages.MSG_CRAFT_SCAN_DONE); return(true); }, (bool result, Exception ex) => { View.ShowProcessingIcon = false; EventDistributor.InvokeAsyncTaskDone(Instance); if (ex != null) { Messenger.AddError(string.Format(Messages.MSG_ERROR_DURING_CRAFT_READING_0, ex.Message), ex); } else { RefreshTreeView(); ValidateCrafts(); } }); }
private void ConfigAsyncTask() { mAsyncTask = new AsyncTask(this); }
/// <summary> /// Starts a async download of a mod from KSP Spaceport. /// </summary> /// <param name="modInfo"></param> /// <param name="finished"></param> /// <param name="progressChanged"></param> public static void DownloadModAsync(string downloadURL, ref ModInfo modInfo, AsyncResultHandler<bool> finished = null, AsyncProgressChangedHandler progressChanged = null) { // get save path int start = downloadURL.LastIndexOf("/") + 1; string filename = downloadURL.Substring(start, downloadURL.Length - start); modInfo.LocalPath = Path.Combine(downloadURL, filename); AsyncTask<bool> asyncJob = new AsyncTask<bool>(); asyncJob.SetDownloadCallbackFunctions(modInfo.SpaceportURL, modInfo.LocalPath, finished, progressChanged); asyncJob.RunDownload(); ; }
public Future RunAsync(string databaseName, AsyncTask function) { Database database = GetDatabase(databaseName); return(RunAsync(new _Runnable_342(function, database))); }
protected override TaskMergeInstruction CanMergeWithCore(AsyncTask otherTask) { var theOtherTask = otherTask as UpdateGraphAsyncTask; if (theOtherTask == null) return base.CanMergeWithCore(otherTask); if (theOtherTask.IsScheduledAfter(this) && theOtherTask.Contains(this)) return TaskMergeInstruction.KeepOther; else if (this.IsScheduledAfter(theOtherTask) && this.Contains(theOtherTask)) return TaskMergeInstruction.KeepThis; else return TaskMergeInstruction.KeepBoth; }
public _Runnable_342(AsyncTask function, Database database) { this.function = function; this.database = database; }
public override void Update() { if (m_ARCoreSession == null) { return; } AsyncTask.OnUpdate(); if (lastFrameTrackingState == SessionStatus.Tracking && Session.Status != SessionStatus.Tracking && !_trackingLostCountdownInProgress) { //Debounce - if we regain tracking within a second, just send it as a TrackingJumped event - less disruptive that completely losing tracking. Mapbox.Unity.Utilities.Console.Instance.Log("Tracking lost (changed from " + lastFrameTrackingState + " to " + Session.Status + "), starting countdown timer", "yellow"); _trackingLostCountdownInProgress = true; _trackingLostLastPose = Frame.Pose; _trackingLostTime = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond; } if (Session.Status != lastFrameTrackingState && Session.Status == SessionStatus.Tracking) { if (!_trackingLostCountdownInProgress) { OnTrackingStarted(Frame.Pose); } else { //Regained tracking within a second, send a jump. long timeNow = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond; Mapbox.Unity.Utilities.Console.Instance.Log("Tracking recovered after " + (timeNow - _trackingLostTime) + "ms, sending a TrackingJump instead of TrackingLost & TrackingStart. ", "yellow"); OnTrackingJumped(Frame.Pose, lastFramePose); _trackingLostCountdownInProgress = false; _trackingLostLastPose = new Pose(); _trackingLostTime = 0; } } if (lastFrameTrackingState == SessionStatus.Tracking && //Do not fire "OnTrackingJumped" on the first frame when tracking just started (OnTrackingStarted will fire instead, see above). Session.Status == SessionStatus.Tracking && ((Frame.Pose.position - lastFramePose.position).magnitude > 1 || Quaternion.Angle(Frame.Pose.rotation, lastFramePose.rotation) > 30) ) { Mapbox.Unity.Utilities.Console.Instance.Log(string.Format("Jump strength: position: {0}m, rotation: {1} degrees ", (Frame.Pose.position - lastFramePose.position).magnitude, Quaternion.Angle(Frame.Pose.rotation, lastFramePose.rotation)), "yellow"); OnTrackingJumped(Frame.Pose, lastFramePose); } //Check if trackingLost timer expired if (Session.Status != SessionStatus.Tracking && _trackingLostCountdownInProgress) { long timeNow = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond; if (timeNow - _trackingLostTime >= 1000) { Mapbox.Unity.Utilities.Console.Instance.Log("Tracking lost timer expired after " + (timeNow - _trackingLostTime) + "ms, sending TrackingLost", "yellow"); OnTrackingLost(_trackingLostLastPose); _trackingLostCountdownInProgress = false; _trackingLostLastPose = new Pose(); _trackingLostTime = 0; } } //Save frameTrackingState so we can compare on next frame & detect changes. lastFrameTrackingState = Session.Status; if (Session.Status == SessionStatus.Tracking) { lastFramePose = Frame.Pose; } if (Session.Status != SessionStatus.Tracking) { return; } if (m_ARCoreSessionConfig.EnablePlaneFinding) { Session.GetTrackables <TrackedPlane>(m_TrackedPlaneBuffer, TrackableQueryFilter.All); foreach (var trackedPlane in m_TrackedPlaneBuffer) { BoundedPlane boundedPlane; if (m_TrackedPlanes.TryGetValue(trackedPlane, out boundedPlane)) { // remove any subsumed planes if (trackedPlane.SubsumedBy != null) { OnPlaneRemoved(boundedPlane); m_TrackedPlanes.Remove(trackedPlane); } // update any planes with changed extents else if (PlaneUpdated(trackedPlane, boundedPlane)) { boundedPlane.center = trackedPlane.CenterPose.position; boundedPlane.rotation = trackedPlane.CenterPose.rotation; boundedPlane.extents.x = trackedPlane.ExtentX; boundedPlane.extents.y = trackedPlane.ExtentZ; m_TrackedPlanes[trackedPlane] = boundedPlane; OnPlaneUpdated(boundedPlane); } } // add any new planes else { boundedPlane = new BoundedPlane() { id = Guid.NewGuid().ToString(), center = trackedPlane.CenterPose.position, rotation = trackedPlane.CenterPose.rotation, extents = new Vector2(trackedPlane.ExtentX, trackedPlane.ExtentZ) }; m_TrackedPlanes.Add(trackedPlane, boundedPlane); OnPlaneAdded(boundedPlane); } } // Check for planes that were removed from the tracked plane list List <TrackedPlane> planesToRemove = new List <TrackedPlane>(); foreach (var kvp in m_TrackedPlanes) { var trackedPlane = kvp.Key; if (!m_TrackedPlaneBuffer.Exists(x => x == trackedPlane)) { OnPlaneRemoved(kvp.Value); planesToRemove.Add(trackedPlane); } } foreach (var plane in planesToRemove) { m_TrackedPlanes.Remove(plane); } } //Update Anchors foreach (var anchor in m_Anchors) { anchor.Key.transform.position = anchor.Value.transform.position; anchor.Key.transform.rotation = anchor.Value.transform.rotation; } }
internal void WriteExecutionLog(AsyncTask asyncTask) { var name = asyncTask.GetType().Name; Results.Add(string.Format("{0}: {1}", name, serialNumber)); }
public Future RunAsync(string databaseName, AsyncTask function) { Database database = GetDatabase(databaseName); return RunAsync(new _Runnable_381(function, database)); }
public void TestTaskStateChangedEventHandling() { var observer = new TaskEventObserver(); var schedulerThread = new SampleSchedulerThread(); var scheduler = new DynamoScheduler(schedulerThread, TaskProcessMode.Asynchronous); scheduler.TaskStateChanged += observer.OnTaskStateChanged; // Start scheduling a bunch of tasks. var asyncTasks = new AsyncTask[] { new ErrorProneAsyncTask(scheduler, 7), new InconsequentialAsyncTask(scheduler, 100), new PrioritizedAsyncTask(scheduler, 1), new PrioritizedAsyncTask(scheduler, 5), new ErrorProneAsyncTask(scheduler, 3), new InconsequentialAsyncTask(scheduler, 500), new InconsequentialAsyncTask(scheduler, 300), new PrioritizedAsyncTask(scheduler, 3), new ErrorProneAsyncTask(scheduler, 5), }; foreach (SampleAsyncTask asyncTask in asyncTasks) { scheduler.ScheduleForExecution(asyncTask); } schedulerThread.GetSchedulerToProcessTasks(); // Drops all InconsequentialAsyncTask and leave behind one. // Kept all PrioritizedAsyncTask instances and sorted them. var expected = new List <string> { // Scheduling notifications... "Scheduled: ErrorProneAsyncTask: 7", "Scheduled: InconsequentialAsyncTask: 100", "Scheduled: PrioritizedAsyncTask: 1", "Scheduled: PrioritizedAsyncTask: 5", "Scheduled: ErrorProneAsyncTask: 3", "Scheduled: InconsequentialAsyncTask: 500", "Scheduled: InconsequentialAsyncTask: 300", "Scheduled: PrioritizedAsyncTask: 3", "Scheduled: ErrorProneAsyncTask: 5", // Task discarded notifications... "Discarded: InconsequentialAsyncTask: 100", "Discarded: InconsequentialAsyncTask: 300", // Execution of remaining tasks... "ExecutionStarting: ErrorProneAsyncTask: 7", "ExecutionFailed: ErrorProneAsyncTask: 7", "CompletionHandled: ErrorProneAsyncTask: 7", "ExecutionStarting: PrioritizedAsyncTask: 1", "ExecutionCompleted: PrioritizedAsyncTask: 1", "CompletionHandled: PrioritizedAsyncTask: 1", "ExecutionStarting: PrioritizedAsyncTask: 5", "ExecutionCompleted: PrioritizedAsyncTask: 5", "CompletionHandled: PrioritizedAsyncTask: 5", "ExecutionStarting: ErrorProneAsyncTask: 3", "ExecutionFailed: ErrorProneAsyncTask: 3", "CompletionHandled: ErrorProneAsyncTask: 3", "ExecutionStarting: PrioritizedAsyncTask: 3", "ExecutionCompleted: PrioritizedAsyncTask: 3", "CompletionHandled: PrioritizedAsyncTask: 3", "ExecutionStarting: ErrorProneAsyncTask: 5", "ExecutionFailed: ErrorProneAsyncTask: 5", "CompletionHandled: ErrorProneAsyncTask: 5", // Execution of InconsequentialAsyncTask last... "ExecutionStarting: InconsequentialAsyncTask: 500", "ExecutionCompleted: InconsequentialAsyncTask: 500", "CompletionHandled: InconsequentialAsyncTask: 500" }; Assert.AreEqual(expected.Count, observer.Results.Count()); int index = 0; foreach (var actual in observer.Results) { Assert.AreEqual(expected[index++], actual); } }
private void onCompleteTestTask(AsyncTask task, int errCode, IDictionary<int, object> result) { //Debug.Log("onCompleteTestTask, taskID=" + task.getTaskID()); Debug.Log("soldier-" + task.taskID + " has found path with errCode=" + errCode); IList<AStarNode> path = result[0] as IList<AStarNode>; if (++_i >= _num && errCode == 0) { printPath(path); } }