public static TaskResults Run(Coaster coaster) { TaskResults taskResults = TaskResults.Successful; taskResults = BuildToYaw.Run( coaster, new List <float>() { MathHelper.KeepBetween360Degrees(coaster.Tracks[Rules.lastCollsionIndex].Yaw), MathHelper.KeepBetween360Degrees(coaster.Tracks[Rules.lastCollsionIndex].Yaw + 180), MathHelper.KeepBetween360Degrees(Builder.lastRuleIssueTrack.Yaw + 180) }); return(taskResults); //if(taskResults == TaskResults.Successful) //{ // return taskResults; //} ////Go To XYZ //float x = coaster.LastTrack.X; //float y = coaster.LastTrack.Y; //float z = coaster.LastTrack.Z; ////Determine //x = x + (float)(Math.Cos(MathHelper.ToRadians(coaster.LastTrack.Yaw)) * Math.Cos(MathHelper.ToRadians(coaster.LastTrack.Pitch)) * Globals.TRACK_LENGTH * 10); //y = y + (float)(Math.Sin(MathHelper.ToRadians(coaster.LastTrack.Yaw)) * Math.Cos(MathHelper.ToRadians(coaster.LastTrack.Pitch)) * Globals.TRACK_LENGTH * 10); //z = z + (float)(Math.Sin(MathHelper.ToRadians(coaster.LastTrack.Pitch)) * Globals.TRACK_LENGTH * 10); ////Check if there in bonunds and that there is no track at that location ////Try To Build To them ////If Fail return fail. }
/// <summary> /// Istanzia un nuovo oggetto della classe TaskExecutionCompletedEventArgs con i parametri specificati. /// </summary> /// <param name="cancelled">un valore che indica se il task è stato annullato</param> /// <param name="error">l'eventuale errore verificatosi durante la comunicazione col servizio</param> /// <param name="result">gli eventuali risultati scaricati dal server di elaborazione</param> /// <param name="id">l'identificativo del task assegnato dal servizio di elaborazione</param> /// <remarks> /// Se non si è verificato alcun errore durante la comunicazione col servizio, il patametro corrispondente /// va impostato a null. In modo analogo, se i risultati dell'elaborazione di un task non sono disponibili /// a causa di un errore o perché l'operazione è stata annullata, il parametro corrispondente dovrà essere /// impostato a null. /// </remarks> public TaskExecutionCompletedEventArgs(bool cancelled, Exception error, TaskResults result, string id) { Cancelled = cancelled; Error = error; Result = result; Id = id; }
/// <summary> /// Permette il trasferimento dei risultati relativi ad un task già elaborato e specificato dal proprio /// identificativo, impostando l'oggetto che dovrà contenere queste informazioni. /// </summary> /// <param name="id">l'identificativo precedentemente associato alla richiesta di elaborazione</param> /// <param name="results">i risultati relativi al task di cui è stata completata l'elaborazione</param> public void GetResults(string id, out TaskResults results) { m_Container.WriteToLog("GetResults: task request id = {0}.", id); ServiceFault fault = null; // Ottiene la copia dei metadati relativi al task. TaskMetadata tm; if (!m_Container.TryGetUserTask(id, out tm, out fault)) { throw new FaultException<ServiceFault>(fault); } m_Container.WriteToLog("GetResults: sending results from file {0}.", tm.PathToTargetFile); // Prepara e invia il risultato. try { results = new TaskResults() { ElapsedTime = m_Container.GetProcessingTime(tm), EncounteredErrors = tm.Errors, Contents = File.ReadAllText(tm.PathToTargetFile) }; } catch (Exception e) { m_Container.HandleError(e.ToString(), ServiceFaultCode.SendTaskResultsFailed, out fault); throw new FaultException<ServiceFault>(fault); } }
public static TaskResults Run(Coaster coaster, List <float> angles) { List <BuildAction> buildActions = new List <BuildAction>(); TaskResults results = TaskResults.Fail; buildActions.Clear(); for (int i = 0; i < 15; i++) { float startPitch = coaster.LastTrack.Pitch; foreach (float angle in angles) { results = Builder.BuildTracks(DetermineActions(angle, i, startPitch), coaster); if (results == TaskResults.Successful) { return(results); } else { coaster.Reset(); } } } return(results); }
private static void te_OnTaskExecutionCompleted(object sender, TaskExecutionCompletedEventArgs e) { string result = string.Empty; string report = string.Empty; if (e.Cancelled) { report = string.Format("Annullato (task id = {0}).", e.Id); } else if (e.Error != null) { report = string.Format("Errore (task id = {0}).", e.Id) + e.Error.Message; } else { TaskResults tr = e.Result; report = string.Format("Completato (task id = {0}) in {1} con {2} errori.", e.Id, tr.ElapsedTime, tr.EncounteredErrors.Length); result = string.Format("Risultati (task id = {0}).", e.Id) + Environment.NewLine + tr.Contents; } Console.WriteLine(report); Console.WriteLine("result: " + result); mre.Set(); }
/// <summary> /// Permette il trasferimento dei risultati relativi ad un task già elaborato e specificato dal proprio /// identificativo, impostando l'oggetto che dovrà contenere queste informazioni. /// </summary> /// <param name="id">l'identificativo precedentemente associato alla richiesta di elaborazione</param> /// <param name="results">i risultati relativi al task di cui è stata completata l'elaborazione</param> public void GetResults(string id, out TaskResults results) { m_Container.WriteToLog("GetResults: task request id = {0}.", id); ServiceFault fault = null; // Ottiene la copia dei metadati relativi al task. TaskMetadata tm; if (!m_Container.TryGetUserTask(id, out tm, out fault)) { throw new FaultException <ServiceFault>(fault); } m_Container.WriteToLog("GetResults: sending results from file {0}.", tm.PathToTargetFile); // Prepara e invia il risultato. try { results = new TaskResults() { ElapsedTime = m_Container.GetProcessingTime(tm), EncounteredErrors = tm.Errors, Contents = File.ReadAllText(tm.PathToTargetFile) }; } catch (Exception e) { m_Container.HandleError(e.ToString(), ServiceFaultCode.SendTaskResultsFailed, out fault); throw new FaultException <ServiceFault>(fault); } }
public BuildTask(BuildTaskManager manager) { Manager = manager; _importers = new Dictionary <string, ImporterInstance>(); _processors = new Dictionary <string, ProcessorInstance>(); Results = new TaskResults(); }
public TaskResults Run(Coaster coaster) { TaskResults results = RCLibrary.Support.BuildToXY.Run( coaster, Globals.FINSH_AREA_X, Globals.FINSH_AREA_Y, Globals.FINSH_AREA_X_RANGE, Globals.FINSH_AREA_Y_RANGE); return(results); }
/// <summary> /// Genera un nuovo evento per notificare il completamento della richiesta di elaborazione del task. /// </summary> /// <param name="cancelled">un valore che indica se il task è stato annullato</param> /// <param name="error">l'eventuale errore verificatosi durante la comunicazione col servizio</param> /// <param name="result">gli eventuali risultati scaricati dal server di elaborazione</param> /// <remarks> /// Se non si è verificato alcun errore durante la comunicazione col servizio, il patametro corrispondente /// va impostato a null. In modo analogo, se i risultati dell'elaborazione di un task non sono disponibili /// a causa di un errore o perché l'operazione è stata annullata, il parametro corrispondente dovrà essere /// impostato a null. /// </remarks> private void RaiseTaskExecutionCompleted(bool cancelled, Exception error, TaskResults result) { TaskExecutionCompletedHandler handler = OnTaskExecutionCompleted; if (handler != null) { TaskExecutionCompletedEventArgs args = new TaskExecutionCompletedEventArgs(cancelled, error, result, m_TaskRequestId); OnTaskExecutionCompleted(this, args); } }
public void BuildToX(float x, float withInX) { if (coaster.TracksStarted == false) { return; } TaskResults results = RCLibrary.Support.BuildToX.Run(coaster, x, withInX); builder.ProcessAfterBuildAttempt(coaster, results); }
public void BuildToPitch(List <float> pitch) { if (coaster.TracksStarted == false) { return; } TaskResults results = RCLibrary.Support.BuildToPitch.Run(coaster, pitch); builder.ProcessAfterBuildAttempt(coaster, results); }
/// <summary> /// Determina l'avvio della procedura che permette di inviare il task specificato al servizio di elaborazione, /// di verificarne periodicamente il completamento e di eseguire alla fine il download dei relativi risultati /// eventualmente prodotti. /// </summary> /// <remarks> /// Prima di invocare questo metodo, è necessario utilizzare il metodo SetTaskData per poter impostare i dati /// relativi al task da elaborare. /// Inoltre, questo metodo non dovrebbe essere invocato sul thread della UI, in quanto la verifica periodica /// del completamento dell'elaborazione blocca tale thread per l'intervallo di polling specificato. /// </remarks> public void Start() { if (m_Proxy == null) { try { RaiseTaskExecutionProgress(TaskRequestState.InitializingProxy, null); m_Proxy = new ProcessingServiceClient(m_Binding, m_Endpoint); m_Proxy.Open(); RaiseTaskExecutionProgress(TaskRequestState.ProxyInitialized, null); RaiseTaskExecutionProgress(TaskRequestState.SendingRequest, null); m_TaskRequestId = m_Proxy.SubmitData(m_TaskData); RaiseTaskExecutionProgress(TaskRequestState.RequestSent, null); bool completed = false; while (!completed) { m_PollingWaitHandle.WaitOne(m_PollingInterval); TaskState ts = m_Proxy.GetState(m_TaskRequestId); switch (ts) { case TaskState.Completed: RaiseTaskExecutionProgress(TaskRequestState.DownloadingResults, null); m_TaskResults = m_Proxy.GetResults(m_TaskRequestId); RaiseTaskExecutionProgress(TaskRequestState.ResultsDownloaded, null); RaiseTaskExecutionCompleted(false, null, m_TaskResults); completed = true; break; case TaskState.None: completed = true; break; default: completed = false; break; } } RaiseTaskExecutionProgress(TaskRequestState.DisposingProxy, null); m_Proxy.Close(); RaiseTaskExecutionProgress(TaskRequestState.ProxyDisposed, null); } catch (Exception ex) { HandleError(ex); } } }
private static TaskResults GoToZ(Coaster coaster, float z, float withIn) { List <BuildAction> buildActions = new List <BuildAction>(); TaskResults results = TaskResults.Successful; float pitchGoal = 0; float lastDistance = Math.Abs(coaster.LastTrack.Z - z); if (z > coaster.LastTrack.Z) { pitchGoal = 90; } else { pitchGoal = 270; } results = BuildToPitch.Run(coaster, new List <float>() { pitchGoal }); if (results != TaskResults.Successful) { return(results); } while (!((coaster.LastTrack.Z < z + (withIn / 2) && coaster.LastTrack.Z > z - (withIn / 2))) && results == TaskResults.Successful) { buildActions.Add(new BuildAction(TrackType.Stright)); results = Builder.BuildTracks(buildActions, coaster); buildActions.Clear(); float distance = Math.Abs(coaster.LastTrack.Z - z); if (distance >= lastDistance) { return(TaskResults.Fail); } lastDistance = distance; } if (coaster.LastTrack.Z < z + (withIn / 2) && coaster.LastTrack.Z > z - (withIn / 2)) { return(TaskResults.Successful); } else { return(TaskResults.Fail); } }
public bool ProcessBuildAction(Coaster coaster, BuilderTask task) { if (coaster.TracksStarted == false || (lastBuildActionFail && task.GetType() == lastBuildTask.GetType())) { return(false); } TaskResults results = task.Run(coaster); initialTaskResults = results; initialTaskResults = results; lastBuildTask = task; return(ProcessAfterBuildAttempt(coaster, results)); }
public IterationResult(SymuEnvironment environment) { Environment = environment ?? throw new ArgumentNullException(nameof(environment)); OrganizationFlexibility = new OrganizationFlexibility(Environment); KnowledgeAndBeliefResults = new KnowledgeAndBeliefResults(Environment); Blockers = new BlockerResults(Environment); Tasks = new TaskResults(Environment); Messages = new MessageResults(Environment); Results.Add(OrganizationFlexibility); Results.Add(KnowledgeAndBeliefResults); Results.Add(Blockers); Results.Add(Tasks); Results.Add(Messages); Results.Add(KeyFrames); }
/// <summary> /// Istanzia un nuovo oggetto della classe TaskExecution con i parametri specificati. /// </summary> /// <param name="serviceUri">indirizzo del servizio di elaborazione del task</param> /// <param name="pollingInterval">tempo di attesa nella verifica di completamento del task</param> /// <exception cref="UriFormatException"> /// Se si specifica un URI non valido come indirizzo del servizio di elaborazione. /// </exception> /// <exception cref="ArgumentNullException"> /// Se si specifica il valore null come indirizzo del servizio di elaborazione. /// </exception> public TaskExecution(string serviceUri, TimeSpan pollingInterval) { m_PollingInterval = pollingInterval; m_PollingWaitHandle = new ManualResetEvent(false); m_Binding = new BasicHttpBinding(); m_Endpoint = new EndpointAddress(serviceUri); m_Proxy = null; m_CommunicationErrorsMapping = new Dictionary<Type, TaskExecutionState>() { { typeof(TimeoutException), TaskExecutionState.TimeoutError }, { typeof(EndpointNotFoundException), TaskExecutionState.ServiceNotFoundError }, { typeof(CommunicationException), TaskExecutionState.CommunicationError } }; m_TaskRequestId = string.Empty; m_TaskData = new TaskData() { Name = string.Empty, Contents = string.Empty }; m_TaskResults = null; }
public TaskResults Run(Coaster coaster) { List <Command> commands = new List <Command>(); List <BuildAction> buildActions = new List <BuildAction>(); TaskResults result = TaskResults.Fail; bool loopDetected = true; for (int i = coaster.TrackCount - 42; i < coaster.TrackCount; i++) { if (coaster.Tracks[i].TrackType != TrackType.Up) { loopDetected = false; } } if (loopDetected) { for (int i = 0; i < 42; i++) { buildActions.Add(new BuildAction(true)); } result = Builder.BuildTracks(buildActions, coaster); if (result != TaskResults.Fail) { return((new BuildLoop()).Run(coaster)); } else { return(result); } } else { buildActions.Add(new BuildAction(TrackType.Up)); buildActions.Add(new BuildAction(TrackType.Up)); buildActions.Add(new BuildAction(TrackType.Up)); return(Builder.BuildTracks(buildActions, coaster)); } }
/// <summary> /// Istanzia un nuovo oggetto della classe TaskExecution con i parametri specificati. /// </summary> /// <param name="serviceUri">indirizzo del servizio di elaborazione del task</param> /// <param name="pollingInterval">tempo di attesa nella verifica di completamento del task</param> /// <exception cref="UriFormatException"> /// Se si specifica un URI non valido come indirizzo del servizio di elaborazione. /// </exception> /// <exception cref="ArgumentNullException"> /// Se si specifica il valore null come indirizzo del servizio di elaborazione. /// </exception> public TaskExecution(string serviceUri, TimeSpan pollingInterval) { m_PollingInterval = pollingInterval; m_PollingWaitHandle = new ManualResetEvent(false); m_Binding = new BasicHttpBinding(); m_Endpoint = new EndpointAddress(serviceUri); m_Proxy = null; m_CommunicationErrorsMapping = new Dictionary <Type, TaskRequestState>() { { typeof(TimeoutException), TaskRequestState.TimeoutError }, { typeof(EndpointNotFoundException), TaskRequestState.ServiceNotFoundError }, { typeof(CommunicationException), TaskRequestState.CommunicationError } }; m_TaskRequestId = string.Empty; m_TaskData = new TaskData() { Name = string.Empty, Contents = string.Empty }; m_TaskResults = null; }
public static TaskResults BuildTracks(List <BuildAction> buildActions, Coaster coaster, bool removeChunk = false) { //Check If Coater Finshed TaskResults result = TaskResults.Successful; foreach (BuildAction buildAction in buildActions) { if (buildAction.RemoveTrack == false) { result = BuildTrack(coaster, buildAction); } else { result = RemoveTrack(coaster, removeChunk); } if (result != TaskResults.Successful) { break; } } return(result); }
public TaskResults Run(Coaster coaster) { TaskResults results = TaskResults.Fail; List <BuildAction> buildActions = new List <BuildAction>(); if (coaster.LastTrack.Pitch == 0) { buildActions.Add(new BuildAction(TrackType.Custom)); for (int i = 0; i < 3; i++) { buildActions.Add(new BuildAction(TrackType.Custom)); } results = Builder.BuildTracks(buildActions, coaster); } else { results = BuildToPitch.Run(coaster, new List <float>() { 0 }); } return(results); }
public void BadGeneric() { Assert.ThrowsException <NullReferenceException>(() => TaskResults.BadGeneric <object>()); }
static void MainPrimes(string[] args) { DateTime tS = DateTime.UtcNow; const int numJobs = 100; const int numCores = 1; // TODO - implement config class! HPCUtilities.Init(HPCEnvironment.KubernetesAWS); JobData jd; SharedJobData sjd; List <TaskData> tasks; JobDataUtilities.CreateJobDataPrimes( numJobs, numCores, out jd, out sjd, out tasks); byte[] sharedDataBlob = HPCUtilities.Serialize(sjd); List <byte[]> taskBlobs = new List <byte[]>(); foreach (var task in tasks) { taskBlobs.Add(HPCUtilities.Serialize(task)); } // TODO - send shared data blob to cluster // TODO - send task blobs to cluster // TODO - collect results // TODO - where should we output the data? //string outputFolder = @"c:\temp\"; string dataDirectoryPath = null; // send input file and task blobs to cluster, collect results TaskSender taskSender = new TaskSender(Orchestrator.Docker); List <byte[]> results = taskSender.Send(taskBlobs); // DK - temp output results Console.WriteLine("processing complete"); foreach (var result in results) { TaskResults taskResults = HPCUtilities.Deserialize <TaskResults>(result); DataEntry[] data = taskResults.Results; Console.Write("number: " + BitConverter.ToInt32(data[0].Data) + ", factors: "); for (int i = 1; i < data.Length - 1; i++) { Console.Write(BitConverter.ToInt32(data[i].Data) + " "); } Console.WriteLine(); } // DK- following code not quite hooked up yet with k8s /* * * string[] resultFiles = new string[] { }; * List<ZOSResult> processedResults = new List<ZOSResult>(); * int numProcessed = 0; * int numFail = 0; * foreach (string resultFile in resultFiles) * { * var tr = HPCUtilities.Deserialize<TaskResults>(System.IO.File.ReadAllBytes(resultFile)); * ZOSResult result; * JobDataUtilities.ProcessZOSResult(tr, out result); * if (result != null) * { * JobDataUtilities.StoreZOSResult(jd.JobType, result, outputFolder, numProcessed); * } * else * { ++numFail; * } ++numProcessed; * } * * int numSucceed; * var stats = JobDataUtilities.GetZOSStats( * jd.JobType, * tS, * outputFolder, * out numSucceed, * ref numFail); * * foreach (var stat in stats) * { * Console.WriteLine(stat.ToString()); * } * */ Console.WriteLine(); Console.WriteLine("Press any key to exit"); Console.ReadKey(); }
/// <summary> /// There are no comments for TaskResults in the schema. /// </summary> public void AddToTaskResults(TaskResults taskResults) { base.AddObject("TaskResults", taskResults); }
/// <summary> /// Create a new TaskResults object. /// </summary> /// <param name="taskId">Initial value of TaskId.</param> public static TaskResults CreateTaskResults(int taskId) { TaskResults taskResults = new TaskResults(); taskResults.TaskId = taskId; return taskResults; }
public void AddToTaskResults(int index) { GraphicsDataSet gds = null; DataSet ds = null; TaskResultNode tr = null; string dsName = "No Name Found"; if (m_taskResults == null) m_taskResults = FindControlRecursive(Page, m_taskResultsId) as TaskResults; if (m_taskResults != null) { DataTable[] tbList = System.Web.HttpContext.Current.Session["WebAppIdentifyDataTables"] as DataTable[]; DataTable tb = tbList[index]; if ( tb.ExtendedProperties.Contains("displayName") ) dsName = tb.ExtendedProperties["displayName"].ToString(); if(tb is GraphicsLayer) { gds = new GraphicsDataSet(); gds.DataSetName = dsName; gds.Tables.Add(tb); tr = m_taskResults.CreateTaskResultNode(null, null, null, gds, false, true); } else { ds = new DataSet(); ds.DataSetName = dsName; ds.Tables.Add(tb); tr = m_taskResults.CreateTaskResultNode(null, null, null, ds, false, true); } tr.Expanded = true; m_taskResults.DisplayResults(null, null, null, tr); this.CallbackResults.CopyFrom(m_taskResults.CallbackResults); } }
public Task GoodReferenceValueAsync() { return(TaskResults.GoodReferenceValueAsync().AsTask()); }
public Task GoodReferenceAsync() { return(TaskResults.GoodReferenceAsync()); }
/// <summary> /// Determina l'avvio della procedura che permette di inviare il task specificato al servizio di elaborazione, /// di verificarne periodicamente il completamento e di eseguire alla fine il download dei relativi risultati /// eventualmente prodotti. /// </summary> /// <remarks> /// Prima di invocare questo metodo, è necessario utilizzare il metodo SetTaskData per poter impostare i dati /// relativi al task da elaborare. /// Inoltre, questo metodo non dovrebbe essere invocato sul thread della UI, in quanto la verifica periodica /// del completamento dell'elaborazione blocca tale thread per l'intervallo di polling specificato. /// </remarks> public void Start() { if (m_Proxy == null) { try { RaiseTaskExecutionProgress(TaskExecutionState.InitializingProxy, null); m_Proxy = new ProcessingServiceClient(m_Binding, m_Endpoint); m_Proxy.Open(); RaiseTaskExecutionProgress(TaskExecutionState.ProxyInitialized, null); RaiseTaskExecutionProgress(TaskExecutionState.SendingRequest, null); m_TaskRequestId = m_Proxy.SubmitData(m_TaskData); RaiseTaskExecutionProgress(TaskExecutionState.RequestSent, null); bool completed = false; while (!completed) { m_PollingWaitHandle.WaitOne(m_PollingInterval); TaskState ts = m_Proxy.GetState(m_TaskRequestId); switch (ts) { case TaskState.Completed: RaiseTaskExecutionProgress(TaskExecutionState.DownloadingResults, null); m_TaskResults = m_Proxy.GetResults(m_TaskRequestId); RaiseTaskExecutionProgress(TaskExecutionState.ResultsDownloaded, null); completed = true; break; case TaskState.None: completed = true; break; default: completed = false; break; } } RaiseTaskExecutionProgress(TaskExecutionState.DisposingProxy, null); m_Proxy.Close(); RaiseTaskExecutionProgress(TaskExecutionState.ProxyDisposed, null); RaiseTaskExecutionCompleted(false, null, m_TaskResults); } catch (Exception ex) { HandleError(ex); } } }
public async Task DefaultValueType() { Assert.AreEqual(false, await TaskResults.DefaultValueType()); }
public Task BadGenericNotNullConstraintAsync() { return(Assert.ThrowsExceptionAsync <NullReferenceException>(() => TaskResults.BadGenericAsync <object>())); }
public Task GoodGenericNotNullConstraintAsync() { return(TaskResults.GoodGenericAsync <object>()); }
/// <summary> /// Constructs an instance from the execution results of an /// <see cref="AnsiblePlayer"/> play operation. /// </summary> /// <param name="rawResults">The execution results.</param> internal AnsiblePlayResults(ExecuteResult rawResults) { Covenant.Requires <ArgumentNullException>(rawResults != null); RawResults = rawResults; if (rawResults.ExitCode != 0 && rawResults.ExitCode != 2) { // Must be a command line argument or playbook syntax error // as opposed to a valid playbook that had one or more failed // tasks. throw new Exception(rawResults.ErrorText); } using (var reader = new StringReader(rawResults.OutputText)) { string line; // Skip over all lines until we see the first task line. for (line = reader.ReadLine(); line != null; line = reader.ReadLine()) { if (line.StartsWith("TASK [") && line.EndsWith("**********")) { break; } } var sbTask = new StringBuilder(); var lastTask = false; while (!lastTask) { // Capture the current line and any subsequent lines up to but not // including the next task marker or the PLAY RECAP line and then // use this to create the next task result. sbTask.AppendLine(line); for (line = reader.ReadLine(); line != null; line = reader.ReadLine()) { if (line.StartsWith("TASK [") && line.EndsWith("**********")) { break; } else if (line.StartsWith("PLAY RECAP **********") && line.EndsWith("**********")) { lastTask = true; break; } sbTask.AppendLine(line); } var taskResult = new AnsibleTaskResult(sbTask.ToString()); if (taskResult.HasStatus) { TaskResults.Add(taskResult); } if (!lastTask) { sbTask.Clear(); sbTask.AppendLine(line); // This is the first line of the next task } } } }
/// <summary> /// Questo metodo viene invocato nel momento in cui gli eventuali risultati dell'elaborazione sono stati /// ricevuti: in tal caso viene segnalato il completamento dell'elaborazione e richiesta la chiusura del /// canale di comunicazione. /// </summary> /// <param name="sender">l'oggetto che ha generato l'evento</param> /// <param name="args">informazioni aggiuntive sull'evento</param> private void Proxy_GetResultsCompleted(object sender, GetResultsCompletedEventArgs args) { if (HandleCancellationIfRequired(args.Cancelled)) return; if (HandleErrorIfRequired(args.Error)) return; RaiseTaskExecutionProgress(TaskExecutionState.ResultsDownloaded, null); m_TaskResults = args.Result; RaiseTaskExecutionCompleted(false, null, m_TaskResults); BeginCloseProxy(); }
protected override void OnPreRender(EventArgs e) { base.OnPreRender(e); m_id = this.ClientID; // find the map, task results and map resource manager controls m_map = Page.FindControl(m_mapBuddyId) as Map; m_taskResults = FindControlRecursive(Page, m_taskResultsId) as TaskResults; m_resourceManger = m_map.MapResourceManagerInstance; #region Register script for creating script object ScriptManager sm = ScriptManager.GetCurrent(this.Page); if (sm != null) sm.RegisterAsyncPostBackControl(this); string create = String.Format("\nSys.Application.add_init(function() {{\n\t$create(ESRI.ADF.UI.MapIdentifyTool,{{\"id\":\"{3}\",\"uniqueID\":\"{0}\",\"callbackFunctionString\":\"{1}\",\"identifyIcon\":\"{4}\",\"waitIcon\":\"{5}\"}},null,{{\"map\":\"{2}\"}});\n\tMapIdentifyTool = function() {{ $find('{3}').startIdentify(); }};\n }});\n", this.UniqueID, this.CallbackFunctionString, m_map.ClientID, this.ClientID, m_identifyIconUrl, m_waitIconUrl); Page.ClientScript.RegisterStartupScript(this.GetType(), this.Id + "_startup", create, true); #endregion }
public Task GoodReferenceValueAsyncWithoutAwait() { return(TaskResults.GoodReferenceValueAsyncWithoutAwait().AsTask()); }
public Task BadReferenceAsync() { return(Assert.ThrowsExceptionAsync <NullReferenceException>(() => TaskResults.BadReferenceAsync())); }
private static TaskResults GoToY(Coaster coaster, float y, float withIn, TrackType type) { List <BuildAction> buildActions = new List <BuildAction>(); TaskResults results = TaskResults.Successful; float yawGoal = 0; if (y > coaster.LastTrack.Y) { yawGoal = 0; } else { yawGoal = 180; } bool firstStrightTrack = true; float lastY = 0; float lastDiffernce = 0; results = BuildToPitch.Run(coaster, new List <float>() { 0 }); if (results != TaskResults.Successful) { return(results); } while (!((coaster.LastTrack.Y < y + (withIn / 2) && coaster.LastTrack.Y > y - (withIn / 2))) && results == TaskResults.Successful) { if (coaster.LastTrack.Yaw == yawGoal) { buildActions.Add(new BuildAction(TrackType.Stright)); results = Builder.BuildTracks(buildActions, coaster); if (results != TaskResults.Successful) { return(results); } buildActions.Clear(); float differnce = Math.Abs(coaster.LastTrack.Y - lastY); if (!firstStrightTrack) { //This Means You Passed The Goal Point, This could have been done by turning, Or After the Fact. But You Are now going the wrong way. if (differnce > lastDiffernce) { return(TaskResults.Fail); } } else { firstStrightTrack = true; } lastY = coaster.LastTrack.Y; lastDiffernce = differnce; } else { buildActions.Add(new BuildAction(type)); results = Builder.BuildTracks(buildActions, coaster); buildActions.Clear(); } } if (coaster.LastTrack.Y < y + (withIn / 2) && coaster.LastTrack.Y > y - (withIn / 2)) { return(TaskResults.Successful); } else { return(TaskResults.Fail); } }
public Task BadReferenceAsyncValueWithoutAwait() { return(Assert.ThrowsExceptionAsync <NullReferenceException>(() => TaskResults.BadReferenceAsyncValueWithoutAwait().AsTask())); }