System.IO.StreamReader.ReadBlockAsync C# (CSharp) Method

        public override Task<int> ReadBlockAsync(char[] buffer, int index, int count)
        {
            if (buffer == null)
            {
                throw new ArgumentNullException(nameof(buffer), SR.ArgumentNull_Buffer);
            }
            if (index < 0 || count < 0)
            {
                throw new ArgumentOutOfRangeException(index < 0 ? nameof(index) : nameof(count), SR.ArgumentOutOfRange_NeedNonNegNum);
            }
            if (buffer.Length - index < count)
            {
                throw new ArgumentException(SR.Argument_InvalidOffLen);
            }

            // If we have been inherited into a subclass, the following implementation could be incorrect
            // since it does not call through to Read() which a subclass might have overridden.  
            // To be safe we will only use this implementation in cases where we know it is safe to do so,
            // and delegate to our base class (which will call into Read) when we are not sure.
            if (GetType() != typeof(StreamReader))
            {
                return base.ReadBlockAsync(buffer, index, count);
            }

            if (_stream == null)
            {
                throw new ObjectDisposedException(null, SR.ObjectDisposed_ReaderClosed);
            }

            CheckAsyncTaskInProgress();

            Task<int> task = base.ReadBlockAsync(buffer, index, count);
            _asyncReadTask = task;

            return task;
        }

        protected static async Task <object> ReadStreamInChuncksAsync(Stream stream, int?maxLength = null)
        {
            if (stream == null || stream?.Length == 0)
            {
                return("");
            }

            string hasMore = maxLength.HasValue ? (stream.Length > maxLength.Value ? "..." : "") : "";

            int readChunkBufferength = 4096;

            if (maxLength.HasValue && maxLength < readChunkBufferength)
            {
                readChunkBufferength = maxLength.Value;
            }

            stream.Seek(0, SeekOrigin.Begin);

            using (var textwriter = new StringWriter())
            {
                using (var reader = new System.IO.StreamReader(stream, System.Text.Encoding.Default, true, 1024, true))
                {
                    var readChunk       = new char[readChunkBufferength];
                    int readChunkLength = 0;
                    int alreadyRead     = 0;
                    do
                    {
                        readChunkLength = await reader.ReadBlockAsync(readChunk, 0, readChunkBufferength);

                        alreadyRead += readChunkLength;

                        await textwriter.WriteAsync(readChunk, 0, readChunkLength);

                        if (maxLength.HasValue && alreadyRead + readChunkBufferength > maxLength)
                        {
                            readChunkBufferength = maxLength.Value - alreadyRead;
                        }
                    }while (readChunkLength > 0 && readChunkBufferength > 0);

                    if (hasMore.Length > 0)
                    {
                        return(textwriter.ToString() + hasMore);
                    }
                    else
                    {
                        try
                        {
                            return(System.Text.Json.JsonSerializer.Deserialize <System.Text.Json.JsonElement>(textwriter.ToString()));
                        }
                        catch
                        {
                            return(textwriter.ToString());
                        }
                    }
                }
            }

            stream.Seek(0, SeekOrigin.Begin);
        }