.NET MAUI Datenextraktions-SDK (Tutorial für Entwickler)

Einführung

.NET MAUI, oder .NET Multi-platform App UI, ist ein Framework für die Erstellung plattformübergreifender Anwendungen. Es ermöglicht Entwicklern, Anwendungen mit einer einzigen Codebasis zu erstellen, die auf Windows, macOS, iOS, Android und jedem anderen Gerät laufen. Ähnlich wie React Native, arbeitet aber mit C# statt mit JavaScript.

.NET MAUI ermöglicht C#-Entwicklern die problemlose Erstellung von mobilen Anwendungen und Desktop-Apps in einer einzigen Umgebung. Microsoft .NET MAUI bietet eine umfassende Dokumentation und Ressourcen, die Entwicklern helfen, den Prozess der App-Entwicklung zu vereinfachen und zu optimieren.

In diesem Artikel wird die Integration von IronZIP, einer leistungsstarken C#-ZIP-Archivbibliothek, mit .NET MAUI für die Datenextraktion untersucht.

Wie man Daten aus Zip-Archiven extrahiert

1. Erstellen eines Visual Studio .NET MAUI-Projekts

2. C# Zip-Bibliothek mit NuGet installieren

3. Design Datenextraktion App-Schnittstelle

4. Implementierung der Methoden Create Zip und Extract Zip

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 für das Erstellen, Lesen und Extrahieren von Archiven in .NET entwickelt wurde. Es unterstützt eine breite Palette von Archivformaten, darunter ZIP, TAR, GZIP und BZIP2. IronZIP ist mit verschiedenen .NET-Versionen kompatibel, 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 unter Windows, Linux, Mac, iOS, Android, Docker, Azure und AWS ausgeführt werden.

Die wichtigsten Merkmale von IronZIP sind:

• 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 zur Erstellung von Multiplattform-Anwendungen.

Voraussetzungen

Bevor Sie beginnen, sollten Sie sicherstellen, dass Sie über die folgenden Voraussetzungen verfügen:

1. Visual Studio mit installiertem .NET MAUI-Workload.

2. IronZIP-Bibliothek zu Ihrem .NET MAUI-Projekt hinzugefügt.

Schritte zum Erstellen von .NET MAUI-Anwendungen in Visual Studio

1. Öffnen Sie Visual Studio und klicken Sie auf "Ein neues Projekt erstellen"

2. Wählen Sie die Projektvorlage .NET MAUI App und klicken Sie auf Weiter.

   

3. Konfigurieren Sie Projekteinstellungen, Projektname und Standort. Klicken Sie auf Weiter.

   

4. Wählen Sie unter Zusatzinformationen das richtige .NET-Framework aus. IronZIP unterstützt die neueste Version des .NET-Frameworks, so dass Sie diese wählen können.

   

5. Klicken Sie auf Erstellen, um die .NET MAUI-App für die Extraktion von Zip-Daten mit der IronZIP-Bibliothek zu erstellen.

IronZIP installieren

Führen Sie die folgenden Schritte aus, um IronZIP in Ihr .NET MAUI-Projekt zu integrieren:

1. Öffnen Sie den Solution Explorer aus der Ansicht.

   

2. Klicken Sie mit der rechten Maustaste auf Ihr Projekt im Projektmappen-Explorer.

3. Wählen Sie "NuGet-Pakete für Lösung verwalten"

   

4. Suchen Sie auf der Registerkarte NuGet browse nach "IronZIP" und installieren Sie das Paket für Ihr Projekt.

   

5. Klicken Sie im Dialogfeld Vorschau der Änderungen auf "Übernehmen", um die Änderungen vorzunehmen, und dann auf "Akzeptieren", um die IronZIP-Lizenz zu akzeptieren.

6. NuGet beendet die Installation und eine Bestätigungsmeldung wird angezeigt.

   Nachdem nun alles installiert und eingerichtet ist, können wir uns der Aufgabe der Datenextraktion widmen, indem wir einen Zip-Extraktor in .NET MAUI erstellen.

Schritte zur Erstellung eines Zip-Extraktors

Schritt 1 Design Apps Schnittstelle

In diesem Abschnitt konzentrieren wir uns auf die Gestaltung der Benutzeroberfläche für Ihre .NET MAUI-Anwendung. Öffnen Sie die Datei MainPage.xaml in Ihrem Projektordner und fügen Sie den erforderlichen 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. Es sind auch einige Etiketten erforderlich, um entsprechende Meldungen zu übermitteln. Das folgende Codebeispiel zeigt den Xaml-Code des Entwurfs:

<?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 werden die Ausgabe als normale Windows-Formulare auf dem Bildschirm sehen.

Schritt 2 Implementierung des Codes

1. Zip erstellen

