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));
}
