Repository: dotnet/runtime
File: src/libraries/System.IO.Compression/src/System/IO/Compression/ZipArchiveEntry.cs (C#)

Code before:
            ThrowIfInvalidArchive();

            if (access is not FileAccess.Read and not FileAccess.Write and not FileAccess.ReadWrite)
                throw new ArgumentException(SR.InvalidFileAccess, nameof(access));

            // Validate that the requested access is compatible with the archive's mode
            switch (_archive.Mode)
            {
                case ZipArchiveMode.Read:
                    if (access != FileAccess.Read)
                        throw new ArgumentException(SR.CannotBeWrittenInReadMode, nameof(access));
                    return OpenInReadMode(checkOpenable: true);

                case ZipArchiveMode.Create:
                    if (access == FileAccess.Read)
                        throw new ArgumentException(SR.CannotBeReadInCreateMode, nameof(access));
                    return OpenInWriteMode();

                case ZipArchiveMode.Update:
                default:
                    Debug.Assert(_archive.Mode == ZipArchiveMode.Update);
                    return access switch
                    {
                        FileAccess.Read => OpenInReadMode(checkOpenable: true),
                        FileAccess.Write => OpenInWriteMode(),
                        FileAccess.ReadWrite => OpenInUpdateMode()
                    };
            }
        }

        /// <summary>
        /// Returns the FullName of the entry.
        /// </summary>
        /// <returns>FullName of the entry</returns>
        public override string ToString()
        {
            return FullName;
        }

        private string DecodeEntryString(byte[] entryStringBytes)
        {
            Debug.Assert(entryStringBytes != null);

            Encoding readEntryStringEncoding =
                (_generalPurposeBitFlag & BitFlagValues.UnicodeFileNameAndComment) == BitFlagValues.UnicodeFileNameAndComment
                ? Encoding.UTF8
                : _archive?.EntryNameAndCommentEncoding ?? Encoding.UTF8;

            return readEntryStringEncoding.GetString(entryStringBytes);
        }


Review comment (suggestion):
The switch expression should include a discard pattern to ensure exhaustiveness. While the validation on line 378 guarantees only Read, Write, or ReadWrite values reach this point, adding `_ => throw new UnreachableException()` makes the code more robust and satisfies the compiler's exhaustiveness checking.

```csharp
return access switch
{
    FileAccess.Read => OpenInReadMode(checkOpenable: true),
    FileAccess.Write => OpenInWriteMode(),
    FileAccess.ReadWrite => OpenInUpdateMode(),
    _ => throw new UnreachableException()
};
```
```suggestion
                        FileAccess.ReadWrite => OpenInUpdateMode(),
                        _ => throw new UnreachableException()
```

Code after:
                    Debug.Assert(_archive.Mode == ZipArchiveMode.Update);
                    return OpenInUpdateMode();
            }
        }

        /// <summary>
        /// Opens the entry with the specified access mode. This allows for more granular control over the returned stream's capabilities.
        /// </summary>
        /// <param name="access">The file access mode for the returned stream.</param>
        /// <returns>A <see cref="Stream"/> that represents the contents of the entry with the specified access capabilities.</returns>
        /// <remarks>
        /// <para>The allowed <paramref name="access"/> values depend on the <see cref="ZipArchiveMode"/>:</para>
        /// <list type="bullet">
        /// <item><description><see cref="ZipArchiveMode.Read"/>: Only <see cref="FileAccess.Read"/> is allowed.</description></item>
        /// <item><description><see cref="ZipArchiveMode.Create"/>: <see cref="FileAccess.Write"/> and <see cref="FileAccess.ReadWrite"/> are allowed (both write-only).</description></item>
        /// <item><description><see cref="ZipArchiveMode.Update"/>: All values are allowed. <see cref="FileAccess.Read"/> reads directly from the archive. <see cref="FileAccess.Write"/> discards existing content and provides an empty writable stream. <see cref="FileAccess.ReadWrite"/> loads existing content into memory (equivalent to <see cref="Open()"/>).</description></item>
        /// </list>
        /// </remarks>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="access"/> is not a valid <see cref="FileAccess"/> value.</exception>
        /// <exception cref="InvalidOperationException">The requested access is not compatible with the archive's open mode.</exception>
        /// <exception cref="IOException">The entry is already currently open for writing. -or- The entry has been deleted from the archive. -or- The archive that this entry belongs to was opened in ZipArchiveMode.Create, and this entry has already been written to once.</exception>
        /// <exception cref="InvalidDataException">The entry is missing from the archive or is corrupt and cannot be read. -or- The entry has been compressed using a compression method that is not supported.</exception>
        /// <exception cref="ObjectDisposedException">The ZipArchive that this entry belongs to has been disposed.</exception>
        public Stream Open(FileAccess access)
        {
            ThrowIfInvalidArchive();

            if (access is not (FileAccess.Read or FileAccess.Write or FileAccess.ReadWrite))
                throw new ArgumentOutOfRangeException(nameof(access), SR.InvalidFileAccess);

            // Validate that the requested access is compatible with the archive's mode
            switch (_archive.Mode)
            {
                case ZipArchiveMode.Read:
                    if (access != FileAccess.Read)
                        throw new InvalidOperationException(SR.CannotBeWrittenInReadMode);
                    return OpenInReadMode(checkOpenable: true);

                case ZipArchiveMode.Create:
                    if (access == FileAccess.Read)
                        throw new InvalidOperationException(SR.CannotBeReadInCreateMode);
                    return OpenInWriteMode();

                case ZipArchiveMode.Update:
                default:
                    Debug.Assert(_archive.Mode == ZipArchiveMode.Update);
                    switch (access)
                    {
                        case FileAccess.Read:
                            return OpenInReadMode(checkOpenable: true);
                        case FileAccess.Write: