685 lines
22 KiB
C#
685 lines
22 KiB
C#
//
|
|
// WebMessageFormatter.cs
|
|
//
|
|
// Author:
|
|
// Atsushi Enomoto <atsushi@ximian.com>
|
|
// Atsushi Enomoto <atsushi@xamarin.com>
|
|
//
|
|
// Copyright (C) 2008,2009 Novell, Inc (http://www.novell.com)
|
|
// Copyright (C) 2011 Xamarin, Inc (http://xamarin.com)
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Runtime.Serialization;
|
|
using System.Runtime.Serialization.Json;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Description;
|
|
using System.ServiceModel.Web;
|
|
using System.Text;
|
|
using System.Xml;
|
|
|
|
#if MOBILE
|
|
using XmlObjectSerializer = System.Object;
|
|
#endif
|
|
|
|
namespace System.ServiceModel.Dispatcher
|
|
{
|
|
// This set of classes is to work as message formatters for
|
|
// WebHttpBehavior. There are couple of aspects to differentiate
|
|
// implementations:
|
|
// - request/reply and client/server
|
|
// by WebMessageFormatter hierarchy
|
|
// - WebClientMessageFormatter - for client
|
|
// - RequestClientFormatter - for request
|
|
// - ReplyClientFormatter - for response
|
|
// - WebDispatchMessageFormatter - for server
|
|
// - RequestDispatchFormatter - for request
|
|
// - ReplyDispatchFormatter - for response
|
|
//
|
|
// FIXME: below items need more work
|
|
// - HTTP method differences
|
|
// - GET (WebGet)
|
|
// - POST (other way)
|
|
// - output format: Stream, JSON, XML ...
|
|
|
|
internal abstract class WebMessageFormatter
|
|
{
|
|
OperationDescription operation;
|
|
ServiceEndpoint endpoint;
|
|
QueryStringConverter converter;
|
|
WebHttpBehavior behavior;
|
|
UriTemplate template;
|
|
WebAttributeInfo info = null;
|
|
|
|
public WebMessageFormatter (OperationDescription operation, ServiceEndpoint endpoint, QueryStringConverter converter, WebHttpBehavior behavior)
|
|
{
|
|
this.operation = operation;
|
|
this.endpoint = endpoint;
|
|
this.converter = converter;
|
|
this.behavior = behavior;
|
|
ApplyWebAttribute ();
|
|
#if !MOBILE
|
|
// This is a hack for WebScriptEnablingBehavior
|
|
var jqc = converter as JsonQueryStringConverter;
|
|
if (jqc != null)
|
|
BodyName = jqc.CustomWrapperName;
|
|
#endif
|
|
}
|
|
|
|
void ApplyWebAttribute ()
|
|
{
|
|
MethodInfo mi = operation.SyncMethod ?? operation.BeginMethod;
|
|
|
|
object [] atts = mi.GetCustomAttributes (typeof (WebGetAttribute), false);
|
|
if (atts.Length > 0)
|
|
info = ((WebGetAttribute) atts [0]).Info;
|
|
atts = mi.GetCustomAttributes (typeof (WebInvokeAttribute), false);
|
|
if (atts.Length > 0)
|
|
info = ((WebInvokeAttribute) atts [0]).Info;
|
|
if (info == null)
|
|
info = new WebAttributeInfo ();
|
|
|
|
template = info.BuildUriTemplate (Operation, GetMessageDescription (MessageDirection.Input));
|
|
}
|
|
|
|
public string BodyName { get; set; }
|
|
|
|
public WebHttpBehavior Behavior {
|
|
get { return behavior; }
|
|
}
|
|
|
|
public WebAttributeInfo Info {
|
|
get { return info; }
|
|
}
|
|
|
|
public WebMessageBodyStyle BodyStyle {
|
|
get { return info.IsBodyStyleSetExplicitly ? info.BodyStyle : behavior.DefaultBodyStyle; }
|
|
}
|
|
|
|
public bool IsRequestBodyWrapped {
|
|
get {
|
|
switch (BodyStyle) {
|
|
case WebMessageBodyStyle.Wrapped:
|
|
case WebMessageBodyStyle.WrappedRequest:
|
|
return true;
|
|
}
|
|
return BodyName != null;
|
|
}
|
|
}
|
|
|
|
public bool IsResponseBodyWrapped {
|
|
get {
|
|
switch (BodyStyle) {
|
|
case WebMessageBodyStyle.Wrapped:
|
|
case WebMessageBodyStyle.WrappedResponse:
|
|
return true;
|
|
}
|
|
return BodyName != null;
|
|
}
|
|
}
|
|
|
|
public OperationDescription Operation {
|
|
get { return operation; }
|
|
}
|
|
|
|
public QueryStringConverter Converter {
|
|
get { return converter; }
|
|
}
|
|
|
|
public ServiceEndpoint Endpoint {
|
|
get { return endpoint; }
|
|
}
|
|
|
|
public UriTemplate UriTemplate {
|
|
get { return template; }
|
|
}
|
|
|
|
protected WebContentFormat ToContentFormat (WebMessageFormat src, object result)
|
|
{
|
|
if (result is Stream)
|
|
return WebContentFormat.Raw;
|
|
switch (src) {
|
|
case WebMessageFormat.Xml:
|
|
return WebContentFormat.Xml;
|
|
case WebMessageFormat.Json:
|
|
return WebContentFormat.Json;
|
|
}
|
|
throw new SystemException ("INTERNAL ERROR: should not happen");
|
|
}
|
|
|
|
protected string GetMediaTypeString (WebContentFormat fmt)
|
|
{
|
|
switch (fmt) {
|
|
case WebContentFormat.Raw:
|
|
return "application/octet-stream";
|
|
case WebContentFormat.Json:
|
|
return "application/json";
|
|
case WebContentFormat.Xml:
|
|
default:
|
|
return "application/xml";
|
|
}
|
|
}
|
|
|
|
protected void CheckMessageVersion (MessageVersion messageVersion)
|
|
{
|
|
if (messageVersion == null)
|
|
throw new ArgumentNullException ("messageVersion");
|
|
|
|
if (!MessageVersion.None.Equals (messageVersion))
|
|
throw new ArgumentException (String.Format ("Only MessageVersion.None is supported. {0} is not.", messageVersion));
|
|
}
|
|
|
|
protected MessageDescription GetMessageDescription (MessageDirection dir)
|
|
{
|
|
foreach (MessageDescription md in operation.Messages)
|
|
if (md.Direction == dir)
|
|
return md;
|
|
throw new SystemException ("INTERNAL ERROR: no corresponding message description for the specified direction: " + dir);
|
|
}
|
|
|
|
protected XmlObjectSerializer GetSerializer (WebContentFormat msgfmt, bool isWrapped, MessagePartDescription part)
|
|
{
|
|
if (part.Type == typeof (void))
|
|
return null; // no serialization should be done.
|
|
|
|
switch (msgfmt) {
|
|
case WebContentFormat.Xml:
|
|
if (xml_serializer == null)
|
|
xml_serializer = isWrapped ? new DataContractSerializer (part.Type, part.Name, part.Namespace) : new DataContractSerializer (part.Type);
|
|
return xml_serializer;
|
|
case WebContentFormat.Json:
|
|
// FIXME: after name argument they are hack
|
|
if (json_serializer == null)
|
|
json_serializer = isWrapped ? new DataContractJsonSerializer (part.Type, BodyName ?? part.Name, null, 0x100000, false, null, true) : new DataContractJsonSerializer (part.Type);
|
|
return json_serializer;
|
|
default:
|
|
throw new NotImplementedException (msgfmt.ToString ());
|
|
}
|
|
}
|
|
|
|
XmlObjectSerializer xml_serializer, json_serializer;
|
|
|
|
protected object DeserializeObject (XmlObjectSerializer serializer, Message message, MessageDescription md, bool isWrapped, WebContentFormat fmt)
|
|
{
|
|
// FIXME: handle ref/out parameters
|
|
|
|
var reader = message.GetReaderAtBodyContents ();
|
|
reader.MoveToContent ();
|
|
|
|
bool wasEmptyElement = reader.IsEmptyElement;
|
|
|
|
if (isWrapped) {
|
|
if (fmt == WebContentFormat.Json)
|
|
reader.ReadStartElement ("root", String.Empty); // note that the wrapper name is passed to the serializer.
|
|
else
|
|
reader.ReadStartElement (md.Body.WrapperName, md.Body.WrapperNamespace);
|
|
}
|
|
|
|
var ret = (serializer == null) ? null : ReadObjectBody (serializer, reader);
|
|
|
|
if (isWrapped && !wasEmptyElement)
|
|
reader.ReadEndElement ();
|
|
|
|
return ret;
|
|
}
|
|
|
|
protected object ReadObjectBody (XmlObjectSerializer serializer, XmlReader reader)
|
|
{
|
|
#if MOBILE
|
|
return (serializer is DataContractJsonSerializer) ?
|
|
((DataContractJsonSerializer) serializer).ReadObject (reader) :
|
|
((DataContractSerializer) serializer).ReadObject (reader, true);
|
|
#else
|
|
return serializer.ReadObject (reader, true);
|
|
#endif
|
|
}
|
|
|
|
internal class RequestClientFormatter : WebClientMessageFormatter
|
|
{
|
|
public RequestClientFormatter (OperationDescription operation, ServiceEndpoint endpoint, QueryStringConverter converter, WebHttpBehavior behavior)
|
|
: base (operation, endpoint, converter, behavior)
|
|
{
|
|
}
|
|
|
|
public override object DeserializeReply (Message message, object [] parameters)
|
|
{
|
|
throw new NotSupportedException ();
|
|
}
|
|
}
|
|
|
|
internal class ReplyClientFormatter : WebClientMessageFormatter
|
|
{
|
|
public ReplyClientFormatter (OperationDescription operation, ServiceEndpoint endpoint, QueryStringConverter converter, WebHttpBehavior behavior)
|
|
: base (operation, endpoint, converter, behavior)
|
|
{
|
|
}
|
|
|
|
public override Message SerializeRequest (MessageVersion messageVersion, object [] parameters)
|
|
{
|
|
throw new NotSupportedException ();
|
|
}
|
|
}
|
|
|
|
#if !MOBILE
|
|
internal class RequestDispatchFormatter : WebDispatchMessageFormatter
|
|
{
|
|
public RequestDispatchFormatter (OperationDescription operation, ServiceEndpoint endpoint, QueryStringConverter converter, WebHttpBehavior behavior)
|
|
: base (operation, endpoint, converter, behavior)
|
|
{
|
|
}
|
|
|
|
public override Message SerializeReply (MessageVersion messageVersion, object [] parameters, object result)
|
|
{
|
|
throw new NotSupportedException ();
|
|
}
|
|
}
|
|
|
|
internal class ReplyDispatchFormatter : WebDispatchMessageFormatter
|
|
{
|
|
public ReplyDispatchFormatter (OperationDescription operation, ServiceEndpoint endpoint, QueryStringConverter converter, WebHttpBehavior behavior)
|
|
: base (operation, endpoint, converter, behavior)
|
|
{
|
|
}
|
|
|
|
public override void DeserializeRequest (Message message, object [] parameters)
|
|
{
|
|
throw new NotSupportedException ();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
internal abstract class WebClientMessageFormatter : WebMessageFormatter, IClientMessageFormatter
|
|
{
|
|
IClientMessageFormatter default_formatter;
|
|
|
|
protected WebClientMessageFormatter (OperationDescription operation, ServiceEndpoint endpoint, QueryStringConverter converter, WebHttpBehavior behavior)
|
|
: base (operation, endpoint, converter, behavior)
|
|
{
|
|
}
|
|
|
|
public virtual Message SerializeRequest (MessageVersion messageVersion, object [] parameters)
|
|
{
|
|
if (parameters == null)
|
|
throw new ArgumentNullException ("parameters");
|
|
CheckMessageVersion (messageVersion);
|
|
|
|
var c = new Dictionary<string,string> ();
|
|
|
|
MessageDescription md = GetMessageDescription (MessageDirection.Input);
|
|
|
|
Message ret;
|
|
Uri to;
|
|
object msgpart = null;
|
|
|
|
|
|
for (int i = 0; i < parameters.Length; i++) {
|
|
var p = md.Body.Parts [i];
|
|
string name = p.Name.ToUpper (CultureInfo.InvariantCulture);
|
|
if (UriTemplate.PathSegmentVariableNames.Contains (name) ||
|
|
UriTemplate.QueryValueVariableNames.Contains (name))
|
|
c.Add (name, parameters [i] != null ? Converter.ConvertValueToString (parameters [i], parameters [i].GetType ()) : null);
|
|
else {
|
|
// FIXME: bind as a message part
|
|
if (msgpart == null)
|
|
msgpart = parameters [i];
|
|
else
|
|
throw new NotImplementedException (String.Format ("More than one parameters including {0} that are not contained in the URI template {1} was found.", p.Name, UriTemplate));
|
|
}
|
|
}
|
|
ret = Message.CreateMessage (messageVersion, (string) null, msgpart);
|
|
|
|
to = UriTemplate.BindByName (Endpoint.Address.Uri, c);
|
|
ret.Headers.To = to;
|
|
|
|
var hp = new HttpRequestMessageProperty ();
|
|
hp.Method = Info.Method;
|
|
|
|
WebMessageFormat msgfmt = Info.IsResponseFormatSetExplicitly ? Info.ResponseFormat : Behavior.DefaultOutgoingResponseFormat;
|
|
var contentFormat = ToContentFormat (msgfmt, msgpart);
|
|
string mediaType = GetMediaTypeString (contentFormat);
|
|
// FIXME: get encoding from somewhere
|
|
hp.Headers ["Content-Type"] = mediaType + "; charset=utf-8";
|
|
|
|
#if !MOBILE
|
|
if (WebOperationContext.Current != null)
|
|
WebOperationContext.Current.OutgoingRequest.Apply (hp);
|
|
#endif
|
|
// FIXME: set hp.SuppressEntityBody for some cases.
|
|
ret.Properties.Add (HttpRequestMessageProperty.Name, hp);
|
|
|
|
var wp = new WebBodyFormatMessageProperty (ToContentFormat (Info.IsRequestFormatSetExplicitly ? Info.RequestFormat : Behavior.DefaultOutgoingRequestFormat, null));
|
|
ret.Properties.Add (WebBodyFormatMessageProperty.Name, wp);
|
|
|
|
return ret;
|
|
}
|
|
|
|
public virtual object DeserializeReply (Message message, object [] parameters)
|
|
{
|
|
if (parameters == null)
|
|
throw new ArgumentNullException ("parameters");
|
|
CheckMessageVersion (message.Version);
|
|
|
|
#if !MOBILE
|
|
if (OperationContext.Current != null) {
|
|
// Set response in the context
|
|
OperationContext.Current.IncomingMessage = message;
|
|
}
|
|
#endif
|
|
|
|
if (message.IsEmpty)
|
|
return null; // empty message, could be returned by HttpReplyChannel.
|
|
|
|
string pname = WebBodyFormatMessageProperty.Name;
|
|
if (!message.Properties.ContainsKey (pname))
|
|
throw new SystemException ("INTERNAL ERROR: it expects WebBodyFormatMessageProperty existence");
|
|
var wp = (WebBodyFormatMessageProperty) message.Properties [pname];
|
|
var fmt = wp != null ? wp.Format : WebContentFormat.Xml;
|
|
|
|
var md = GetMessageDescription (MessageDirection.Output);
|
|
var serializer = GetSerializer (wp.Format, IsResponseBodyWrapped, md.Body.ReturnValue);
|
|
var ret = DeserializeObject (serializer, message, md, IsResponseBodyWrapped, fmt);
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
internal class WrappedBodyWriter : BodyWriter
|
|
{
|
|
public WrappedBodyWriter (object value, XmlObjectSerializer serializer, string name, string ns, WebContentFormat fmt)
|
|
: base (true)
|
|
{
|
|
this.name = name;
|
|
this.ns = ns;
|
|
this.value = value;
|
|
this.serializer = serializer;
|
|
this.fmt = fmt;
|
|
}
|
|
|
|
WebContentFormat fmt;
|
|
string name, ns;
|
|
object value;
|
|
XmlObjectSerializer serializer;
|
|
|
|
#if !MOBILE
|
|
protected override BodyWriter OnCreateBufferedCopy (int maxBufferSize)
|
|
{
|
|
return new WrappedBodyWriter (value, serializer, name, ns, fmt);
|
|
}
|
|
#endif
|
|
|
|
protected override void OnWriteBodyContents (XmlDictionaryWriter writer)
|
|
{
|
|
switch (fmt) {
|
|
case WebContentFormat.Raw:
|
|
WriteRawContents (writer);
|
|
break;
|
|
case WebContentFormat.Json:
|
|
WriteJsonBodyContents (writer);
|
|
break;
|
|
case WebContentFormat.Xml:
|
|
WriteXmlBodyContents (writer);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void WriteRawContents (XmlDictionaryWriter writer)
|
|
{
|
|
throw new NotSupportedException ("Some unsupported sequence of writing operation occured. It is likely a missing feature.");
|
|
}
|
|
|
|
void WriteJsonBodyContents (XmlDictionaryWriter writer)
|
|
{
|
|
if (name != null) {
|
|
writer.WriteStartElement ("root");
|
|
writer.WriteAttributeString ("type", "object");
|
|
}
|
|
WriteObject (serializer, writer, value);
|
|
if (name != null)
|
|
writer.WriteEndElement ();
|
|
}
|
|
|
|
void WriteXmlBodyContents (XmlDictionaryWriter writer)
|
|
{
|
|
if (name != null)
|
|
writer.WriteStartElement (name, ns);
|
|
WriteObject (serializer, writer, value);
|
|
if (name != null)
|
|
writer.WriteEndElement ();
|
|
}
|
|
|
|
void WriteObject (XmlObjectSerializer serializer, XmlDictionaryWriter writer, object value)
|
|
{
|
|
if (serializer != null){
|
|
#if MOBILE
|
|
if (serializer is DataContractJsonSerializer)
|
|
((DataContractJsonSerializer) serializer).WriteObject (writer, value);
|
|
else
|
|
((DataContractSerializer) serializer).WriteObject (writer, value);
|
|
#else
|
|
serializer.WriteObject (writer, value);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
#if !MOBILE
|
|
internal abstract class WebDispatchMessageFormatter : WebMessageFormatter, IDispatchMessageFormatter
|
|
{
|
|
protected WebDispatchMessageFormatter (OperationDescription operation, ServiceEndpoint endpoint, QueryStringConverter converter, WebHttpBehavior behavior)
|
|
: base (operation, endpoint, converter, behavior)
|
|
{
|
|
}
|
|
|
|
public virtual Message SerializeReply (MessageVersion messageVersion, object [] parameters, object result)
|
|
{
|
|
try {
|
|
return SerializeReplyCore (messageVersion, parameters, result);
|
|
} finally {
|
|
if (WebOperationContext.Current != null)
|
|
OperationContext.Current.Extensions.Remove (WebOperationContext.Current);
|
|
}
|
|
}
|
|
|
|
Message SerializeReplyCore (MessageVersion messageVersion, object [] parameters, object result)
|
|
{
|
|
// parameters could be null.
|
|
// result could be null. For Raw output, it becomes no output.
|
|
|
|
CheckMessageVersion (messageVersion);
|
|
|
|
MessageDescription md = GetMessageDescription (MessageDirection.Output);
|
|
|
|
// FIXME: use them.
|
|
// var dcob = Operation.Behaviors.Find<DataContractSerializerOperationBehavior> ();
|
|
// XmlObjectSerializer xos = dcob.CreateSerializer (result.GetType (), md.Body.WrapperName, md.Body.WrapperNamespace, null);
|
|
// var xsob = Operation.Behaviors.Find<XmlSerializerOperationBehavior> ();
|
|
// XmlSerializer [] serializers = XmlSerializer.FromMappings (xsob.GetXmlMappings ().ToArray ());
|
|
|
|
WebMessageFormat msgfmt = Info.IsResponseFormatSetExplicitly ? Info.ResponseFormat : Behavior.DefaultOutgoingResponseFormat;
|
|
|
|
XmlObjectSerializer serializer = null;
|
|
|
|
// FIXME: serialize ref/out parameters as well.
|
|
|
|
string name = null, ns = null;
|
|
|
|
switch (msgfmt) {
|
|
case WebMessageFormat.Xml:
|
|
serializer = GetSerializer (WebContentFormat.Xml, IsResponseBodyWrapped, md.Body.ReturnValue);
|
|
name = IsResponseBodyWrapped ? md.Body.WrapperName : null;
|
|
ns = IsResponseBodyWrapped ? md.Body.WrapperNamespace : null;
|
|
break;
|
|
case WebMessageFormat.Json:
|
|
serializer = GetSerializer (WebContentFormat.Json, IsResponseBodyWrapped, md.Body.ReturnValue);
|
|
name = IsResponseBodyWrapped ? (BodyName ?? md.Body.ReturnValue.Name) : null;
|
|
ns = String.Empty;
|
|
break;
|
|
}
|
|
|
|
var contentFormat = ToContentFormat (msgfmt, result);
|
|
string mediaType = GetMediaTypeString (contentFormat);
|
|
Message ret = contentFormat == WebContentFormat.Raw ? new RawMessage ((Stream) result) : Message.CreateMessage (MessageVersion.None, null, new WrappedBodyWriter (result, serializer, name, ns, contentFormat));
|
|
|
|
// Message properties
|
|
|
|
var hp = new HttpResponseMessageProperty ();
|
|
// FIXME: get encoding from somewhere
|
|
hp.Headers ["Content-Type"] = mediaType + "; charset=utf-8";
|
|
|
|
// apply user-customized HTTP results via WebOperationContext.
|
|
if (WebOperationContext.Current != null) // this formatter must be available outside ServiceHost.
|
|
WebOperationContext.Current.OutgoingResponse.Apply (hp);
|
|
|
|
// FIXME: fill some properties if required.
|
|
ret.Properties.Add (HttpResponseMessageProperty.Name, hp);
|
|
|
|
var wp = new WebBodyFormatMessageProperty (contentFormat);
|
|
ret.Properties.Add (WebBodyFormatMessageProperty.Name, wp);
|
|
|
|
return ret;
|
|
}
|
|
|
|
public virtual void DeserializeRequest (Message message, object [] parameters)
|
|
{
|
|
if (parameters == null)
|
|
throw new ArgumentNullException ("parameters");
|
|
CheckMessageVersion (message.Version);
|
|
|
|
IncomingWebRequestContext iwc = null;
|
|
if (OperationContext.Current != null) {
|
|
OperationContext.Current.Extensions.Add (new WebOperationContext (OperationContext.Current));
|
|
iwc = WebOperationContext.Current.IncomingRequest;
|
|
}
|
|
|
|
var wp = message.Properties [WebBodyFormatMessageProperty.Name] as WebBodyFormatMessageProperty;
|
|
var fmt = wp != null ? wp.Format : WebContentFormat.Xml;
|
|
|
|
Uri to = message.Headers.To;
|
|
UriTemplateMatch match = to == null ? null : UriTemplate.Match (Endpoint.Address.Uri, to);
|
|
if (match != null && iwc != null)
|
|
iwc.UriTemplateMatch = match;
|
|
|
|
MessageDescription md = GetMessageDescription (MessageDirection.Input);
|
|
|
|
for (int i = 0; i < parameters.Length; i++) {
|
|
var p = md.Body.Parts [i];
|
|
string name = p.Name.ToUpperInvariant ();
|
|
if (fmt == WebContentFormat.Raw && p.Type == typeof (Stream)) {
|
|
var rmsg = (RawMessage) message;
|
|
parameters [i] = rmsg.Stream;
|
|
} else {
|
|
var str = match.BoundVariables [name];
|
|
if (str != null)
|
|
parameters [i] = Converter.ConvertStringToValue (str, p.Type);
|
|
else {
|
|
if (info.Method != "GET") {
|
|
var serializer = GetSerializer (fmt, IsRequestBodyWrapped, p);
|
|
parameters [i] = DeserializeObject (serializer, message, md, IsRequestBodyWrapped, fmt);
|
|
}
|
|
// for GET Uri template parameters, there is no <anyType xsi:nil='true' />. So just skip the member.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
internal class RawMessage : Message
|
|
{
|
|
public RawMessage (Stream stream)
|
|
{
|
|
this.Stream = stream;
|
|
headers = new MessageHeaders (MessageVersion.None);
|
|
properties = new MessageProperties ();
|
|
}
|
|
|
|
public override MessageVersion Version {
|
|
get { return MessageVersion.None; }
|
|
}
|
|
|
|
MessageHeaders headers;
|
|
|
|
public override MessageHeaders Headers {
|
|
get { return headers; }
|
|
}
|
|
|
|
MessageProperties properties;
|
|
|
|
public override MessageProperties Properties {
|
|
get { return properties; }
|
|
}
|
|
|
|
public Stream Stream { get; private set; }
|
|
|
|
protected override void OnWriteBodyContents (XmlDictionaryWriter writer)
|
|
{
|
|
writer.WriteString ("-- message body is raw binary --");
|
|
}
|
|
|
|
protected override MessageBuffer OnCreateBufferedCopy (int maxBufferSize)
|
|
{
|
|
var ms = Stream as MemoryStream;
|
|
if (ms == null) {
|
|
ms = new MemoryStream ();
|
|
Stream.CopyTo (ms);
|
|
this.Stream = ms;
|
|
}
|
|
return new RawMessageBuffer (ms.ToArray (), headers, properties);
|
|
}
|
|
}
|
|
|
|
internal class RawMessageBuffer : MessageBuffer
|
|
{
|
|
byte [] buffer;
|
|
MessageHeaders headers;
|
|
MessageProperties properties;
|
|
|
|
public RawMessageBuffer (byte [] buffer, MessageHeaders headers, MessageProperties properties)
|
|
{
|
|
this.buffer = buffer;
|
|
this.headers = new MessageHeaders (headers);
|
|
this.properties = new MessageProperties (properties);
|
|
}
|
|
|
|
public override int BufferSize {
|
|
get { return buffer.Length; }
|
|
}
|
|
|
|
public override void Close ()
|
|
{
|
|
}
|
|
|
|
public override Message CreateMessage ()
|
|
{
|
|
var msg = new RawMessage (new MemoryStream (buffer));
|
|
msg.Headers.CopyHeadersFrom (headers);
|
|
msg.Properties.CopyProperties (properties);
|
|
return msg;
|
|
}
|
|
}
|
|
}
|
|
}
|