Exemple #1
0
        public override void ExecuteOperation(AbstractOperation runnable)
        {
            //if (runnable is AbstractOperation)
            //{
            //    AbstractOperation operation = (AbstractOperation)runnable;

            //    if (operation.Execution != null)
            //    {
            //        logger.LogInformation($"Execution tree while executing operation {operation.GetType()} :");
            //        ExecutionTree eTree = ExecutionTreeUtil.buildExecutionTree(operation.Execution);
            //        logger.LogInformation($"\r\n{eTree.ToString()}");

            //        string root = Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory);

            //        lock (syncRoot)
            //        {
            //            string file = Path.Combine(root, $"task_trees\\{DateTime.Now.ToString("yyyyMMdd")}.txt");
            //            Directory.CreateDirectory(Path.GetDirectoryName(file));

            //            File.AppendAllText(file, $"{(File.Exists(file) ? "\r\n" : "")}{eTree.ToString()}");
            //        }
            //    }
            //}

            base.ExecuteOperation(runnable);
        }
Exemple #2
0
        public async Task Register(AbstractOperation operation)
        {
            operation.SetDescription();
            operation.CalculateRate();

            _context.AbstractOperation.Add(operation);
            await _context.SaveChangesAsync();
        }
        public override void ExecuteOperation(AbstractOperation runnable)
        {
            try
            {
                ProcessEngineConfigurationImpl processEngineConfiguration = Context.ProcessEngineConfiguration;
                if (processEngineConfiguration.EnableEventDispatcher)
                {
                    if (runnable.Execution != null)
                    {
                        processEngineConfiguration.EventDispatcher.DispatchEvent(new WorkflowDebuggerEvent(runnable.Execution));
                    }
                }

                base.ExecuteOperation(runnable);
            }
            catch (Exception ex)
            {
                throw new WorkflowDebugException(Authentication.AuthenticatedUser?.Id, runnable.Execution, ex);
            }
        }
        static void Main(string[] args)
        {
            AbstractFactory   ft1 = null;
            AbstractOperation op1 = null;

            //ft1 = new AddFactory();
            ft1      = new SubtractFactory();
            op1      = ft1.CreateProductOperation();
            op1.num1 = 10.1;
            op1.num2 = 20.5;
            Console.WriteLine(op1.ShowResult());

            //ft1 = new SubtractFactory();
            //op1 = ft1.CreateProductOperation();
            //op1.num1 = 100.6;
            //op1.num2 = 20.4;
            //Console.WriteLine(op1.ShowResult());

            Console.ReadLine();
        }
        /// <summary>
        /// IExpressionリスト取得
        /// </summary>
        /// <param name="operation">IOperationインスタンス</param>
        /// <param name="container">イベントコンテナ</param>
        /// <returns>IExpressionリスト</returns>
        public static List <IExpression> GetExpressionList(IOperation operation, EventContainer container)
        {
            List <IExpression> result = new List <IExpression>();

            AbstractOperation instance = null;

            switch (operation)
            {
            // 式系
            case ISimpleAssignmentOperation param:
                instance = new SimpleAssignment(param, container);
                break;

            case IInvocationOperation param:
                instance = new Invocation(param, container);
                break;

            case IBinaryOperation param:
                instance = new Binary(param, container);
                break;

            case IIncrementOrDecrementOperation param:
                instance = new Increment(param, container);
                break;

            case ICompoundAssignmentOperation param:
                instance = new CompoundAssignment(param, container);
                break;

            case IConversionOperation param:
                result.AddRange(GetExpressionList(param.Operand, container));
                break;

            // 参照系
            case IInstanceReferenceOperation param:
                instance = new InstanceReference(param, container);
                break;

            case IFieldReferenceOperation param:
                instance = new FieldReference(param, container);
                break;

            case IPropertyReferenceOperation param:
                instance = new PropertyReference(param, container);
                break;

            case ILocalReferenceOperation param:
                instance = new LocalReference(param, container);
                break;

            case IParameterReferenceOperation param:
                instance = new ParameterReference(param, container);
                break;

            case IArrayElementReferenceOperation param:
                instance = new ArrayElementReference(param, container);
                break;

            case IArgumentOperation param:
                instance = new Argument(param, container);
                break;

            // 生成系
            case IObjectCreationOperation param:
                instance = new ObjectCreation(param, container);
                break;

            case IArrayCreationOperation param:
                instance = new ArrayCreation(param, container);
                break;

            case IArrayInitializerOperation param:
                instance = new ArrayInitializer(param, container);
                break;

            case IVariableDeclaratorOperation param:
                instance = new VariableDeclarator(param, container);
                break;

            // 直値
            case ILiteralOperation param:
                instance = new Literal(param, container);
                break;

            // Switch Case系
            case IDefaultCaseClauseOperation param:
                instance = new DefalutCase(param, container);
                break;

            case IDeclarationPatternOperation param:
                instance = new DeclarationPattern(param, container);
                break;

            //If系
            case IIsPatternOperation param:
                instance = new IsPattern(param, container);
                break;

            case IIsTypeOperation param:
                instance = new IsType(param, container);
                break;


            default:
                Console.Write($" [{operation.Kind} is none] ");
                break;
            }

            // リスト追加
            if (instance != null)
            {
                result.AddRange(instance.Expressions);
            }

            return(result);
        }