.NET MAUI Datenextraktions-SDK mit IronZIP

1. Zip erstellen

Öffnen Sie die Datei MainPage.xaml.cs und erstellen Sie die Funktionalität "Zip erstellen". Implementieren Sie die Methode OnSelectFilesButtonClicked, um den FilePicker zu öffnen und das Auswählen mehrerer Dateien jeglicher Art zur Erstellung einer Zip-Datei zu ermöglichen.

Erstellen Sie dann eine Liste aller Pfade aus den ausgewählten Dateien. Zum Schluss übergeben Sie es an die CreateZip-Methode, bei der IronZIP nahtlos innerhalb einer Sekunde eine Zip-Datei mit allen Dateipfaden erstellt.

Das folgende Codebeispiel zeigt, wie diese Aufgabe erreicht wird.

private async void OnSelectFilesButtonClicked(object sender, EventArgs e)
{
    try
    {
        var status = await Permissions.RequestAsync<Permissions.StorageRead>();
        if (status != PermissionStatus.Granted)
        {
            await DisplayAlert("Alert!", "Storage Access Denied", "Ok");
            return;
        }
        // Select multiple files of any type
        var results = await FilePicker.PickMultipleAsync();
        if (results != null)
        {
            var selectedFilePaths = new List<string>();
            foreach (var file in results)
            {
                // Add file full path to the list one by one
                selectedFilePaths.Add(file.FullPath);
            }
            CreateZip(selectedFilePaths);
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error: {ex.Message}");
    }
}

private async void OnSelectFilesButtonClicked(object sender, EventArgs e)
{
    try
    {
        var status = await Permissions.RequestAsync<Permissions.StorageRead>();
        if (status != PermissionStatus.Granted)
        {
            await DisplayAlert("Alert!", "Storage Access Denied", "Ok");
            return;
        }
        // Select multiple files of any type
        var results = await FilePicker.PickMultipleAsync();
        if (results != null)
        {
            var selectedFilePaths = new List<string>();
            foreach (var file in results)
            {
                // Add file full path to the list one by one
                selectedFilePaths.Add(file.FullPath);
            }
            CreateZip(selectedFilePaths);
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error: {ex.Message}");
    }
}

Private Async Sub OnSelectFilesButtonClicked(ByVal sender As Object, ByVal e As EventArgs)
	Try
		Dim status = Await Permissions.RequestAsync(Of Permissions.StorageRead)()
		If status <> PermissionStatus.Granted Then
			Await DisplayAlert("Alert!", "Storage Access Denied", "Ok")
			Return
		End If
		' Select multiple files of any type
		Dim results = Await FilePicker.PickMultipleAsync()
		If results IsNot Nothing Then
			Dim selectedFilePaths = New List(Of String)()
			For Each file In results
				' Add file full path to the list one by one
				selectedFilePaths.Add(file.FullPath)
			Next file
			CreateZip(selectedFilePaths)
		End If
	Catch ex As Exception
		Console.WriteLine($"Error: {ex.Message}")
	End Try
End Sub

Implementieren Sie als Nächstes die CreateZip-Methode. Die IronArchive-Klasse von IronZIP übernimmt den Pfad, an dem die Zip-Datei erstellt werden soll. Jeder ausgewählte Dateipfad wird mit der Add-Methode zur Zip-Datei hinzugefügt.

Nachdem die Dateien hinzugefügt wurden, wird eine Bestätigungsnachricht mit DisplayAlert angezeigt.

private async void CreateZip(List<string> selectedFilePaths)
{
    var path = "E:\\output.zip";
    // Create a Zip
    using (var archive = new IronArchive(path))
    {
        // Add files to the ZIP
        foreach (var file in selectedFilePaths)
        {
            archive.Add(file);
        }
    }
    await DisplayAlert("Congratulations", "All files added to " + path, "Ok");
}

private async void CreateZip(List<string> selectedFilePaths)
{
    var path = "E:\\output.zip";
    // Create a Zip
    using (var archive = new IronArchive(path))
    {
        // Add files to the ZIP
        foreach (var file in selectedFilePaths)
        {
            archive.Add(file);
        }
    }
    await DisplayAlert("Congratulations", "All files added to " + path, "Ok");
}

Private Async Sub CreateZip(ByVal selectedFilePaths As List(Of String))
	Dim path = "E:\output.zip"
	' Create a Zip
	Using archive = New IronArchive(path)
		' Add files to the ZIP
		For Each file In selectedFilePaths
			archive.Add(file)
		Next file
	End Using
	Await DisplayAlert("Congratulations", "All files added to " & path, "Ok")
End Sub

Für detailliertere Informationen darüber, wie Sie eine Zip erstellen, Dateien zu bestehenden Zips hinzufügen und einen Zip extrahieren, besuchen Sie bitte diese tutorial-Seite.

2. Zip extrahieren

Nun erstellen wir die Funktionalität "Zip extrahieren". Wieder in der Datei MainPage.xaml.cs implementieren Sie die Methode OnSelectFileButtonClicked, um den FilePicker zu öffnen und das Auswählen einer einzelnen Zip-Datei zur Extraktion zu ermöglichen.

Der vollständige Pfad der ausgewählten Datei wird einer Zeichenfolgenvariable zugewiesen und an die ExtractZip-Methode gesendet, bei der IronZIP die Extraktion durchführt. Der Code sieht wie folgt aus:

private async void OnSelectFileButtonClicked(object sender, EventArgs e)
{
    try
    {
        var status = await Permissions.RequestAsync<Permissions.StorageRead>();
        if (status != PermissionStatus.Granted)
        {
            await DisplayAlert("Alert!", "Storage Access Denied", "Ok");
            return;
        }
        // Select a single file of any type
        var result = await FilePicker.PickAsync();
        if (result != null)
        {
            // Add File Full Path to the list one by one
            var selectedFile = result.FullPath;
            ExtractZip(selectedFile);
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error: {ex.Message}");
    }
}

private async void OnSelectFileButtonClicked(object sender, EventArgs e)
{
    try
    {
        var status = await Permissions.RequestAsync<Permissions.StorageRead>();
        if (status != PermissionStatus.Granted)
        {
            await DisplayAlert("Alert!", "Storage Access Denied", "Ok");
            return;
        }
        // Select a single file of any type
        var result = await FilePicker.PickAsync();
        if (result != null)
        {
            // Add File Full Path to the list one by one
            var selectedFile = result.FullPath;
            ExtractZip(selectedFile);
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error: {ex.Message}");
    }
}

Private Async Sub OnSelectFileButtonClicked(ByVal sender As Object, ByVal e As EventArgs)
	Try
		Dim status = Await Permissions.RequestAsync(Of Permissions.StorageRead)()
		If status <> PermissionStatus.Granted Then
			Await DisplayAlert("Alert!", "Storage Access Denied", "Ok")
			Return
		End If
		' Select a single file of any type
		Dim result = Await FilePicker.PickAsync()
		If result IsNot Nothing Then
			' Add File Full Path to the list one by one
			Dim selectedFile = result.FullPath
			ExtractZip(selectedFile)
		End If
	Catch ex As Exception
		Console.WriteLine($"Error: {ex.Message}")
	End Try
End Sub

Erstellen Sie als Nächstes die ExtractZip-Methode. In dieser Methode richten Sie den Pfad zum Ausgabeordner ein, in dem Sie die Dateien extrahieren möchten.

Verwenden Sie die ExtractArchiveToDirectory-Methode von IronZIP und übergeben Sie den ausgewählten Dateipfad und den Ausgabepfad. Diese Methode konvertiert und überträgt nahtlos alle Dateien im Zip in den Ausgabeordner. Zu guter Letzt wird eine Bestätigungsnachricht bei erfolgreicher Extraktion angezeigt.

Der Code sieht wie folgt aus:

private async void ExtractZip(string selectedFilePath)
{
    var path = "E:\\Extracted Files";
    IronArchive.ExtractArchiveToDirectory(selectedFilePath, path);
    await DisplayAlert("Congratulations", "All files extracted to " + path, "Ok");
}

private async void ExtractZip(string selectedFilePath)
{
    var path = "E:\\Extracted Files";
    IronArchive.ExtractArchiveToDirectory(selectedFilePath, path);
    await DisplayAlert("Congratulations", "All files extracted to " + path, "Ok");
}

Private Async Sub ExtractZip(ByVal selectedFilePath As String)
	Dim path = "E:\Extracted Files"
	IronArchive.ExtractArchiveToDirectory(selectedFilePath, path)
	Await DisplayAlert("Congratulations", "All files extracted to " & path, "Ok")
End Sub

1. Zip erstellen testen

Versuchen wir zunächst, eine Zip-Datei zu erstellen. Klicken Sie auf die Schaltfläche Zip erstellen und es öffnet sich ein Dateidialog. Sie können mehrere oder eine einzelne Datei auswählen, die der Zip hinzugefügt werden soll.

Klicken Sie auf Öffnen und es wird eine Bestätigungsnachricht angezeigt, dass die Dateien erfolgreich zu output.zip hinzugefügt wurden.

Wenn wir zur output.zip-Datei navigieren und ihren Inhalt anzeigen, werden wir alle Dateien sehen, die wir hinzugefügt haben.

2. Zip extrahieren testen

Lassen Sie uns nun eine Zip-Datei extrahieren. Klicken Sie auf die Zip extrahieren-Schaltfläche und ein Dateidialog wird angezeigt. Wählen Sie eine Zip-Datei, die Sie extrahieren möchten, und klicken Sie auf Öffnen.

Sobald die Datenerfassung aus der Zip-Datei abgeschlossen ist und in den gewünschten Ordner extrahiert wurde, wird die Bestätigungsnachricht angezeigt.

Navigieren Sie nun zum Ordner "Extracted Files" und Sie werden die Dateien sehen, die aus dem Zip, das wir ausgewählt haben, extrahiert wurden.