public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { if (!DocumentUpgrader.Current.CanUpgradeType(type)) return base.ReadFromStreamAsync(type, readStream, content, formatterLogger); Task<object> task = Task<object>.Factory.StartNew(() => { using (var reader = new StreamReader(readStream)) { string json = reader.ReadToEnd(); try { if (Settings.Current.SaveIncomingErrorsToDisk) File.WriteAllText(String.Format("{0}\\{1}.json", Settings.Current.IncomingErrorPath, Guid.NewGuid().ToString("N")), json); } catch (Exception ex) { formatterLogger.LogError(String.Empty, ex); } try { JObject document = JObject.Parse(json); DocumentUpgrader.Current.Upgrade(document, type); return JsonConvert.DeserializeObject(document.ToString(), type); } catch (Exception ex) { ex.ToExceptionless().AddObject(json, "Error").Submit(); formatterLogger.LogError(String.Empty, ex); throw; } } }); return task; }
/// <summary> /// Asynchronously deserializes an object of the specified type. /// </summary> /// <param name="type">The type of the object to deserialize.</param> /// <param name="readStream">The <see cref="T:System.IO.Stream" /> to read.</param> /// <param name="content">The <see cref="T:System.Net.Http.HttpContent" />, if available. It may be null.</param> /// <param name="formatterLogger">The <see cref="T:System.Net.Http.Formatting.IFormatterLogger" /> to log events to.</param> /// <returns> /// A <see cref="T:System.Threading.Tasks.Task" /> whose result will be an object of the given type. /// </returns> public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger) { var tcs = new TaskCompletionSource<object>(); try { var reader = GetJsonReader(readStream); using (reader) { var jsonSerializerSettings = new JsonSerializerSettings(); jsonSerializerSettings.Converters.Add(new HyperNewtonsoftJsonConverter()); var jsonSerializer = JsonSerializer.Create(jsonSerializerSettings); var output = jsonSerializer.Deserialize(reader, type); if (formatterLogger != null) { jsonSerializer.Error += (sender, e) => { var exception = e.ErrorContext.Error; formatterLogger.LogError(e.ErrorContext.Path, exception.Message); e.ErrorContext.Handled = true; }; } tcs.SetResult(output); } } catch (Exception e) { if (formatterLogger == null) throw; formatterLogger.LogError(String.Empty, e.Message); tcs.SetResult(GetDefaultValueForType(type)); } return tcs.Task; }
public override object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { HttpContentHeaders contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == null) { return GetDefaultValueForType(type); } try { using (readStream) { using (var reader = XmlReader.Create(readStream)) { var formatter = new Atom10ItemFormatter(); formatter.ReadFrom(reader); var command = Activator.CreateInstance(type); ((IPublicationCommand)command).ReadSyndicationItem(formatter.Item); return command; } } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return GetDefaultValueForType(type); } }
private async Task<object> Deserialize(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { var headers = (content == null) ? null : content.Headers; if (headers != null && headers.ContentLength == 0L) { return MediaTypeFormatter.GetDefaultValueForType(type); } object result = null; try { result = DeserializeByJsonSerializer(type, readStream, headers); } catch (Exception exception) { if (formatterLogger != null) { formatterLogger.LogError(string.Empty, exception); } result = MediaTypeFormatter.GetDefaultValueForType(type); } return result; }
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger) { var taskCompletionSource = new TaskCompletionSource<object>(); try { BsonReader reader = new BsonReader(readStream); if (typeof(IEnumerable).IsAssignableFrom(type)) reader.ReadRootValueAsArray = true; using (reader) { var jsonSerializer = JsonSerializer.Create(_jsonSerializerSettings); var output = jsonSerializer.Deserialize(reader, type); if (formatterLogger != null) { jsonSerializer.Error += (sender, e) => { Exception exception = e.ErrorContext.Error; formatterLogger.LogError(e.ErrorContext.Path, exception.Message); e.ErrorContext.Handled = true; }; } taskCompletionSource.SetResult(output); } } catch (Exception ex) { if (formatterLogger == null) throw; formatterLogger.LogError(String.Empty, ex.Message); taskCompletionSource.SetResult(GetDefaultValueForType(type)); } return taskCompletionSource.Task; }
private object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { var root = GetRootFieldName(type); var contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) return GetDefaultValueForType(type); // Get the character encoding for the content var effectiveEncoding = SelectCharacterEncoding(contentHeaders); try { using (var reader = (new StreamReader(readStream, effectiveEncoding))) { var json = reader.ReadToEnd(); var serializer = new EmberJsonSerializer(); var deserialized = serializer.Deserialize(json, root); return deserialized.ToObject(type); } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return GetDefaultValueForType(type); } }
/// <summary> /// Read RDF/XML from an HTTP input stream and convert to .NET objects /// </summary> /// <param name="type"></param> /// <param name="readStream"></param> /// <param name="content"></param> /// <param name="formatterLogger"></param> /// <returns></returns> public override Task <object> ReadFromStreamAsync( Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger ) { var tcs = new TaskCompletionSource <object>(); if (content != null && content.Headers != null && content.Headers.ContentLength == 0) { return(null); } try { JsonObject jsonObject = (JsonObject)JsonObject.Load(readStream); Debug.WriteLine("JsonMediaTypeFormatter.ReadFromStreamAsync(): Loaded JSON: " + jsonObject); bool isSingleton = IsSinglton(type); object output = JsonHelper.FromJson(jsonObject, isSingleton ? type : GetMemberType(type)); if (isSingleton) { bool haveOne = (int)output.GetType().GetProperty("Count").GetValue(output, null) > 0; tcs.SetResult(haveOne ? output.GetType().GetProperty("Item").GetValue(output, new object[] { 0 }): null); } else if (type.IsArray) { tcs.SetResult(output.GetType().GetMethod("ToArray", Type.EmptyTypes).Invoke(output, null)); } else { tcs.SetResult(output); } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e.Message); tcs.SetResult(GetDefaultValueForType(type)); } return(tcs.Task); }
/// <summary> /// Called during deserialization to read an object of the specified <paramref name="type"/> /// from the specified <paramref name="stream"/>. /// </summary> /// <param name="type">The type of object to read.</param> /// <param name="stream">The <see cref="Stream"/> from which to read.</param> /// <param name="contentHeaders">The <see cref="HttpContentHeaders"/> for the content being read.</param> /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param> /// <returns>A <see cref="Task"/> whose result will be the object instance that has been read.</returns> public override Task <object> ReadFromStreamAsync(Type type, Stream stream, HttpContentHeaders contentHeaders, IFormatterLogger formatterLogger) { if (type == null) { throw new ArgumentNullException("type"); } if (stream == null) { throw new ArgumentNullException("stream"); } return(TaskHelpers.RunSynchronously <object>(() => { // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) { return GetDefaultValueForType(type); } // Get the character encoding for the content Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders); object serializer = GetSerializerForType(type); try { using (XmlReader reader = XmlDictionaryReader.CreateTextReader(new NonClosingDelegatingStream(stream), effectiveEncoding, _readerQuotas, null)) { XmlSerializer xmlSerializer = serializer as XmlSerializer; if (xmlSerializer != null) { return xmlSerializer.Deserialize(reader); } else { XmlObjectSerializer xmlObjectSerializer = (XmlObjectSerializer)serializer; return xmlObjectSerializer.ReadObject(reader); } } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e.Message); return GetDefaultValueForType(type); } })); }
/// <summary> /// Called during deserialization to read an object of the specified <paramref name="type"/> /// from the specified <paramref name="readStream"/>. /// </summary> /// <remarks> /// Public for delegating wrappers of this class. Expected to be called only from /// <see cref="ReadFromStreamAsync"/>. /// </remarks> /// <param name="type">The <see cref="Type"/> of object to read.</param> /// <param name="readStream">The <see cref="Stream"/> from which to read.</param> /// <param name="effectiveEncoding">The <see cref="Encoding"/> to use when reading.</param> /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param> /// <returns>The <see cref="object"/> instance that has been read.</returns> public virtual object ReadFromStream(Type type, Stream readStream, Encoding effectiveEncoding, IFormatterLogger formatterLogger) { if (type == null) { throw Error.ArgumentNull("type"); } if (readStream == null) { throw Error.ArgumentNull("readStream"); } if (effectiveEncoding == null) { throw Error.ArgumentNull("effectiveEncoding"); } using (JsonReader jsonReader = CreateJsonReaderInternal(type, readStream, effectiveEncoding)) { jsonReader.CloseInput = false; jsonReader.MaxDepth = _maxDepth; JsonSerializer jsonSerializer = CreateJsonSerializerInternal(); EventHandler <Newtonsoft.Json.Serialization.ErrorEventArgs> errorHandler = null; if (formatterLogger != null) { // Error must always be marked as handled // Failure to do so can cause the exception to be rethrown at every recursive level and overflow the stack for x64 CLR processes errorHandler = (sender, e) => { Exception exception = e.ErrorContext.Error; formatterLogger.LogError(e.ErrorContext.Path, exception); e.ErrorContext.Handled = true; }; jsonSerializer.Error += errorHandler; } try { return(jsonSerializer.Deserialize(jsonReader, type)); } finally { if (errorHandler != null) { // Clean up the error handler in case CreateJsonSerializer() reuses a serializer jsonSerializer.Error -= errorHandler; } } } }
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { HttpContentHeaders contentHeaders = content == null ? null : content.Headers; if (!DocumentUpgrader.Current.CanUpgradeType(type) || (contentHeaders != null && contentHeaders.ContentLength == 0)) return base.ReadFromStreamAsync(type, readStream, content, formatterLogger); Task<object> task = Task<object>.Factory.StartNew(() => { Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders); try { using (var reader = new StreamReader(readStream, effectiveEncoding)) { string json = reader.ReadToEnd(); try { if (Settings.Current.SaveIncomingErrorsToDisk) File.WriteAllText(String.Format("{0}\\{1}.json", Settings.Current.IncomingErrorPath, Guid.NewGuid().ToString("N")), json); } catch (Exception ex) { if (formatterLogger != null) formatterLogger.LogError(String.Empty, ex); } try { JObject document = JObject.Parse(json); DocumentUpgrader.Current.Upgrade(document, type); return JsonConvert.DeserializeObject(document.ToString(), type); } catch (Exception ex) { ex.ToExceptionless().AddObject(json, "Error").Submit(); throw new Exception("An exception occurred while upgrading the document.", ex); } } } catch (Exception ex) { if (formatterLogger == null) throw; formatterLogger.LogError(String.Empty, ex); return GetDefaultValueForType(type); } }); return task; }
private T GetValue <T>(string name, string value, IFormatterLogger logger) { T result = default(T); try { result = (T)System.Convert.ChangeType(value, typeof(T)); } catch { logger.LogError(name, "Cannot Parse Value"); } return(result); }
/// <summary> /// Asynchronously deserializes an object of the specified type. /// </summary> /// <param name="type">The type of the object to deserialize.</param> /// <param name="readStream">The <see cref="T:System.IO.Stream" /> to read.</param> /// <param name="content">The <see cref="T:System.Net.Http.HttpContent" />, if available. It may be null.</param> /// <param name="formatterLogger">The <see cref="T:System.Net.Http.Formatting.IFormatterLogger" /> to log events to.</param> /// <returns> /// A <see cref="T:System.Threading.Tasks.Task" /> whose result will be an object of the given type. /// </returns> public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger) { var tcs = new TaskCompletionSource <object>(); try { var reader = GetJsonReader(readStream); using (reader) { var jsonSerializerSettings = new JsonSerializerSettings(); jsonSerializerSettings.Converters.Add(new HyperNewtonsoftJsonConverter()); var jsonSerializer = JsonSerializer.Create(jsonSerializerSettings); var output = jsonSerializer.Deserialize(reader, type); if (formatterLogger != null) { jsonSerializer.Error += (sender, e) => { var exception = e.ErrorContext.Error; formatterLogger.LogError(e.ErrorContext.Path, exception.Message); e.ErrorContext.Handled = true; }; } tcs.SetResult(output); } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e.Message); tcs.SetResult(GetDefaultValueForType(type)); } return(tcs.Task); }
private object ReadFromStream(Type type, Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger, CancellationToken cancellationToken) { try { if (cancellationToken.IsCancellationRequested) { return(null); } var buffer = new byte[16 * 1024]; byte[] data; using (var ms = new MemoryStream()) { int read; while ((read = readStream.Read(buffer, 0, buffer.Length)) > 0) { if (cancellationToken.IsCancellationRequested) { return(null); } ms.Write(buffer, 0, read); } data = ms.ToArray(); } if (cancellationToken.IsCancellationRequested) { return(null); } var serializer = ObjectBuilder.GetSerializer(); var deserialized = serializer.Deserialize(data, null, type, ModeType.WebAPI); return(deserialized); } catch (Exception ex) { if (formatterLogger != null) { formatterLogger.LogError(this.GetType().FullName, ex); } throw; } }
private async Task <object> Deserialize(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { var idContent = content as IdFromRouteHttpContent; if (idContent != null) { content = idContent.Raw; } var headers = (content == null) ? null : content.Headers; if (headers != null && headers.ContentLength == 0L) { return(MediaTypeFormatter.GetDefaultValueForType(type)); } object result = null; try { //对实体的属性进行特殊的处理。 if (typeof(IDomainComponent).IsAssignableFrom(type)) { var json = await content.ReadAsStringAsync(); result = DeserializeDomainComponent(type, idContent != null ? idContent.Id : null, json); } //else if (type == typeof(CommonQueryCriteria)) //{ // result = DesrializeCommonQueryCriteria(strContent); //} else { result = DeserializeByJsonSerializer(type, readStream, headers); } } catch (Exception exception) { if (formatterLogger != null) { formatterLogger.LogError(string.Empty, exception); } result = MediaTypeFormatter.GetDefaultValueForType(type); } return(result); }
private object ReadFromStream( Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger ) { HttpContentHeaders contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) { return(GetDefaultValueForType(type)); } object serializer = GetDeserializer(type, content); try { using (XmlReader reader = CreateXmlReader(readStream, content)) { XmlSerializer xmlSerializer = serializer as XmlSerializer; if (xmlSerializer != null) { return(xmlSerializer.Deserialize(reader)); } else { XmlObjectSerializer xmlObjectSerializer = serializer as XmlObjectSerializer; if (xmlObjectSerializer == null) { ThrowInvalidSerializerException(serializer, "GetDeserializer"); } return(xmlObjectSerializer.ReadObject(reader)); } } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return(GetDefaultValueForType(type)); } }
private object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { var httpContentHeaders = content == null ? (HttpContentHeaders)null : content.Headers; if (httpContentHeaders != null) { var contentLength = httpContentHeaders.ContentLength; if ((contentLength.GetValueOrDefault() != 0L ? 0 : (contentLength.HasValue ? 1 : 0)) != 0) { return(GetDefaultValueForType(type)); } } var settings = new XmlReaderSettings { DtdProcessing = DtdProcessing.Ignore }; var deserializer = GetDeserializer(type, content); try { // The standard XmlMediaTypeFormatter will get the encoding from the HttpContent, instead // here the XmlReader will decide by itself according to the content using (var xmlReader = XmlReader.Create(readStream, settings)) { var xmlSerializer = deserializer as XmlSerializer; if (xmlSerializer != null) { return(xmlSerializer.Deserialize(xmlReader)); } var objectSerializer = deserializer as XmlObjectSerializer; if (objectSerializer == null) { throw new InvalidOperationException("xml object deserializer not available"); } return(objectSerializer.ReadObject(xmlReader)); } } catch (Exception ex) { if (formatterLogger == null) { throw; } formatterLogger.LogError(string.Empty, ex); return(GetDefaultValueForType(type)); } }
private async Task<object> ReadFromStreamAsyncCore(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { object obj = await base.ReadFromStreamAsync(typeof(FormDataCollection), readStream, content, formatterLogger); FormDataCollection fd = (FormDataCollection)obj; try { return fd.ReadAs(type, String.Empty, RequiredMemberSelector, formatterLogger, _configuration); } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return GetDefaultValueForType(type); } }
private async Task <object> Deserialize(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { var headers = (content == null) ? null : content.Headers; if (headers != null && headers.ContentLength == 0L) { return(MediaTypeFormatter.GetDefaultValueForType(type)); } object result = null; try { var strContent = await content.ReadAsStringAsync(); //对实体的属性进行特殊的处理。 if (type.IsSubclassOf(typeof(Entity))) { var jObject = JObject.Parse(strContent); result = DesrializeEntity(type, jObject); } //else if (type == typeof(CommonQueryCriteria)) //{ // result = DesrializeCommonQueryCriteria(strContent); //} else { result = DeserializeByJsonSerializer(type, readStream, headers); } } catch (Exception exception) { if (formatterLogger != null) { formatterLogger.LogError(string.Empty, exception); } result = MediaTypeFormatter.GetDefaultValueForType(type); } return(result); }
/// <param name="type">The type of the object to deserialize.</param> /// <param name="readStream">The <see cref="T:System.IO.Stream"/> to read.</param> /// <param name="content">The <see cref="T:System.Net.Http.HttpContent"/>, if available. It may be null.</param> /// <param name="formatterLogger">The <see cref="T:System.Net.Http.Formatting.IFormatterLogger"/> to log events to.</param> /// <returns>A <see cref="T:System.Threading.Tasks.Task"/> whose result will be an object of the given type.</returns> public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { if (type == null) { throw new ArgumentNullException("type"); } if (!CanReadType(type)) { throw new InvalidOperationException(); } if (content == null) { throw new ArgumentNullException("content"); } if (!content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } try { return(ReadFormDataAsync(content)); } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(string.Empty, e); #if WEB_API2 return(Task.FromResult <object>(new InputParameters())); #else // ASP.NET Web API 1 var tcs = new TaskCompletionSource <object>(); tcs.SetResult(new InputParameters()); return(tcs.Task); #endif } }
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { if (content.IsMimeMultipartContent()) { var provider = GetMultipartProvider(); try { content.ReadAsMultipartAsync(provider); object uploadData = GetFormData(type, provider); return Task.FromResult(uploadData); } catch (Exception e) { formatterLogger.LogError(e.Message, e); } } return base.ReadFromStreamAsync(type, readStream, content, formatterLogger); }
private async Task <object> ReadFromStreamAsyncCore(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { object obj = await base.ReadFromStreamAsync(typeof(FormDataCollection), readStream, content, formatterLogger); FormDataCollection fd = (FormDataCollection)obj; try { return(fd.ReadAs(type, String.Empty, RequiredMemberSelector, formatterLogger)); } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return(GetDefaultValueForType(type)); } }
private object ReadFromStream(Type type, Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger, CancellationToken cancellationToken) { try { if (cancellationToken.IsCancellationRequested) return null; var buffer = new byte[16*1024]; byte[] data; using (var ms = new MemoryStream()) { int read; while ((read = readStream.Read(buffer, 0, buffer.Length)) > 0) { if (cancellationToken.IsCancellationRequested) return null; ms.Write(buffer, 0, read); } data = ms.ToArray(); } if (cancellationToken.IsCancellationRequested) return null; var serializer = ObjectBuilder.GetSerializer(); var deserialized = serializer.Deserialize(data, null, type, ModeType.WebAPI); return deserialized; } catch(Exception ex) { if (formatterLogger != null) formatterLogger.LogError(this.GetType().FullName, ex); throw; } }
/// <summary> /// Reads synchronously from the buffered stream. /// </summary> /// <param name="type">The type of the object to deserialize.</param> /// <param name="readStream">The stream from which to read</param> /// <param name="content">The <see cref="T:System.Net.Http.HttpContent" />, if available. Can be null.</param> /// <param name="formatterLogger">The <see cref="T:System.Net.Http.Formatting.IFormatterLogger" /> to log events to.</param> /// <returns> /// An object of the given <paramref name="type" />. /// </returns> public override object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { Throw.IfArgumentNull(type, "type"); Throw.IfArgumentNull(readStream, "readStream"); HttpContentHeaders contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) { return(GetDefaultValueForType(type)); } try { using (readStream) { if (type.Implements <IPublication>()) { return(ReadEntry(type, readStream, content.Headers.ContentType.MediaType)); } else { var command = Activator.CreateInstance(type); ((IMediaResourceCommand)command).ContentType = content.Headers.ContentType.MediaType; ((IMediaResourceCommand)command).Content = ReadFully(readStream); ((IMediaResourceCommand)command).Summary = "Added using Web Api"; return(command); } } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return(GetDefaultValueForType(type)); } }
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { if (content.IsMimeMultipartContent()) { var provider = GetMultipartProvider(); try { content.ReadAsMultipartAsync(provider); object uploadData = GetFormData(type, provider); return(Task.FromResult(uploadData)); } catch (Exception e) { formatterLogger.LogError(e.Message, e); } } return(base.ReadFromStreamAsync(type, readStream, content, formatterLogger)); }
public override object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { Ensure.Argument.NotNull(type, "type"); Ensure.Argument.NotNull(readStream, "readStream"); HttpContentHeaders contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) { return(GetDefaultValueForType(type)); } try { using (readStream) { using (var reader = XmlReader.Create(readStream)) { var formatter = new Atom10ItemFormatter(); formatter.ReadFrom(reader); var command = Activator.CreateInstance(type); ((IPublicationCommand)command) .ReadSyndicationItem(formatter.Item); return(command); } } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return(GetDefaultValueForType(type)); } }
public async override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { byte[] buffer = new byte[Math.Min(content.Headers.ContentLength.Value, buffersize)]; string[] items = Encoding.Default.GetString(buffer, 0, await readStream.ReadAsync(buffer, 0, buffer.Length)).Split(',', '='); if (items.Length == 4) { return(new Numbers( GetValue <int>("first", items[0], formatterLogger), GetValue <int>("second", items[1], formatterLogger)) { Op = new Operation { Add = GetValue <bool>("Add", items[2], formatterLogger), Double = GetValue <bool>("Double", items[3], formatterLogger) } }); } else { formatterLogger.LogError("", "Wrong number of items"); return(null); } }
public override object ReadFromStream(Type type, System.IO.Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger) { if (content.Headers != null && content.Headers.ContentLength == 0) return null; object result; try { var packer = new CompiledPacker(packPrivateField: false); result = packer.Unpack(type, readStream); } catch (Exception ex) { if (formatterLogger == null) throw; formatterLogger.LogError("", ex.Message); result = GetDefaultValueForType(type); } return result; }
public override Task<object> ReadFromStreamAsync(Type type, Stream stream, HttpContentHeaders contentHeaders, IFormatterLogger formatterLogger) { if (type == null) { throw new ArgumentNullException("type"); } if (stream == null) { throw new ArgumentNullException("stream"); } // For simple types, defer to base class if (base.CanReadType(type)) { return base.ReadFromStreamAsync(type, stream, contentHeaders, formatterLogger); } return base.ReadFromStreamAsync(typeof(FormDataCollection), stream, contentHeaders, formatterLogger).Then( (obj) => { FormDataCollection fd = (FormDataCollection)obj; try { return fd.ReadAs(type, String.Empty, RequiredMemberSelector, formatterLogger); } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e.Message); return GetDefaultValueForType(type); } }); }
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { if (type == null) { throw new ArgumentNullException("type"); } if (readStream == null) { throw new ArgumentNullException("readStream"); } // For simple types, defer to base class if (base.CanReadType(type)) { return(base.ReadFromStreamAsync(type, readStream, content, formatterLogger)); } return(base.ReadFromStreamAsync(typeof(FormDataCollection), readStream, content, formatterLogger).Then( (obj) => { FormDataCollection fd = (FormDataCollection)obj; try { return fd.ReadAs(type, String.Empty, RequiredMemberSelector, formatterLogger); } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return GetDefaultValueForType(type); } })); }
private object ReadFromStream( Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger ) { Contract.Assert(type != null); Contract.Assert(readStream != null); HttpContentHeaders contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) { return(GetDefaultValueForType(type)); } // Get the character encoding for the content // Never non-null since SelectCharacterEncoding() throws in error / not found scenarios Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders); try { return(ReadFromStream(type, readStream, effectiveEncoding, formatterLogger)); } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return(GetDefaultValueForType(type)); } }
public override async Task <object> ReadFromStreamAsync( Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (readStream == null) { throw new ArgumentNullException(nameof(readStream)); } try { // load multipart data into memory var multipartProvider = await content.ReadAsMultipartAsync(); // fill parts into a ditionary for later binding to model var modelDictionary = await ToModelDictionaryAsync(multipartProvider); // bind data to model return(BindToModel(modelDictionary, type, formatterLogger)); } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(string.Empty, e); return(GetDefaultValueForType(type)); } }
/// <inheritdoc /> /// <exception cref="T:System.ArgumentNullException"><paramref name="type"/> is <see langword="null"/></exception> public override async Task <object?> ReadFromStreamAsync( Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (readStream == null) { throw new ArgumentNullException(nameof(readStream)); } if (content == null) { throw new ArgumentNullException(nameof(content)); } long?contentLength = content.Headers.ContentLength; if (contentLength.HasValue && contentLength.GetValueOrDefault() == 0L) { return(GetDefaultForType(type)); } try { var result = await MessagePackSerializer.DeserializeAsync(type, readStream, _options) .ConfigureAwait(false); return(result); } // ReSharper disable once CatchAllClause catch (Exception exception) { formatterLogger.LogError(string.Empty, exception); return(GetDefaultForType(type)); } }
public override Task<object> ReadFromStreamAsync(Type type, Stream stream, HttpContent content, IFormatterLogger formatterLogger) { var tcs = new TaskCompletionSource<object>(); try { var serializer = MessagePackSerializer.Create(type); object result; using (var unpacker = Unpacker.Create(stream)) { unpacker.Read(); result = serializer.UnpackFrom(unpacker); } tcs.SetResult(result); } catch (Exception e) { if (formatterLogger == null) throw; formatterLogger.LogError(String.Empty, e.Message); tcs.SetResult(GetDefaultValueForType(type)); } return tcs.Task; }
public async override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { byte[] buffer = new byte[Math.Min(content.Headers.ContentLength.Value, bufferSize)]; string jsonString = Encoding.Default.GetString(buffer, 0, await readStream.ReadAsync(buffer, 0, buffer.Length)); JObject jData = JObject.Parse(jsonString); if (jData.Properties().Any(p => string.Compare(p.Name, "includeinsale", true) == 0)) { formatterLogger.LogError("IncludeInSale", "Request Must Not Contain IncludeInSale Value"); } return(new Product { Name = (string)jData["name"], Price = (decimal)jData["price"] }); }
private object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { var root = GetRootFieldName(type); var contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) { return(GetDefaultValueForType(type)); } // Get the character encoding for the content var effectiveEncoding = SelectCharacterEncoding(contentHeaders); try { using (var reader = (new StreamReader(readStream, effectiveEncoding))) { var json = reader.ReadToEnd(); var parsedJson = JObject.Parse(json); var deserialized = parsedJson.SelectToken(root); return(deserialized.ToObject(type)); } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return(GetDefaultValueForType(type)); } }
private object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { object result; HttpContentHeaders contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders == null || contentHeaders.ContentLength == 0) { result = GetDefaultValueForType(type); } else { IEdmModel model = Request.GetEdmModel(); if (model == null) { throw Error.InvalidOperation(SRResources.RequestMustHaveModel); } IEdmTypeReference expectedPayloadType; ODataDeserializer deserializer = GetDeserializer(type, Request.GetODataPath(), model, _deserializerProvider, out expectedPayloadType); if (deserializer == null) { throw Error.Argument("type", SRResources.FormatterReadIsNotSupportedForType, type.FullName, GetType().FullName); } try { ODataMessageReaderSettings oDataReaderSettings = new ODataMessageReaderSettings(MessageReaderSettings); oDataReaderSettings.BaseUri = GetBaseAddress(Request); IODataRequestMessage oDataRequestMessage = new ODataMessageWrapper(readStream, contentHeaders, Request.GetODataContentIdMapping()); ODataMessageReader oDataMessageReader = new ODataMessageReader(oDataRequestMessage, oDataReaderSettings, model); Request.RegisterForDispose(oDataMessageReader); ODataPath path = Request.GetODataPath(); ODataDeserializerContext readContext = new ODataDeserializerContext { Path = path, Model = model, Request = Request, ResourceType = type, ResourceEdmType = expectedPayloadType, RequestContext = Request.GetRequestContext(), }; result = deserializer.Read(oDataMessageReader, type, readContext); } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); result = GetDefaultValueForType(type); } } return result; }
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { if (type == null) throw new ArgumentNullException("type"); if (readStream == null) throw new ArgumentNullException("readStream"); var serializer = SerializersCache.Current.GetSerializerForClass(type); if (serializer == null) return base.ReadFromStreamAsync(type, readStream, content, formatterLogger); return TaskHelpers.RunSynchronously<object>(() => { HttpContentHeaders contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) { return GetDefaultValueForType(type); } // Get the character encoding for the content Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders); try { using (JsonTextReader jsonTextReader = new JsonTextReader(new StreamReader(readStream, effectiveEncoding)) { CloseInput = false, MaxDepth = 256 }) { var defaultSerializerSettings = CreateDefaultSerializerSettings(); defaultSerializerSettings.ContractResolver = serializer.GetContractResolver(); JsonSerializer jsonSerializer = JsonSerializer.Create(defaultSerializerSettings); if (formatterLogger != null) { // Error must always be marked as handled // Failure to do so can cause the exception to be rethrown at every recursive level and overflow the stack for x64 CLR processes jsonSerializer.Error += (sender, e) => { Exception exception = e.ErrorContext.Error; formatterLogger.LogError(e.ErrorContext.Path, exception); e.ErrorContext.Handled = true; }; } return jsonSerializer.Deserialize(jsonTextReader, type); // } } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return GetDefaultValueForType(type); } }); }
/// <inheritdoc/> public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { if (type == null) { throw Error.ArgumentNull("type"); } if (readStream == null) { throw Error.ArgumentNull("readStream"); } return TaskHelpers.RunSynchronously<object>(() => { object result; HttpContentHeaders contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) { result = GetDefaultValueForType(type); } else { bool isPatchMode = TryGetInnerTypeForDelta(ref type); ODataDeserializer deserializer = ODataDeserializerProvider.GetODataDeserializer(type); if (deserializer == null) { throw Error.Argument("type", SRResources.FormatterReadIsNotSupportedForType, type.FullName, GetType().FullName); } ODataMessageReader oDataMessageReader = null; ODataMessageReaderSettings oDataReaderSettings = new ODataMessageReaderSettings { DisableMessageStreamDisposal = true }; try { IODataRequestMessage oDataRequestMessage = new ODataMessageWrapper(readStream, contentHeaders); oDataMessageReader = new ODataMessageReader(oDataRequestMessage, oDataReaderSettings, ODataDeserializerProvider.EdmModel); ODataDeserializerContext readContext = new ODataDeserializerContext { IsPatchMode = isPatchMode, PatchKeyMode = PatchKeyMode, Request = Request, Model = Model }; result = deserializer.Read(oDataMessageReader, readContext); } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); result = GetDefaultValueForType(type); } finally { if (oDataMessageReader != null) { oDataMessageReader.Dispose(); } } } return result; }); }
private object ReadValue(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { var contentHeaders = content == null ? null : content.Headers; if (contentHeaders != null && contentHeaders.ContentLength == 0) { return GetDefaultValueForType(type); } var encoding = SelectCharacterEncoding(contentHeaders); try { var serializer = XmlSerializer.Create(type, new XmlSerializationOptions(encoding: encoding, shouldIndent: Indent)); return serializer.Deserialize(readStream); } catch (Exception ex) { if (formatterLogger == null) { throw; } formatterLogger.LogError(string.Empty, ex); return GetDefaultValueForType(type); } }
private object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { object retval = null; Type singleType = GetSingleType(type); var contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) return GetDefaultValueForType(type); try { var effectiveEncoding = SelectCharacterEncoding(contentHeaders); JsonReader reader = this.CreateJsonReader(typeof (IDictionary<string, object>), readStream, effectiveEncoding); reader.Read(); if (reader.TokenType != JsonToken.StartObject) throw new JsonSerializationException("Document root is not an object!"); bool foundPrimaryData = false; while (reader.Read()) { if (reader.TokenType == JsonToken.PropertyName) { string value = (string) reader.Value; reader.Read(); // burn the PropertyName token switch (value) { case IncludedKeyName: //TODO: If we want to capture linked/related objects in a compound document when deserializing, do it here...do we? reader.Skip(); break; case RelationshipsKeyName: // ignore this, is it even meaningful in a PUT/POST body? reader.Skip(); break; case PrimaryDataKeyName: // Could be a single resource or multiple, according to spec! foundPrimaryData = true; retval = DeserializePrimaryData(singleType, reader); break; case AttributesKeyName: // Could be a single resource or multiple, according to spec! foundPrimaryData = true; retval = DeserializePrimaryData(singleType, reader); break; } } else reader.Skip(); } if (!foundPrimaryData) throw new BadRequestException(String.Format("Expected primary data located at the `{0}` key", PrimaryDataKeyName)); /* WARNING: May transform a single object into a list of objects!!! * This is a necessary workaround to support POST and PUT of multiple * resoruces as per the spec, because WebAPI does NOT allow you to overload * a POST or PUT method based on the input parameter...i.e., you cannot * have a method that responds to POST of a single resource and a second * method that responds to the POST of a collection (list) of resources! */ if (retval != null) { if (!type.IsAssignableFrom(retval.GetType()) && _modelManager.IsSerializedAsMany(type)) { IList list = (IList) Activator.CreateInstance(typeof (List<>).MakeGenericType(singleType)); list.Add(retval); return list; } else { return retval; } } } catch (BadRequestException ex) { // We have to perform our own serialization of the error response here. var response = new HttpResponseMessage(HttpStatusCode.BadRequest); using (var writeStream = new MemoryStream()) { var effectiveEncoding = SelectCharacterEncoding(contentHeaders); JsonWriter writer = CreateJsonWriter(typeof (object), writeStream, effectiveEncoding); JsonSerializer serializer = CreateJsonSerializer(); var httpError = new HttpError(ex, true); // TODO: allow consumer to choose whether to include error detail _errorSerializer.SerializeError(httpError, writeStream, writer, serializer); writer.Flush(); writeStream.Flush(); writeStream.Seek(0, SeekOrigin.Begin); using (var stringReader = new StreamReader(writeStream)) { var stringContent = stringReader.ReadToEnd(); // TODO: use async version response.Content = new StringContent(stringContent, Encoding.UTF8, "application/vnd.api+json"); } } throw new HttpResponseException(response); } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return GetDefaultValueForType(type); } return GetDefaultValueForType(type); }
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { if (type == null) { throw Error.ArgumentNull("type"); } if (readStream == null) { throw Error.ArgumentNull("readStream"); } if (Request == null) { throw Error.InvalidOperation(SRResources.ReadFromStreamAsyncMustHaveRequest); } object defaultValue = GetDefaultValueForType(type); // If content length is 0 then return default value for this type HttpContentHeaders contentHeaders = (content == null) ? null : content.Headers; if (contentHeaders == null || contentHeaders.ContentLength == 0) { return(Task.FromResult(defaultValue)); } try { Func <ODataDeserializerContext> getODataDeserializerContext = () => { return(new ODataDeserializerContext { Request = Request, }); }; Action <Exception> logErrorAction = (ex) => { if (formatterLogger == null) { throw ex; } formatterLogger.LogError(String.Empty, ex); }; ODataDeserializerProvider deserializerProvider = Request.GetRequestContainer() .GetRequiredService <ODataDeserializerProvider>(); return(Task.FromResult(ODataInputFormatterHelper.ReadFromStream( type, defaultValue, Request.GetModel(), GetBaseAddressInternal(Request), new WebApiRequestMessage(Request), () => ODataMessageWrapperHelper.Create(readStream, contentHeaders, Request.GetODataContentIdMapping(), Request.GetRequestContainer()), (objectType) => deserializerProvider.GetEdmTypeDeserializer(objectType), (objectType) => deserializerProvider.GetODataDeserializer(objectType, Request), getODataDeserializerContext, (disposable) => Request.RegisterForDispose(disposable), logErrorAction))); } catch (Exception ex) { return(TaskHelpers.FromError <object>(ex)); } }
/// <summary> /// Called during deserialization to read an object of the specified <paramref name="type"/> /// from the specified <paramref name="stream"/>. /// </summary> /// <param name="type">The type of object to read.</param> /// <param name="stream">The <see cref="Stream"/> from which to read.</param> /// <param name="contentHeaders">The <see cref="HttpContentHeaders"/> for the content being written.</param> /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param> /// <returns>A <see cref="Task"/> whose result will be the object instance that has been read.</returns> public override Task <object> ReadFromStreamAsync(Type type, Stream stream, HttpContentHeaders contentHeaders, IFormatterLogger formatterLogger) { if (type == null) { throw new ArgumentNullException("type"); } if (stream == null) { throw new ArgumentNullException("stream"); } return(TaskHelpers.RunSynchronously <object>(() => { // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) { return GetDefaultValueForType(type); } // Get the character encoding for the content Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders); try { if (UseDataContractJsonSerializer) { DataContractJsonSerializer dataContractSerializer = GetDataContractSerializer(type); using (XmlReader reader = JsonReaderWriterFactory.CreateJsonReader(new NonClosingDelegatingStream(stream), effectiveEncoding, _readerQuotas, null)) { return dataContractSerializer.ReadObject(reader); } } else { using (JsonTextReader jsonTextReader = new SecureJsonTextReader(new StreamReader(stream, effectiveEncoding), _maxDepth) { CloseInput = false }) { JsonSerializer jsonSerializer = JsonSerializer.Create(_jsonSerializerSettings); if (formatterLogger != null) { jsonSerializer.Error += (sender, e) => { Exception exception = e.ErrorContext.Error; // reader quota exceptions are fatal and cannot be recovered from // we need to shortcircuit any further deserialization if (exception is JsonReaderQuotaException) { e.ErrorContext.Handled = false; } else { formatterLogger.LogError(e.ErrorContext.Path, exception.Message); e.ErrorContext.Handled = true; } }; } return jsonSerializer.Deserialize(jsonTextReader, type); } } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e.Message); return GetDefaultValueForType(type); } })); }
/// <summary> /// Called during deserialization to read an object of the specified <paramref name="type"/> /// from the specified <paramref name="readStream"/>. /// </summary> /// <param name="type">The type of object to read.</param> /// <param name="readStream">The <see cref="Stream"/> from which to read.</param> /// <param name="content">The <see cref="HttpContent"/> for the content being written.</param> /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param> /// <returns>A <see cref="Task"/> whose result will be the object instance that has been read.</returns> public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { if (type == null) { throw Error.ArgumentNull("type"); } if (readStream == null) { throw Error.ArgumentNull("readStream"); } return(TaskHelpers.RunSynchronously <object>(() => { HttpContentHeaders contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) { return GetDefaultValueForType(type); } // Get the character encoding for the content Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders); try { #if !NETFX_CORE if (UseDataContractJsonSerializer) { DataContractJsonSerializer dataContractSerializer = GetDataContractSerializer(type); using (XmlReader reader = JsonReaderWriterFactory.CreateJsonReader(new NonClosingDelegatingStream(readStream), effectiveEncoding, _readerQuotas, null)) { return dataContractSerializer.ReadObject(reader); } } else #endif { using (JsonTextReader jsonTextReader = new JsonTextReader(new StreamReader(readStream, effectiveEncoding)) { CloseInput = false, MaxDepth = _maxDepth }) { JsonSerializer jsonSerializer = JsonSerializer.Create(_jsonSerializerSettings); if (formatterLogger != null) { // Error must always be marked as handled // Failure to do so can cause the exception to be rethrown at every recursive level and overflow the stack for x64 CLR processes jsonSerializer.Error += (sender, e) => { Exception exception = e.ErrorContext.Error; formatterLogger.LogError(e.ErrorContext.Path, exception); e.ErrorContext.Handled = true; }; } return jsonSerializer.Deserialize(jsonTextReader, type); } } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return GetDefaultValueForType(type); } })); }
/// <summary> /// Called during deserialization to read an object of the specified <paramref name="type"/> /// from the specified <paramref name="readStream"/>. /// </summary> /// <remarks> /// Public for delegating wrappers of this class. Expected to be called only from /// <see cref="ReadFromStreamAsync"/>. /// </remarks> /// <param name="type">The <see cref="Type"/> of object to read.</param> /// <param name="readStream">The <see cref="Stream"/> from which to read.</param> /// <param name="effectiveEncoding">The <see cref="Encoding"/> to use when reading.</param> /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param> /// <returns>The <see cref="object"/> instance that has been read.</returns> public virtual object ReadFromStream(Type type, Stream readStream, Encoding effectiveEncoding, IFormatterLogger formatterLogger) { if (type == null) { throw Error.ArgumentNull("type"); } if (readStream == null) { throw Error.ArgumentNull("readStream"); } if (effectiveEncoding == null) { throw Error.ArgumentNull("effectiveEncoding"); } using (JsonReader jsonReader = CreateJsonReaderInternal(type, readStream, effectiveEncoding)) { jsonReader.CloseInput = false; jsonReader.MaxDepth = _maxDepth; JsonSerializer jsonSerializer = CreateJsonSerializerInternal(); EventHandler<Newtonsoft.Json.Serialization.ErrorEventArgs> errorHandler = null; if (formatterLogger != null) { // Error must always be marked as handled // Failure to do so can cause the exception to be rethrown at every recursive level and overflow the stack for x64 CLR processes errorHandler = (sender, e) => { Exception exception = e.ErrorContext.Error; formatterLogger.LogError(e.ErrorContext.Path, exception); e.ErrorContext.Handled = true; }; jsonSerializer.Error += errorHandler; } try { return jsonSerializer.Deserialize(jsonReader, type); } finally { if (errorHandler != null) { // Clean up the error handler in case CreateJsonSerializer() reuses a serializer jsonSerializer.Error -= errorHandler; } } } }
private object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { Contract.Assert(type != null); Contract.Assert(readStream != null); HttpContentHeaders contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) { return GetDefaultValueForType(type); } // Get the character encoding for the content // Never non-null since SelectCharacterEncoding() throws in error / not found scenarios Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders); try { return ReadFromStream(type, readStream, effectiveEncoding, formatterLogger); } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return GetDefaultValueForType(type); } }
private object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { object retval = null; Type singleType = GetSingleType(type); var pripropname = _modelManager.GetJsonKeyForType(type); var contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) { return(GetDefaultValueForType(type)); } try { var effectiveEncoding = SelectCharacterEncoding(contentHeaders); JsonReader reader = this.CreateJsonReader(typeof(IDictionary <string, object>), readStream, effectiveEncoding); JsonSerializer serializer = this.CreateJsonSerializer(); reader.Read(); if (reader.TokenType != JsonToken.StartObject) { throw new JsonSerializationException("Document root is not an object!"); } while (reader.Read()) { if (reader.TokenType == JsonToken.PropertyName) { string value = (string)reader.Value; reader.Read(); // burn the PropertyName token switch (value) { case "linked": //TODO: If we want to capture linked/related objects in a compound document when deserializing, do it here...do we? reader.Skip(); break; case "links": // ignore this, is it even meaningful in a PUT/POST body? reader.Skip(); break; default: if (value == pripropname) { // Could be a single resource or multiple, according to spec! if (reader.TokenType == JsonToken.StartArray) { Type listType = (typeof(List <>)).MakeGenericType(singleType); retval = (IList)Activator.CreateInstance(listType); reader.Read(); // Burn off StartArray token while (reader.TokenType == JsonToken.StartObject) { ((IList)retval).Add(Deserialize(singleType, readStream, reader, serializer)); } // burn EndArray token... if (reader.TokenType != JsonToken.EndArray) { throw new JsonReaderException(String.Format("Expected JsonToken.EndArray but got {0}", reader.TokenType)); } reader.Read(); } else { // Because we choose what to deserialize based on the ApiController method signature // (not choose the method signature based on what we're deserializing), the `type` // parameter will always be `IList<Model>` even if a single model is sent! retval = Deserialize(singleType, readStream, reader, serializer); } } else { reader.Skip(); } break; } } else { reader.Skip(); } } /* WARNING: May transform a single object into a list of objects!!! * This is a necessary workaround to support POST and PUT of multiple * resoruces as per the spec, because WebAPI does NOT allow you to overload * a POST or PUT method based on the input parameter...i.e., you cannot * have a method that responds to POST of a single resource and a second * method that responds to the POST of a collection (list) of resources! */ if (retval != null) { if (!type.IsAssignableFrom(retval.GetType()) && _modelManager.IsSerializedAsMany(type)) { IList list = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(singleType)); list.Add(retval); return(list); } else { return(retval); } } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return(GetDefaultValueForType(type)); } /* * try * { * using (var reader = (new StreamReader(readStream, effectiveEncoding))) * { * var json = reader.ReadToEnd(); * var jo = JObject.Parse(json); * return jo.SelectToken(root, false).ToObject(type); * } * } * catch (Exception e) * { * if (formatterLogger == null) * { * throw; * } * formatterLogger.LogError(String.Empty, e); * return GetDefaultValueForType(type); * } */ return(GetDefaultValueForType(type)); }
/// <summary> /// Called during deserialization to read an object of the specified <paramref name="type"/> /// from the specified <paramref name="stream"/>. /// </summary> /// <param name="type">The type of object to read.</param> /// <param name="stream">The <see cref="Stream"/> from which to read.</param> /// <param name="contentHeaders">The <see cref="HttpContentHeaders"/> for the content being written.</param> /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param> /// <returns>A <see cref="Task"/> whose result will be the object instance that has been read.</returns> public override Task<object> ReadFromStreamAsync(Type type, Stream stream, HttpContentHeaders contentHeaders, IFormatterLogger formatterLogger) { if (type == null) { throw new ArgumentNullException("type"); } if (stream == null) { throw new ArgumentNullException("stream"); } return TaskHelpers.RunSynchronously<object>(() => { // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) { return GetDefaultValueForType(type); } // Get the character encoding for the content Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders); try { if (UseDataContractJsonSerializer) { DataContractJsonSerializer dataContractSerializer = GetDataContractSerializer(type); using (XmlReader reader = JsonReaderWriterFactory.CreateJsonReader(new NonClosingDelegatingStream(stream), effectiveEncoding, _readerQuotas, null)) { return dataContractSerializer.ReadObject(reader); } } else { using (JsonTextReader jsonTextReader = new SecureJsonTextReader(new StreamReader(stream, effectiveEncoding), _maxDepth) { CloseInput = false }) { JsonSerializer jsonSerializer = JsonSerializer.Create(_jsonSerializerSettings); if (formatterLogger != null) { jsonSerializer.Error += (sender, e) => { Exception exception = e.ErrorContext.Error; // reader quota exceptions are fatal and cannot be recovered from // we need to shortcircuit any further deserialization if (exception is JsonReaderQuotaException) { e.ErrorContext.Handled = false; } else { formatterLogger.LogError(e.ErrorContext.Path, exception.Message); e.ErrorContext.Handled = true; } }; } return jsonSerializer.Deserialize(jsonTextReader, type); } } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e.Message); return GetDefaultValueForType(type); } }); }
private object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { HttpContentHeaders contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) { return GetDefaultValueForType(type); } // Get the character encoding for the content Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders); try { using (JsonTextReader jsonTextReader = new JsonTextReader(new StreamReader(readStream, effectiveEncoding)) { CloseInput = false, MaxDepth = _maxDepth }) { JsonSerializer jsonSerializer = JsonSerializer.Create(_jsonSerializerSettings); if (formatterLogger != null) { // Error must always be marked as handled // Failure to do so can cause the exception to be rethrown at every recursive level and overflow the stack for x64 CLR processes jsonSerializer.Error += (sender, e) => { Exception exception = e.ErrorContext.Error; formatterLogger.LogError(e.ErrorContext.Path, exception); e.ErrorContext.Handled = true; }; } return jsonSerializer.Deserialize(jsonTextReader, type); } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return GetDefaultValueForType(type); } }
/// <summary> /// Read RDF/XML from an HTTP input stream and convert to .NET objects /// </summary> /// <param name="type"></param> /// <param name="readStream"></param> /// <param name="content"></param> /// <param name="formatterLogger"></param> /// <returns></returns> public override Task <object> ReadFromStreamAsync( Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger ) { var tcs = new TaskCompletionSource <object>(); if (content != null && content.Headers != null && content.Headers.ContentLength == 0) { return(null); } try { IRdfReader rdfParser; if (content == null || content.Headers == null || content.Headers.ContentType.MediaType.Equals(OslcMediaType.APPLICATION_RDF_XML)) { rdfParser = new RdfXmlParser(); } else if (content.Headers.ContentType.MediaType.Equals(OslcMediaType.TEXT_TURTLE)) { rdfParser = new TurtleParser(TurtleSyntax.W3C); } else { //For now, use the dotNetRDF RdfXmlParser() for application/xml. This could change //rdfParser = new OslcXmlParser(); rdfParser = new RdfXmlParser(); } IGraph graph = new Graph(); StreamReader streamReader = new StreamReader(readStream); using (streamReader) { rdfParser.Load(graph, streamReader); bool isSingleton = IsSinglton(type); object output = DotNetRdfHelper.FromDotNetRdfGraph(graph, isSingleton ? type : GetMemberType(type)); if (isSingleton) { bool haveOne = (int)output.GetType().GetProperty("Count").GetValue(output, null) > 0; tcs.SetResult(haveOne ? output.GetType().GetProperty("Item").GetValue(output, new object[] { 0 }): null); } else if (type.IsArray) { tcs.SetResult(output.GetType().GetMethod("ToArray", Type.EmptyTypes).Invoke(output, null)); } else { tcs.SetResult(output); } } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e.Message); tcs.SetResult(GetDefaultValueForType(type)); } return(tcs.Task); }
private object DeSerialize(Type type, Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger) { HttpContentHeaders contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) { return GetDefaultValueForType(type); } // Get the character encoding for the content Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders); try { using (var reader = new StreamReader(readStream, effectiveEncoding, false, 512, true)) { var deserialize = TypedDeserializers.GetTyped(type); return deserialize(reader, _jilOptions); } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return GetDefaultValueForType(type); } }
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { if (type == null) { throw Error.ArgumentNull("type"); } if (readStream == null) { throw Error.ArgumentNull("readStream"); } if (_request == null) { throw Error.InvalidOperation(SRResources.ReadFromStreamAsyncMustHaveRequest); } return(TaskHelpers.RunSynchronously <object>(() => { object result; HttpContentHeaders contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders == null || contentHeaders.ContentLength == 0) { result = GetDefaultValueForType(type); } else { IEdmModel model = _request.GetEdmModel(); if (model == null) { throw Error.InvalidOperation(SRResources.RequestMustHaveModel); } Type originalType = type; bool isPatchMode = TryGetInnerTypeForDelta(ref type); ODataDeserializer deserializer = _deserializerProvider.GetODataDeserializer(model, type); if (deserializer == null) { throw Error.Argument("type", SRResources.FormatterReadIsNotSupportedForType, type.FullName, GetType().FullName); } ODataMessageReader oDataMessageReader = null; ODataMessageReaderSettings oDataReaderSettings = new ODataMessageReaderSettings { DisableMessageStreamDisposal = true, MessageQuotas = MessageReaderQuotas, BaseUri = GetBaseAddress(_request) }; try { IODataRequestMessage oDataRequestMessage = new ODataMessageWrapper(readStream, contentHeaders); oDataMessageReader = new ODataMessageReader(oDataRequestMessage, oDataReaderSettings, model); _request.RegisterForDispose(oDataMessageReader); ODataPath path = _request.GetODataPath(); ODataDeserializerContext readContext = new ODataDeserializerContext { IsPatchMode = isPatchMode, Path = path, Model = model, Request = _request }; if (isPatchMode) { readContext.PatchEntityType = originalType; } result = deserializer.Read(oDataMessageReader, readContext); } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); result = GetDefaultValueForType(type); } } return result; })); }
private object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { object result; HttpContentHeaders contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders == null || contentHeaders.ContentLength == 0) { result = GetDefaultValueForType(type); } else { IEdmModel model = Request.ODataProperties().Model; if (model == null) { throw Error.InvalidOperation(SRResources.RequestMustHaveModel); } IEdmTypeReference expectedPayloadType; ODataDeserializer deserializer = GetDeserializer(type, Request.ODataProperties().Path, model, _deserializerProvider, out expectedPayloadType); if (deserializer == null) { throw Error.Argument("type", SRResources.FormatterReadIsNotSupportedForType, type.FullName, GetType().FullName); } try { ODataMessageReaderSettings oDataReaderSettings = new ODataMessageReaderSettings(MessageReaderSettings); oDataReaderSettings.BaseUri = GetBaseAddress(Request); IODataRequestMessage oDataRequestMessage = new ODataMessageWrapper(readStream, contentHeaders, Request.GetODataContentIdMapping()); ODataMessageReader oDataMessageReader = new ODataMessageReader(oDataRequestMessage, oDataReaderSettings, model); Request.RegisterForDispose(oDataMessageReader); ODataPath path = Request.ODataProperties().Path; ODataDeserializerContext readContext = new ODataDeserializerContext { Path = path, Model = model, Request = Request, ResourceType = type, ResourceEdmType = expectedPayloadType, RequestContext = Request.GetRequestContext(), }; result = deserializer.Read(oDataMessageReader, type, readContext); } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); result = GetDefaultValueForType(type); } } return(result); }
/// <summary> /// Called during deserialization to read an object of the specified <paramref name="type"/> /// from the specified <paramref name="readStream"/>. /// </summary> /// <param name="type">The type of object to read.</param> /// <param name="readStream">The <see cref="Stream"/> from which to read.</param> /// <param name="content">The <see cref="HttpContent"/> for the content being written.</param> /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param> /// <returns>A <see cref="Task"/> whose result will be the object instance that has been read.</returns> public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { if (type == null) { throw Error.ArgumentNull("type"); } if (readStream == null) { throw Error.ArgumentNull("readStream"); } return TaskHelpers.RunSynchronously<object>(() => { HttpContentHeaders contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders != null && contentHeaders.ContentLength == 0) { return GetDefaultValueForType(type); } // Get the character encoding for the content Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders); try { #if !NETFX_CORE if (UseDataContractJsonSerializer) { DataContractJsonSerializer dataContractSerializer = GetDataContractSerializer(type); using (XmlReader reader = JsonReaderWriterFactory.CreateJsonReader(new NonClosingDelegatingStream(readStream), effectiveEncoding, _readerQuotas, null)) { return dataContractSerializer.ReadObject(reader); } } else #endif { using (JsonTextReader jsonTextReader = new JsonTextReader(new StreamReader(readStream, effectiveEncoding)) { CloseInput = false, MaxDepth = _maxDepth }) { JsonSerializer jsonSerializer = JsonSerializer.Create(_jsonSerializerSettings); if (formatterLogger != null) { // Error must always be marked as handled // Failure to do so can cause the exception to be rethrown at every recursive level and overflow the stack for x64 CLR processes jsonSerializer.Error += (sender, e) => { Exception exception = e.ErrorContext.Error; formatterLogger.LogError(e.ErrorContext.Path, exception); e.ErrorContext.Handled = true; }; } return jsonSerializer.Deserialize(jsonTextReader, type); } } } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); return GetDefaultValueForType(type); } }); }
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger) { if (type == null) { throw Error.ArgumentNull("type"); } if (readStream == null) { throw Error.ArgumentNull("readStream"); } if (_request == null) { throw Error.InvalidOperation(SRResources.ReadFromStreamAsyncMustHaveRequest); } return TaskHelpers.RunSynchronously<object>(() => { object result; HttpContentHeaders contentHeaders = content == null ? null : content.Headers; // If content length is 0 then return default value for this type if (contentHeaders == null || contentHeaders.ContentLength == 0) { result = GetDefaultValueForType(type); } else { IEdmModel model = _request.GetEdmModel(); if (model == null) { throw Error.InvalidOperation(SRResources.RequestMustHaveModel); } Type originalType = type; bool isPatchMode = TryGetInnerTypeForDelta(ref type); ODataDeserializer deserializer = _deserializerProvider.GetODataDeserializer(model, type); if (deserializer == null) { throw Error.Argument("type", SRResources.FormatterReadIsNotSupportedForType, type.FullName, GetType().FullName); } ODataMessageReader oDataMessageReader = null; ODataMessageReaderSettings oDataReaderSettings = new ODataMessageReaderSettings { DisableMessageStreamDisposal = true, MessageQuotas = MessageReaderQuotas, BaseUri = GetBaseAddress(_request) }; try { IODataRequestMessage oDataRequestMessage = new ODataMessageWrapper(readStream, contentHeaders); oDataMessageReader = new ODataMessageReader(oDataRequestMessage, oDataReaderSettings, model); _request.RegisterForDispose(oDataMessageReader); ODataPath path = _request.GetODataPath(); ODataDeserializerContext readContext = new ODataDeserializerContext { IsPatchMode = isPatchMode, Path = path, Model = model, Request = _request }; if (isPatchMode) { readContext.PatchEntityType = originalType; } result = deserializer.Read(oDataMessageReader, readContext); } catch (Exception e) { if (formatterLogger == null) { throw; } formatterLogger.LogError(String.Empty, e); result = GetDefaultValueForType(type); } } return result; }); }
private object BindToModel(IDictionary <string, object> data, Type type, IFormatterLogger formatterLogger) { if (data == null) { throw new ArgumentNullException(nameof(data)); } if (type == null) { throw new ArgumentNullException(nameof(type)); } using (var config = new HttpConfiguration()) { // if there is a requiredMemberSelector set, use this one by replacing the validator provider var validateRequiredMembers = RequiredMemberSelector != null && formatterLogger != null; if (validateRequiredMembers) { config.Services.Replace(typeof(ModelValidatorProvider), new RequiredMemberModelValidatorProvider(RequiredMemberSelector)); } // create a action context for model binding var actionContext = new HttpActionContext { ControllerContext = new HttpControllerContext { Configuration = config, ControllerDescriptor = new HttpControllerDescriptor { Configuration = config } } }; // create model binder context var valueProvider = new NameValuePairsValueProvider(data, CultureInfo.InvariantCulture); var metadataProvider = actionContext.ControllerContext.Configuration.Services.GetModelMetadataProvider(); var metadata = metadataProvider.GetMetadataForType(null, type); var modelBindingContext = new ModelBindingContext { ModelName = string.Empty, FallbackToEmptyPrefix = false, ModelMetadata = metadata, ModelState = actionContext.ModelState, ValueProvider = valueProvider }; // bind model var modelBinderProvider = new CompositeModelBinderProvider(config.Services.GetModelBinderProviders()); var binder = modelBinderProvider.GetBinder(config, type); var haveResult = binder.BindModel(actionContext, modelBindingContext); // log validation errors if (formatterLogger != null) { foreach (var modelStatePair in actionContext.ModelState) { foreach (var modelError in modelStatePair.Value.Errors) { if (modelError.Exception != null) { formatterLogger.LogError(modelStatePair.Key, modelError.Exception); } else { formatterLogger.LogError(modelStatePair.Key, modelError.ErrorMessage); } } } } return(haveResult ? modelBindingContext.Model : GetDefaultValueForType(type)); } }