.NET MAUI, oder .NET Multi-platform App UI, ist ein Framework für den Bau von plattformübergreifenden Anwendungen. Es ermöglicht Entwicklern, Anwendungen mit einem einzigen Codebase zu erstellen, der auf Windows, macOS, iOS, Android und anderen Geräten läuft. Ähnlich wie React Native, aber es verwendet C# anstelle von JavaScript.

.NET MAUI ermöglicht es C#-Entwicklern, mühelos mobile Anwendungen und Desktop-Apps aus einer einzigen Umgebung zu erstellen. Microsoft .NET MAUI bietet umfassende Dokumentation und Ressourcen, um Entwicklern zu helfen, den App-Entwicklungsprozess zu optimieren und zu rationalisieren.

In diesem Artikel werden wir die Integration von IronZIP, einer leistungsstarken C# ZIP-Archiv-Bibliothek, mit .NET MAUI für Datenextraktionszwecke erkunden.

Wie man Daten aus ZIP-Archiven extrahiert

1. Erstellen Sie ein Visual Studio .NET MAUI-Projekt
2. Installieren Sie die C#-ZIP-Bibliothek über NuGet
3. Entwerfen Sie die Oberfläche der Datenextraktions-App
4. Implementieren Sie die Methoden Zip erstellen und Zip extrahieren
5. Führen Sie die Anwendung aus und überprüfen Sie die Ergebnisse

Einführung in IronZIP

IronZIP ist eine umfassende C# ZIP-Archivbibliothek, die zum Erstellen, Lesen und Extrahieren von Archiven in .NET entwickelt wurde. Es unterstützt eine Vielzahl von Archivformaten, darunter ZIP, TAR, GZIP und BZIP2. IronZIP ist mit verschiedenen .NET-Versionen kompatibel, wie z.B. .NET 7, 6, 5, Core, Standard und Framework.

Es ist plattformübergreifend und eignet sich daher für C#, F# und VB.NET-Anwendungen, die auf Windows, Linux, Mac, iOS, Android, Docker, Azure und AWS laufen.

Zu den Hauptmerkmalen von IronZIP gehören:

• Plattformübergreifende Unterstützung für verschiedene Betriebssysteme.
• Kompatibilität mit verschiedenen .NET-Versionen und Projekttypen.
• Unterstützung für das Erstellen, Lesen und Extrahieren von ZIP-, TAR-, GZIP- und BZIP2-Archiven.
• Integration mit .NET MAUI zum Erstellen von plattformübergreifenden Anwendungen.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllt haben:

1. Visual Studio mit installierter .NET MAUI-Arbeitslast.
2. IronZIP-Bibliothek zu Ihrem .NET MAUI-Projekt hinzugefügt.

Schritte zum Erstellen einer .NET MAUI-Anwendung in Visual Studio

1. Öffnen Sie Visual Studio und klicken Sie auf "Neues Projekt erstellen."
2. Wählen Sie die Projektvorlage .NET MAUI App und klicken Sie auf Weiter.

3. Konfigurieren Sie die Projekteinstellungen, den Projektnamen und den Speicherort. Drücken Sie Weiter.

4. Wählen Sie im Bereich Zusätzliche Informationen das richtige .NET Framework aus. IronZIP unterstützt die neueste Version des .NET Framework, so dass Sie diese auswählen können.

5. Klicken Sie auf Erstellen, um die .NET MAUI App zur Datenextraktion mit der IronZIP-Bibliothek zu erstellen.

IronZIP installieren

Um IronZIP in Ihr .NET MAUI-Projekt zu integrieren, folgen Sie diesen Schritten:

1. Projektmappen-Explorer unter Ansicht öffnen.

2. Rechtsklick auf Ihr Projekt im Projektmappen-Explorer.
3. Wählen Sie "NuGet-Pakete für Lösung verwalten" aus.

4. Suchen Sie im NuGet-Suchregister nach "IronZIP" und installieren Sie das Paket für Ihr Projekt.

5. Klicken Sie im Dialogfeld Vorschau der Änderungen auf "Anwenden", um die Änderungen vorzunehmen, und dann auf "Akzeptieren", um die IronZIP-Lizenz zu akzeptieren.
6. NuGet wird die Installation abschließen und eine Bestätigungsnachricht wird angezeigt.

Jetzt, da alles installiert und eingerichtet ist, gehen wir zur Aufgabe der Datenextraktion über, um einen Zip-Extractor in .NET MAUI zu erstellen.

Schritte zum Erstellen eines Zip-Extractors

Schritt 1: Benutzeroberfläche der App gestalten

