private void ExecuteProcess(IRobotServiceClass processClass, RobotServiceItemClass process)
        {
            try
            {
                OnStep(String.Format(Resources.Process_ManagingExecutionStatus, process.Identificator));

                // Armazena o status inicial de execução
                var initialStatus = process.Status;

                // Caso o status seja aguardando início ou retorno
                if (initialStatus != RobotServiceItemStatus.WaitingStart &&
                    initialStatus != RobotServiceItemStatus.WaitingReturn)
                {
                    return;
                }

                // Trata atualização de status
                if (initialStatus == RobotServiceItemStatus.WaitingStart)
                {
                    process.Status = RobotServiceItemStatus.Executing;
                    processClass.UpdateProcessStatus(process);
                }
                else if (initialStatus == RobotServiceItemStatus.WaitingReturn)
                {
                    process.Status = RobotServiceItemStatus.RequestingReturn;
                    processClass.UpdateProcessStatus(process);
                }

                try
                {
                    // Processa
                    OnStep(String.Format(Resources.Process_Processing, process.Identificator));
                    var executed = processClass.Process(process);

                    // Trata atualização de status após processamento
                    OnStep(String.Format(Resources.Process_ManagingPostExecutionStatus, process.Identificator));
                    if (initialStatus == RobotServiceItemStatus.WaitingStart)
                    {
                        process.Status = process.HasReturn
                                             ? RobotServiceItemStatus.WaitingReturn
                                             : RobotServiceItemStatus.Processed;
                    }
                    else if (initialStatus == RobotServiceItemStatus.WaitingReturn)
                    {
                        process.Status = executed
                                             ? RobotServiceItemStatus.Processed
                                             : RobotServiceItemStatus.WaitingReturn;
                    }

                    OnStep(String.Format(Resources.Process_ExecutionFinalized, process.Identificator));
                }
                catch (Exception exp)
                {
                    process.Status       = RobotServiceItemStatus.ProcessedWithErrors;
                    process.ErrorMessage = exp.Message;
                    OnError(exp);
                }
                finally
                {
                    processClass.UpdateProcessStatus(process);
                }
            }
            catch (Exception exp)
            {
                OnError(exp);
            }
        }
        public void Execute()
        {
            try
            {
                if (_executionType == ServiceClassExecutionType.ByDefinition)
                {
                    _processClass = this.GetServiceClassInstance(_classDefinition, _appPath);
                }

                if (_processClass == null)
                {
                    throw new NullReferenceException(Resources.ProcessClassNotFoundErrorMessage);
                }

                // Caso a propriedade de forçar a execução tenha sido setada no Manager ele sobrepõe a mesma propriedade configurada na classe de serviço.
                if (_enforceDefined)
                {
                    _processClass.EnforceExecution = _enforceExecution;
                }

                var classType = _processClass.GetType();

                OnStep(String.Format(Resources.Class_Executing, classType.FullName));

                // Solicita os processos a serem executados
                OnStep(String.Format(Resources.Class_RequestingProcesses, classType.FullName));
                var processes = _processClass.GetCurrentProcesses();

                if (processes != null && processes.Any())
                {
                    // Varre os processos e executa um a um
                    OnStep(String.Format(Resources.Class_EnumeratingProcesses, classType.FullName));

                    foreach (RobotServiceItemClass process in processes)
                    {
                        if (String.IsNullOrEmpty(process.Identificator))
                        {
                            process.Identificator = classType.FullName;
                        }

                        OnStep(String.Format(Resources.Process_ValidatingExecution, process.Identificator));

                        var executeProcess = false;

                        // Verifica se esta esperando retorno caso esteja executa de qualquer forma

                        OnStep(String.Format(Resources.Process_ValidatingStatus, process.Identificator));

                        if (process.Status == RobotServiceItemStatus.WaitingReturn)
                        {
                            executeProcess = true;
                        }
                        else
                        {
                            if (_processClass.EnforceExecution)
                            {
                                executeProcess = true;
                            }
                            else
                            {
                                OnStep(String.Format(Resources.Process_ValidatingExecutionTimeInterval, process.Identificator));

                                // Valida se foi informado uma hora ou um intervalo de execução
                                if (process.ExecuteTime == null && process.ExecuteInterval == null)
                                {
                                    process.Status       = RobotServiceItemStatus.NotProcessedWithErrors;
                                    process.ErrorMessage = String.Format(Resources.ExecutionTimeNotFoundErrorMessage, process.Identificator);
                                    _processClass.UpdateProcessStatus(process);
                                }
                                else
                                {
                                    // Pega a hora base para validação
                                    var baseTime = process.LastExecutionTime == null ? process.CreateTime : process.LastExecutionTime.Value;

                                    // Valida se é a hora de executar o processo
                                    if (process.ExecuteTime != null)
                                    {
                                        // Verifica se á exatamente a mesma hora da execução
                                        var nowTime     = DateTime.Now.ToShortTimeString();
                                        var executeTime = process.ExecuteTime.Value.ToShortTimeString();

                                        if (nowTime == executeTime)
                                        {
                                            executeProcess = true;
                                        }

                                        // Verifica se a hora da execução já passou e nada foi executado ainda
                                        if (!executeProcess)
                                        {
                                            var nowDateTime     = DateTime.Now;
                                            var executeDateTime = new DateTime(nowDateTime.Year, nowDateTime.Month, nowDateTime.Day, process.ExecuteTime.Value.Hour, process.ExecuteTime.Value.Minute, process.ExecuteTime.Value.Second);

                                            // Verifica se a hora de execução é menor que a hora atual (já passou a hora de ser executado)
                                            if (executeDateTime < nowDateTime)
                                            {
                                                // Verifica se a hora da ultima execução é menor que a hora de executar (ainda não foi executado)
                                                if (baseTime < executeDateTime)
                                                {
                                                    executeProcess = true;
                                                }
                                            }
                                        }
                                    }
                                    else if (process.ExecuteInterval != null)
                                    {
                                        // Pega o intervalo entre a ultima execução e a hora atual
                                        var lastExecuteInterval = DateTime.Now - baseTime;

                                        // Verifica se o intervalo de execução já passou
                                        if (lastExecuteInterval >= process.ExecuteInterval)
                                        {
                                            executeProcess = true;
                                        }
                                    }
                                }
                            }
                        }

                        OnStep(String.Format(Resources.Process_VerifyingExecution, process.Identificator));

                        // Executa o processo caso necessário
                        if (executeProcess)
                        {
                            // Verificar se o processo é síncrono
                            if (process.Type != RobotServiceItemType.Asynchronous)
                            {
                                // Executa o processo de forma síncrona
                                OnStep(String.Format(Resources.Process_ExecutingSyncProcess, process.Identificator));

                                ExecuteProcess(_processClass, process);
                            }
                            else
                            {
                                // Executa o processo de forma assíncrona
                                OnStep(String.Format(Resources.Process_ExecutingAsyncProcess, process.Identificator));

                                var asyncProcess = new AsyncThreadCaller();
                                asyncProcess.MethodCall += asyncProcess_MethodCall;

                                var parameters = new Dictionary <string, object>();
                                parameters["processClass"] = _processClass;
                                parameters["process"]      = process;

                                asyncProcess.Start(parameters);
                            }
                        }
                    }
                }

                OnStep(String.Format(Resources.Class_ExecutionFinalized, classType.FullName));
                OnComplete(this._classDefinition);
            }
            catch (Exception exp)
            {
                OnError(exp);
                OnComplete(this._classDefinition);
            }
        }