ZipFile.OpenRead(String) Methode

Definitie

Hiermee opent u een zip-archief voor lezen op het opgegeven pad.

public:
 static System::IO::Compression::ZipArchive ^ OpenRead(System::String ^ archiveFileName);
public static System.IO.Compression.ZipArchive OpenRead(string archiveFileName);
static member OpenRead : string -> System.IO.Compression.ZipArchive
Public Shared Function OpenRead (archiveFileName As String) As ZipArchive

Parameters

archiveFileName
String

Het pad naar het archief dat moet worden geopend, opgegeven als een relatief of absoluut pad. Een relatief pad wordt geïnterpreteerd als relatief ten opzichte van de huidige werkmap.

Retouren

Het geopende zip-archief.

Uitzonderingen

archiveFileName is Empty, bevat slechts witruimte of bevat ten minste één ongeldig teken.

archiveFileName is null.

Het archiveFileNameopgegeven pad, de bestandsnaam of beide overschrijden de door het systeem gedefinieerde maximumlengte.

archiveFileName is ongeldig of bestaat niet (bijvoorbeeld op een niet-toegewezen station).

archiveFileName kan niet worden geopend.

– of –

Er is een niet-opgegeven I/O-fout opgetreden tijdens het openen van het bestand.

archiveFileName hiermee geeft u een map.

– of –

De aanroeper heeft niet de vereiste machtiging om toegang te krijgen tot het bestand dat is opgegeven in archiveFileName.

Het opgegeven archiveFileName bestand is niet gevonden.

archiveFileName bevat een ongeldige indeling.

archiveFileName kan niet worden geïnterpreteerd als een zip-archief.

Voorbeelden

In het volgende voorbeeld ziet u hoe u een zip-archief opent om te lezen.

using System;
using System.IO;
using System.IO.Compression;

class Program
{
    static void Main(string[] args)
    {
        string zipPath = @".\result.zip";

        Console.WriteLine("Provide path where to extract the zip file:");
        string extractPath = Console.ReadLine();

        // Normalizes the path.
        extractPath = Path.GetFullPath(extractPath);

        // Ensures that the last character on the extraction path
        // is the directory separator char.
        // Without this, a malicious zip file could try to traverse outside of the expected
        // extraction path.
        if (!extractPath.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal))
            extractPath += Path.DirectorySeparatorChar;

        using (ZipArchive archive = ZipFile.OpenRead(zipPath))
        {
            foreach (ZipArchiveEntry entry in archive.Entries)
            {
                if (entry.FullName.EndsWith(".txt", StringComparison.OrdinalIgnoreCase))
                {
                    // Gets the full path to ensure that relative segments are removed.
                    string destinationPath = Path.GetFullPath(Path.Combine(extractPath, entry.FullName));

                    // Ordinal match is safest, case-sensitive volumes can be mounted within volumes that
                    // are case-insensitive.
                    if (destinationPath.StartsWith(extractPath, StringComparison.Ordinal))
                        entry.ExtractToFile(destinationPath);
                }
            }
        }
    }
}
open System
open System.IO;
open System.IO.Compression;

[<EntryPoint>]
let main _ =
    let zipPath = @".\result.zip"

    printfn "Provide path where to extract the zip file:"
    let extractPath = stdin.ReadLine();

    // Normalizes the path.
    let mutable extractPath = Path.GetFullPath extractPath

    // Ensures that the last character on the extraction path
    // is the directory separator char.
    // Without this, a malicious zip file could try to traverse outside of the expected
    // extraction path.
    if extractPath.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal) |> not then
        extractPath <- extractPath + string Path.DirectorySeparatorChar

    use archive = ZipFile.OpenRead zipPath

    for entry in archive.Entries do
        if entry.FullName.EndsWith(".txt", StringComparison.OrdinalIgnoreCase) then
            // Gets the full path to ensure that relative segments are removed.
            let destinationPath = Path.GetFullPath(Path.Combine(extractPath, entry.FullName))

            // Ordinal match is safest, case-sensitive volumes can be mounted within volumes that
            // are case-insensitive.
            if destinationPath.StartsWith(extractPath, StringComparison.Ordinal) then
                entry.ExtractToFile destinationPath
    0
Imports System.IO
Imports System.IO.Compression

Module Module1

    Sub Main()
        Dim zipPath As String = ".\result.zip"

        Console.WriteLine("Provide path where to extract the zip file:")
        Dim extractPath As String = Console.ReadLine()

        ' Normalizes the path.
        extractPath = Path.GetFullPath(extractPath)

        ' Ensures that the last character on the extraction path
        ' is the directory separator char. 
        ' Without this, a malicious zip file could try to traverse outside of the expected
        ' extraction path.
        If Not extractPath.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal) Then
            extractPath += Path.DirectorySeparatorChar
        End If

        Using archive As ZipArchive = ZipFile.OpenRead(zipPath)
            For Each entry As ZipArchiveEntry In archive.Entries
                If entry.FullName.EndsWith(".txt", StringComparison.OrdinalIgnoreCase) Then

                    ' Gets the full path to ensure that relative segments are removed.
                    Dim destinationPath As String = Path.GetFullPath(Path.Combine(extractPath, entry.FullName))
                    
                    ' Ordinal match is safest, case-sensitive volumes can be mounted within volumes that
                    ' are case-insensitive.
                    If destinationPath.StartsWith(extractPath, StringComparison.Ordinal) Then 
                        entry.ExtractToFile(destinationPath)
                    End If

                End If
            Next
        End Using
    End Sub

End Module

Opmerkingen

Deze methode is gelijk aan het aanroepen van de Open methode en het instellen van de mode parameter op Read. Het archief wordt geopend met FileMode.Open als de waarde van de bestandsmodus. Als het archief niet bestaat, wordt er een FileNotFoundException uitzondering gegenereerd.

Van toepassing op