Read-only QuicStream throws inconsistent exceptions

[PatrikTrefil]

Description

When we open a unidirectional stream and attempt to read from it, we get different exceptions for different read operations. ReadByte throws InvalidOperationException. CopyTo throws NotSupportedException.

Reproduction Steps

var outgoingStream = await connection.OpenOutboundStreamAsync(QuicStreamType.Unidirectional);
outgoingStream.ReadByte(); // throws InvalidOperationException
outgoingStream.CopyTo(new MemoryStream()); // throws NotSupportedException

Expected behavior

Both operations should throw the same exception.

Actual behavior

The operations throw different exceptions.

Regression?

Known Workarounds

Configuration

Not relevant.

Other information

No response

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/ncl
See info in area-owners.md if you want to be subscribed.

[CarnaViire]

Triage: We should fix this in 11.0. Quoting @MihuBot from MihuBot/dotnet-triage#22:

This is a bug in QuicStream: the exception thrown for unsupported read operations should be consistent and follow the Stream contract (NotSupportedException). See the "Exceptions" section of the Stream.ReadByte() docs.

• The Stream contract expects NotSupportedException for unsupported operations (e.g., reading from a write-only stream) and InvalidOperationException for invalid state (e.g., concurrent operations).
• The current behavior in QuicStream (per your issue) is inconsistent: ReadByte throws InvalidOperationException, while CopyTo throws NotSupportedException on a write-only (unidirectional outbound) stream.
• API proposals and reviews indicate that NotSupportedException is the correct exception for unsupported operations, including reading from a write-only stream.
• Consistency: All read operations on a write-only QuicStream should throw NotSupportedException, matching the behavior of other Stream implementations in .NET.