EncodingExtensions.cs

Go to the documentation of this file.

using System.Buffers;
using System.Text;
 
namespace System.Text
{
 
    static class EncodingExtensions
    {
 
#if NETFRAMEWORK
 
        const int MaxInputElementsPerIteration = 1 * 1024 * 1024;
 
        public static unsafe long GetBytes(this Encoding encoding, ReadOnlySpan<char> chars, IBufferWriter<byte> writer)
        {
            if (encoding is null)
                throw new ArgumentNullException(nameof(encoding));
            if (writer is null)
                throw new ArgumentNullException(nameof(writer));
 
            if (chars.Length <= MaxInputElementsPerIteration)
            {
                // The input span is small enough where we can one-shot this.
 
                int byteCount = encoding.GetByteCount(chars);
                Span<byte> scratchBuffer = writer.GetSpan(byteCount);
 
                int actualBytesWritten = encoding.GetBytes(chars, scratchBuffer);
 
                writer.Advance(actualBytesWritten);
                return actualBytesWritten;
            }
            else
            {
                // Allocate a stateful Encoder instance and chunk this.
 
                encoding.GetEncoder().Convert(chars, writer, flush: true, out long totalBytesWritten, out _);
                return totalBytesWritten;
            }
        }
 
        public static unsafe int GetBytes(this Encoding encoding, string chars, Span<byte> bytes)
        {
            return encoding.GetBytes(chars.AsSpan(), bytes);
        }
 
        public static unsafe int GetChars(this Encoding encoding, ReadOnlySpan<byte> bytes, Span<char> chars)
        {
            fixed (byte* bytesPtr = bytes)
            fixed (char* charsPtr = chars)
                return encoding.GetChars(bytesPtr, bytes.Length, charsPtr, chars.Length);
        }
 
        public static unsafe int GetCharCount(this Encoding encoding, ReadOnlySpan<byte> bytes)
        {
            fixed (byte* bytesPtr = bytes)
            {
                return encoding.GetCharCount(bytesPtr, bytes.Length);
            }
        }
 
        public static unsafe int GetByteCount(this Encoder encoder, ReadOnlySpan<char> chars, bool flush)
        {
            fixed (char* charsPtr = chars)
            {
                return encoder.GetByteCount(charsPtr, chars.Length, flush);
            }
        }
 
        public static void Convert(this Encoder encoder, ReadOnlySpan<char> chars, IBufferWriter<byte> writer, bool flush, out long bytesUsed, out bool completed)
        {
            if (encoder is null)
                throw new ArgumentNullException(nameof(encoder));
            if (writer is null)
                throw new ArgumentNullException(nameof(writer));
 
            // We need to perform at least one iteration of the loop since the encoder could have internal state.
 
            long totalBytesWritten = 0;
 
            do
            {
                // If our remaining input is very large, instead truncate it and tell the encoder
                // that there'll be more data after this call. This truncation is only for the
                // purposes of getting the required byte count. Since the writer may give us a span
                // larger than what we asked for, we'll pass the entirety of the remaining data
                // to the transcoding routine, since it may be able to make progress beyond what
                // was initially computed for the truncated input data.
 
                int byteCountForThisSlice = chars.Length <= MaxInputElementsPerIteration
                  ? encoder.GetByteCount(chars, flush)
                  : encoder.GetByteCount(chars.Slice(0, MaxInputElementsPerIteration), flush: false /* this isn't the end of the data */);
 
                Span<byte> scratchBuffer = writer.GetSpan(byteCountForThisSlice);
 
                encoder.Convert(chars, scratchBuffer, flush, out int charsUsedJustNow, out int bytesWrittenJustNow, out completed);
 
                chars = chars.Slice(charsUsedJustNow);
                writer.Advance(bytesWrittenJustNow);
                totalBytesWritten += bytesWrittenJustNow;
            } while (!chars.IsEmpty);
 
            bytesUsed = totalBytesWritten;
        }
 
        public static unsafe void Convert(this Encoder encoder, ReadOnlySpan<char> chars, Span<byte> bytes, bool flush, out int charsUsed, out int bytesUsed, out bool completed)
        {
            fixed (char* charsPtr = chars)
            fixed (byte* bytesPtr = bytes)
            {
                encoder.Convert(charsPtr, chars.Length, bytesPtr, bytes.Length, flush, out charsUsed, out bytesUsed, out completed);
            }
        }
 
#endif
 
    }
 
}