Exemplo n.º 1
0
        private IStartableMessageBus Build() {
            var messageTypes = MessageTypeConventions.ScanAssembliesForMessageTypes(assembliesToScan);
            var messageMapper = new MessageMapper();
            messageMapper.SetMessageTypeConventions(this.MessageTypeConventions);
            messageMapper.Initialize(messageTypes);
            var allMessageTypes = messageTypes.Concat(messageMapper.DynamicTypes);

            MessageSerializer = new XmlMessageSerializer(messageMapper);
            (MessageSerializer as XmlMessageSerializer).Initialize(messageTypes);

            this.MessageHandlers.AddAssembliesToScan(assembliesToScan);
            this.MessageHandlers.Init();
            if (executeTheseHandlersFirst.Any())
                this.MessageHandlers.ExecuteTheseHandlersFirst(executeTheseHandlersFirst);
            if (executeTheseHandlersLast.Any())
                this.MessageHandlers.ExecuteTheseHandlersLast(executeTheseHandlersLast);

            // Get endpoint mapping
            foreach (MessageEndpointMapping mapping in this.MessageEndpointMappingCollection) {
                try {
                    var messageType = Type.GetType(mapping.Messages, false);
                    if (messageType != null && MessageTypeConventions.IsMessageType(messageType))
                    {
                        typesToEndpoints[messageType] = mapping.Endpoint.Trim();
                        continue;
                    }
                } catch (Exception ex) {
                    Logger.Error("Problem loading message type: " + mapping.Messages, ex);
                }

                try {
                    var a = Assembly.Load(mapping.Messages);
                    foreach (var t in a.GetTypes().Where(t => MessageTypeConventions.IsMessageType(t)))
                        typesToEndpoints[t] = mapping.Endpoint.Trim();
                } catch (Exception ex) {
                    throw new ArgumentException("Problem loading message assembly: " + mapping.Messages, ex);
                }

            }

            var transport = TransportBuilder.Build();

            var messageDispatcher = new MessageDispatcher(ServiceLocator, this.MessageHandlers);
            var messageBus = new UnicastMessageBus(messageMapper, transport, messageDispatcher);
            messageBus.MapMessageTypesToAddress(typesToEndpoints);

            var performanceCounters = new PerformanceCounters();
            messageBus.MessageReceived += performanceCounters.OnMessageReceived;
            messageBus.MessageSent += performanceCounters.OnMessageSent;
            messageBus.MessageFailed += performanceCounters.OnMessageFailure;
            messageBus.MessageHandled += performanceCounters.OnMessageHandled;

            return messageBus;
        }
Exemplo n.º 2
0
        private IStartableMessageBus Build()
        {
            var messageTypes  = MessageTypeConventions.ScanAssembliesForMessageTypes(assembliesToScan);
            var messageMapper = new MessageMapper();

            messageMapper.SetMessageTypeConventions(this.MessageTypeConventions);
            messageMapper.Initialize(messageTypes);
            var allMessageTypes = messageTypes.Concat(messageMapper.DynamicTypes);

            MessageSerializer = new XmlMessageSerializer(messageMapper);
            (MessageSerializer as XmlMessageSerializer).Initialize(messageTypes);

            this.MessageHandlers.AddAssembliesToScan(assembliesToScan);
            this.MessageHandlers.Init();
            if (executeTheseHandlersFirst.Any())
            {
                this.MessageHandlers.ExecuteTheseHandlersFirst(executeTheseHandlersFirst);
            }
            if (executeTheseHandlersLast.Any())
            {
                this.MessageHandlers.ExecuteTheseHandlersLast(executeTheseHandlersLast);
            }

            // Get endpoint mapping
            foreach (MessageEndpointMapping mapping in this.MessageEndpointMappingCollection)
            {
                try {
                    var messageType = Type.GetType(mapping.Messages, false);
                    if (messageType != null && MessageTypeConventions.IsMessageType(messageType))
                    {
                        typesToEndpoints[messageType] = mapping.Endpoint.Trim();
                        continue;
                    }
                } catch (Exception ex) {
                    Logger.Error("Problem loading message type: " + mapping.Messages, ex);
                }

                try {
                    var a = Assembly.Load(mapping.Messages);
                    foreach (var t in a.GetTypes().Where(t => MessageTypeConventions.IsMessageType(t)))
                    {
                        typesToEndpoints[t] = mapping.Endpoint.Trim();
                    }
                } catch (Exception ex) {
                    throw new ArgumentException("Problem loading message assembly: " + mapping.Messages, ex);
                }
            }

            var transport = TransportBuilder.Build();

            var messageDispatcher = new MessageDispatcher(ServiceLocator, this.MessageHandlers);
            var messageBus        = new UnicastMessageBus(messageMapper, transport, messageDispatcher);

            messageBus.MapMessageTypesToAddress(typesToEndpoints);

            var performanceCounters = new PerformanceCounters();

            messageBus.MessageReceived += performanceCounters.OnMessageReceived;
            messageBus.MessageSent     += performanceCounters.OnMessageSent;
            messageBus.MessageFailed   += performanceCounters.OnMessageFailure;
            messageBus.MessageHandled  += performanceCounters.OnMessageHandled;

            return(messageBus);
        }