In diesem Abschnitt konzentrieren wir uns auf die Gestaltung der Benutzeroberfläche Ihrer .NET MAUI-Anwendung. Öffnen Sie die Datei MainPage.xaml in Ihrem Projektordner und fügen Sie den notwendigen XAML-Code hinzu, um eine benutzerfreundliche Oberfläche zu erstellen.

Hier benötigen wir zwei Schaltflächen, eine zum Erstellen von Zip-Dateien und eine zweite zum Extrahieren von Zip-Dateien. Einige Labels sind ebenfalls erforderlich, um geeignete Meldungen bereitzustellen. Das folgende Codebeispiel zeigt den XAML-Code des Designs:

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MauiAppDataExtraction.MainPage">
    <ScrollView>
        <VerticalStackLayout
            Spacing="25"
            Padding="30,0"
            VerticalOptions="Center">
            <Label
                Text="IronZIP - A Zip Library to Create and Extract Zip Content!"
                SemanticProperties.HeadingLevel="Level1"
                FontSize="32"
                HorizontalOptions="Center" />
            <Label
                Text="Welcome to .NET Multi-platform App UI"
                SemanticProperties.HeadingLevel="Level2"
                SemanticProperties.Description="Welcome to dot net Multi platform App U I"
                FontSize="18"
                HorizontalOptions="Center" />
            <Button
                x:Name="OpenFileBtn"
                Text="Extract Zip File"
                SemanticProperties.Hint="Opens the File Picker"
                Clicked="OnSelectFileButtonClicked"
                HorizontalOptions="Center" />
            <Button
                 x:Name="OpenFilesBtn"
                 Text="Create Zip"
                 SemanticProperties.Hint="Opens the File Picker"
                 Clicked="OnSelectFilesButtonClicked"
                 HorizontalOptions="Center" />  
        </VerticalStackLayout>
    </ScrollView>
</ContentPage>

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MauiAppDataExtraction.MainPage">
    <ScrollView>
        <VerticalStackLayout
            Spacing="25"
            Padding="30,0"
            VerticalOptions="Center">
            <Label
                Text="IronZIP - A Zip Library to Create and Extract Zip Content!"
                SemanticProperties.HeadingLevel="Level1"
                FontSize="32"
                HorizontalOptions="Center" />
            <Label
                Text="Welcome to .NET Multi-platform App UI"
                SemanticProperties.HeadingLevel="Level2"
                SemanticProperties.Description="Welcome to dot net Multi platform App U I"
                FontSize="18"
                HorizontalOptions="Center" />
            <Button
                x:Name="OpenFileBtn"
                Text="Extract Zip File"
                SemanticProperties.Hint="Opens the File Picker"
                Clicked="OnSelectFileButtonClicked"
                HorizontalOptions="Center" />
            <Button
                 x:Name="OpenFilesBtn"
                 Text="Create Zip"
                 SemanticProperties.Hint="Opens the File Picker"
                 Clicked="OnSelectFilesButtonClicked"
                 HorizontalOptions="Center" />  
        </VerticalStackLayout>
    </ScrollView>
</ContentPage>

Führen Sie die Anwendung aus und Sie sehen die Ausgabe als normale Windows-Formulare auf dem Bildschirm.

Schritt 2: Code implementieren

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

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

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

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

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

Schritt 3: Anwendung ausführen

Nach der erfolgreichen Integration des Codes zusammen mit IronZIP erstellen und führen Sie die Anwendung aus, um Datenextraktionsaufgaben durchzuführen. Testen Sie die Funktionalität, indem Sie eine Zip-Datei erstellen und Dateien aus einer Zip-Datei extrahieren.

Überprüfen Sie die Ergebnisse, indem Sie die Ausgabe und die extrahierten Dateien in den angegebenen Verzeichnissen überprüfen.

Schritt 4: Ergebnisse überprüfen

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 Datei zum Zip hinzufügen.

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.

Abschluss

Zusammenfassend bietet die Integration von IronZIP mit .NET MAUI eine leistungsstarke Lösung zum Erstellen, Lesen und Extrahieren von Archiven in plattformübergreifenden Anwendungen.

Das bereitgestellte Beispiel zeigt, wie IronZIP verwendet wird, um mehrere Dateien auszuwählen, ein Zip-Archiv zu erzeugen und Dateien aus einem Zip-Archiv innerhalb von .NET MAUI zu extrahieren.

Diese Kombination von Technologien bietet Entwicklern ein nahtloses Erlebnis beim Verwalten und Bearbeiten von Archiven auf verschiedenen Plattformen.

Für detailliertere Informationen und Codebeispiele besuchen Sie bitte diese Dokumentationsseite.

IronZIP bietet eine kostenlose Testversion. Sie können die Bibliothek von hier herunterladen und ausprobieren.