C# IMessageHandler.GetType方法代码示例

        public override void Invoke(Type msgType, IMessage message, IMessageHandler handler)
        {
            // PERF: cache or create compiled Lambda to invoke this
            var method = handler.GetType().GetMethod("Handle", new[] { msgType });

            method.Invoke(handler, new object[] { message });
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="QueueCreationDecorator" /> class.
 /// </summary>
 /// <param name="metrics">The metrics factory.</param>
 /// <param name="handler">The handler.</param>
 /// <param name="connectionInformation">The connection information.</param>
 public MessageHandlerDecorator(IMetrics metrics,
     IMessageHandler handler,
     IConnectionInformation connectionInformation)
 {
     var name = handler.GetType().Name;
     _runCodeTimer = metrics.Timer($"{connectionInformation.QueueName}.{name}.HandleTimer", Units.Calls);
     _handler = handler;
 }

        public void RegisterMessageHandler(IMessageHandler handler, params string[] allowedRooms)
        {
            Type handlerType = handler.GetType();

            foreach (MethodInfo endpoint in handlerType.GetMethods(BindingFlags.Public | BindingFlags.Instance))
            {
                var messageAttributes = endpoint.GetCustomAttributes(typeof(HandleMessageAttribute), true);

                foreach (HandleMessageAttribute messageAttribute in messageAttributes)
                {
                    var route = messageAttribute.CreateRoute(handler, endpoint);

                    _routes.Add(allowedRooms == null || !allowedRooms.Any() ? route : new RoomSecurityRoute(route, allowedRooms));
                }
            }
        }

 /// <summary>
 /// Deterministically generates a queue name for a 
 /// <paramref name="messageHandler"/> based on the MD5 hash of its full
 /// type name
 /// </summary>
 /// <param name="messageHandler">The message handler</param>
 /// <returns>A unique and deterministic queue name based on the message
 /// handler type</returns>
 public static QueueName GenerateQueueName(IMessageHandler messageHandler)
 {
     // Produce a short type name that is safe (ish?) from collisions
     var typeName = messageHandler.GetType().FullName;
     var typeNameBytes = Encoding.UTF8.GetBytes(typeName);
     var typeHash = MD5.Create().ComputeHash(typeNameBytes);
     return string.Join("", typeHash.Select(b => ((ushort) b).ToString("x2")));
 }

        private void OnMapRequestHandler()
        {
            if (ProcessingFinished)
            {
                return;
            }

            _handler = _factory.GetHandler(Context.Request);
            if (_handler.GetType() == typeof(NullMessageHandler))
            {
                // TODO: handle error here.
                CompleteProcessing();
            }
        }

        private bool SafelyHandles(IMessageHandler handler, EventMessageBase message, string originalMessage)
        {
            var handles = false;

            try
            {
                handles = handler.CanHandle(message);
            }
            catch (Exception ex)
            {
                this.Logger.Error($"{handler.GetType().Name} threw exception in CanHandle() with message: {originalMessage}", ex);
            }

            return handles;
        }