diff --git a/src/Renci.SshNet/ShellStream.cs b/src/Renci.SshNet/ShellStream.cs
index ce57072d5..0a3d14348 100644
--- a/src/Renci.SshNet/ShellStream.cs
+++ b/src/Renci.SshNet/ShellStream.cs
@@ -41,7 +41,7 @@ public class ShellStream : Stream
         /// Gets a value indicating whether data is available on the <see cref="ShellStream"/> to be read.
         /// </summary>
         /// <value>
-        /// <see langword="true"/> if data is available to be read; otherwise, <see langword="false"/>.
+        /// <c>true</c> if data is available to be read; otherwise, <c>false</c>.
         /// </value>
         public bool DataAvailable
         {
@@ -119,7 +119,7 @@ internal ShellStream(ISession session, string terminalName, uint columns, uint r
         /// Gets a value indicating whether the current stream supports reading.
         /// </summary>
         /// <returns>
-        /// <see langword="true"/> if the stream supports reading; otherwise, <see langword="false"/>.
+        /// <c>true</c> if the stream supports reading; otherwise, <c>false</c>.
         /// </returns>
         public override bool CanRead
         {
@@ -130,7 +130,7 @@ public override bool CanRead
         /// Gets a value indicating whether the current stream supports seeking.
         /// </summary>
         /// <returns>
-        /// <see langword="true"/> if the stream supports seeking; otherwise, <see langword="false"/>.
+        /// <c>true</c> if the stream supports seeking; otherwise, <c>false</c>.
         /// </returns>
         public override bool CanSeek
         {
@@ -141,7 +141,7 @@ public override bool CanSeek
         /// Gets a value indicating whether the current stream supports writing.
         /// </summary>
         /// <returns>
-        /// <see langword="true"/> if the stream supports writing; otherwise, <see langword="false"/>.
+        /// <c>true</c> if the stream supports writing; otherwise, <c>false</c>.
         /// </returns>
         public override bool CanWrite
         {
@@ -155,14 +155,10 @@ public override bool CanWrite
         /// <exception cref="ObjectDisposedException">Methods were called after the stream was closed.</exception>
         public override void Flush()
         {
-#if NET7_0_OR_GREATER
-            ObjectDisposedException.ThrowIf(_channel is null, this);
-#else
             if (_channel is null)
             {
-                throw new ObjectDisposedException(GetType().FullName);
+                throw new ObjectDisposedException("ShellStream");
             }
-#endif // NET7_0_OR_GREATER
 
             if (_outgoing.Count > 0)
             {
@@ -203,6 +199,36 @@ public override long Position
             set { throw new NotSupportedException(); }
         }
 
+        /// <summary>
+        /// Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values between <paramref name="offset"/> and (<paramref name="offset"/> + <paramref name="count"/> - 1) replaced by the bytes read from the current source.</param>
+        /// <param name="offset">The zero-based byte offset in <paramref name="buffer"/> at which to begin storing the data read from the current stream.</param>
+        /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
+        /// <returns>
+        /// The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.
+        /// </returns>
+        /// <exception cref="ArgumentException">The sum of <paramref name="offset"/> and <paramref name="count"/> is larger than the buffer length. </exception>
+        /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="offset"/> or <paramref name="count"/> is negative.</exception>
+        /// <exception cref="IOException">An I/O error occurs.</exception>
+        /// <exception cref="NotSupportedException">The stream does not support reading.</exception>
+        /// <exception cref="ObjectDisposedException">Methods were called after the stream was closed.</exception>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            var i = 0;
+
+            lock (_incoming)
+            {
+                for (; i < count && _incoming.Count > 0; i++)
+                {
+                    buffer[offset + i] = _incoming.Dequeue();
+                }
+            }
+
+            return i;
+        }
+
         /// <summary>
         /// This method is not supported.
         /// </summary>
@@ -231,6 +257,31 @@ public override void SetLength(long value)
             throw new NotSupportedException();
         }
 
+        /// <summary>
+        /// Writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. This method copies <paramref name="count"/> bytes from <paramref name="buffer"/> to the current stream.</param>
+        /// <param name="offset">The zero-based byte offset in <paramref name="buffer"/> at which to begin copying bytes to the current stream.</param>
+        /// <param name="count">The number of bytes to be written to the current stream.</param>
+        /// <exception cref="ArgumentException">The sum of <paramref name="offset"/> and <paramref name="count"/> is greater than the buffer length.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="offset"/> or <paramref name="count"/> is negative.</exception>
+        /// <exception cref="IOException">An I/O error occurs.</exception>
+        /// <exception cref="NotSupportedException">The stream does not support writing.</exception>
+        /// <exception cref="ObjectDisposedException">Methods were called after the stream was closed.</exception>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            foreach (var b in buffer.Take(offset, count))
+            {
+                if (_outgoing.Count == _bufferSize)
+                {
+                    Flush();
+                }
+
+                _outgoing.Enqueue(b);
+            }
+        }
+
         /// <summary>
         /// Expects the specified expression and performs action when one is found.
         /// </summary>
@@ -300,95 +351,6 @@ public void Expect(TimeSpan timeout, params ExpectAction[] expectActions)
             while (!expectedFound);
         }
 
-        /// <summary>
-        /// Expects the expression specified by text.
-        /// </summary>
-        /// <param name="text">The text to expect.</param>
-        /// <returns>
-        /// Text available in the shell that ends with expected text.
-        /// </returns>
-        public string Expect(string text)
-        {
-            return Expect(new Regex(Regex.Escape(text)), Session.InfiniteTimeSpan);
-        }
-
-        /// <summary>
-        /// Expects the expression specified by text.
-        /// </summary>
-        /// <param name="text">The text to expect.</param>
-        /// <param name="timeout">Time to wait for input.</param>
-        /// <returns>
-        /// The text available in the shell that ends with expected text, or <see langword="null"/> if the specified time has elapsed.
-        /// </returns>
-        public string Expect(string text, TimeSpan timeout)
-        {
-            return Expect(new Regex(Regex.Escape(text)), timeout);
-        }
-
-        /// <summary>
-        /// Expects the expression specified by regular expression.
-        /// </summary>
-        /// <param name="regex">The regular expression to expect.</param>
-        /// <returns>
-        /// The text available in the shell that contains all the text that ends with expected expression.
-        /// </returns>
-        public string Expect(Regex regex)
-        {
-            return Expect(regex, TimeSpan.Zero);
-        }
-
-        /// <summary>
-        /// Expects the expression specified by regular expression.
-        /// </summary>
-        /// <param name="regex">The regular expression to expect.</param>
-        /// <param name="timeout">Time to wait for input.</param>
-        /// <returns>
-        /// The text available in the shell that contains all the text that ends with expected expression,
-        /// or <see langword="null"/> if the specified time has elapsed.
-        /// </returns>
-        public string Expect(Regex regex, TimeSpan timeout)
-        {
-            var text = string.Empty;
-
-            while (true)
-            {
-                lock (_incoming)
-                {
-                    if (_incoming.Count > 0)
-                    {
-                        text = _encoding.GetString(_incoming.ToArray(), 0, _incoming.Count);
-                    }
-
-                    var match = regex.Match(text);
-
-                    if (match.Success)
-                    {
-                        // Remove processed items from the queue
-                        for (var i = 0; i < match.Index + match.Length && _incoming.Count > 0; i++)
-                        {
-                            _ = _incoming.Dequeue();
-                        }
-
-                        break;
-                    }
-                }
-
-                if (timeout.Ticks > 0)
-                {
-                    if (!_dataReceived.WaitOne(timeout))
-                    {
-                        return null;
-                    }
-                }
-                else
-                {
-                    _ = _dataReceived.WaitOne();
-                }
-            }
-
-            return text;
-        }
-
         /// <summary>
         /// Begins the expect.
         /// </summary>
@@ -438,9 +400,7 @@ public IAsyncResult BeginExpect(AsyncCallback callback, object state, params Exp
         /// <returns>
         /// An <see cref="IAsyncResult" /> that references the asynchronous operation.
         /// </returns>
-#pragma warning disable CA1859 // Use concrete types when possible for improved performance
         public IAsyncResult BeginExpect(TimeSpan timeout, AsyncCallback callback, object state, params ExpectAction[] expectActions)
-#pragma warning restore CA1859 // Use concrete types when possible for improved performance
         {
             var text = string.Empty;
 
@@ -521,9 +481,6 @@ public IAsyncResult BeginExpect(TimeSpan timeout, AsyncCallback callback, object
         /// Ends the execute.
         /// </summary>
         /// <param name="asyncResult">The async result.</param>
-        /// <returns>
-        /// Text available in the shell that ends with expected text.
-        /// </returns>
         /// <exception cref="ArgumentException">Either the IAsyncResult object did not come from the corresponding async method on this type, or EndExecute was called multiple times with the same IAsyncResult.</exception>
         public string EndExpect(IAsyncResult asyncResult)
         {
@@ -536,6 +493,97 @@ public string EndExpect(IAsyncResult asyncResult)
             return ar.EndInvoke();
         }
 
+        /// <summary>
+        /// Expects the expression specified by text.
+        /// </summary>
+        /// <param name="text">The text to expect.</param>
+        /// <returns>
+        /// Text available in the shell that ends with expected text.
+        /// </returns>
+        public string Expect(string text)
+        {
+            return Expect(new Regex(Regex.Escape(text)), Session.InfiniteTimeSpan);
+        }
+
+        /// <summary>
+        /// Expects the expression specified by text.
+        /// </summary>
+        /// <param name="text">The text to expect.</param>
+        /// <param name="timeout">Time to wait for input.</param>
+        /// <returns>
+        /// The text available in the shell that ends with expected text, or <c>null</c> if the specified time has elapsed.
+        /// </returns>
+        public string Expect(string text, TimeSpan timeout)
+        {
+            return Expect(new Regex(Regex.Escape(text)), timeout);
+        }
+
+        /// <summary>
+        /// Expects the expression specified by regular expression.
+        /// </summary>
+        /// <param name="regex">The regular expression to expect.</param>
+        /// <returns>
+        /// The text available in the shell that contains all the text that ends with expected expression.
+        /// </returns>
+        public string Expect(Regex regex)
+        {
+            return Expect(regex, TimeSpan.Zero);
+        }
+
+        /// <summary>
+        /// Expects the expression specified by regular expression.
+        /// </summary>
+        /// <param name="regex">The regular expression to expect.</param>
+        /// <param name="timeout">Time to wait for input.</param>
+        /// <returns>
+        /// The text available in the shell that contains all the text that ends with expected expression,
+        /// or <c>null</c> if the specified time has elapsed.
+        /// </returns>
+        public string Expect(Regex regex, TimeSpan timeout)
+        {
+            var text = string.Empty;
+
+            while (true)
+            {
+                lock (_incoming)
+                {
+                    if (_incoming.Count > 0)
+                    {
+                        text = _encoding.GetString(_incoming.ToArray(), 0, _incoming.Count);
+                    }
+
+                    var match = regex.Match(text);
+
+                    if (match.Success)
+                    {
+                        //  Remove processed items from the queue
+                        text = text.Substring(0, match.Index + match.Length);
+                        var bytesProcessed = _encoding.GetByteCount(text);
+                        for (var i = 0; i < bytesProcessed && _incoming.Count > 0; i++)
+                        {
+                            _ = _incoming.Dequeue();
+                        }
+
+                        break;
+                    }
+                }
+
+                if (timeout.Ticks > 0)
+                {
+                    if (!_dataReceived.WaitOne(timeout))
+                    {
+                        return null;
+                    }
+                }
+                else
+                {
+                    _ = _dataReceived.WaitOne();
+                }
+            }
+
+            return text;
+        }
+
         /// <summary>
         /// Reads the line from the shell. If line is not available it will block the execution and will wait for new line.
         /// </summary>
@@ -552,7 +600,7 @@ public string ReadLine()
         /// </summary>
         /// <param name="timeout">Time to wait for input.</param>
         /// <returns>
-        /// The line read from the shell, or <see langword="null"/> when no input is received for the specified timeout.
+        /// The line read from the shell, or <c>null</c> when no input is received for the specified timeout.
         /// </returns>
         public string ReadLine(TimeSpan timeout)
         {
@@ -621,42 +669,12 @@ public string Read()
             return text;
         }
 
-        /// <summary>
-        /// Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.
-        /// </summary>
-        /// <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values between <paramref name="offset"/> and (<paramref name="offset"/> + <paramref name="count"/> - 1) replaced by the bytes read from the current source.</param>
-        /// <param name="offset">The zero-based byte offset in <paramref name="buffer"/> at which to begin storing the data read from the current stream.</param>
-        /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
-        /// <returns>
-        /// The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.
-        /// </returns>
-        /// <exception cref="ArgumentException">The sum of <paramref name="offset"/> and <paramref name="count"/> is larger than the buffer length. </exception>
-        /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentOutOfRangeException"><paramref name="offset"/> or <paramref name="count"/> is negative.</exception>
-        /// <exception cref="IOException">An I/O error occurs.</exception>
-        /// <exception cref="NotSupportedException">The stream does not support reading.</exception>
-        /// <exception cref="ObjectDisposedException">Methods were called after the stream was closed.</exception>
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            var i = 0;
-
-            lock (_incoming)
-            {
-                for (; i < count && _incoming.Count > 0; i++)
-                {
-                    buffer[offset + i] = _incoming.Dequeue();
-                }
-            }
-
-            return i;
-        }
-
         /// <summary>
         /// Writes the specified text to the shell.
         /// </summary>
         /// <param name="text">The text to be written to the shell.</param>
         /// <remarks>
-        /// If <paramref name="text"/> is <see langword="null"/>, nothing is written.
+        /// If <paramref name="text"/> is <c>null</c>, nothing is written.
         /// </remarks>
         public void Write(string text)
         {
@@ -665,50 +683,21 @@ public void Write(string text)
                 return;
             }
 
-#if NET7_0_OR_GREATER
-            ObjectDisposedException.ThrowIf(_channel is null, this);
-#else
             if (_channel is null)
             {
-                throw new ObjectDisposedException(GetType().FullName);
+                throw new ObjectDisposedException("ShellStream");
             }
-#endif // NET7_0_OR_GREATER
 
             var data = _encoding.GetBytes(text);
             _channel.SendData(data);
         }
 
-        /// <summary>
-        /// Writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.
-        /// </summary>
-        /// <param name="buffer">An array of bytes. This method copies <paramref name="count"/> bytes from <paramref name="buffer"/> to the current stream.</param>
-        /// <param name="offset">The zero-based byte offset in <paramref name="buffer"/> at which to begin copying bytes to the current stream.</param>
-        /// <param name="count">The number of bytes to be written to the current stream.</param>
-        /// <exception cref="ArgumentException">The sum of <paramref name="offset"/> and <paramref name="count"/> is greater than the buffer length.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentOutOfRangeException"><paramref name="offset"/> or <paramref name="count"/> is negative.</exception>
-        /// <exception cref="IOException">An I/O error occurs.</exception>
-        /// <exception cref="NotSupportedException">The stream does not support writing.</exception>
-        /// <exception cref="ObjectDisposedException">Methods were called after the stream was closed.</exception>
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            foreach (var b in buffer.Take(offset, count))
-            {
-                if (_outgoing.Count == _bufferSize)
-                {
-                    Flush();
-                }
-
-                _outgoing.Enqueue(b);
-            }
-        }
-
         /// <summary>
         /// Writes the line to the shell.
         /// </summary>
         /// <param name="line">The line to be written to the shell.</param>
         /// <remarks>
-        /// If <paramref name="line"/> is <see langword="null"/>, only the line terminator is written.
+        /// If <paramref name="line"/> is <c>null</c>, only the line terminator is written.
         /// </remarks>
         public void WriteLine(string line)
         {
@@ -718,7 +707,7 @@ public void WriteLine(string line)
         /// <summary>
         /// Releases the unmanaged resources used by the <see cref="Stream"/> and optionally releases the managed resources.
         /// </summary>
-        /// <param name="disposing"><see langword="true"/> to release both managed and unmanaged resources; <see langword="false"/> to release only unmanaged resources.</param>
+        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
         protected override void Dispose(bool disposing)
         {
             base.Dispose(disposing);
@@ -759,7 +748,7 @@ protected override void Dispose(bool disposing)
         /// </summary>
         /// <param name="session">The session.</param>
         /// <remarks>
-        /// Does nothing when <paramref name="session"/> is <see langword="null"/>.
+        /// Does nothing when <paramref name="session"/> is <c>null</c>.
         /// </remarks>
         private void UnsubscribeFromSessionEvents(ISession session)
         {