public static void ValidateValue(ReadOnlySpan <char> value)
{
if (value.Length > JsonConstants.MaxCharacterTokenSize)
{
ThrowHelper.ThrowArgumentException_ValueTooLarge(value.Length);
}
}
public static void ValidateBytes(ReadOnlySpan <byte> bytes)
{
if (bytes.Length > JsonConstants.MaxBase46ValueTokenSize)
{
ThrowHelper.ThrowArgumentException_ValueTooLarge(bytes.Length);
}
}
public static void ValidateValue(ReadOnlySpan <byte> value)
{
if (value.Length > JsonConstants.MaxUnescapedTokenSize)
{
ThrowHelper.ThrowArgumentException_ValueTooLarge(value.Length);
}
}
private void TranscodeAndWriteRawValue(ReadOnlySpan <char> json, bool skipInputValidation)
{
if (json.Length > JsonConstants.MaxUtf16RawValueLength)
{
ThrowHelper.ThrowArgumentException_ValueTooLarge(json.Length);
}
byte[]? tempArray = null;
// For performance, avoid obtaining actual byte count unless memory usage is higher than the threshold.
Span <byte> utf8Json = json.Length <= (JsonConstants.ArrayPoolMaxSizeBeforeUsingNormalAlloc / JsonConstants.MaxExpansionFactorWhileTranscoding) ?
// Use a pooled alloc.
tempArray = ArrayPool <byte> .Shared.Rent(json.Length *JsonConstants.MaxExpansionFactorWhileTranscoding) :
// Use a normal alloc since the pool would create a normal alloc anyway based on the threshold (per current implementation)
// and by using a normal alloc we can avoid the Clear().
new byte[JsonReaderHelper.GetUtf8ByteCount(json)];
try
{
int actualByteCount = JsonReaderHelper.GetUtf8FromText(json, utf8Json);
utf8Json = utf8Json.Slice(0, actualByteCount);
WriteRawValueCore(utf8Json, skipInputValidation);
}
finally
{
if (tempArray != null)
{
utf8Json.Clear();
ArrayPool <byte> .Shared.Return(tempArray);
}
}
}
/// <summary>
/// Writes the input as JSON content. It is expected that the input content is a single complete JSON value.
/// </summary>
/// <param name="utf8Json">The raw JSON content to write.</param>
/// <param name="skipInputValidation">Whether to validate if the input is an RFC 8259-compliant JSON payload.</param>
/// <exception cref="ArgumentException">Thrown if the length of the input is zero or equal to <see cref="int.MaxValue"/>.</exception>
/// <exception cref="JsonException">
/// Thrown if <paramref name="skipInputValidation"/> is <see langword="false"/>, and the input
/// is not a valid, complete, single JSON value according to the JSON RFC (https://tools.ietf.org/html/rfc8259)
/// or the input JSON exceeds a recursive depth of 64.
/// </exception>
/// <remarks>
/// When writing untrused JSON values, do not set <paramref name="skipInputValidation"/> to <see langword="true"/> as this can result in invalid JSON
/// being written, and/or the overall payload being written to the writer instance being invalid.
///
/// When using this method, the input content will be written to the writer destination as-is, unless validation fails (when it is enabled).
///
/// The <see cref="JsonWriterOptions.SkipValidation"/> value for the writer instance is honored when using this method.
///
/// The <see cref="JsonWriterOptions.Indented"/> and <see cref="JsonWriterOptions.Encoder"/> values for the writer instance are not applied when using this method.
/// </remarks>
public void WriteRawValue(ReadOnlySpan <byte> utf8Json, bool skipInputValidation = false)
{
if (!_options.SkipValidation)
{
ValidateWritingValue();
}
if (utf8Json.Length == int.MaxValue)
{
ThrowHelper.ThrowArgumentException_ValueTooLarge(int.MaxValue);
}
WriteRawValueCore(utf8Json, skipInputValidation);
}
