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

Code before:

            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 => OpenInWriteModeForUpdate(),
                        FileAccess.ReadWrite => OpenInUpdateMode(),
                        _ => throw new UnreachableException()
                    };
            }
        }

        /// <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 UnreachableException in the switch expression default case is unnecessary. Since the access parameter is validated at lines 394-395 to be one of Read, Write, or ReadWrite, and all three cases are explicitly handled in the switch expression (lines 415-417), the default case at line 418 can never be reached. This makes the code slightly harder to reason about. Consider removing the default case entirely, as the switch expression will be exhaustive without it.
```suggestion
                        FileAccess.ReadWrite => OpenInUpdateMode()
```

Code after:
        /// </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:
                            return OpenInUpdateMode(loadExistingContent: false);
                        case FileAccess.ReadWrite:
                        default:
                            return OpenInUpdateMode(loadExistingContent: true);
                    }
            }
        }

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