public async Task HandleSumThree() { var handler = new HandlerProvider(); var resolver = new Resolver(); resolver.LoadFromReference <HandlingTests>(); handler.LoadFromReference <HandlingTests>(); var result = await handler.HandleAsync <int>(resolver.CreateSession(), 0, new object[] { new IntArgument() { Left = 2, Right = 3 }, new IntArgument() { Left = 4, Right = 5 }, new ByteArgument { Left = 6, Right = 7 } }); Assert.IsNotNull(result); Assert.IsTrue(result is int); Assert.IsTrue((int)result == (2 + 3 + 4 + 5 + 6 + 7)); }
public async Task HandleManySum() { var handler = new HandlerProvider(); var resolver = new Resolver(); resolver.LoadFromReference <HandlingTests>(); handler.LoadFromReference <HandlingTests>(); resolver.Register(new CalculatorParameter() { First = 10 }); var watch = Stopwatch.StartNew(); for (int i = 0; i < 100000; i++) { //var result = await handler.HandleAsync(0, new IntArgument() { Left = 2, Right = 3 }); //var result = await handler.HandleAsync(0, new IntArgument() { Left = 2, Right = 3 }); var value = await handler.HandleAsync <CalculatorResult>(resolver.CreateSession(), 1, new object[] { new CalculatorArgument() { Left = 2, Right = 3 }, }); } watch.Stop(); // s: 100k 0.59s }
public IResolverSession GetProtocolResolver(IPacketStream packetStream, CancellationToken cancellationToken) { var resolver = new Resolver(); resolver.LoadFromReference <ProtocolTests>(); var session = resolver.CreateSession(); var handler = new HandlerProvider(session.Resolve <IMethodContextInfoProvider>()); handler.LoadFromReference <ProtocolTests>(); var converter = new Serializer(); converter.LoadFromReference <ProtocolTests>(); var protocol = new SocketProtocolHandler(session, packetStream, converter, handler); session.Resolver.Register(protocol); session.Resolver.Register(handler); session.Resolver.Register(converter); var listenTask = protocol.ListenAsync(cancellationToken); return(session); }
public async Task CalculatorAddDuoTest() { var handlerProvider = new HandlerProvider(); var resolver = new Resolver(); resolver.LoadFromReference <HandlingTests>(); handlerProvider.LoadFromReference <HandlingTests>(); resolver.Register(new CalculatorParameter() { First = 10 }); //var sum = InterfaceHandling.CreateHandler<ICalculator, InterfaceHandlerTest<ICalculator>>(new HandlerArgument() { Arg = "5" }); var value = await handlerProvider.HandleAsync <CalculatorResult>(resolver.CreateSession(), "", 1, new CalculatorArgument() { Left = 2, Right = 3 }, new CalculatorArgument() { Left = 4, Right = 5 }); var result = (CalculatorResult)value; Assert.AreEqual(24, result.Result); }
private void Initialize() { HandlerProvider = new HandlerProvider(); Serializer = new Serializer(); Resolver.Register(HandlerProvider); Resolver.Register(Serializer); }
protected override void ConsumeMessage(IMessageContext messageContext) { var eventContext = messageContext as MessageContext; var message = eventContext.Message; var messageHandlerTypes = HandlerProvider.GetHandlerTypes(message.GetType()); if (messageHandlerTypes.Count == 0) { return; } messageHandlerTypes.ForEach(messageHandlerType => { PerMessageContextLifetimeManager.CurrentMessageContext = eventContext; eventContext.ToBeSentMessageContexts.Clear(); var messageStore = IoCFactory.Resolve <IMessageStore>(); var subscriptionName = string.Format("{0}.{1}", SubscriptionName, messageHandlerType.FullName); if (!messageStore.HasEventHandled(eventContext.MessageID, subscriptionName)) { try { var messageHandler = IoCFactory.Resolve(messageHandlerType); ((dynamic)messageHandler).Handle((dynamic)message); var commandContexts = eventContext.ToBeSentMessageContexts; var eventBus = IoCFactory.Resolve <IEventBus>(); var messageContexts = new List <MessageContext>(); eventBus.GetMessages().ForEach(msg => messageContexts.Add(new MessageContext(msg))); messageStore.SaveEvent(eventContext, subscriptionName, commandContexts, messageContexts); if (commandContexts.Count > 0) { ((CommandBus)IoCFactory.Resolve <ICommandBus>()).SendCommands(commandContexts.AsEnumerable()); } if (messageContexts.Count > 0) { IoCFactory.Resolve <IEventPublisher>().Publish(messageContexts.ToArray()); } } catch (Exception e) { if (e is DomainException) { _Logger.Warn(message.ToJson(), e); } else { //IO error or sytem Crash _Logger.Error(message.ToJson(), e); } messageStore.SaveFailHandledEvent(eventContext, subscriptionName, e); } finally { PerMessageContextLifetimeManager.CurrentMessageContext = null; } } }); }
public bool RegisterHandler(Type type, bool isSingletone) { if (HandlerProvider.RegisterHandler(type)) { Resolver.Register(type, true, isSingletone); return(true); } return(false); }
public bool RegisterHandler(object instance, bool includeBase) { if (HandlerProvider.RegisterHandler(instance.GetType())) { Resolver.Register(instance, includeBase); return(true); } return(false); }
public RouteContext GetContext(RouteId id, HttpContext ctx) { var spec = Specs[id]; var options = RouteOptionsBuilder.Build(id, Config); var callCtx = RequestContextBuilder.Build(ctx); var handler = HandlerProvider.GetHandler(options.Handler, options.Config, responseContext: null); return(new RouteContext(options, spec, callCtx, handler, Logger)); }
public async Task HandleSumString() { var handler = new HandlerProvider(); var resolver = new Resolver(); resolver.LoadFromReference <HandlingTests>(); handler.LoadFromReference <HandlingTests>(); var result = await handler.HandleAsync <string>(resolver.CreateSession(), 0, "s"); Assert.IsNotNull(result); Assert.IsTrue(result is string); Assert.IsTrue((string)result == "sums"); }
public async Task HandleSumZero() { var handler = new HandlerProvider(); var resolver = new Resolver(); resolver.LoadFromReference <HandlingTests>(); handler.LoadFromReference <HandlingTests>(); var result = await handler.HandleAsync <int>(resolver.CreateSession(), 0, new object[] { }); Assert.IsNotNull(result); Assert.IsTrue(result is int); Assert.IsTrue((int)result == 1); }
public async Task HandleMinusAsyncWithRole() { var handler = new HandlerProvider(); var resolver = new Resolver(); resolver.LoadFromReference <HandlingTests>(); handler.LoadFromReference <HandlingTests>(); var result = await handler.HandleAsync <int>(resolver.CreateSession(), 2, new IntArgument() { Left = 2, Right = 3 }); Assert.IsNotNull(result); Assert.IsTrue(result is int); Assert.IsTrue((int)result == -1); }
static async Task Main(string[] args) { var provider = new HandlerProvider(); var pipeline = new PipeLineBuilder(provider); pipeline.UseHandler <MessageHandler>(); pipeline.UseHandler <EmailHandler>(); var del = pipeline.Build(); await del(new HandlerContext() { Topic = "Email" }); Console.Read(); }
public async Task CalculatorAddStringTest() { var handler = new HandlerProvider(); var resolver = new Resolver(); resolver.LoadFromReference <HandlingTests>(); handler.LoadFromReference <HandlingTests>(); resolver.Register(new CalculatorParameter() { First = 10 }); //var sum = InterfaceHandling.CreateHandler<ICalculator, InterfaceHandlerTest<ICalculator>>(new HandlerArgument() { Arg = "5" }); var result = await handler.HandleAsync <CalculatorResult>(resolver.CreateSession(), "IAddString", 1, "6"); Assert.AreEqual(7, result.Result); }
public void LoadFromReference <T>() { if (loaded) { throw new Exception($"Already initialized"); } Resolver.LoadFromReference <T>(); if (Resolver.TryResolveSingletone <IMethodContextInfoProvider>(out var contextProvider)) { HandlerProvider = new HandlerProvider(contextProvider); Resolver.Register(HandlerProvider); } HandlerProvider.LoadFromReference <T>(); Serializer.LoadFromReference <T>(); loaded = true; }
public async Task HandleManyMultiplyAsync() { var handler = new HandlerProvider(); var resolver = new Resolver(); resolver.LoadFromReference <HandlingTests>(); handler.LoadFromReference <HandlingTests>(); var watch = Stopwatch.StartNew(); for (int i = 0; i < 100000; i++) { var result = await handler.HandleAsync <int>(resolver.CreateSession(), 1, new IntArgument() { Left = 2, Right = 3 }); } watch.Stop(); // 0.48s (0.8) 100k }
public async Task HandlerByteMinusAsyncWithAdminMinusRoles() { var resolver = new Resolver(); resolver.LoadFromReference <HandlingTests>(); var handler = new HandlerProvider(); handler.LoadFromReference <HandlingTests>(); resolver.Register(new Roles("Minus", "Admin")); var result = await handler.HandleAsync <int>(resolver.CreateSession(), 2, new ByteArgument() { Left = 6, Right = 2 }); Assert.IsNotNull(result); Assert.IsTrue(result is int); Assert.IsTrue((int)result == 3); }
Task SendInProc(IMessageContext commandContext, CancellationToken cancellationToken) { Task task = null; var command = commandContext.Message as ICommand; if (command is ILinearCommand) { task = SendAsync(commandContext, cancellationToken); } else //if not a linear command, we run synchronously. { task = new Task(() => { var commandHandler = HandlerProvider.GetHandler(command.GetType()); if (commandHandler == null) { throw new NoCommandHandlerExists(); } MessageState messageState = BuildMessageState(commandContext.MessageID, command, cancellationToken); PerMessageContextLifetimeManager.CurrentMessageContext = commandContext; try { var unitOfWork = IoCFactory.Resolve <IUnitOfWork>(); commandHandler.Handle(command); unitOfWork.Commit(); } finally { commandContext.ClearItems(); } }); task.RunSynchronously(); if (task.Exception != null) { throw task.Exception.GetBaseException(); } } return(task); }
public async Task InterfaceToMethodProtocolHandlerTest() { var resolver = new Resolver(); resolver.LoadFromReference <ProtocolTests>(); resolver.Register(new CalculatorParameter() { First = 10 }); var session = resolver.CreateSession(); //resolver.Register(session); var handler = new HandlerProvider(session.Resolve <IMethodContextInfoProvider>()); handler.LoadFromReference <ProtocolTests>(); var methodHandler = new MethodProtocolHandler(handler, session); resolver.Register(methodHandler, true); var calculator = InterfaceHandling.CreateHandler <ICalculator, ProtocolInterfaceHandler <ICalculator> >(session); List <Task> tasks = new List <Task>(); var watch = Stopwatch.StartNew(); for (int i = 0; i < 10000; i++) { var task = calculator.AddAsync("20"); tasks.Add(task); } await Task.WhenAll(tasks); watch.Stop(); // a: 10k 0.2-0.3s //Assert.AreEqual(30, task.Result); }
public SyncSession(SyncServer server, HandlerProvider provider, ILogger <SyncSession> logger) : base(server, provider, logger) { }
protected override void ConsumeMessage(IFramework.MessageQueue.EQueue.MessageFormat.MessageContext messageContext, EQueueProtocols.QueueMessage queueMessage) { if (messageContext == null || messageContext.Message == null) { return; } var message = messageContext.Message as ICommand; if (message == null) { return; } MessageReply messageReply = null; var needRetry = message.NeedRetry; bool commandHasHandled = false; IMessageStore messageStore = null; try { PerMessageContextLifetimeManager.CurrentMessageContext = messageContext; messageStore = IoCFactory.Resolve <IMessageStore>(); commandHasHandled = messageStore.HasCommandHandled(messageContext.MessageID); if (!commandHasHandled) { var messageHandler = HandlerProvider.GetHandler(message.GetType()); _Logger.InfoFormat("Handle command, commandID:{0}", messageContext.MessageID); if (messageHandler == null) { messageReply = new MessageReply(messageContext.ReplyToEndPoint, messageContext.MessageID, new NoHandlerExists()); } else { do { try { ((dynamic)messageHandler).Handle((dynamic)message); messageReply = new MessageReply(messageContext.ReplyToEndPoint, messageContext.MessageID, messageContext.Reply); needRetry = false; } catch (Exception ex) { if (!(ex is OptimisticConcurrencyException) || !needRetry) { throw; } } } while (needRetry); } } else { messageReply = new MessageReply(messageContext.ReplyToEndPoint, messageContext.MessageID, new MessageDuplicatelyHandled()); } } catch (Exception e) { messageReply = new MessageReply(messageContext.ReplyToEndPoint, messageContext.MessageID, e.GetBaseException()); if (e is DomainException) { _Logger.Warn(message.ToJson(), e); } else { _Logger.Error(message.ToJson(), e); } if (messageStore != null) { messageStore.SaveFailedCommand(messageContext); } } finally { PerMessageContextLifetimeManager.CurrentMessageContext = null; } if (!commandHasHandled) { OnMessageHandled(messageContext, messageReply); HandledMessageCount++; } }
private static Type GetHandler <TAction>(TAction action) where TAction : IAction { return(HandlerProvider.GetHandler <IActionHandler <TAction> >()); }
protected virtual Task SendInProc(IMessageContext commandContext, CancellationToken cancellationToken) { Task task = null; var command = commandContext.Message as ICommand; if (command is ILinearCommand) { task = SendAsync(commandContext, cancellationToken); } else if (command != null) //if not a linear command, we run synchronously. { task = Task.Factory.StartNew(() => { IMessageStore messageStore = null; try { var needRetry = command.NeedRetry; object result = null; PerMessageContextLifetimeManager.CurrentMessageContext = commandContext; messageStore = IoCFactory.Resolve <IMessageStore>(); if (!messageStore.HasCommandHandled(commandContext.MessageID)) { var commandHandler = HandlerProvider.GetHandler(command.GetType()); if (commandHandler == null) { PerMessageContextLifetimeManager.CurrentMessageContext = null; throw new NoHandlerExists(); } do { try { ((dynamic)commandHandler).Handle((dynamic)command); result = commandContext.Reply; needRetry = false; } catch (Exception ex) { if (!(ex is OptimisticConcurrencyException) || !needRetry) { throw; } } } while (needRetry); return(result); } else { throw new MessageDuplicatelyHandled(); } } catch (Exception e) { if (e is DomainException) { _Logger.Warn(command.ToJson(), e); } else { _Logger.Error(command.ToJson(), e); } if (messageStore != null) { messageStore.SaveFailedCommand(commandContext); } throw; } finally { PerMessageContextLifetimeManager.CurrentMessageContext = null; } }, cancellationToken); } return(task); }
private IPersonIdentifierDisplayHandler GetDisplayHandler(IdentifierDefinition identifierType) => HandlerProvider.GetDisplayHandler(identifierType);