C# IMessage.SetHeader方法代码示例

        public void SetUp()
        {
            var bus = MockRepository.GenerateStub<IBus>();

            headerManager = new MessageHeaderManager();

            bus.Stub(x => x.CurrentMessageContext).Return(new FakeMessageConext
                                                              {
                                                                  Id = idOfIncommingMessage
                                                              });
            ExtensionMethods.SetHeaderAction = headerManager.SetHeader;
            ExtensionMethods.GetHeaderAction = headerManager.GetHeader;

            incomingMessage = new TestMessage();

            incomingMessage.SetOriginatingSiteHeader(originatingSite);

            addressOfOriginatingEndpoint = "EnpointLocatedInSiteA";
            incomingMessage.SetHeader("ReturnAddress",addressOfOriginatingEndpoint);

            gatewayHeaderManager = new GatewayHeaderManager
                                       {
                                           Bus = bus
                                       };

            gatewayHeaderManager.MutateIncoming(incomingMessage);

            responseMessage = new TransportMessage
            {
                Headers = new Dictionary<string, string>(),
                CorrelationId = idOfIncommingMessage
            };
        }

 private static void AppendHeaders(IMessage message, IEnumerable<KeyValuePair<string, object>> headers)
 {
     headers = headers.Where(x => x.Key.StartsWith(BusPrefixKey));
     foreach (var header in headers)
     {
         var key = header.Key.Substring(BusPrefixKey.Length);
         var value = (header.Value ?? string.Empty).ToString();
         message.SetHeader(key, value);
     }
 }

        IMessage IMutateOutgoingMessages.MutateOutgoing(IMessage message)
        {
            var timeToBeReceived = message.TimeToBeReceived();

            using (new TransactionScope(TransactionScopeOption.Suppress))
                foreach (var dataBusProperty in message.DataBusPropertiesWithValues())
                {
                    using (var stream = new MemoryStream())
                    {
                        serializer.Serialize(dataBusProperty.GetValue(), stream);
                        stream.Position = 0;

                        dataBusProperty.Key = dataBus.Put(stream, timeToBeReceived);

                        //we use the headers to in order to allow the infrastructure (eg. the gateway) to modify the actual key
                        message.SetHeader(DATABUS_PREFIX + dataBusProperty.Key, dataBusProperty.Key);

                    }
                }

            return message;
        }

 /// <summary>
 /// Adds the headers.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="data">The data.</param>
 public void AddHeaders (IMessage message, IAdditionalMessageData data)
 {
     message.SetHeader(_headers.StandardHeaders.FirstPossibleDeliveryDate, new ValueTypeWrapper<DateTime>(_getFirstMessageDeliveryTime.GetTime(message, data)));
 }

        internal static void Push(RtmpConnection connection, IMessage message, IMessageClient messageClient)
        {
            if (connection != null)
            {
                object response = message;
                if (message is BinaryMessage)
                {
                    BinaryMessage binaryMessage = message as BinaryMessage;
                    binaryMessage.Update(messageClient);
                    byte[] binaryContent = binaryMessage.body as byte[];
                    //byte[] destClientBinaryId = messageClient.GetBinaryId();
                    //Array.Copy(destClientBinaryId, 0, binaryContent, binaryMessage.PatternPosition, destClientBinaryId.Length);

                    RawBinary result = new RawBinary(binaryContent);
                    response = result;
                }
                else
                {
                    //This should be a clone of the original message
                    message.SetHeader(MessageBase.DestinationClientIdHeader, messageClient.ClientId);
                    message.clientId = messageClient.ClientId;
                }

                RtmpChannel channel = connection.GetChannel(3);
                FlexInvoke reply = new FlexInvoke();
                Call call = new Call("receive", new object[] { response });
                reply.ServiceCall = call;
                //reply.Cmd = "receive";
                //reply.Response = response;
                reply.InvokeId = connection.InvokeId;
                channel.Write(reply);
            }
        }

 public IMessage MutateOutgoing(IMessage message)
 {
     if(message is ICommand)
         message.SetHeader("CommandId",Guid.NewGuid().ToString());
     return message;
 }

        /// <summary>
        /// Sends the specified message.
        /// </summary>
        /// <param name="messageToSend">The message to send.</param>
        /// <param name="data">The data.</param>
        /// <returns></returns>
        /// <exception cref="DotNetWorkQueueException">An error occurred while sending a message</exception>
        public IQueueOutputMessage Send(IMessage messageToSend, IAdditionalMessageData data)
        {
            try
            {
                //TODO - temp - fail all messages with routes, as they are not supported yet
                if (!string.IsNullOrEmpty(data.Route))
                {
                    throw new NotImplementedException("Redis transport does not yet support routes");
                }

                //correlationID must be stored as a message header
                messageToSend.SetHeader(_headers.CorelationId, new RedisQueueCorrelationIdSerialized((Guid)data.CorrelationId.Id.Value));

                var messageId = _sendMessage.Handle(new SendMessageCommand(messageToSend, data));
                if (messageId == "JobAlreadyExists")
                {
                    return new QueueOutputMessage(_sentMessageFactory.Create(null, data.CorrelationId), new DotNetWorkQueueException("Failed to enqueue a record. The job already exists"));
                }
                return new QueueOutputMessage(_sentMessageFactory.Create(new RedisQueueId(messageId), data.CorrelationId));
            }
            catch (Exception exception)
            {
                return new QueueOutputMessage(_sentMessageFactory.Create(null, data.CorrelationId), exception);
            }
        }