Consider the TryWrite pattern, optimistically assuming you have enough space rather than pre-computing

[ahsonkhan]

For context: #2291 (comment)

Investigate if certain JsonWriter APIs become faster if we skip the pre-compute bytes needed step and use the TryWrite pattern.

I think we should write everything with Try methods, as in most cases the buffer will be large enough.

cc @KrzysztofCwalina

[ahsonkhan]

For example:

        public void WriteAttribute(string name, string value)
        {
            if (UseFastUtf8)
            {
                ReadOnlySpan<byte> nameSpan = MemoryMarshal.AsBytes(name.AsSpan());
                ReadOnlySpan<byte> valueSpan = MemoryMarshal.AsBytes(value.AsSpan());
                // int bytesNeeded = CalculateAttributeBytesNeeded(nameSpan, valueSpan, sizeof(byte));
                // WriteAttributeUtf8(nameSpan, valueSpan, bytesNeeded);
                while (!TryWriteAttributeUtf8(nameSpan, valueSpan))
                {
                    EnsureBuffer();
                }
            }
            ...

        private bool TryWriteAttributeUtf8(ReadOnlySpan<byte> nameSpanByte, ReadOnlySpan<byte> valueSpanByte)
        {
            Span<byte> byteBuffer = _bufferWriter.GetSpan();
            int idx = 0;

            if (!_firstItem)
            {
                if (byteBuffer.Length < idx) goto False; // extra check since we aren't pre-computing
                byteBuffer[idx++] = JsonConstants.ListSeperator;
            }

            if (_prettyPrint)
            {
                if (byteBuffer.Length - 1 < idx) goto False; // extra check since we aren't pre-computing
                byteBuffer[idx++] = JsonConstants.CarriageReturn;
                byteBuffer[idx++] = JsonConstants.LineFeed;

                int indent = _indent;

                while (indent-- >= 0)
                {
                    if (byteBuffer.Length - 1 < idx) goto False; // extra check since we aren't pre-computing
                    byteBuffer[idx++] = JsonConstants.Space;
                    byteBuffer[idx++] = JsonConstants.Space;
                }
            }

            if (byteBuffer.Length - 1 < idx) goto False; // extra check since we aren't pre-computing
            byteBuffer[idx++] = JsonConstants.Quote;

            OperationStatus status = Encodings.Utf16.ToUtf8(nameSpanByte, byteBuffer.Slice(idx), out int consumed, out int written);
            if (status == OperationStatus.DestinationTooSmall) goto False; // extra check since we aren't pre-computing
            Debug.Assert(consumed == nameSpanByte.Length);
            if (status != OperationStatus.Done)
            {
                JsonThrowHelper.ThrowFormatException();
            }

            idx += written;

            if (byteBuffer.Length - 1 < idx) goto False; // extra check since we aren't pre-computing
            byteBuffer[idx++] = JsonConstants.Quote;

            byteBuffer[idx++] = JsonConstants.KeyValueSeperator;

            if (_prettyPrint)
            {
                if (byteBuffer.Length < idx) goto False; // extra check since we aren't pre-computing
                byteBuffer[idx++] = JsonConstants.Space;
            }

            if (byteBuffer.Length - 1 < idx) goto False; // extra check since we aren't pre-computing
            byteBuffer[idx++] = JsonConstants.Quote;

            status = Encodings.Utf16.ToUtf8(valueSpanByte, byteBuffer.Slice(idx), out consumed, out written);
            if (status == OperationStatus.DestinationTooSmall) goto False; // extra check since we aren't pre-computing
            Debug.Assert(consumed == valueSpanByte.Length);
            if (status != OperationStatus.Done)
            {
                JsonThrowHelper.ThrowFormatException();
            }
            idx += written;

            if (byteBuffer.Length - 1 < idx) goto False; // extra check since we aren't pre-computing
            byteBuffer[idx++] = JsonConstants.Quote;

            _bufferWriter.Advance(idx);
            _firstItem = false;

            return true;
            False:
            return false;
        }

[KrzysztofCwalina]

The Try implementation is very long. It won't be inlined. And so one thing you might type is to remove all the range checks and simply wrap the method body in try-catch(IndexOutOfRangeException). It would give us an idea of the perf we could get is we added a Try setter to Span<T>.