예제 #1
0
        public async Task Start <TData, TStep>(TData data, Action <object> onCompletedWorkflow)
            where TData : new()
            where TStep : Step
        {
            _logger.Log(LogLevel.Trace, "Main Workflow started.");
            var   task = _mainWorkflowManager.Start <TData, TStep>(data, onCompletedWorkflow);
            await task;

            if (task.IsCompletedSuccessfully)
            {
                _logger.Log(LogLevel.Trace, "Main Workflow completed successfully.");
            }

            if (task.IsCanceled)
            {
                _logger.Log(LogLevel.Warning & LogLevel.Trace, "Main Workflow was canceled.");
            }

            if (task.Exception != null)
            {
                _logger.LogFatalException(task.Exception);
            }

            if (task.IsFaulted)
            {
                _logger.LogFatalException(FatalException.GetFatalException("Main workflow stopped unexpected."));
            }
        }
예제 #2
0
        protected StepDependencyPack GetStepDependencyPack <T>() where T : Step
        {
            var type = typeof(T);
            var pack = _stepDependencyPacks.SingleOrDefault(x => x.StepType == type);

            if (pack == null)
            {
                throw FatalException.GetFatalException(string.Empty);
            }

            return(pack);
        }
예제 #3
0
        public async Task <TFlow> Run <TFlow, TStep>(TStep step)
            where TFlow : IWorkflow
            where TStep : Step
        {
            var result = await this.RunWorkflowAsync(step);

            if (result is TFlow correctResultType)
            {
                return(correctResultType);
            }

            throw FatalException.GetFatalException("");
        }
예제 #4
0
        public async Task <TFlow> AwaitProcessAsync <TFlow, TStep>(string key = null)
            where TFlow : IWorkflow
            where TStep : Step <TFlow>
        {
            key = typeof(TStep).GenerateKey(key);

            if (MemoryProcesses.TryGetValue(key, out var value))
            {
                return(value is Task <TFlow> task
                    ? await task
                    : throw FatalException.GetFatalException(""));
            }

            throw FatalException.GetFatalException("");;
        }
예제 #5
0
        public IWorkflow <T> GetWorkflow <T>(string key) where T : new()
        {
            key = typeof(T).GenerateKey(key);

            if (_workflows.TryGetValue(key, out var value))
            {
                if (value is IWorkflow <T> wf)
                {
                    return(wf);
                }
                else
                {
                    throw FatalException.GetFatalException(string.Empty);
                }
            }

            throw FatalException.GetFatalException(string.Empty);
        }
예제 #6
0
        public void RemoveWorkflow <TF, TD>(string key)
            where TF : IWorkflow <TD>
            where TD : new()
        {
            key = typeof(TD).GenerateKey(key);

            if (_workflows.TryGetValue(key, out var workflow))
            {
                if (workflow is TF)
                {
                    _workflows.Remove(key);
                }
                else
                {
                    throw FatalException.GetFatalException(string.Empty);
                }
            }
            else
            {
                throw FatalException.GetFatalException(string.Empty);
            }
        }