C# Globalization.Message类代码示例

        public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
        {
            var context = WebOperationContext.Current;
            if (HttpContext.Current != null && context != null && context.IncomingRequest.UriTemplateMatch != null)
            {
                var curatedFeedName = HttpContext.Current.Request.QueryString["name"];
                
                // Grab the base and request URIs
                UriBuilder baseUriBuilder = new UriBuilder(context.IncomingRequest.UriTemplateMatch.BaseUri);
                UriBuilder requestUriBuilder = new UriBuilder(context.IncomingRequest.UriTemplateMatch.RequestUri);

                // Replace Host Name
                baseUriBuilder.Host = HttpContext.Current.Request.Url.Host;
                requestUriBuilder.Host = baseUriBuilder.Host;

                // Replace "/api/v2/curated-feed" with "/api/v2/curated-feeds/[feedname]"
                baseUriBuilder.Path = RewriteUrlPath(baseUriBuilder.Path, curatedFeedName);
                requestUriBuilder.Path = RewriteUrlPath(requestUriBuilder.Path, curatedFeedName);

                // Set the matching properties on the incoming request
                OperationContext.Current.IncomingMessageProperties["MicrosoftDataServicesRootUri"] = baseUriBuilder.Uri;
                OperationContext.Current.IncomingMessageProperties["MicrosoftDataServicesRequestUri"] = requestUriBuilder.Uri;
            }

            return null;
        }

        public Message Get(Message message)
        {
            HttpRequestMessageProperty requestMessageProperty = (HttpRequestMessageProperty) message.Properties[HttpRequestMessageProperty.Name];
            HttpResponseMessageProperty responseMessageProperty = new HttpResponseMessageProperty();

            if ((requestMessageProperty != null) && IsServiceUnchanged(requestMessageProperty.Headers[JsonGlobals.IfModifiedSinceString]))
            {
                Message responseMessage = Message.CreateMessage(MessageVersion.None, string.Empty);
                responseMessageProperty.StatusCode = HttpStatusCode.NotModified;
                responseMessage.Properties.Add(HttpResponseMessageProperty.Name, responseMessageProperty);
                return responseMessage;
            }

            string proxyContent = this.GetProxyContent(UriTemplate.RewriteUri(this.endpoint.Address.Uri, requestMessageProperty.Headers[HttpRequestHeader.Host]));
            Message response = new WebScriptMetadataMessage(string.Empty, proxyContent);
            responseMessageProperty.Headers.Add(JsonGlobals.LastModifiedString, ServiceLastModifiedRfc1123String);
            responseMessageProperty.Headers.Add(JsonGlobals.ExpiresString, ServiceLastModifiedRfc1123String);
            if (AspNetEnvironment.Current.AspNetCompatibilityEnabled)
            {
                HttpContext.Current.Response.Cache.SetCacheability(HttpCacheability.Public);
            }
            else
            {
                responseMessageProperty.Headers.Add(JsonGlobals.CacheControlString, JsonGlobals.publicString);
            }
            response.Properties.Add(HttpResponseMessageProperty.Name, responseMessageProperty);
            return response;
        }

        /// <summary>
        /// Associates a local operation with the incoming method.
        /// </summary>
        /// <param name="message">The incoming <see cref="Message"/> to be associated with an operation.</param>
        /// <returns>The name of the operation to be associated with the message.</returns>
        string IDispatchOperationSelector.SelectOperation(ref Message message)
        {
            if (message == null)
            {
                throw new ArgumentNullException("message");
            }

            HttpRequestMessage requestMessage = message.ToHttpRequestMessage();
            if (requestMessage == null)
            {
                throw new InvalidOperationException(
                    string.Format(
                        CultureInfo.CurrentCulture,
                        SR.HttpOperationSelectorNullRequest,
                        this.GetType().Name));
            }

            string operation = this.SelectOperation(requestMessage);
            if (operation == null)
            {
                throw new InvalidOperationException(
                    string.Format(
                        CultureInfo.CurrentCulture,
                        SR.HttpOperationSelectorNullOperation,
                        this.GetType().Name));
            }

            return operation;
        }

        public override void HandleMessage(Message message)
        {
            if (message.Name == "ASR.MainForm:updateSection")
            {
                var ctl = message.Sender as Sitecore.Web.UI.HtmlControls.Control;
                if (ctl != null)
                {
                    Sitecore.Context.ClientPage.ClientResponse.Refresh(ctl);
                }
                return;
            }
            if (message.Name.StartsWith("ASRMainFormCommand:"))
            {
                string commandname = message.Name.Substring(message.Name.IndexOf(':') + 1);
                var parameters = new NameValueCollection { { "name", commandname } };
                Sitecore.Context.ClientPage.Start(this, "RunCommand", parameters);
                return;
            }
            if (message.Name == "event:click")
            {
                var nvc = message.Sender as NameValueCollection;
                if (nvc != null)
                {
                    string eventname = nvc["__PARAMETERS"];
                    if (!string.IsNullOrEmpty(eventname))
                    {
                        HandleClickEvent(message, eventname);
                        return;
                    }
                }
            }

            base.HandleMessage(message);
        }

        public bool TryCreateException(Message message, MessageFault fault, out Exception exception)
        {
            if (message == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
            }
            if (fault == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("fault");
            }

            bool created = this.OnTryCreateException(message, fault, out exception);

            if (created)
            {
                if (exception == null)
                {
                    string text = SR.Format(SR.FaultConverterDidNotCreateException, this.GetType().Name);
                    Exception error = new InvalidOperationException(text);
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error);
                }
            }
            else
            {
                if (exception != null)
                {
                    string text = SR.Format(SR.FaultConverterCreatedException, this.GetType().Name);
                    Exception error = new InvalidOperationException(text, exception);
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error);
                }
            }

            return created;
        }

        public SecurityHeader(Message message,
            string actor, bool mustUnderstand, bool relay,
            SecurityStandardsManager standardsManager, SecurityAlgorithmSuite algorithmSuite,
            MessageDirection transferDirection)
        {
            if (message == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
            }
            if (actor == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("actor");
            }
            if (standardsManager == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("standardsManager");
            }
            if (algorithmSuite == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("algorithmSuite");
            }

            _message = message;
            _actor = actor;
            _mustUnderstand = mustUnderstand;
            _relay = relay;
            _standardsManager = standardsManager;
            _algorithmSuite = algorithmSuite;
            _transferDirection = transferDirection;
        }

 private void ApplyChannelBinding(Message message)
 {
     if (this.enableChannelBinding)
     {
         ChannelBindingUtility.TryAddToMessage(this.ChannelBinding, message, true);
     }
 }

            public void should_change_message_label()
            {
                var processor = new ContentBasedRouter(m => string.Format("l-{0}", ((string)m.Payload).Length).ToMessageLabel());

                var message = new Message(
                    "boo".ToMessageLabel(),
                    new Dictionary<string, object> { { "This", "That" } },
                    "Body");

                var result = processor.Apply(message).ToList();

                result.Should().HaveCount(1);
                result.Single().Label.Name.Should().Be("l-4");
                result.Single().Payload.Should().Be("Body");

                message = new Message(
                    "boo".ToMessageLabel(),
                    new Dictionary<string, object> { { "This", "That" } },
                    "Another");

                result = processor.Apply(message).ToList();

                result.Should().HaveCount(1);
                result.Single().Label.Name.Should().Be("l-7");
            }

        /// <summary>
        /// Publishes the message.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="delayMilliseconds">The delay in ms.</param>
        public void PublishMessage(Message message, int delayMilliseconds)
        {
            var messageId = message.Id;
            var deliveryTag = message.Header.Bag.ContainsKey(HeaderNames.DELIVERY_TAG) ? message.GetDeliveryTag().ToString() : null;

            var headers = new Dictionary<string, object>
            {
                { HeaderNames.MESSAGE_TYPE, message.Header.MessageType.ToString() },
                { HeaderNames.TOPIC, message.Header.Topic },
                { HeaderNames.HANDLED_COUNT, message.Header.HandledCount.ToString(CultureInfo.InvariantCulture) }
            };

            if (message.Header.CorrelationId != Guid.Empty)
                headers.Add(HeaderNames.CORRELATION_ID, message.Header.CorrelationId.ToString());

            message.Header.Bag.Each(header =>
            {
                if (!_headersToReset.Any(htr => htr.Equals(header.Key))) headers.Add(header.Key, header.Value);
            });

            if (!string.IsNullOrEmpty(deliveryTag))
                headers.Add(HeaderNames.DELIVERY_TAG, deliveryTag);

            if (delayMilliseconds > 0)
                headers.Add(HeaderNames.DELAY_MILLISECONDS, delayMilliseconds);

            _channel.BasicPublish(
                _exchangeName,
                message.Header.Topic,
                false,
                CreateBasicProperties(messageId, message.Header.TimeStamp, message.Body.BodyType, message.Header.ContentType, headers),
                message.Body.Bytes);
        }

        private void IntroduceErrorToMessage(ref Message message)
        {
            XmlDocument doc = new XmlDocument();
            doc.Load(message.GetReaderAtBodyContents());

            XmlNamespaceManager nsManager = new XmlNamespaceManager(doc.NameTable);
            nsManager.AddNamespace("tempuri", "http://tempuri.org/");
            XmlElement xNode = doc.SelectSingleNode("//tempuri:x", nsManager) as XmlElement;
            XmlText xValue = xNode.FirstChild as XmlText;
            xValue.Value = (double.Parse(xValue.Value, CultureInfo.InvariantCulture) + 1).ToString(CultureInfo.InvariantCulture);

            MemoryStream ms = new MemoryStream();
            XmlWriterSettings writerSettings = new XmlWriterSettings
            {
                CloseOutput = false,
                OmitXmlDeclaration = true,
                Encoding = Encoding.UTF8,
            };

            XmlWriter writer = XmlWriter.Create(ms, writerSettings);
            doc.WriteTo(writer);
            writer.Close();
            ms.Position = 0;
            XmlReader reader = XmlReader.Create(ms);

            Message newMessage = Message.CreateMessage(message.Version, null, reader);
            newMessage.Headers.CopyHeadersFrom(message);
            newMessage.Properties.CopyProperties(message.Properties);
            message.Close();
            message = newMessage;
        }

        private void AppendTypeToBody(Message message, StringBuilder bodyBuilder) {
            Type type = message.GetType();
            string typeRef = this._typeResolver.CreateTypeRef(type);

            bodyBuilder.Append(IntegerToString(typeRef.Length));
            bodyBuilder.Append(typeRef);
        }

        /// <summary>
        /// Determines whether the requested message is JSONP. When detected
        /// changes the message to be treated by the WCF Data services Runtime 
        /// as a common JSON request and correlates the output with the requested
        /// callback.
        /// </summary>
        /// <param name="request">Requested message.</param>
        /// <param name="channel">Current client channel.</param>
        /// <param name="instanceContext">Context where the service is running.</param>
        /// <returns>Returns a correlation value indicating the requested callback (when applies).</returns>
        public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
        {
            if (request.Properties.ContainsKey("UriTemplateMatchResults"))
            {
                var match = (UriTemplateMatch)request.Properties["UriTemplateMatchResults"];
                var format = match.QueryParameters["$format"];

                if ("json".Equals(format, StringComparison.InvariantCultureIgnoreCase))
                {
                    // strip out $format from the query options to avoid an error
                    // due to use of a reserved option (starts with "$")
                    match.QueryParameters.Remove("$format");

                    // replace the Accept header so that the Data Services runtime
                    // assumes the client asked for a JSON representation
                    var httpmsg = (HttpRequestMessageProperty)request.Properties[HttpRequestMessageProperty.Name];
                    httpmsg.Headers["Accept"] = "application/json";

                    var callback = match.QueryParameters["$callback"];

                    if (!string.IsNullOrEmpty(callback))
                    {
                        match.QueryParameters.Remove("$callback");
                        return callback;
                    }
                }
            }

            return null;
        }

        /// <summary>
        /// Wraps the resulting content into a JSONP callback function 
        /// extracted on the AfterReceiveReply message.
        /// </summary>
        /// <param name="reply">Outgoing response message.</param>
        /// <param name="correlationState">Correlation state returned by the AfterReceiveReply method.</param>
        public void BeforeSendReply(ref Message reply, object correlationState)
        {
            if (correlationState == null || !(correlationState is string))
                return;

            // If we have a JSONP callback then buffer the response, wrap it with the
            // callback call and then re-create the response message
            var callback = (string)correlationState;

            var reader = reply.GetReaderAtBodyContents();
            reader.ReadStartElement();

            var content = Encoding.UTF8.GetString(reader.ReadContentAsBase64());
            content = string.Format(CultureInfo.InvariantCulture, "{0}({1});", callback, content);

            var newReply = Message.CreateMessage(MessageVersion.None, string.Empty, new JsonBodyWriter(content));
            newReply.Properties.CopyProperties(reply.Properties);
            reply = newReply;

            // change response content type to text/javascript if the JSON (only done when wrapped in a callback)
            var replyProperties =
                (HttpResponseMessageProperty)reply.Properties[HttpResponseMessageProperty.Name];

            replyProperties.Headers["Content-Type"] =
                replyProperties.Headers["Content-Type"].Replace("application/json", "text/javascript");
        }

		public InitiatorSecureMessageDecryptor (
			Message source, SecurityMessageProperty secprop, InitiatorMessageSecurityBindingSupport security)
			: base (source, security)
		{
			this.security = security;
			request_security = secprop;
		}

 public void DeserializeRequest(Message message, object[] parameters)
 {
     if (message == null)
     {
         return;
     }
     WebContentFormat format;
     IDispatchMessageFormatter selectedFormatter;
     if (TryGetEncodingFormat(message, out format))
     {
         this.formatters.TryGetValue(format, out selectedFormatter);
         if (selectedFormatter == null)
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.UnrecognizedHttpMessageFormat, format, GetSupportedFormats())));
         }
     }
     else
     {
         selectedFormatter = this.defaultFormatter;
         if (selectedFormatter == null)
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.MessageFormatPropertyNotFound3)));
         }
     }
     selectedFormatter.DeserializeRequest(message, parameters);
 }