Öffnen Sie die Datei MainPage.xaml.cs und erstellen Sie die "Zip erstellenfunktionalität". Implementieren Sie die Methode OnSelectFilesButtonClicked, um das Öffnen des FilePicker und die Auswahl mehrerer Dateien eines beliebigen Typs für die Erstellung einer Zip-Datei zu ermöglichen.

Erstellen Sie dann eine Liste mit allen Pfaden der ausgewählten Dateien. Zum Schluss übergeben Sie sie an die Methode CreateZip, mit der IronZIP innerhalb einer Sekunde eine Zip-Datei mit allen Dateipfaden erstellt.

Das folgende Codebeispiel zeigt, wie diese Aufgabe gelöst werden kann.

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 wir nun die Methode CreateZip, wobei die Klasse IronArchive von IronZIP den Pfad des zu erstellenden Zip-Dateinamens übernimmt. Jeder ausgewählte Dateipfad wird in einer Schleife durchlaufen und mit der Methode Add zur Zip-Datei hinzugefügt.

Wenn die Dateien hinzugefügt wurden, wird mit DisplayAlert eine Bestätigungsmeldung 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 add to the " + 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 add to the " + path, "Ok");
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Ausführlichere Informationen über das Erstellen, Hinzufügen von Dateien zu bestehenden ZIP-Dateien und Extrahieren von ZIP-Dateien finden Sie hier Tutorial-Seite.

2. Zip extrahieren

Jetzt erstellen wir die "Zip extrahierenfunktionalität". Implementieren Sie wiederum in der Datei MainPage.xaml.cs die Methode OnSelectFileButtonClicked, um das Öffnen des FilePicker und die Auswahl einer einzelnen Zip-Datei für die Extraktion zu ermöglichen.

Der vollständige Pfad der ausgewählten Datei wird in eine String-Variable gesetzt und an die ExtractZip-Methode gesendet, mit der IronZIP die Extraktion vornimmt. Der Code lautet wie folgt:

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 Multiple files 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 Multiple files 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 Multiple files 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 wir nun die Methode ExtractZip. Bei dieser Methode geben Sie den Pfad zum Ausgabeordner an, in den Sie die Dateien extrahieren möchten.

Mit der IronZIP-Methode ExtractArchiveToDirectory übergeben Sie den ausgewählten Dateipfad und den Ausgabepfad. Diese Methode konvertiert und überträgt alle Dateien in der ZIP-Datei nahtlos in den Ausgabeordner. Schließlich wird bei erfolgreicher Extraktion eine Bestätigungsmeldung angezeigt.

Der Code lautet wie folgt:

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

private async void ExtractZip(string selectedFilePath)
{
    var path = "E:\\Extracted Files";
    IronArchive.ExtractArchiveToDirectory(selectedFilePath, path);
    await DisplayAlert("Congratulations", "All files extracted to the " + 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 the " & path, "Ok")
End Sub

Schritt 3 Anwendung ausführen

Nachdem Sie den Code zusammen mit IronZIP erfolgreich integriert haben, erstellen Sie die Anwendung und führen Sie sie 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 Überprüfen der Ergebnisse

1. Testen Zip erstellen

Lassen Sie uns zunächst versuchen, eine Zip-Datei zu erstellen. Klicken Sie auf die Schaltfläche "Create Zip" (Zip erstellen), und es wird ein Dateidialog angezeigt. Sie können mehrere oder eine einzelne Datei auswählen, die Sie dem ZIP-Archiv hinzufügen möchten.

Klicken Sie auf Öffnen, und es erscheint eine Bestätigungsmeldung, dass die Dateien erfolgreich zur Datei output.zip hinzugefügt wurden.

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

2. Prüfung Extract Zip

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

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

Navigieren Sie nun zu dem Ordner "Extracted Files" und Sie sehen die Dateien, die aus der von uns gewählten ZIP-Datei extrahiert wurden.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass die Integration von IronZIP mit .NET MAUI eine leistungsstarke Lösung für das Erstellen, Lesen und Extrahieren von Archiven in plattformübergreifenden Anwendungen darstellt.

Das mitgelieferte Beispiel zeigt, wie IronZIP für die Auswahl mehrerer Dateien, die Erstellung eines ZIP-Archivs und das Extrahieren von Dateien aus einem ZIP-Archiv innerhalb von .NET MAUI verwendet werden kann.

Diese Kombination von Technologien bietet Entwicklern eine nahtlose Erfahrung bei der Verwaltung und Bearbeitung von Archiven auf verschiedenen Plattformen.

Ausführlichere Informationen und Codebeispiele finden Sie hier Dokumentation seite.

IronZIP bietet eine kostenlos testen. Sie können die Bibliothek herunterladen von *hier und probieren Sie es aus.