private string Serialize <T>(T value, JsonSerializerOptions options) { JsonSerializerContext context = _customContextCreator(new JsonSerializerOptions(options)); JsonTypeInfo <T> typeInfo = (JsonTypeInfo <T>)context.GetTypeInfo(typeof(T)); return(JsonSerializer.Serialize(value, typeInfo)); }
/// <summary> /// Convert the provided value to UTF-8 encoded JSON text and write it to the <see cref="System.IO.Stream"/>. /// </summary> /// <returns>A task that represents the asynchronous write operation.</returns> /// <param name="utf8Json">The UTF-8 <see cref="System.IO.Stream"/> to write to.</param> /// <param name="value">The value to convert.</param> /// <param name="inputType">The type of the <paramref name="value"/> to convert.</param> /// <param name="context">A metadata provider for serializable types.</param> /// <param name="cancellationToken">The <see cref="System.Threading.CancellationToken"/> which may be used to cancel the write operation.</param> /// <exception cref="ArgumentException"> /// <paramref name="inputType"/> is not compatible with <paramref name="value"/>. /// </exception> /// <exception cref="ArgumentNullException"> /// <paramref name="utf8Json"/> or <paramref name="inputType"/> is <see langword="null"/>. /// </exception> /// <exception cref="NotSupportedException"> /// There is no compatible <see cref="System.Text.Json.Serialization.JsonConverter"/> /// for <paramref name="inputType"/> or its serializable members. /// </exception> public static Task SerializeAsync( Stream utf8Json, object?value, [DynamicallyAccessedMembers(MembersAccessedOnWrite)] Type inputType, JsonSerializerContext context, CancellationToken cancellationToken = default) { if (utf8Json == null) { throw new ArgumentNullException(nameof(utf8Json)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } Type runtimeType = GetRuntimeTypeAndValidateInputType(value, inputType); return(WriteAsyncCore( utf8Json, value !, JsonHelpers.GetTypeInfo(context, runtimeType), cancellationToken)); }
public override Task <T> DeserializeWrapper <T>(string json, JsonSerializerOptions?options = null) { JsonSerializerContext context = GetJsonSerializerContext(options); JsonTypeInfo <T> typeInfo = (JsonTypeInfo <T>)context.GetTypeInfo(typeof(T)); return(Task.FromResult(JsonSerializer.Deserialize <T>(json, typeInfo))); }
private T Deserialize <T>(string json, JsonSerializerOptions options) { JsonSerializerContext context = _customContextCreator(new JsonSerializerOptions(options)); JsonTypeInfo <T> typeInfo = (JsonTypeInfo <T>)context.GetTypeInfo(typeof(T)); return(JsonSerializer.Deserialize <T>(json, typeInfo)); }
/// <summary> /// Converts the provided value to UTF-8 encoded JSON text and write it to the <see cref="System.IO.Stream"/>. /// </summary> /// <returns>A task that represents the asynchronous write operation.</returns> /// <param name="utf8Json">The UTF-8 <see cref="System.IO.Stream"/> to write to.</param> /// <param name="value">The value to convert.</param> /// <param name="inputType">The type of the <paramref name="value"/> to convert.</param> /// <param name="context">A metadata provider for serializable types.</param> /// <param name="cancellationToken">The <see cref="System.Threading.CancellationToken"/> that can be used to cancel the write operation.</param> /// <exception cref="ArgumentException"> /// <paramref name="inputType"/> is not compatible with <paramref name="value"/>. /// </exception> /// <exception cref="ArgumentNullException"> /// <paramref name="utf8Json"/>, <paramref name="inputType"/>, or <paramref name="context"/> is <see langword="null"/>. /// </exception> /// <exception cref="NotSupportedException"> /// There is no compatible <see cref="System.Text.Json.Serialization.JsonConverter"/> /// for <paramref name="inputType"/> or its serializable members. /// </exception> public static Task SerializeAsync( Stream utf8Json, object?value, Type inputType, JsonSerializerContext context, CancellationToken cancellationToken = default) { if (utf8Json == null) { throw new ArgumentNullException(nameof(utf8Json)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } Type runtimeType = GetRuntimeTypeAndValidateInputType(value, inputType); return(WriteStreamAsync( utf8Json, value !, GetTypeInfo(context, runtimeType), cancellationToken)); }
//--- Constructors --- /// <summary> /// Constructs instance of serializer. /// </summary> /// <param name="serializerContext">A callback to customize the serializer settings.</param> /// <param name="jsonWriterCustomizer"></param> public LambdaSourceGeneratorJsonSerializer(JsonSerializerContext serializerContext, Action <JsonWriterOptions>?jsonWriterCustomizer = null) { _jsonSerializerContext = serializerContext ?? throw new ArgumentNullException(nameof(serializerContext)); _writerOptions = new JsonWriterOptions { Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping }; jsonWriterCustomizer?.Invoke(_writerOptions); }
private static void CopyJsonSerializerContext(JsonSerializerOptions source, JsonSerializerOptions target) { JsonSerializerContext context = (JsonSerializerContext)s_optionsContextField.GetValue(source); if (context != null) { s_optionsContextField.SetValue(target, context); } }
/// <summary> /// Parse the text representing a single JSON value into a <paramref name="returnType"/>. /// </summary> /// <returns>A <paramref name="returnType"/> representation of the JSON value.</returns> /// <param name="json">JSON text to parse.</param> /// <param name="returnType">The type of the object to convert to and return.</param> /// <param name="context">A metadata provider for serializable types.</param> /// <exception cref="System.ArgumentNullException"> /// <paramref name="json"/> is <see langword="null"/>. /// /// -or- /// /// <paramref name="context"/> is <see langword="null"/>. /// </exception> /// <exception cref="JsonException"> /// The JSON is invalid. /// /// -or- /// /// <paramref name="returnType" /> is not compatible with the JSON. /// /// -or- /// /// There is remaining data in the string beyond a single JSON value.</exception> /// <exception cref="NotSupportedException"> /// There is no compatible <see cref="System.Text.Json.Serialization.JsonConverter"/> /// for <paramref name="returnType"/> or its serializable members. /// </exception> /// <exception cref="InvalidOperationException"> /// The <see cref="JsonSerializerContext.GetTypeInfo(Type)"/> method of the provided /// <paramref name="context"/> returns <see langword="null"/> for the type to convert. /// </exception> /// <remarks>Using a <see cref="string"/> is not as efficient as using the /// UTF-8 methods since the implementation natively uses UTF-8. /// </remarks> public static object?Deserialize(string json, Type returnType, JsonSerializerContext context) { if (json == null) { throw new ArgumentNullException(nameof(json)); } return(Deserialize(json.AsSpan(), returnType, context)); }
/// <summary> /// Gets the <see cref="JsonTypeInfo{T}" /> for <typeparamref name="T"/> from the <paramref name="context"/>, /// or throws an exception if it is not present. /// </summary> /// <typeparam name="T">Type to lookup.</typeparam> /// <param name="context">The <see cref="JsonSerializerContext"/>.</param> /// <returns>The <see cref="JsonTypeInfo{T}"/> from the context.</returns> /// <exception cref="InvalidOperationException">The type info was not found.</exception> public static JsonTypeInfo <T> GetTypeInfo <T>(this JsonSerializerContext context) { if (context.TryGetTypeInfo <T>(out var typeInfo)) { return(typeInfo); } ThrowNoMetadataForType(typeof(T)); return(null !); }
static void AssertGenericContext(JsonSerializerContext context) { Assert.NotNull(context); string json = JsonSerializer.Serialize(new JsonMessage { Message = "Hi" }, typeof(JsonMessage), context); JsonMessage deserialized = (JsonMessage)JsonSerializer.Deserialize(json, typeof(JsonMessage), context); Assert.Equal("Hi", deserialized.Message); }
public ContextSystemTextJsonSerializer(JsonSerializerContext context) { // ReSharper disable once ConditionIsAlwaysTrueOrFalse if (context == null) { ThrowHelper.ThrowArgumentNullException(nameof(context)); } Context = context; }
/// <summary> /// Converts the provided value into a <see cref="JsonDocument"/>. /// </summary> /// <returns>A <see cref="JsonDocument"/> representation of the value.</returns> /// <param name="value">The value to convert.</param> /// <param name="inputType">The type of the <paramref name="value"/> to convert.</param> /// <param name="context">A metadata provider for serializable types.</param> /// <exception cref="NotSupportedException"> /// There is no compatible <see cref="System.Text.Json.Serialization.JsonConverter"/> /// for <paramref name="inputType"/> or its serializable members. /// </exception> /// <exception cref="InvalidOperationException"> /// The <see cref="JsonSerializerContext.GetTypeInfo(Type)"/> method of the provided /// <paramref name="context"/> returns <see langword="null"/> for the type to convert. /// </exception> /// <exception cref="ArgumentNullException"> /// <paramref name="inputType"/> or <paramref name="context"/> is <see langword="null"/>. /// </exception> public static JsonDocument SerializeToDocument(object?value, Type inputType, JsonSerializerContext context) { if (context is null) { ThrowHelper.ThrowArgumentNullException(nameof(context)); } ValidateInputType(value, inputType); return(WriteDocumentAsObject(value, GetTypeInfo(context, inputType))); }
public override Task <object> DeserializeWrapper(string json, Type type, JsonSerializerContext context) { if (json is null) { // Emulate a null document for API validation tests. return(Task.FromResult(JsonSerializer.Deserialize(document: null, type, context))); } using JsonDocument document = JsonDocument.Parse(json); return(Task.FromResult(document.Deserialize(type, context))); }
/// <summary> /// Converts the provided value into a <see cref="byte"/> array. /// </summary> /// <returns>A UTF-8 representation of the value.</returns> /// <param name="value">The value to convert.</param> /// <param name="inputType">The type of the <paramref name="value"/> to convert.</param> /// <param name="context">A metadata provider for serializable types.</param> /// <exception cref="ArgumentException"> /// <paramref name="inputType"/> is not compatible with <paramref name="value"/>. /// </exception> /// <exception cref="System.ArgumentNullException"> /// <paramref name="inputType"/> is <see langword="null"/>. /// </exception> /// <exception cref="NotSupportedException"> /// There is no compatible <see cref="System.Text.Json.Serialization.JsonConverter"/> /// for <paramref name="inputType"/> or its serializable members. /// </exception> /// <exception cref="InvalidOperationException"> /// The <see cref="JsonSerializerContext.GetTypeInfo(Type)"/> method of the provided /// <paramref name="context"/> returns <see langword="null"/> for the type to convert. /// </exception> public static byte[] SerializeToUtf8Bytes(object?value, Type inputType, JsonSerializerContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } Type runtimeType = GetRuntimeTypeAndValidateInputType(value, inputType); return(WriteCoreBytes(value !, GetTypeInfo(context, runtimeType))); }
/// <summary> /// Converts the provided value into a <see cref="string"/>. /// </summary> /// <returns>A <see cref="string"/> representation of the value.</returns> /// <param name="value">The value to convert.</param> /// <param name="inputType">The type of the <paramref name="value"/> to convert.</param> /// <param name="context">A metadata provider for serializable types.</param> /// <exception cref="NotSupportedException"> /// There is no compatible <see cref="System.Text.Json.Serialization.JsonConverter"/> /// for <paramref name="inputType"/> or its serializable members. /// </exception> /// <exception cref="InvalidOperationException"> /// The <see cref="JsonSerializerContext.GetTypeInfo(Type)"/> method of the provided /// <paramref name="context"/> returns <see langword="null"/> for the type to convert. /// </exception> /// <exception cref="ArgumentNullException"> /// <paramref name="inputType"/> or <paramref name="context"/> is <see langword="null"/>. /// </exception> /// <remarks>Using a <see cref="string"/> is not as efficient as using UTF-8 /// encoding since the implementation internally uses UTF-8. See also <see cref="SerializeToUtf8Bytes(object?, Type, JsonSerializerContext)"/> /// and <see cref="SerializeAsync(IO.Stream, object?, Type, JsonSerializerContext, Threading.CancellationToken)"/>. /// </remarks> public static string Serialize(object?value, Type inputType, JsonSerializerContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } Type runtimeType = GetRuntimeTypeAndValidateInputType(value, inputType); return(WriteUsingMetadata(value, GetTypeInfo(context, runtimeType))); }
/// <summary> /// Converts the provided value into a <see cref="JsonDocument"/>. /// </summary> /// <returns>A <see cref="JsonDocument"/> representation of the value.</returns> /// <param name="value">The value to convert.</param> /// <param name="inputType">The type of the <paramref name="value"/> to convert.</param> /// <param name="context">A metadata provider for serializable types.</param> /// <exception cref="NotSupportedException"> /// There is no compatible <see cref="System.Text.Json.Serialization.JsonConverter"/> /// for <paramref name="inputType"/> or its serializable members. /// </exception> /// <exception cref="InvalidOperationException"> /// The <see cref="JsonSerializerContext.GetTypeInfo(Type)"/> method of the provided /// <paramref name="context"/> returns <see langword="null"/> for the type to convert. /// </exception> /// <exception cref="ArgumentNullException"> /// <paramref name="inputType"/> or <paramref name="context"/> is <see langword="null"/>. /// </exception> public static JsonDocument SerializeToDocument(object?value, Type inputType, JsonSerializerContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } Type runtimeType = GetRuntimeTypeAndValidateInputType(value, inputType); return(WriteDocumentUsingGeneratedSerializer(value, GetTypeInfo(context, runtimeType))); }
/// <summary> /// Converts the provided value into a <see cref="string"/>. /// </summary> /// <returns>A <see cref="string"/> representation of the value.</returns> /// <param name="value">The value to convert.</param> /// <param name="inputType">The type of the <paramref name="value"/> to convert.</param> /// <param name="context">A metadata provider for serializable types.</param> /// <exception cref="NotSupportedException"> /// There is no compatible <see cref="System.Text.Json.Serialization.JsonConverter"/> /// for <paramref name="inputType"/> or its serializable members. /// </exception> /// <exception cref="InvalidOperationException"> /// The <see cref="JsonSerializerContext.GetTypeInfo(Type)"/> method of the provided /// <paramref name="context"/> returns <see langword="null"/> for the type to convert. /// </exception> /// <exception cref="ArgumentNullException"> /// <paramref name="inputType"/> or <paramref name="context"/> is <see langword="null"/>. /// </exception> /// <remarks>Using a <see cref="string"/> is not as efficient as using UTF-8 /// encoding since the implementation internally uses UTF-8. See also <see cref="SerializeToUtf8Bytes(object?, Type, JsonSerializerContext)"/> /// and <see cref="SerializeAsync(IO.Stream, object?, Type, JsonSerializerContext, Threading.CancellationToken)"/>. /// </remarks> public static string Serialize(object?value, Type inputType, JsonSerializerContext context) { if (context is null) { ThrowHelper.ThrowArgumentNullException(nameof(context)); } Type type = GetRuntimeTypeAndValidateInputType(value, inputType); JsonTypeInfo jsonTypeInfo = GetTypeInfo(context, type); return(WriteStringUsingGeneratedSerializer(value, jsonTypeInfo)); }
public override Task <object> DeserializeWrapper(string json, Type type, JsonSerializerContext context) { if (json is null) { // Emulate a null document for API validation tests. return(Task.FromResult(JsonSerializer.Deserialize(node: null, type, context?.Options))); } JsonNode node = JsonNode.Parse(json, OptionsHelpers.GetNodeOptions(context?.Options), OptionsHelpers.GetDocumentOptions(context?.Options)); return(Task.FromResult(node.Deserialize(type, context))); }
/// <summary> /// Converts the provided value into a <see cref="byte"/> array. /// </summary> /// <returns>A UTF-8 representation of the value.</returns> /// <param name="value">The value to convert.</param> /// <param name="inputType">The type of the <paramref name="value"/> to convert.</param> /// <param name="context">A metadata provider for serializable types.</param> /// <exception cref="ArgumentException"> /// <paramref name="inputType"/> is not compatible with <paramref name="value"/>. /// </exception> /// <exception cref="System.ArgumentNullException"> /// <paramref name="inputType"/> is <see langword="null"/>. /// </exception> /// <exception cref="NotSupportedException"> /// There is no compatible <see cref="System.Text.Json.Serialization.JsonConverter"/> /// for <paramref name="inputType"/> or its serializable members. /// </exception> /// <exception cref="InvalidOperationException"> /// The <see cref="JsonSerializerContext.GetTypeInfo(Type)"/> method of the provided /// <paramref name="context"/> returns <see langword="null"/> for the type to convert. /// </exception> public static byte[] SerializeToUtf8Bytes(object?value, Type inputType, JsonSerializerContext context) { if (context is null) { ThrowHelper.ThrowArgumentNullException(nameof(context)); } ValidateInputType(value, inputType); JsonTypeInfo jsonTypeInfo = GetTypeInfo(context, inputType); return(WriteBytesAsObject(value, jsonTypeInfo)); }
/// <summary> /// Reads one JSON value (including objects or arrays) from the provided reader into a <paramref name="returnType"/>. /// </summary> /// <returns>A <paramref name="returnType"/> representation of the JSON value.</returns> /// <param name="reader">The reader to read.</param> /// <param name="returnType">The type of the object to convert to and return.</param> /// <param name="context">A metadata provider for serializable types.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="returnType"/> or <paramref name="context"/> is <see langword="null"/>. /// </exception> /// <exception cref="JsonException"> /// The JSON is invalid, /// <paramref name="returnType"/> is not compatible with the JSON, /// or a value could not be read from the reader. /// </exception> /// <exception cref="ArgumentException"> /// <paramref name="reader"/> is using unsupported options. /// </exception> /// <exception cref="NotSupportedException"> /// There is no compatible <see cref="System.Text.Json.Serialization.JsonConverter"/> /// for <paramref name="returnType"/> or its serializable members. /// </exception> /// <exception cref="InvalidOperationException"> /// The <see cref="JsonSerializerContext.GetTypeInfo(Type)"/> method on the provided <paramref name="context"/> /// did not return a compatible <see cref="JsonTypeInfo"/> for <paramref name="returnType"/>. /// </exception> /// <remarks> /// <para> /// If the <see cref="Utf8JsonReader.TokenType"/> property of <paramref name="reader"/> /// is <see cref="JsonTokenType.PropertyName"/> or <see cref="JsonTokenType.None"/>, the /// reader will be advanced by one call to <see cref="Utf8JsonReader.Read"/> to determine /// the start of the value. /// </para> /// /// <para> /// Upon completion of this method, <paramref name="reader"/> will be positioned at the /// final token in the JSON value. If an exception is thrown, the reader is reset to /// the state it was in when the method was called. /// </para> /// /// <para> /// This method makes a copy of the data the reader acted on, so there is no caller /// requirement to maintain data integrity beyond the return of this method. /// </para> /// <para> /// The <see cref="JsonReaderOptions"/> used to create the instance of the <see cref="Utf8JsonReader"/> take precedence over the <see cref="JsonSerializerOptions"/> when they conflict. /// Hence, <see cref="JsonReaderOptions.AllowTrailingCommas"/>, <see cref="JsonReaderOptions.MaxDepth"/>, and <see cref="JsonReaderOptions.CommentHandling"/> are used while reading. /// </para> /// </remarks> public static object?Deserialize(ref Utf8JsonReader reader, Type returnType, JsonSerializerContext context) { if (returnType is null) { ThrowHelper.ThrowArgumentNullException(nameof(returnType)); } if (context is null) { ThrowHelper.ThrowArgumentNullException(nameof(context)); } return(Read <object>(ref reader, GetTypeInfo(context, returnType))); }
private static JsonTypeInfo GetTypeInfo(JsonSerializerContext context, Type type) { Debug.Assert(context != null); Debug.Assert(type != null); JsonTypeInfo?info = context.GetTypeInfo(type); if (info is null) { ThrowHelper.ThrowInvalidOperationException_NoMetadataForType(type); } return(info); }
/// <summary> /// Parse the text representing a single JSON value into a <paramref name="returnType"/>. /// </summary> /// <returns>A <paramref name="returnType"/> representation of the JSON value.</returns> /// <param name="json">JSON text to parse.</param> /// <param name="returnType">The type of the object to convert to and return.</param> /// <param name="context">A metadata provider for serializable types.</param> /// <exception cref="System.ArgumentNullException"> /// <paramref name="json"/> is <see langword="null"/>. /// /// -or- /// /// <paramref name="context"/> is <see langword="null"/>. /// </exception> /// <exception cref="JsonException"> /// The JSON is invalid. /// /// -or- /// /// <paramref name="returnType" /> is not compatible with the JSON. /// /// -or- /// /// There is remaining data in the string beyond a single JSON value.</exception> /// <exception cref="NotSupportedException"> /// There is no compatible <see cref="System.Text.Json.Serialization.JsonConverter"/> /// for <paramref name="returnType"/> or its serializable members. /// </exception> /// <exception cref="InvalidOperationException"> /// The <see cref="JsonSerializerContext.GetTypeInfo(Type)"/> method of the provided /// <paramref name="context"/> returns <see langword="null"/> for the type to convert. /// </exception> /// <remarks>Using a <see cref="string"/> is not as efficient as using the /// UTF-8 methods since the implementation natively uses UTF-8. /// </remarks> public static object?Deserialize(ReadOnlySpan <char> json, Type returnType, JsonSerializerContext context) { if (returnType == null) { throw new ArgumentNullException(nameof(returnType)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } return(ReadUsingMetadata <object?>(json, GetTypeInfo(context, returnType))); }
public override Task <string> SerializeWrapper <T>(T value, JsonSerializerOptions?options = null) { Type runtimeType = GetRuntimeType(value); if (runtimeType != typeof(T)) { return(SerializeWrapper(value, runtimeType, options)); } JsonSerializerContext context = GetJsonSerializerContext(options); JsonTypeInfo <T> typeInfo = (JsonTypeInfo <T>)context.GetTypeInfo(typeof(T)); return(Task.FromResult(JsonSerializer.Serialize(value, typeInfo))); }
/// <summary> /// Converts the <see cref="JsonElement"/> representing a single JSON value into a <paramref name="returnType"/>. /// </summary> /// <returns>A <paramref name="returnType"/> representation of the JSON value.</returns> /// <param name="element">The <see cref="JsonElement"/> to convert.</param> /// <param name="returnType">The type of the object to convert to and return.</param> /// <param name="context">A metadata provider for serializable types.</param> /// <exception cref="System.ArgumentNullException"> /// <paramref name="returnType"/> is <see langword="null"/>. /// /// -or- /// /// <paramref name="context"/> is <see langword="null"/>. /// </exception> /// <exception cref="JsonException"> /// The JSON is invalid. /// /// -or- /// /// <paramref name="returnType" /> is not compatible with the JSON. /// /// -or- /// /// There is remaining data in the string beyond a single JSON value.</exception> /// <exception cref="NotSupportedException"> /// There is no compatible <see cref="System.Text.Json.Serialization.JsonConverter"/> /// for <paramref name="returnType"/> or its serializable members. /// </exception> /// <exception cref="InvalidOperationException"> /// The <see cref="JsonSerializerContext.GetTypeInfo(Type)"/> method of the provided /// <paramref name="context"/> returns <see langword="null"/> for the type to convert. /// </exception> public static object?Deserialize(this JsonElement element, Type returnType, JsonSerializerContext context) { if (returnType == null) { throw new ArgumentNullException(nameof(returnType)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } return(ReadUsingMetadata <object?>(element, GetTypeInfo(context, returnType))); }
/// <summary> /// Reads one JSON value (including objects or arrays) from the provided reader into a <paramref name="returnType"/>. /// </summary> /// <returns>A <paramref name="returnType"/> representation of the JSON value.</returns> /// <param name="reader">The reader to read.</param> /// <param name="returnType">The type of the object to convert to and return.</param> /// <param name="context">A metadata provider for serializable types.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="returnType"/> or <paramref name="context"/> is <see langword="null"/>. /// </exception> /// <exception cref="JsonException"> /// Thrown when the JSON is invalid, /// <paramref name="returnType"/> is not compatible with the JSON, /// or a value could not be read from the reader. /// </exception> /// <exception cref="ArgumentException"> /// <paramref name="reader"/> is using unsupported options. /// </exception> /// <exception cref="NotSupportedException"> /// There is no compatible <see cref="System.Text.Json.Serialization.JsonConverter"/> /// for <paramref name="returnType"/> or its serializable members. /// </exception> /// <exception cref="InvalidOperationException"> /// The <see cref="JsonSerializerContext.GetTypeInfo(Type)"/> method on the provided <paramref name="context"/> /// did not return a compatible <see cref="JsonTypeInfo"/> for <paramref name="returnType"/>. /// </exception> /// <remarks> /// <para> /// If the <see cref="Utf8JsonReader.TokenType"/> property of <paramref name="reader"/> /// is <see cref="JsonTokenType.PropertyName"/> or <see cref="JsonTokenType.None"/>, the /// reader will be advanced by one call to <see cref="Utf8JsonReader.Read"/> to determine /// the start of the value. /// </para> /// /// <para> /// Upon completion of this method <paramref name="reader"/> will be positioned at the /// final token in the JSON value. If an exception is thrown the reader is reset to /// the state it was in when the method was called. /// </para> /// /// <para> /// This method makes a copy of the data the reader acted on, so there is no caller /// requirement to maintain data integrity beyond the return of this method. /// </para> /// <para> /// The <see cref="JsonReaderOptions"/> used to create the instance of the <see cref="Utf8JsonReader"/> take precedence over the <see cref="JsonSerializerOptions"/> when they conflict. /// Hence, <see cref="JsonReaderOptions.AllowTrailingCommas"/>, <see cref="JsonReaderOptions.MaxDepth"/>, and <see cref="JsonReaderOptions.CommentHandling"/> are used while reading. /// </para> /// </remarks> public static object?Deserialize(ref Utf8JsonReader reader, Type returnType, JsonSerializerContext context) { if (returnType == null) { throw new ArgumentNullException(nameof(returnType)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } return(ReadUsingMetadata <object>(ref reader, GetTypeInfo(context, returnType))); }
/// <summary> /// Converts the <see cref="JsonNode"/> representing a single JSON value into a <paramref name="returnType"/>. /// </summary> /// <returns>A <paramref name="returnType"/> representation of the JSON value.</returns> /// <param name="node">The <see cref="JsonNode"/> to convert.</param> /// <param name="returnType">The type of the object to convert to and return.</param> /// <param name="context">A metadata provider for serializable types.</param> /// <exception cref="System.ArgumentNullException"> /// <paramref name="returnType"/> is <see langword="null"/>. /// /// -or- /// /// <paramref name="context"/> is <see langword="null"/>. /// </exception> /// <exception cref="JsonException"> /// The JSON is invalid. /// /// -or- /// /// <paramref name="returnType" /> is not compatible with the JSON. /// /// -or- /// /// There is remaining data in the string beyond a single JSON value.</exception> /// <exception cref="NotSupportedException"> /// There is no compatible <see cref="System.Text.Json.Serialization.JsonConverter"/> /// for <paramref name="returnType"/> or its serializable members. /// </exception> /// <exception cref="InvalidOperationException"> /// The <see cref="JsonSerializerContext.GetTypeInfo(Type)"/> method of the provided /// <paramref name="context"/> returns <see langword="null"/> for the type to convert. /// </exception> public static object?Deserialize(this JsonNode?node, Type returnType, JsonSerializerContext context) { if (returnType is null) { ThrowHelper.ThrowArgumentNullException(nameof(returnType)); } if (context is null) { ThrowHelper.ThrowArgumentNullException(nameof(context)); } JsonTypeInfo jsonTypeInfo = GetTypeInfo(context, returnType); return(ReadNode <object?>(node, jsonTypeInfo)); }
private static JsonTypeInfo GetTypeInfo(JsonSerializerContext context, Type inputType) { Debug.Assert(context != null); Debug.Assert(inputType != null); JsonTypeInfo?info = context.GetTypeInfo(inputType); if (info is null) { ThrowHelper.ThrowInvalidOperationException_NoMetadataForType(inputType, context); } info.EnsureConfigured(); return(info); }
public void ConstructingFromOptionsKeepsReference() { JsonStringEnumConverter converter = new(); JsonSerializerOptions options = new() { PropertyNameCaseInsensitive = true, Converters = { converter } }; JsonSerializerContext context = (JsonSerializerContext)_contextCreator(options); Assert.Same(options, context.Options); Assert.Equal(options.PropertyNameCaseInsensitive, context.Options.PropertyNameCaseInsensitive); Assert.Same(converter, context.Options.Converters[0]); }
public void JsonContextOptionsNotMutableAfterConstruction() { JsonSerializerContext context = (JsonSerializerContext)DefaultContext; InvalidOperationException ex = Assert.Throws <InvalidOperationException>(() => context.Options.PropertyNameCaseInsensitive = true); string exAsStr = ex.ToString(); Assert.Contains("JsonSerializerOptions", exAsStr); Assert.Contains("JsonSerializerContext", exAsStr); context = (JsonSerializerContext)_contextCreator(new JsonSerializerOptions()); ex = Assert.Throws <InvalidOperationException>(() => context.Options.PropertyNameCaseInsensitive = true); exAsStr = ex.ToString(); Assert.Contains("JsonSerializerOptions", exAsStr); Assert.Contains("JsonSerializerContext", exAsStr); }
/// <summary> /// Converts the <see cref="JsonElement"/> representing a single JSON value into a <paramref name="returnType"/>. /// </summary> /// <returns>A <paramref name="returnType"/> representation of the JSON value.</returns> /// <param name="element">The <see cref="JsonElement"/> to convert.</param> /// <param name="returnType">The type of the object to convert to and return.</param> /// <param name="context">A metadata provider for serializable types.</param> /// <exception cref="System.ArgumentNullException"> /// <paramref name="returnType"/> is <see langword="null"/>. /// /// -or- /// /// <paramref name="context"/> is <see langword="null"/>. /// </exception> /// <exception cref="JsonException"> /// The JSON is invalid. /// /// -or- /// /// <paramref name="returnType" /> is not compatible with the JSON. /// /// -or- /// /// There is remaining data in the string beyond a single JSON value.</exception> /// <exception cref="NotSupportedException"> /// There is no compatible <see cref="System.Text.Json.Serialization.JsonConverter"/> /// for <paramref name="returnType"/> or its serializable members. /// </exception> /// <exception cref="InvalidOperationException"> /// The <see cref="JsonSerializerContext.GetTypeInfo(Type)"/> method of the provided /// <paramref name="context"/> returns <see langword="null"/> for the type to convert. /// </exception> public static object?Deserialize(this JsonElement element, Type returnType, JsonSerializerContext context) { if (returnType is null) { ThrowHelper.ThrowArgumentNullException(nameof(returnType)); } if (context is null) { ThrowHelper.ThrowArgumentNullException(nameof(context)); } JsonTypeInfo jsonTypeInfo = GetTypeInfo(context, returnType); return(ReadUsingMetadata <object?>(element, jsonTypeInfo)); }