public void ConfigureHttpResponseMessage(Message message, HttpResponseMessage httpResponseMessage, HttpResponseMessageProperty responseProperty)
{
HttpChannelUtilities.EnsureHttpResponseMessageContentNotNull(httpResponseMessage);
string action = message.Headers.Action;
if (message.Version.Addressing == AddressingVersion.None)
{
if (MessageLogger.LogMessagesAtTransportLevel)
{
message.Properties.Add(AddressingProperty.Name, new AddressingProperty(message.Headers));
}
message.Headers.Action = null;
message.Headers.To = null;
}
bool httpResponseMessagePropertyFound = responseProperty != null;
string contentType = null;
if (message.Version == MessageVersion.None && httpResponseMessagePropertyFound && !string.IsNullOrEmpty(responseProperty.Headers[HttpResponseHeader.ContentType]))
{
contentType = responseProperty.Headers[HttpResponseHeader.ContentType];
responseProperty.Headers.Remove(HttpResponseHeader.ContentType);
if (!messageEncoder.IsContentTypeSupported(contentType))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new ProtocolException(SR.GetString(SR.ResponseContentTypeNotSupported,
contentType)));
}
}
if (string.IsNullOrEmpty(contentType))
{
MtomMessageEncoder mtomMessageEncoder = messageEncoder as MtomMessageEncoder;
if (mtomMessageEncoder == null)
{
contentType = messageEncoder.ContentType;
}
else
{
contentType = mtomMessageEncoder.GetContentType(out this.mtomBoundary);
// For MTOM messages, add a MIME version header
httpResponseMessage.Headers.Add(HttpChannelUtilities.MIMEVersionHeader, DefaultMimeVersion);
}
}
if (isRequest && FxTrace.Trace.IsEnd2EndActivityTracingEnabled)
{
EnsureEventTraceActivity(message);
}
if (this.CanSendCompressedResponses)
{
string contentEncoding;
string compressionContentType = contentType;
if (HttpChannelUtilities.GetHttpResponseTypeAndEncodingForCompression(ref compressionContentType, out contentEncoding))
{
contentType = compressionContentType;
this.SetContentEncoding(contentEncoding);
}
}
if (httpResponseMessage.Content != null && !string.IsNullOrEmpty(contentType))
{
MediaTypeHeaderValue mediaTypeHeaderValue;
if (!MediaTypeHeaderValue.TryParse(contentType, out mediaTypeHeaderValue))
{
throw FxTrace.Exception.Argument("contentType", SR.GetString(SR.InvalidContentTypeError, contentType));
}
httpResponseMessage.Content.Headers.ContentType = mediaTypeHeaderValue;
}
bool httpMethodIsHead = string.Compare(this.HttpMethod, "HEAD", StringComparison.OrdinalIgnoreCase) == 0;
if (httpMethodIsHead ||
httpResponseMessagePropertyFound && responseProperty.SuppressEntityBody)
{
httpResponseMessage.Content.Headers.ContentLength = 0;
httpResponseMessage.Content.Headers.ContentType = null;
}
if (httpResponseMessagePropertyFound)
{
httpResponseMessage.StatusCode = responseProperty.StatusCode;
if (responseProperty.StatusDescription != null)
{
responseProperty.StatusDescription = responseProperty.StatusDescription;
}
foreach (string key in responseProperty.Headers.AllKeys)
{
httpResponseMessage.AddHeader(key, responseProperty.Headers[key]);
}
}
if (!message.IsEmpty)
{
using (HttpContent content = httpResponseMessage.Content)
{
if (this.streamed)
{
IStreamedMessageEncoder streamedMessageEncoder = this.messageEncoder as IStreamedMessageEncoder;
Stream stream = null;
if (streamedMessageEncoder != null)
{
stream = streamedMessageEncoder.GetResponseMessageStream(message);
}
if (stream != null)
{
httpResponseMessage.Content = new StreamContent(stream);
}
else
{
httpResponseMessage.Content = new OpaqueContent(this.messageEncoder, message, this.mtomBoundary);
}
}
else
{
// HttpOutputByteArrayContent assumes responsibility for returning the buffer to the bufferManager.
ArraySegment<byte> messageBytes = this.SerializeBufferedMessage(message, false);
httpResponseMessage.Content = new HttpOutputByteArrayContent(messageBytes.Array, messageBytes.Offset, messageBytes.Count, this.bufferManager);
}
httpResponseMessage.Content.Headers.Clear();
foreach (var header in content.Headers)
{
httpResponseMessage.Content.Headers.Add(header.Key, header.Value);
}
}
}
}
private static HttpResponseMessage CreateResponseMessage(Message message, HttpResponseMessageProperty responseMessageProperty)
{
Fx.Assert(message != null, "The 'message' parameter should not be null.");
Fx.Assert(responseMessageProperty != null, "The 'responseMessageProperty' parameter should not be null.");
HttpResponseMessage response = new HttpResponseMessage();
response.StatusCode = responseMessageProperty.HasStatusCodeBeenSet ?
responseMessageProperty.StatusCode :
message.IsFault ? HttpStatusCode.InternalServerError : HttpStatusCode.OK;
string reasonPhrase = responseMessageProperty.StatusDescription;
if (!string.IsNullOrEmpty(reasonPhrase))
{
response.ReasonPhrase = reasonPhrase;
}
response.Content = CreateMessageContent(message, responseMessageProperty.SuppressEntityBody);
WebHeaderCollection headers = responseMessageProperty.Headers;
foreach (string headerKey in headers.AllKeys)
{
response.AddHeader(headerKey, headers[headerKey]);
}
return response;
}
