C# IHttpRequest.GetRequestBody方法代码示例

            private void CompareRequest(ExpectedClientRequest expected, IHttpRequest actual)
            {
                this.parent.Assert.AreEqual(expected.Verb, actual.Verb, "Request verb did not match");

                // The headers are quite different when using XmlHttp
                if (!this.contextData.UsesXmlHttpStack())
                {
                    this.CompareHeaders(expected.Headers, actual.Headers);
                }

                if (expected.Body == null)
                {
                    int actualLength = 0;
                    var actualBody = actual.GetRequestBody();
                    if (actualBody != null)
                    {
                        actualLength = actualBody.Length;
                    }

                    this.parent.Assert.AreEqual(0, actualLength, "Request should not have had a body");
                }
                else
                {
                    ODataPayloadElement actualPayload;
                    if (expected.Body.ElementType == ODataPayloadElementType.EntityInstance)
                    {
                        actualPayload = actual.DeserializeAndCast<EntityInstance>(this.parent.FormatSelector);
                    }
                    else if (expected.Body.ElementType == ODataPayloadElementType.DeferredLink)
                    {
                        actualPayload = actual.DeserializeAndCast<DeferredLink>(this.parent.FormatSelector);
                    }
                    else
                    {
                        ExceptionUtilities.Assert(expected.Body.ElementType == ODataPayloadElementType.PrimitiveValue, "Expected payload element was neither an entity, a link, nor a stream");
                        actualPayload = new PrimitiveValue(null, actual.GetRequestBody());
                    }

                    try
                    {
                        this.parent.PayloadComparer.Compare(expected.Body, actualPayload);
                    }
                    catch (TestFailedException e)
                    {
                        this.parent.Log.WriteLine(LogLevel.Error, "Expected client request payload did not match actual.");
                                                
                        var strategy = this.parent.FormatSelector.GetStrategy(actual.GetHeaderValueIfExists(HttpHeaders.ContentType), null);
                        var expectedBinary = strategy.GetSerializer().SerializeToBinary(expected.Body);

                        this.parent.Log.WriteLine(LogLevel.Verbose, "Expected request:");
                        var expectedToLog = new HttpRequestData() { Verb = expected.Verb, Uri = expected.Uri, Body = expectedBinary };
                        expectedToLog.Headers.AddRange(expected.Headers);
                        expectedToLog.WriteToLog(this.parent.Log, LogLevel.Verbose);

                        this.parent.Log.WriteLine(LogLevel.Verbose, "Actual request:");
                        actual.WriteToLog(this.parent.Log, LogLevel.Verbose);

                        // wrap to preserve call stack
                        throw new AssertionFailedException("Expected client request payload did not match actual.", e);
                    }
                }
            }

        /// <summary>
        /// Constructs an HttpWebRequest for the given information and sends it (by writing to the stream).
        /// If the server responds with certain status-codes, this method will throw due to the underlying stack's implementation.
        /// </summary>
        /// <param name="request">The request to send, should not be null, and should have an absolute Uri</param>
        /// <returns>An HttpWebRequest</returns>
        private HttpWebRequest SendRequest(IHttpRequest request)
        {
            // some sanity checks
            ExceptionUtilities.Assert(request != null, "request == null");

            Uri requestUri = request.GetRequestUri();
            ExceptionUtilities.Assert(requestUri != null, "requestUri == null");
            ExceptionUtilities.Assert(requestUri.IsAbsoluteUri, "!requestUri.IsAbsoluteUri");

            // create the request
            HttpWebRequest underlyingRequest = (HttpWebRequest)HttpWebRequest.Create(requestUri);

            if (this.AuthenticationProvider.UseDefaultCredentials)
            {
                underlyingRequest.UseDefaultCredentials = true;
            }
            else if (this.AuthenticationProvider.GetAuthenticationCredentials() != null)
            {
                underlyingRequest.Credentials = this.AuthenticationProvider.GetAuthenticationCredentials();
            }

            IDictionary<string, string> authenticationHeaders = this.AuthenticationProvider.GetAuthenticationHeaders();
            if (authenticationHeaders != null)
            {
                foreach (var header in authenticationHeaders)
                {
                    underlyingRequest.Headers[header.Key] = header.Value;
                }
            }

            // set the HTTP method
            underlyingRequest.Method = request.Verb.ToHttpMethod();

            // clear default values
            underlyingRequest.Accept = null;
            underlyingRequest.ContentType = null;

            // set the request's headers. Accept and Content-Type are special cases due to HttpWebRequest's API.
            foreach (KeyValuePair<string, string> header in request.Headers)
            {
                switch (header.Key)
                {
                    case HttpHeaders.Accept:
                        // use the special API
                        underlyingRequest.Accept = header.Value;
                        break;

                    case HttpHeaders.ContentType:
                        // use the special API, and randomize it
                        underlyingRequest.ContentType = header.Value;
                        break;

                    default:
                        underlyingRequest.Headers.Add(header.Key, header.Value);
                        break;
                }
            }

            // log request before sending
            this.Logger.WriteLine(LogLevel.Verbose, "HTTP: {0} {1} {2}", underlyingRequest.Method, underlyingRequest.RequestUri, underlyingRequest.Accept);

            // if the request is empty, explicitly set the content length to 0
            var requestBody = request.GetRequestBody();
            if (requestBody == null || requestBody.Length == 0)
            {
                underlyingRequest.ContentLength = 0;
            }
            else
            {
                // set the content length, and write all the bytes to the stream
                // note that this will cause the request to be sent to the server
                underlyingRequest.ContentLength = requestBody.Length;
                using (Stream os = underlyingRequest.GetRequestStream())
                {
                    os.Write(requestBody, 0, requestBody.Length);
                }
            }

            // return the request
            return underlyingRequest;
        }