//public static void MiddleWareAnalysis() //{ // Console.WriteLine(" ** 模拟 Middleware **"); // var context = new RequestContext() { name = "xx", id = 1 }; // MiddleWareBuild middleWareEvent = new MiddleWareBuild(); // //PipeLineExtensions.ActionExcutingEvent += c => middleWareEvent.ActionExcutingEventHanlder(c); // //PipeLineExtensions.ActionExcutedEvent += c => middleWareEvent.ActionExcutedEventHanlder(c); // //PipeLineExtensions.ExceptionEvent += c => middleWareEvent.ExceptionEventHanlder(c); // IList<Func<Action<RequestContext>, Action<RequestContext>>> _pipeline // = new List<Func<Action<RequestContext>, Action<RequestContext>>>(); // Action<RequestContext, Action> ac1 = (context, next) => // { // Console.WriteLine("1 Before"); // next(); // Console.WriteLine("1 After"); // }; // Action<RequestContext, Action> ac2 = (context, next) => // { // Console.WriteLine("2 Before"); // next(); // Console.WriteLine("2 After"); // }; // Func<Action<RequestContext>, Action<RequestContext>> func1 = (next) => // context => // ac1(context, () => { next(context); }); // _pipeline.Add(func1); // Func<Action<RequestContext>, Action<RequestContext>> func2 = (next) => // context => // ac2(context, () => next(context)); // _pipeline.Add(func2); // Action<RequestContext> ac = context => Console.WriteLine($"{nameof(context.name)} {context.name}"); // foreach (var item in _pipeline.Reverse()) // ac = item(ac); // ac(context); //} public static void BuildUse() { Console.WriteLine(" *** Use MiddleWare ***"); var context = new RequestContext <CheckProductMode>() { Mode = new CheckProductMode { AliexpressRule = "1" } }; //MiddleWareBuild middleWareEvent = new MiddleWareBuild(); //PipeLineExtensions.ActionExcutingEvent += c => middleWareEvent.ActionExcutingEventHanlder(c); //PipeLineExtensions.ActionExcutedEvent += c => middleWareEvent.ActionExcutedEventHanlder(c); //PipeLineExtensions.ExceptionEvent += c => middleWareEvent.ExceptionEventHanlder(c); var builder = PipelineBuilder <RequestContext <CheckProductMode> > .Create(context => { }); builder.UseMiddleware <RequestContext <CheckProductMode>, CustomExceptionMiddleWare <RequestContext <CheckProductMode> > >(); builder.UseMiddleware <RequestContext <CheckProductMode>, CustomMiddleWare>(); builder.UseMiddleware <RequestContext <CheckProductMode>, CustomMiddleWare2>(); var app = builder.Build(); app(context); Console.WriteLine(context.ExceptionInfo.Message); Console.ReadLine(); }
public async Task ExampleTest() { T LogStep <T>(T prev) { Console.WriteLine(prev.ToString()); return(prev); } Pipeline <string, int> stringLengthPipeline = PipelineBuilder .Create <string>() .AddStep(new ConcatStringPipelineStep(", let's count ")) .AddStep(new ConcatStringPipelineStep("this string length!")) .AddStep(LogStep) .AddStep(new StringLengthPipelineStep()) .Build(); Pipeline <string, string> pipeline = PipelineBuilder .Create <string>() .AddStep(LogStep) .AddStep(stringLengthPipeline) .AddStep(length => $"So, result is {length}") .Build(); string result = await pipeline.ExecuteAsync("Hello"); Console.WriteLine(result); Assert.Equal("So, result is 38", result); }
public static void Test() { var requestContext = new RequestContext() { RequesterName = "Kangkang", Hour = 12, }; var builder = PipelineBuilder.Create <RequestContext>(context => { Console.WriteLine($"{context.RequesterName} {context.Hour}h apply failed"); }) .Use((context, next) => { if (context.Hour <= 2) { Console.WriteLine("pass 1"); } else { next(); } }) .Use((context, next) => { if (context.Hour <= 4) { Console.WriteLine("pass 2"); } else { next(); } }) .Use((context, next) => { if (context.Hour <= 6) { Console.WriteLine("pass 3"); } else { next(); } }) ; var requestPipeline = builder.Build(); Console.WriteLine(); foreach (var i in Enumerable.Range(1, 8)) { Console.WriteLine($"--------- h:{i} apply Pipeline------------------"); requestContext.Hour = i; requestPipeline.Invoke(requestContext); Console.WriteLine("----------------------------"); } }
static void Main(string[] args) { var pipeline = PipelineBuilder.Create <LoadXmlStage>() .Extend <SpecParserStage>() .Extend <CollationStage>() .Extend <GenerationStage>() .Extend <EmissionStage>() .Build(); pipeline.Run(); }
public void AddStep_WhenCallsChained_ShouldForwardStepsToNextBuilder() { // Arrange var step1 = new ConcatStringPipelineStep("Hey"); PipelineBuilder <string, string> builder = PipelineBuilder.Create <string>(); // Act builder = builder.AddStep(step1); // Assert Assert.Equal(1, builder.Steps.Count); Assert.Equal(step1, builder.Steps.First()); }
public void AddStep_ShouldAddStep() { // Arrange var step1 = new ConcatStringPipelineStep("Hey"); var builder = PipelineBuilder.Create <string>(); // Act builder.AddStep(step1); // Assert Assert.Equal(1, builder.Steps.Count); Assert.Equal(step1, builder.Steps.First()); }
public static void InvokeAspectDelegate(MethodInvocationContext context) { var action = _aspectDelegates.GetOrAdd($"{context.ProxyMethod.DeclaringType}.{context.ProxyMethod}", m => { var aspects = new List <AbstractAspect>(8); if (context.MethodBase != null) { foreach (var aspect in context.MethodBase.GetCustomAttributes <AbstractAspect>()) { if (!aspects.Exists(x => x.GetType() == aspect.GetType())) { aspects.Add(aspect); } } } var methodParameterTypes = context.ProxyMethod.GetParameters().Select(p => p.GetType()).ToArray(); foreach (var implementedInterface in context.ProxyTarget.GetType().GetImplementedInterfaces()) { var method = implementedInterface.GetMethod(context.ProxyMethod.Name, methodParameterTypes); if (null != method) { foreach (var aspect in method.GetCustomAttributes <AbstractAspect>()) { if (!aspects.Exists(x => x.GetType() == aspect.GetType())) { aspects.Add(aspect); } } } } var builder = PipelineBuilder.Create <MethodInvocationContext>(x => x.Invoke()); foreach (var aspect in aspects) { builder.Use(aspect.Invoke); } return(builder.Build()); }); action.Invoke(context); // check for return value if (context.ProxyMethod.ReturnType != typeof(void)) { if (context.ReturnValue == null && context.ProxyMethod.ReturnType.IsValueType) { context.ReturnValue = Activator.CreateInstance(context.ProxyMethod.ReturnType); } } }
public void Build_ShouldCreatePipelineWithCurrentSteps() { // Arrange PipelineBuilder <string, string> builder = PipelineBuilder.Create <string>() .AddStep(arg => arg + "sync") .AddStep(async arg => await Task.FromResult(arg + "async")); // Act Pipeline <string, string> pipeline = builder.Build(); // Assert Assert.IsType <DelegatePipelineStep <string, string> >(pipeline.Steps[0]); Assert.IsType <AsyncDelegatePipelineStep <string, string> >(pipeline.Steps[1]); }
public void AddStep_WhenFuncPassed_ShouldAddDelegateStep() { // Arrange var builder = PipelineBuilder.Create <string>(); // Act builder = builder .AddStep(arg => arg + "sync") .AddStep(async arg => await Task.FromResult(arg + "async")); // Assert Assert.IsType <DelegatePipelineStep <string, string> >(builder.Steps[0]); Assert.IsType <AsyncDelegatePipelineStep <string, string> >(builder.Steps[1]); }
public void AddStep_WhenCallsChained_CanReuseSameSteps() { // Arrange var step1 = new ConcatStringPipelineStep("Hey"); PipelineBuilder <string, string> builder = PipelineBuilder.Create <string>(); // Act builder = builder .AddStep(step1) .AddStep(step1) .AddStep(step1); // Assert Assert.Equal(3, builder.Steps.Count); }
public void AddStep_WhenCalledMultipleTimes_ShouldReplaceLastStep() { // Arrange var step1 = new ConcatStringPipelineStep("Hey"); var step2 = new ConcatStringPipelineStep("Hey 2"); PipelineBuilder <string, string> builder = PipelineBuilder.Create <string>(); // Act builder.AddStep(step1); builder.AddStep(step2); // Assert Assert.Equal(1, builder.Steps.Count); Assert.Equal(step2, builder.Steps.First()); }
public static void TestV2() { var requestContext = new RequestContext() { RequesterName = "Kangkang", Hour = 12, }; var builder = PipelineBuilder.Create <RequestContext>(context => { Console.WriteLine($"{context.RequesterName} {context.Hour}h apply failed"); }) .When(context => context.Hour <= 2, pipeline => { pipeline.Use((_, next) => { Console.WriteLine("This should be invoked"); next(); }); pipeline.Run(_ => Console.WriteLine("pass 1")); pipeline.Use((_, next) => { Console.WriteLine("This should not be invoked"); next(); Console.WriteLine("will this invoke?"); }); }) .When(context => context.Hour <= 4, pipeline => { pipeline.Run(_ => Console.WriteLine("pass 2")); }) .When(context => context.Hour <= 6, pipeline => { pipeline.Run(_ => Console.WriteLine("pass 3")); }) ; var requestPipeline = builder.Build(); Console.WriteLine(); foreach (var i in Enumerable.Range(1, 8)) { Console.WriteLine($"--------- h:{i} apply Pipeline------------------"); requestContext.Hour = i; requestPipeline.Invoke(requestContext); Console.WriteLine("----------------------------"); } }
public void Build_WhenStepReplaced_WillNotReflectChanges() { // Arrange var builder = PipelineBuilder.Create <string>(); builder.AddStep(arg => "string"); Pipeline <string, string> pipeline = builder.Build(); // Act // ReSharper disable once MustUseReturnValue builder.AddStep(_ => 0); // Assert Assert.IsType <DelegatePipelineStep <string, string> >(pipeline.Steps.First()); Assert.IsType <DelegatePipelineStep <string, int> >(builder.Steps.First()); }
public async Task RunAsync() { try { _logger.LogInformation("Application started"); var context = new PipelineContext <TestResult>(new TestResult()); var pipeline = PipelineBuilder <TestResult> .Create <TestResult>() .Use(_testRuntimeLibraryHandler) .Use(_testDbHandler) .Use(_testWebApiHandler) .Build(); await pipeline.RunAsync(context); PrintInfo(context.Data); } catch (Exception ex) { _logger.LogError(ex, "Необработанная ошибка {0}", ex.Message); } }