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 => 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):
Instead of `ArgumentException`, I think `InvalidOperationException` is more appropriate. The argument itself is in valid range, but the operation it tries to perform is not valid in the current state.

Code after:
        /// </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:
                            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;
        }