internal static bool IsDefined(WebContentFormat format) { return(format == WebContentFormat.Default || format == WebContentFormat.Xml || format == WebContentFormat.Json || format == WebContentFormat.Raw); }
internal static bool IsDefined(WebContentFormat format) { return (format == WebContentFormat.Default || format == WebContentFormat.Xml || format == WebContentFormat.Json || format == WebContentFormat.Raw); }
public void PutShouldRespectIfMatch(WebContentFormat format, string serviceUri = null) { // Arrange int resourceKey = 1; var testHelper = new HttpTestHelper <int, Resource>(serviceUri ?? ServiceUri); // Act var resultGet = testHelper.GetResource(resourceKey, requestUri: ServiceUri); Assert.AreEqual(HttpStatusCode.OK, resultGet.Status); var putResource = resultGet.Resource; putResource.Data = "modified"; // Put without an entity tag var resultPut1 = testHelper.PutResource(resourceKey, putResource, format: format); // Put with an entity tag var resultPut2 = testHelper.PutResource(resourceKey, putResource, new EntityTag(putResource.Version.ToString()), format: format); // Assert Assert.AreEqual(HttpStatusCode.OK, resultPut1.Status); Assert.AreEqual(HttpStatusCode.PreconditionFailed, resultPut2.Status); }
private void PutShouldBeIdempotent(WebContentFormat format, string serviceUri = null) { // Arrange int resourceKey = 1; var testHelper = new HttpTestHelper <int, Resource>(serviceUri ?? ServiceUri); // Act var resultGet = testHelper.GetResource(resourceKey, requestUri: ServiceUri); Assert.AreEqual(HttpStatusCode.OK, resultGet.Status); var putResource = resultGet.Resource; putResource.Data = "modified"; // Put without an entity tag var resultPut1 = testHelper.PutResource(resourceKey, putResource); // Put without an entity tag var resultPut2 = testHelper.PutResource(resourceKey, putResource); // Assert Assert.AreEqual(HttpStatusCode.OK, resultPut1.Status); Assert.AreEqual(HttpStatusCode.OK, resultPut2.Status); }
public void POST_MUST_append_a_valid_resource_to_the_resource_collection(WebContentFormat format) { // Arrange string expectedData = "Post Data"; var expectedResource = new Resource() { Data = expectedData }; var testHelper = new HttpTestHelper <int, Resource>(ServiceUri); // Act var result = testHelper.Post(expectedResource, format); // Assert Assert.AreEqual(HttpStatusCode.Created, result.Status); // Check entity Assert.AreEqual(expectedData, result.Resource.Data); // Check headers Assert.IsNotNull(result.ResponseHeaders.ETag, "Null etag"); Assert.IsNotNull(result.ResponseHeaders.Location, "Null location"); // Check server generated key and location header Assert.AreEqual(result.Resource.Key, int.Parse(result.LocationKey), "Location header key should match entity key"); Assert.IsTrue(result.Resource.Key > 5, "Server generated key should be > 5 on test data set"); }
public override Message ReadMessage(Stream stream, int maxSizeOfHeaders, string contentType) { if (stream == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("stream")); } WebContentFormat format = GetFormatForContentType(contentType); Message message; switch (format) { case WebContentFormat.Json: message = JsonMessageEncoder.ReadMessage(stream, maxSizeOfHeaders, contentType); message.Properties.Add(WebBodyFormatMessageProperty.Name, WebBodyFormatMessageProperty.JsonProperty); break; case WebContentFormat.Xml: message = TextMessageEncoder.ReadMessage(stream, maxSizeOfHeaders, contentType); message.Properties.Add(WebBodyFormatMessageProperty.Name, WebBodyFormatMessageProperty.XmlProperty); break; case WebContentFormat.Raw: message = RawMessageEncoder.ReadMessage(stream, maxSizeOfHeaders, contentType); message.Properties.Add(WebBodyFormatMessageProperty.Name, WebBodyFormatMessageProperty.RawProperty); break; default: throw Fx.AssertAndThrow("This should never get hit because GetFormatForContentType shouldn't return a WebContentFormat other than Json, Xml, and Raw"); } return(message); }
bool TryGetContentTypeMapping(string contentType, out WebContentFormat format) { if (contentTypeMapper == null) { format = WebContentFormat.Default; return(false); } try { format = contentTypeMapper.GetMessageFormatForContentType(contentType); if (!WebContentFormatHelper.IsDefined(format)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR2.GetString(SR2.UnknownWebEncodingFormat, contentType, format))); } return(true); } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException( SR2.GetString(SR2.ErrorEncounteredInContentTypeMapper), e)); } }
protected XmlObjectSerializer GetSerializer(WebContentFormat msgfmt) { switch (msgfmt) { case WebContentFormat.Xml: if (IsResponseBodyWrapped) { return(GetSerializer(ref xml_serializer, p => new DataContractSerializer(p.Type, p.Name, p.Namespace))); } else { return(GetSerializer(ref xml_serializer, p => new DataContractSerializer(p.Type))); } break; case WebContentFormat.Json: // FIXME: after name argument they are hack #if !NET_2_1 || MONOTOUCH if (IsResponseBodyWrapped) { return(GetSerializer(ref json_serializer, p => new DataContractJsonSerializer(p.Type, BodyName ?? p.Name, null, 0x100000, false, null, true))); } else #endif return(GetSerializer(ref json_serializer, p => new DataContractJsonSerializer(p.Type))); break; default: throw new NotImplementedException(); } }
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) #if MOONLIGHT { json_serializer = new DataContractJsonSerializer(part.Type); } #else { json_serializer = isWrapped ? new DataContractJsonSerializer(part.Type, BodyName ?? part.Name, null, 0x100000, false, null, true) : new DataContractJsonSerializer(part.Type); } #endif return(json_serializer); default: throw new NotImplementedException(msgfmt.ToString()); } }
public WebBodyFormatMessageProperty(WebContentFormat format) { if (format == WebContentFormat.Default) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR2.GetString(SR2.DefaultContentFormatNotAllowedInProperty))); } this.format = format; }
public static void SetWebContentFormatProperty(this Message message, WebContentFormat format) { if (message.Properties.ContainsKey(WebBodyFormatMessageProperty.Name)) message.Properties.Remove(WebBodyFormatMessageProperty.Name); message.Properties.Add(WebBodyFormatMessageProperty.Name, new WebBodyFormatMessageProperty(format)); }
public ResourceResult <TResource> Post(TResource resource, WebContentFormat format = WebContentFormat.Xml) { return(SendRequest( "POST", new Uri(ServiceUri), format, resource)); }
public static string MessageToString(ref Message message) { WebContentFormat messageFormat = message.GetContentFormat(); MemoryStream ms = new MemoryStream(); XmlDictionaryWriter writer = null; switch (messageFormat) { case WebContentFormat.Default: case WebContentFormat.Xml: writer = XmlDictionaryWriter.CreateTextWriter(ms); break; case WebContentFormat.Json: writer = JsonReaderWriterFactory.CreateJsonWriter(ms); break; case WebContentFormat.Raw: return(ReadRawBody(ref message)); } message.WriteMessage(writer); writer.Flush(); string messageBody = Encoding.UTF8.GetString(ms.ToArray()); // The messageBody can be modified here... // Then recreate the message... ms.Position = 0; // if the message body was modified, needs to reencode it, as show below // ms = new MemoryStream(Encoding.UTF8.GetBytes(messageBody)); XmlDictionaryReader reader; if (messageFormat == WebContentFormat.Json) { reader = JsonReaderWriterFactory.CreateJsonReader(ms, XmlDictionaryReaderQuotas.Max); } else { reader = XmlDictionaryReader.CreateTextReader(ms, XmlDictionaryReaderQuotas.Max); } var newMessage = Message.CreateMessage(reader, int.MaxValue, message.Version); newMessage.Properties.CopyProperties(message.Properties); message = newMessage; return(messageBody); }
public static void SetWebContentFormatProperty(this Message message, WebContentFormat format) { if (message.Properties.ContainsKey(WebBodyFormatMessageProperty.Name)) { message.Properties.Remove(WebBodyFormatMessageProperty.Name); } message.Properties.Add(WebBodyFormatMessageProperty.Name, new WebBodyFormatMessageProperty(format)); }
/// <summary> /// Gets the format used for the message body. /// </summary> /// /// <param name="message"> /// The message. /// </param> /// /// <returns> /// The System.ServiceModel.Channels.WebContentFormat that specifies the format used for the message body. /// </returns> public static WebContentFormat GetContentFormat(this Message message) { WebContentFormat format = WebContentFormat.Default; if (message.Properties.ContainsKey(WebBodyFormatMessageProperty.Name)) { format = ((WebBodyFormatMessageProperty)message.Properties[WebBodyFormatMessageProperty.Name]).Format; } return(format); }
public WebHttpErrorHandler(WebMessageFormat format) { if (format == WebMessageFormat.Json) { this.format = WebContentFormat.Json; } else { this.format = WebContentFormat.Xml; } }
/// <summary> /// Get the message's classified format /// </summary> private WebContentFormat GetContentFormat(Message message) { WebContentFormat retVal = WebContentFormat.Default; if (message.Properties.ContainsKey(WebBodyFormatMessageProperty.Name)) { WebBodyFormatMessageProperty propertyValue = message.Properties[WebBodyFormatMessageProperty.Name] as WebBodyFormatMessageProperty; retVal = propertyValue.Format; } return(retVal); }
private WebContentFormat GetMessageContentFormat(Message message) { WebContentFormat format = WebContentFormat.Default; if (message.Properties.ContainsKey(WebBodyFormatMessageProperty.Name)) { WebBodyFormatMessageProperty bodyFormat = (WebBodyFormatMessageProperty)message.Properties[WebBodyFormatMessageProperty.Name]; format = bodyFormat.Format; } return(format); }
public static string MessageToString(ref Message message) { WebContentFormat messageFormat = GetMessageContentFormat(message); MemoryStream ms = new MemoryStream(); XmlDictionaryWriter writer = null; switch (messageFormat) { case WebContentFormat.Default: case WebContentFormat.Xml: writer = XmlDictionaryWriter.CreateTextWriter(ms); break; case WebContentFormat.Json: writer = System.Runtime.Serialization.Json.JsonReaderWriterFactory.CreateJsonWriter(ms); break; case WebContentFormat.Raw: // special case for raw, easier implemented separately return(ReadRawBody(ref message)); } message.WriteMessage(writer); writer.Flush(); string messageBody = System.Text.Encoding.UTF8.GetString(ms.ToArray()); // Here would be a good place to change the message body, if so desired. // now that the message was read, it needs to be recreated. ms.Position = 0; // if the message body was modified, needs to reencode it, as show below //ms = new MemoryStream(Encoding.UTF8.GetBytes(messageBody)); XmlDictionaryReader reader; if (messageFormat == WebContentFormat.Json) { reader = System.Runtime.Serialization.Json.JsonReaderWriterFactory.CreateJsonReader(ms, XmlDictionaryReaderQuotas.Max); } else { reader = XmlDictionaryReader.CreateTextReader(ms, XmlDictionaryReaderQuotas.Max); } Message newMessage = Message.CreateMessage(reader, int.MaxValue, message.Version); newMessage.Properties.CopyProperties(message.Properties); message = newMessage; return(messageBody); }
public override ArraySegment <byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset) { if (message == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("message")); } if (bufferManager == null) { throw TraceUtility.ThrowHelperError(new ArgumentNullException("bufferManager"), message); } if (maxMessageSize < 0) { throw TraceUtility.ThrowHelperError(new ArgumentOutOfRangeException("maxMessageSize", maxMessageSize, SR2.GetString(SR2.ValueMustBeNonNegative)), message); } if (messageOffset < 0 || messageOffset > maxMessageSize) { throw TraceUtility.ThrowHelperError(new ArgumentOutOfRangeException("messageOffset", messageOffset, SR2.GetString(SR2.JsonValueMustBeInRange, 0, maxMessageSize)), message); } ThrowIfMismatchedMessageVersion(message); WebContentFormat messageFormat = ExtractFormatFromMessage(message); JavascriptCallbackResponseMessageProperty javascriptResponseMessageProperty; switch (messageFormat) { case WebContentFormat.Json: return(JsonMessageEncoder.WriteMessage(message, maxMessageSize, bufferManager, messageOffset)); case WebContentFormat.Xml: if (message.Properties.TryGetValue <JavascriptCallbackResponseMessageProperty>(JavascriptCallbackResponseMessageProperty.Name, out javascriptResponseMessageProperty) && javascriptResponseMessageProperty != null && !String.IsNullOrEmpty(javascriptResponseMessageProperty.CallbackFunctionName)) { throw TraceUtility.ThrowHelperError(new InvalidOperationException(SR2.JavascriptCallbackNotsupported), message); } return(TextMessageEncoder.WriteMessage(message, maxMessageSize, bufferManager, messageOffset)); case WebContentFormat.Raw: if (message.Properties.TryGetValue <JavascriptCallbackResponseMessageProperty>(JavascriptCallbackResponseMessageProperty.Name, out javascriptResponseMessageProperty) && javascriptResponseMessageProperty != null && !String.IsNullOrEmpty(javascriptResponseMessageProperty.CallbackFunctionName)) { throw TraceUtility.ThrowHelperError(new InvalidOperationException(SR2.JavascriptCallbackNotsupported), message); } return(RawMessageEncoder.WriteMessage(message, maxMessageSize, bufferManager, messageOffset)); default: throw Fx.AssertAndThrow("This should never get hit because GetFormatForContentType shouldn't return a WebContentFormat other than Json, Xml, and Raw"); } }
private string MessageToString(ref Message message, bool isReturn, ref ReturnMessage <object> returnMessage) { WebContentFormat messageFormat = this.GetMessageContentFormat(message); MemoryStream ms = new MemoryStream(); XmlDictionaryWriter writer = null; switch (messageFormat) { case WebContentFormat.Default: case WebContentFormat.Xml: writer = XmlDictionaryWriter.CreateTextWriter(ms); break; case WebContentFormat.Json: writer = JsonReaderWriterFactory.CreateJsonWriter(ms); break; case WebContentFormat.Raw: // special case for raw, easier implemented separately return(this.ReadRawBody(ref message, isReturn, ref returnMessage)); } message.WriteMessage(writer); writer.Flush(); if (isReturn) { StreamReader sr = new StreamReader(ms); JsonSerializer serializer = JsonHelper.GetDefaultJsonSerializer(); object obj = serializer.Deserialize(sr, typeof(ReturnMessage <object>)); returnMessage = obj as ReturnMessage <object>; } string messageBody = Encoding.UTF8.GetString(ms.ToArray()); if (string.IsNullOrEmpty(messageBody)) { return(messageBody); } // Here would be a good place to change the message body, if so desired. // now that the message was read, it needs to be recreated. ms.Position = 0; // if the message body was modified, needs to reencode it, as show below // ms = new MemoryStream(Encoding.UTF8.GetBytes(messageBody)); XmlDictionaryReader reader; reader = messageFormat == WebContentFormat.Json ? JsonReaderWriterFactory.CreateJsonReader(ms, XmlDictionaryReaderQuotas.Max) : XmlDictionaryReader.CreateTextReader(ms, XmlDictionaryReaderQuotas.Max); Message newMessage = Message.CreateMessage(reader, int.MaxValue, message.Version); newMessage.Properties.CopyProperties(message.Properties); message = newMessage; return(messageBody); }
internal static bool TryGetEncodingFormat(Message message, out WebContentFormat format) { object prop; message.Properties.TryGetValue(WebBodyFormatMessageProperty.Name, out prop); WebBodyFormatMessageProperty formatProperty = prop as WebBodyFormatMessageProperty; if (formatProperty == null) { format = WebContentFormat.Default; return false; } format = formatProperty.Format; return true; }
private StringWithOptionalQuality WebContentFormatString(WebContentFormat format) { switch (format) { case WebContentFormat.Xml: return("application/xml"); case WebContentFormat.Json: return("application/json"); default: throw new ArgumentException(string.Format("Invalid content type for accept header: {0}", format)); } }
private void ReadContent( ResourceResult <TResource> result, HttpResponseMessage response, WebContentFormat format = WebContentFormat.Xml) { if (ReadResourceContent == null) { result.ResponseContent = response.Content.ReadAsString(); } else { result.Resource = ReadResourceContent(response.Content, format); } }
public TResource ReadResourceAsDataContract(HttpContent content, WebContentFormat format = WebContentFormat.Xml) { switch (format) { case WebContentFormat.Xml: return(content.ReadAsDataContract <TResource>()); case WebContentFormat.Json: return(content.ReadAsJsonDataContract <TResource>()); default: throw new NotImplementedException("Unsupported WebContentFormat"); } }
public HttpContent CreateResourceDataContract(TResource resource, WebContentFormat format = WebContentFormat.Xml) { switch (format) { case WebContentFormat.Xml: return(HttpContentExtensions.CreateDataContract <TResource>(resource)); case WebContentFormat.Json: return(HttpContentExtensions.CreateJsonDataContract <TResource>(resource)); default: throw new NotImplementedException("Unsupported WebContentFormat"); } }
public void GET_With_Name_Should_Say_Hello(WebContentFormat format) { // Arrange var testHelper = new HttpTestHelper <int, string>(ServiceUri); string expectedName = "Test Name"; string expectedMessage = string.Format(HelloWorldMessageFormat, expectedName); string requestUri = string.Format(HelloWorldUriFormat, ServiceUri, expectedName); // Act var result = testHelper.SendRequest("GET", new Uri(requestUri), format); // Assert Assert.AreEqual(HttpStatusCode.OK, result.Status); Assert.AreEqual(expectedMessage, result.Resource); }
internal static bool TryGetEncodingFormat(Message message, out WebContentFormat format) { object prop; message.Properties.TryGetValue(WebBodyFormatMessageProperty.Name, out prop); WebBodyFormatMessageProperty formatProperty = prop as WebBodyFormatMessageProperty; if (formatProperty == null) { format = WebContentFormat.Default; return(false); } format = formatProperty.Format; return(true); }
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"); } }
public void GET_MUST_return_zero_or_more_resources_when_take_is_not_provided(WebContentFormat format) { // Arrange int expectedSkip = 5; var testHelper = new HttpTestHelper <int, Resource>(ServiceUri); // Act var result = testHelper.GetResourceSet(expectedSkip, format: format); // Assert Assert.AreEqual(HttpStatusCode.OK, result.Status); Assert.AreEqual(expectedSkip, result.ResourceSet.Skip); Assert.AreEqual(result.ResourceSet.Resources.Count(), result.ResourceSet.SetCount); Assert.IsTrue(result.ResourceSet.Resources.Count() > 0); }
public ResourceSetResult <TResource> GetResourceSet( int?skip = null, int?take = null, WebContentFormat format = WebContentFormat.Xml) { var result = new ResourceSetResult <TResource>(); using (HttpClient client = new HttpClient()) { Uri requestUri = CreateSkipTakeQueryString(skip, take); using (HttpRequestMessage request = new HttpRequestMessage("GET", requestUri)) { Debug.WriteLine("Sending GET to {0}", requestUri); request.Headers.Accept.Add(WebContentFormatString(format)); using (HttpResponseMessage response = client.Send(request)) { Debug.WriteLine("Response: {0} ({1})", (int)response.StatusCode, response.StatusCode); result.Status = response.StatusCode; result.ResponseHeaders = response.Headers; if (response.Content.HasLength() && response.Content.GetLength() > 0) { switch (result.Status) { case HttpStatusCode.OK: if (ReadResourceSetContent == null) { result.ResponseContent = response.Content.ReadAsString(); } else { result.ResourceSet = ReadResourceSetContent(response.Content, format); } break; case HttpStatusCode.BadRequest: result.ErrorMessage = response.Content.ReadAsDataContract <string>(); break; } } } } } return(result); }
public WriteMessageAsyncResult(Message message, Stream stream, WebMessageEncoder webMessageEncoder, AsyncCallback callback, object state) : base(callback, state) { this.message = message; this.stream = stream; this.webMessageEncoder = webMessageEncoder; WebContentFormat messageFormat = webMessageEncoder.ExtractFormatFromMessage(message); JavascriptCallbackResponseMessageProperty javascriptResponseMessageProperty; switch (messageFormat) { case WebContentFormat.Json: this.encoder = webMessageEncoder.JsonMessageEncoder; this.Schedule(); break; case WebContentFormat.Xml: if (message.Properties.TryGetValue <JavascriptCallbackResponseMessageProperty>(JavascriptCallbackResponseMessageProperty.Name, out javascriptResponseMessageProperty) && javascriptResponseMessageProperty != null && !String.IsNullOrEmpty(javascriptResponseMessageProperty.CallbackFunctionName)) { throw TraceUtility.ThrowHelperError(new InvalidOperationException(SR2.JavascriptCallbackNotsupported), message); } this.encoder = webMessageEncoder.TextMessageEncoder; this.Schedule(); break; case WebContentFormat.Raw: if (message.Properties.TryGetValue <JavascriptCallbackResponseMessageProperty>(JavascriptCallbackResponseMessageProperty.Name, out javascriptResponseMessageProperty) && javascriptResponseMessageProperty != null && !String.IsNullOrEmpty(javascriptResponseMessageProperty.CallbackFunctionName)) { throw TraceUtility.ThrowHelperError(new InvalidOperationException(SR2.JavascriptCallbackNotsupported), message); } handleEndWriteMessage = new AsyncCompletion(HandleEndWriteMessage); IAsyncResult result = webMessageEncoder.RawMessageEncoder.BeginWriteMessage(message, stream, PrepareAsyncCompletion(HandleEndWriteMessage), this); if (SyncContinue(result)) { this.Complete(true); } break; default: throw Fx.AssertAndThrow("This should never get hit because GetFormatForContentType shouldn't return a WebContentFormat other than Json, Xml, and Raw"); } }
public void POST_MUST_return_400_Bad_Request_if_the_entity_is_invalid(WebContentFormat format) { // Arrange string expectedData = string.Empty; var expectedResource = new Resource() { Data = expectedData }; var testHelper = new HttpTestHelper <int, Resource>(ServiceUri); // Act var result = testHelper.Post(expectedResource, format); // Assert Assert.AreEqual(HttpStatusCode.BadRequest, result.Status); }
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; }
protected XmlObjectSerializer GetSerializer (WebContentFormat msgfmt) { switch (msgfmt) { case WebContentFormat.Xml: if (IsResponseBodyWrapped) return GetSerializer (ref xml_serializer, p => new DataContractSerializer (p.Type, p.Name, p.Namespace)); else return GetSerializer (ref xml_serializer, p => new DataContractSerializer (p.Type)); case WebContentFormat.Json: // FIXME: after name argument they are hack #if !MOONLIGHT if (IsResponseBodyWrapped) return GetSerializer (ref json_serializer, p => new DataContractJsonSerializer (p.Type, BodyName ?? p.Name, null, 0x100000, false, null, true)); else #endif return GetSerializer (ref json_serializer, p => new DataContractJsonSerializer (p.Type)); default: throw new NotImplementedException (); } }
bool TryGetContentTypeMapping(string contentType, out WebContentFormat format) { if (contentTypeMapper == null) { format = WebContentFormat.Default; return false; } try { format = contentTypeMapper.GetMessageFormatForContentType(contentType); if (!WebContentFormatHelper.IsDefined(format)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR2.GetString(SR2.UnknownWebEncodingFormat, contentType, format))); } return true; } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException( SR2.GetString(SR2.ErrorEncounteredInContentTypeMapper), e)); } }
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 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 ()); } }
public WebBodyFormatMessageProperty (WebContentFormat format) { this.format = format; }
protected XmlObjectSerializer GetSerializer (WebContentFormat msgfmt, bool isWrapped, MessagePartDescription part) { 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) #if MOONLIGHT json_serializer = new DataContractJsonSerializer (part.Type); #else json_serializer = isWrapped ? new DataContractJsonSerializer (part.Type, BodyName ?? part.Name, null, 0x100000, false, null, true) : new DataContractJsonSerializer (part.Type); #endif return json_serializer; default: throw new NotImplementedException (); } }
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"; } }