C# HttpRequestMessage.ToMessage方法代码示例

 public void ToHttpRequestMessage_Returns_The_Original_HttpRequestMessage()
 {
     HttpRequestMessage request = new HttpRequestMessage();
     Message wcfRequest = request.ToMessage();
     HttpRequestMessage requestRoundTripped = wcfRequest.ToHttpRequestMessage();
     Assert.IsNotNull(requestRoundTripped, "Message.ToHttpRequestMessage should not have returned null.");
     Assert.AreSame(request, requestRoundTripped, "Message.ToHttpRequestMessage should have returned the orignal instance of HttpRequestMessage.");
 }

 public void ToHttpRequestMessage_Does_Not_Change_Message_State()
 {
     HttpRequestMessage request = new HttpRequestMessage();
     Message wcfRequest = request.ToMessage();
     MessageState state = wcfRequest.State;
     wcfRequest.ToHttpRequestMessage();
     Assert.AreEqual(state, wcfRequest.State, "Message.State should be the same before and after calling Message.ToHttpRequestMessage.");
 }

        public void ToHttpRequestMessage_Can_Be_Called_Multiple_Times()
        {
            HttpRequestMessage request = new HttpRequestMessage();
            Message wcfRequest = request.ToMessage();
            HttpRequestMessage requestRoundTripped = wcfRequest.ToHttpRequestMessage();
            Assert.IsNotNull(requestRoundTripped, "Message.ToHttpRequestMessage should not have returned null.");
            Assert.AreSame(request, requestRoundTripped, "Message.ToHttpRequestMessage should have returned the orignal instance of HttpRequestMessage.");

            HttpRequestMessage requestRoundTrippedAgain = wcfRequest.ToHttpRequestMessage();
            Assert.IsNotNull(requestRoundTrippedAgain, "Message.ToHttpRequestMessage should not have returned null.");
            Assert.AreSame(request, requestRoundTrippedAgain, "Message.ToHttpRequestMessage should have returned the orignal instance of HttpRequestMessage.");
        }

        private Message TraceHttpRequestMessage(HttpRequestMessage msg)
        {
            string tracemsg = String.Format(
                "Web Request on URL: {0}\n" +
                "Header: {1}\n" +
                "Body: {2}",
                msg.RequestUri.AbsoluteUri,
                msg,
                msg.Content != null ? msg.Content.ReadAsString() : "(empty)");

            LoggingHelper.TraceLine(tracemsg, LoggingHelper.LogLevel.Info);

            return msg.ToMessage();
        }

        public void SelectOperation_Returns_Custom_Operation_Name()
        {
            HttpRequestMessage httpRequestMessage = new HttpRequestMessage();
            Message message = httpRequestMessage.ToMessage();

            SHttpOperationSelector selector = new SHttpOperationSelector();
            selector.OnSelectOperationHttpRequestMessage =
                (localHttpRequestMessag) =>
                {
                    Assert.AreSame(httpRequestMessage, localHttpRequestMessag, "The 'OnSelectOperation' method should have been called with the same HttpRequestMessage instance.");
                    return "CustomOperation";
                };

            string returnedOperation = ((IDispatchOperationSelector)selector).SelectOperation(ref message);
            Assert.AreEqual("CustomOperation", returnedOperation, "SelectOperation should have returned the custom operation name.");
        }

        public void DeserializeRequest_Receives_Message_And_Parameters()
        {
            HttpRequestMessage httpRequestMessage = new HttpRequestMessage();
            Message wcfMessage = httpRequestMessage.ToMessage();
            object[] messageParameters = new object[] { "hello", 5.0 };

            IDispatchMessageFormatter formatter = new MockHttpMessageFormatter()
            {
                OnDeserializeRequest = (msg, parameters) =>
                {
                    Assert.AreSame(httpRequestMessage, msg, "DeserializeRequest did not receive the HttpRequestMessage we specified");
                    Assert.AreSame(messageParameters, parameters, "DeserializeRequest did not receive the parameters we specified");
                }
            };

            formatter.DeserializeRequest(wcfMessage, messageParameters);
            Assert.IsTrue(((MockHttpMessageFormatter)formatter).WasDeserializeRequestCalled, "DeserializeRequest in derived class was not called");
        }

            public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)
            {
                if (bufferManager == null)
                {
                    throw Error.ArgumentNull("bufferManager");
                }

                HttpRequestMessage request = new HttpRequestMessage();
                request.Content = new ByteArrayBufferManagerContent(bufferManager, buffer.Array, buffer.Offset, buffer.Count);
                if (!String.IsNullOrEmpty(contentType))
                {
                    request.Content.Headers.Add(ContentTypeHeaderName, contentType);
                }

                Message message = request.ToMessage();
                message.Properties.Encoder = this;

                return message;
            }

        public void AfterReceiveRequest_Receives_HttpRequestMessage()
        {
            HttpRequestMessage httpRequestMessage = new HttpRequestMessage();
            Message wcfMessage = httpRequestMessage.ToMessage();
            IClientChannel channel = new MockClientChannel();
            InstanceContext context = new InstanceContext(new MockService1());

            IDispatchMessageInspector inspector = new MockHttpMessageInspector()
            {
                OnAfterReceiveRequest = actualMessage =>
                {
                    Assert.AreSame(httpRequestMessage, actualMessage, "AfterReceiveRequest did not receive the HttpRequestMessage");
                    return /*state*/ null;
                }
            };

            inspector.AfterReceiveRequest(ref wcfMessage, channel, context);
            Assert.IsTrue(((MockHttpMessageInspector)inspector).WasAfterReceiveRequestCalled, "AfterReceiveRequest in derived class was not called");
        }

        private Message TraceHttpRequestMessage(HttpRequestMessage msg)
        {
            // get the session from the session header if it's present
            IEnumerable<string> header = new List<string>();
            if (msg.Headers.TryGetValues(HttpApplicationHeaders.Session, out header))
                TraceLog.Session = header.ToArray<string>()[0];

            // trace request
            string messageText = msg.Content != null ? msg.Content.ReadAsStringAsync().Result : "(empty)";
            string tracemsg = String.Format(
                "\n{0} {1}; User-Agent: {2}; Content-Type: {3}; Content-Length: {4}\n" +
                "Body: {5}",
                msg.Method,
                msg.RequestUri.AbsoluteUri,
                msg.Headers.UserAgent,
                msg.Content.Headers.ContentType,
                msg.Content.Headers.ContentLength,
                messageText);
            TraceLog.TraceLine(tracemsg, TraceLog.LogLevel.Detail);
            return msg.ToMessage();
        }

        public void OnDeserializeRequestExecutesRequestPipeline()
        {
            SHttpOperationDescription operation = new SHttpOperationDescription() { CallBase = true, ReturnValue = HttpParameter.ResponseMessage };
            IEnumerable<HttpOperationHandler> emptyHandlers = Enumerable.Empty<HttpOperationHandler>();
            OperationHandlerPipeline pipeline = new OperationHandlerPipeline(emptyHandlers, emptyHandlers, operation);
            MOperationHandlerPipeline molePipeline = new MOperationHandlerPipeline(pipeline);
            molePipeline.BehaveAsDefaultValue();

            MOperationHandlerPipelineContext moleContext = new MOperationHandlerPipelineContext();

            HttpRequestMessage setRequest = null;
            object[] setValues = null;
            OperationHandlerPipelineContext setContext = null;
            molePipeline.ExecuteRequestPipelineHttpRequestMessageObjectArray = (request, values) =>
                {
                    setRequest = request;
                    setValues = values;
                    return setContext = moleContext;
                };

            OperationHandlerFormatter formatter = new OperationHandlerFormatter(molePipeline);
            IDispatchMessageFormatter dispatchMessageFormatter = (IDispatchMessageFormatter)formatter;

            Uri uri = new Uri("http://somehost/Fred");
            HttpRequestMessage httpRequest = new HttpRequestMessage(HttpMethod.Get, uri);
            httpRequest.Content = new StringContent("");

            Message message = httpRequest.ToMessage();
            object[] parameters = new object[0];
            dispatchMessageFormatter.DeserializeRequest(message, parameters);

            HttpAssert.AreEqual(httpRequest, setRequest);
            Assert.IsNotNull(setValues, "Input values were not passed to the pipeline.");
            Assert.AreEqual(0, ((object[])setValues).Length, "Incorrect number of values.");
            Assert.IsNotNull(setContext, "Context was not set.");
        }

            public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)
            {
                if (bufferManager == null)
                {
                    throw Fx.Exception.ArgumentNull("bufferManager");
                }

                // TODO: CSDMAIN 205175 -- reactivate when tracing and logging are available:
                //// if (WebTD.HttpMessageDecodingStartIsEnabled())
                //// {
                ////     WebTD.HttpMessageDecodingStart();
                //// }

                HttpRequestMessage request = new HttpRequestMessage();
                request.Content = new ByteArrayBufferManagerContent(bufferManager, buffer.Array, buffer.Offset, buffer.Count);
                if (!string.IsNullOrEmpty(contentType))
                {
                    request.Content.Headers.Add(ContentTypeHeaderName, contentType);
                }

                Message message = request.ToMessage();
                message.Properties.Encoder = this;

                // TODO: CSDMAIN 205175 -- reactivate when tracing and logging are available:
                //// if (TD.MessageReadByEncoderIsEnabled() && buffer != null)
                //// {
                ////     TD.MessageReadByEncoder(
                ////             EventTraceActivityHelper.TryExtractActivity(message, true),
                ////             buffer.Count,
                ////             this);
                //// }

                // TODO: CSDMAIN 205175 -- reactivate when tracing and logging are available:
                //// if (MessageLogger.LogMessagesAtTransportLevel)
                //// {
                ////     MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive);
                //// }

                return message;
            }

            public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)
            {
                if (bufferManager == null)
                {
                    throw new ArgumentNullException("bufferManager");
                }

                byte[] content = new byte[buffer.Count];
                Array.Copy(buffer.Array, buffer.Offset, content, 0, content.Length);
                bufferManager.ReturnBuffer(buffer.Array);

                HttpRequestMessage request = new HttpRequestMessage();
                var httpContent = new ByteArrayContent(content);
                httpContent.Headers.Clear();

                if (contentType != null)
                {
                    httpContent.Headers.Add("content-type", contentType);
                }

                request.Content = httpContent;

                Message message = request.ToMessage();
                message.Properties.Encoder = this;

                return message;
            }

        private static Message ConfigureRequestMessage(Message message)
        {
            if (message == null)
            {
                return null;
            }

            HttpRequestMessageProperty requestProperty;
            if (!message.Properties.TryGetValue(HttpRequestMessageProperty.Name, out requestProperty))
            {
                throw Error.InvalidOperation(
                    SRResources.RequestMissingHttpRequestMessageProperty,
                    HttpRequestMessageProperty.Name,
                    typeof(HttpRequestMessageProperty).Name);
            }

            Uri uri = message.Headers.To;
            if (uri == null)
            {
                throw Error.InvalidOperation(SRResources.RequestMissingToHeader);
            }

            HttpRequestMessage httpRequestMessage = message.ToHttpRequestMessage();
            if (httpRequestMessage == null)
            {
                if (!message.IsEmpty)
                {
                    throw Error.InvalidOperation(SRResources.NonHttpMessageMustBeEmpty, HttpMessageExtensions.ToHttpRequestMessageMethodName, typeof(HttpMessage).Name);
                }

                httpRequestMessage = new HttpRequestMessage();
                Message oldMessage = message;
                message = httpRequestMessage.ToMessage();
                message.Properties.CopyProperties(oldMessage.Properties);
                oldMessage.Close();
            }
            else
            {
                // Clear headers but not properties.
                message.Headers.Clear();
            }

            // Copy message properties to HttpRequestMessage. While it does have the
            // risk of allowing properties to get out of sync they in virtually all cases are
            // read-only so the risk is low. The downside to not doing it is that it isn't
            // possible to access anything from HttpRequestMessage (or OperationContent.Current)
            // which is worse.
            foreach (KeyValuePair<string, object> kv in message.Properties)
            {
                httpRequestMessage.Properties.Add(kv.Key, kv.Value);
            }

            if (httpRequestMessage.Content == null)
            {
                httpRequestMessage.Content = new ByteArrayContent(new byte[0]);
            }
            else
            {
                httpRequestMessage.Content.Headers.Clear();
            }

            message.Headers.To = uri;

            httpRequestMessage.RequestUri = uri;
            httpRequestMessage.Method = HttpMethodHelper.GetHttpMethod(requestProperty.Method);

            WebHeaderCollection headers = requestProperty.Headers;
            foreach (var headerName in headers.AllKeys)
            {
                string headerValue = headers[headerName];
                if (!httpRequestMessage.Headers.TryAddWithoutValidation(headerName, headerValue))
                {
                    httpRequestMessage.Content.Headers.TryAddWithoutValidation(headerName, headerValue);
                }
            }

            return message;
        }

        private static Message ConfigureRequestMessage(Message message)
        {
            if (message == null)
            {
                return null;
            }

            HttpRequestMessageProperty requestProperty = message.GetHttpRequestMessageProperty();
            if (requestProperty == null)
            {
                throw new InvalidOperationException(
                    string.Format(
                        CultureInfo.CurrentCulture,
                        SR.RequestMissingHttpRequestMessageProperty,
                        HttpRequestMessageProperty.Name,
                        typeof(HttpRequestMessageProperty).FullName));
            }

            Uri uri = message.Headers.To;
            if (uri == null)
            {
                throw new InvalidOperationException(SR.RequestMissingToHeader);
            }

            HttpRequestMessage httpRequestMessage = message.ToHttpRequestMessage();
            if (httpRequestMessage == null)
            {
                httpRequestMessage = new HttpRequestMessage();
                httpRequestMessage.Content = new StringContent(String.Empty);
                httpRequestMessage.Content.Headers.ContentLength = 0;
                message.Close();
                message = httpRequestMessage.ToMessage();
            }
            else
            {
                message.Headers.Clear();
                message.Properties.Clear();
                httpRequestMessage.Headers.Clear();
                httpRequestMessage.GetProperties().Clear();
            }

            message.Headers.To = uri;

            httpRequestMessage.RequestUri = uri;
            httpRequestMessage.Method = new HttpMethod(requestProperty.Method);

            foreach (var headerName in requestProperty.Headers.AllKeys)
            {
                if (headerName.StartsWith("content-", StringComparison.OrdinalIgnoreCase) ||
                    headerName.Equals("Allow", StringComparison.OrdinalIgnoreCase) ||
                    headerName.Equals("Expires") ||
                    headerName.Equals("Expires", StringComparison.OrdinalIgnoreCase))
                {
                    httpRequestMessage.Content.Headers.Remove(headerName);
                    httpRequestMessage.Content.Headers.Add(headerName, requestProperty.Headers[headerName]);
                    continue;
                }

                httpRequestMessage.Headers.Remove(headerName);
                httpRequestMessage.Headers.Add(headerName, requestProperty.Headers[headerName]);
            }

            return message;
        }

            public override Message ReadMessage(Stream stream, int maxSizeOfHeaders, string contentType)
            {
                if (stream == null)
                {
                    throw Error.ArgumentNull("stream");
                }

                HttpRequestMessage request = new HttpRequestMessage();
                request.Content = new StreamContent(stream);
                if (!String.IsNullOrEmpty(contentType))
                {
                    request.Content.Headers.TryAddWithoutValidation(ContentTypeHeaderName, contentType);
                }

                Message message = request.ToMessage();
                message.Properties.Encoder = this;

                return message;
            }