static void RunPatternBasedOnSelectedOption(string option)
        {
            switch (option)
            {
            case "1":
                ExecutionBuilderPattern.Run();
                break;

            case "2":
                ExecutionAbstractFactory.Run();
                break;

            case "3":
                ExecutionFactoryMethod.Run();
                break;

            case "4":
                ExecutionSingleton.Run();
                break;

            case "5":
                ExecutionAdapter.Run();
                break;

            case "6":
                ExecutionFacade.Run();
                break;

            case "7":
                ExecutionComposite.Run();
                break;

            case "8":
                ExecutionDecorator.Run();
                break;

            case "9":
                ExecutionCommand.Run();
                break;

            case "10":
                ExecutionStrategy.Run();
                break;

            case "11":
                ExecutionObserver.Run();
                break;

            case "12":
                ExecutionMediator.Run();
                break;

            default:
                throw new InvalidOperationException();
            }
        }
 protected override ActivityResult VisitNode(
     IGraphNode <TContext> node,
     Guid activityExecutionId, out object activityOutput)
 {
     return(node.ActivitySlot.Execute(
                activityExecutionId,
                Factory,
                Context,
                m_InputProvider ?? this,
                out activityOutput,
                activityInput => ExecutionObserver.ActivityStarted(
                    activityExecutionId,
                    node.Name,
                    node.ActivityType,
                    activityInput)));
 }
 protected override ActivityResult VisitNode(
     IGraphNode <TContext> node,
     Guid activityExecutionId,
     out object activityOutput)
 {
     ExecutionObserver.ActivityStarted(
         activityExecutionId,
         node.Name,
         node.ActivityType + " [FAKE]",
         null);
     return(node.ActivitySlot.Complete(
                activityExecutionId,
                Factory,
                Context,
                m_OutputProvider ?? this,
                out activityOutput));
 }
        public void Execute()
        {
            var s          = CurrentTransactionContext.Trace.StartTime = TimestampHelper.GetUtcNow().ToDateTime();
            var methodName = CurrentTransactionContext.Transaction.MethodName;
            var observer   =
                new ExecutionObserver(CurrentTransactionContext.ExecutionObserverThreshold.ExecutionCallThreshold,
                                      CurrentTransactionContext.ExecutionObserverThreshold.ExecutionBranchThreshold);

            try
            {
                if (!_callHandlers.TryGetValue(methodName, out var handler))
                {
                    throw new RuntimeException(
                              $"Failed to find handler for {methodName}. We have {_callHandlers.Count} handlers: " +
                              string.Join(", ", _callHandlers.Keys.OrderBy(k => k))
                              );
                }

                _smartContractProxy.SetExecutionObserver(observer);

                ExecuteTransaction(handler);

                if (!handler.IsView())
                {
                    CurrentTransactionContext.Trace.StateSet = GetChanges();
                }
                else
                {
                    CurrentTransactionContext.Trace.StateSet = new TransactionExecutingStateSet();
                }
            }
            catch (Exception ex)
            {
                CurrentTransactionContext.Trace.ExecutionStatus = ExecutionStatus.SystemError;
                CurrentTransactionContext.Trace.Error          += ex + "\n";
            }
            finally
            {
                Cleanup();
            }

            var e = CurrentTransactionContext.Trace.EndTime = TimestampHelper.GetUtcNow().ToDateTime();

            CurrentTransactionContext.Trace.Elapsed = (e - s).Ticks;
        }
Exemple #5
0
        public void CallCount_Test()
        {
            var observer = new ExecutionObserver(-1, 5);

            observer.GetCallCount().ShouldBe(0);
            observer.CallCount();
            observer.GetCallCount().ShouldBe(1);

            observer = new ExecutionObserver(5, 5);

            for (int i = 0; i < 5; i++)
            {
                observer.CallCount();
                observer.GetCallCount().ShouldBe(i + 1);
            }

            Assert.Throws <RuntimeCallThresholdExceededException>(() => observer.CallCount());
        }
Exemple #6
0
        private static void Main()
        {
            Console.WriteLine("Choose the operation:");
            Console.WriteLine("------------------------");
            Console.WriteLine("Creational Patterns");
            Console.WriteLine("------------------------");
            Console.WriteLine("1 - Abstract Factory");
            Console.WriteLine("2 - Method Factory");
            Console.WriteLine("3 - Singleton");
            Console.WriteLine("------------------------");
            Console.WriteLine("Structural Patterns");
            Console.WriteLine("------------------------");
            Console.WriteLine("4 - Adapter");
            Console.WriteLine("5 - Facade");
            Console.WriteLine("6 - Composite");
            Console.WriteLine("------------------------");
            Console.WriteLine("Behavioral Patterns");
            Console.WriteLine("------------------------");
            Console.WriteLine("7 - Command");
            Console.WriteLine("8 - Strategy");
            Console.WriteLine("9 - Observer");
            Console.WriteLine("------------------------");

            var opcao = Console.ReadKey();

            Console.WriteLine("");
            Console.WriteLine("------------------------");
            Console.WriteLine("");

            switch (opcao.KeyChar)
            {
            case '1':
                ExecutionAbstractFactory.Run();
                break;

            case '2':
                ExecutionFactoryMethod.Run();
                break;

            case '3':
                ExecutionSingleton.Run();
                break;

            case '4':
                ExecutionAdapter.Run();
                break;

            case '5':
                ExecutionFacade.Run();
                break;

            case '6':
                ExecutionComposite.Run();
                break;

            case '7':
                ExecutionCommand.Run();
                break;

            case '8':
                ExecutionStrategy.Run();
                break;

            case '9':
                ExecutionObserver.Run();
                break;
            }

            Console.ReadKey();
            Console.Clear();
            Main();
        }