.NET-HILFE

Sharpziplib Extract ZIP C# (Wie es funktioniert für Entwickler)

Veröffentlicht 6. Juni 2024

Teilen Sie:

In der heutigen digitalen Landschaft, in der die Datenverwaltung von größter Bedeutung ist, sind effiziente Werkzeuge zur Komprimierung und Dekomprimierung von entscheidender Bedeutung. Ein solches Tool, das im .NET-Ökosystem hervorsticht, ist SharpZipLib. In diesem Artikel werden wir SharpZipLib genauer unter die Lupe nehmen und seine Funktionen, Anwendungen und die Integration in Ihre .NET-Projekte untersuchen.

Was ist SharpZipLib?

SharpZipLib ist eine funktionsreiche, vollständig in C# geschriebene Open-Source-Komprimierungsbibliothek für .NET. Es bietet umfassende Unterstützung für verschiedene Komprimierungsformate, darunter ZIP, GZip und Tar. SharpZipLib wurde von einer engagierten Gemeinschaft entwickelt und bietet eine breite Palette von Funktionen zum effizienten Komprimieren und Dekomprimieren von Dateien.

Funktionen und Möglichkeiten

Unterstützung für mehrere Komprimierungsformate: SharpZipLib unterstützt gängige Komprimierungsformate wie ZIP, GZip und Tar und deckt damit verschiedene Anwendungsfälle und Anforderungen ab.
Stream-basierte Operationen: Die Bibliothek arbeitet mit Streams und ermöglicht es Entwicklern, mit Daten aus verschiedenen Quellen zu arbeiten, einschließlich Dateien, Speicher-Streams oder Netzwerk-Streams. Diese Flexibilität ermöglicht eine nahtlose Integration in verschiedene Teile einer Anwendung.
Komprimierungsstufen: Entwickler können die Komprimierungsstufen fein abstimmen, um ein ausgewogenes Verhältnis zwischen Komprimierungsrate und Verarbeitungsgeschwindigkeit auf der Grundlage ihrer spezifischen Anforderungen zu erreichen.
Passwortschutz: SharpZipLib ermöglicht die Erstellung von passwortgeschützten ZIP-Archiven, die die Datensicherheit durch Verschlüsselung des Inhalts mit einem festgelegten Passwort gewährleisten.
Fehlerbehandlung und Wiederherstellung: Robuste Fehlerbehandlungsmechanismen ermöglichen es den Entwicklern, Ausnahmen während Komprimierungs- und Dekomprimierungsvorgängen elegant zu behandeln. Darüber hinaus unterstützt SharpZipLib die Wiederherstellung von beschädigten Archiven, was die Zuverlässigkeit erhöht.

Anwendungsfälle

Dateikomprimierung und -archivierung: SharpZipLib ist ideal für Anwendungen, die eine Komprimierung und Archivierung von Dateien erfordern, wie z. B. Sicherungsprogramme, Dateiverwaltungstools oder Datenexportfunktionalitäten
Webdienste und APIs: Webdienste, die mit Dateiübertragungen oder Datenaustausch zu tun haben, profitieren oft von Komprimierung, um die Bandbreitennutzung zu reduzieren. SharpZipLib kann nahtlos in solche Dienste integriert werden, um ausgehende Daten zu komprimieren oder eingehende Nutzdaten effizient zu dekomprimieren
Desktop-Anwendungen: Desktop-Anwendungen, die mit großen Datensätzen oder Ressourcendateien arbeiten, können SharpZipLib nutzen, um Dateien für die Speicherung oder Verteilung zu komprimieren. Dies ist besonders nützlich für Software-Installationsprogramme oder Tools zur Datensynchronisation.
Datensicherung und -speicherung: Anwendungen, die regelmäßige Sicherungen oder die Speicherung von Daten in komprimiertem Format erfordern, können mit SharpZipLib den Sicherungsprozess automatisieren und effektiv Speicherplatz einsparen.

Vorteile von SharpZipLib

Open Source: Als Open-Source-Bibliothek fördert SharpZipLib die Zusammenarbeit und die Beiträge der Gemeinschaft, wodurch eine kontinuierliche Verbesserung und Anpassungsfähigkeit an sich entwickelnde Bedürfnisse gewährleistet wird.
Plattformübergreifende Kompatibilität: Da SharpZipLib in C# geschrieben ist und auf das .NET-Framework abzielt, ist es mit verschiedenen Plattformen kompatibel, einschließlich Windows, Linux und macOS, was seine Vielseitigkeit erhöht
Leicht und effizient: SharpZipLib wurde entwickelt, um leicht und effizient zu sein, den Ressourcenverbrauch zu minimieren und gleichzeitig leistungsstarke Komprimierungs- und Dekomprimierungsfunktionen zu bieten
Umfassende Dokumentation und Support: Umfassende Dokumentation und Community-Support erleichtern den Entwicklern die Integration und Fehlerbehebung bei der Verwendung von SharpZipLib.

C&num erstellen; Visual Studio Projekt

Öffnen Sie Visual Studio und klicken Sie auf die Option "Ein neues Projekt erstellen".
Wählen Sie die passende Projektvorlage für Ihre Anforderungen (z.B. Konsolenanwendung, Windows Forms Anwendung).
Geben Sie den Projektnamen und den Speicherort an und klicken Sie dann auf "Weiter".
Wählen Sie unter Zusätzliche Informationen das neueste .NET-Framework aus. Klicken Sie auf "Erstellen", um das Projekt zu erstellen.

Installationsprozess

So integrieren Sie SharpZipLib in Ihr .NET Projekt:

In Ihrem Visual Studio C# ConsoleApp, klicken Sie mit der rechten Maustaste auf Ihr Projekt im Projektmappen-Explorer und wählen Sie "NuGet-Pakete verwalten..."
Suchen Sie im Fenster des NuGet-Paketmanagers nach "SharpZipLib".
Wählen Sie "SharpZipLib" aus den Suchergebnissen und klicken Sie auf die Schaltfläche "Installieren".
NuGet lädt die erforderlichen Abhängigkeiten herunter und fügt sie automatisch zu Ihrem Projekt hinzu.

Code-Beispiel

Hier ist ein vereinfachtes Beispiel, das zeigt, wie man SharpZipLib zum Komprimieren und Dekomprimieren von Dateien verwendet:

using ICSharpCode.SharpZipLib.Zip;
using System;
using System.IO;
namespace SharpZipLibExample
{
    class Program
    {
        static void Main(string[] args)
        {
            string sourceDirectory = @"C:\SourceDirectory";
            string zipFilePath = @"C:\OutputDirectory\compressed.zip";
            // Compress files
            CompressDirectory(sourceDirectory, zipFilePath);
            Console.WriteLine("Files compressed successfully.");
            string extractPath = @"C:\OutputDirectory\extracted";
            // Decompress files
            Decompress(zipFilePath, extractPath);
            Console.WriteLine("Files decompressed successfully.");
        }
        static void CompressDirectory(string sourceDirectory, string zipFilePath)
        {
            using (var zipOutputStream = new ZipOutputStream(File.Create(zipFilePath)))
            {
                zipOutputStream.SetLevel(5); // Compression level (0-9)
                // Recursively add files in the source directory to the ZIP file
                AddDirectoryFilesToZip(sourceDirectory, zipOutputStream);
                zipOutputStream.Finish();
                zipOutputStream.Close();
            }
        }
        static void AddDirectoryFilesToZip(string sourceDirectory, ZipOutputStream zipOutputStream)
        {
            string[] files = Directory.GetFiles(sourceDirectory);
            foreach (string file in files)
            {
                var entry = new ZipEntry(Path.GetFileName(file));
                zipOutputStream.PutNextEntry(entry);
                using (var fileStream = File.OpenRead(file))
                {
                    byte[] buffer = new byte[4096];
                    int sourceBytes;
                    while ((sourceBytes = fileStream.Read(buffer, 0, buffer.Length)) > 0)
                    {
                        zipOutputStream.Write(buffer, 0, sourceBytes);
                    }
                }
            }
            string[] subdirectories = Directory.GetDirectories(sourceDirectory);
            foreach (string subdirectory in subdirectories)
            {
                AddDirectoryFilesToZip(subdirectory, zipOutputStream);
            }
        }
        static void Decompress(string zipFilePath, string extractPath)
        {
            using (var zipInputStream = new ZipInputStream(File.OpenRead(zipFilePath)))
            {
                ZipEntry entry;
                while ((entry = zipInputStream.GetNextEntry()) != null)
                {
                    string entryPath = Path.Combine(extractPath, entry.Name);
                    if (entry.IsFile)
                    {
                        string directoryName = Path.GetDirectoryName(entryPath);
                        if (!Directory.Exists(directoryName))
                            Directory.CreateDirectory(directoryName);
                        using (var fileStream = File.Create(entryPath))
                        {
                            byte[] buffer = new byte[4096];
                            int bytesRead;
                            while ((bytesRead = zipInputStream.Read(buffer, 0, buffer.Length)) > 0)
                            {
                                fileStream.Write(buffer, 0, bytesRead);
                            }
                        }
                    }
                    else if (entry.IsDirectory)
                    {
                        Directory.CreateDirectory(entryPath);
                    }
                }
            }
        }
    }
}

using ICSharpCode.SharpZipLib.Zip;
using System;
using System.IO;
namespace SharpZipLibExample
{
    class Program
    {
        static void Main(string[] args)
        {
            string sourceDirectory = @"C:\SourceDirectory";
            string zipFilePath = @"C:\OutputDirectory\compressed.zip";
            // Compress files
            CompressDirectory(sourceDirectory, zipFilePath);
            Console.WriteLine("Files compressed successfully.");
            string extractPath = @"C:\OutputDirectory\extracted";
            // Decompress files
            Decompress(zipFilePath, extractPath);
            Console.WriteLine("Files decompressed successfully.");
        }
        static void CompressDirectory(string sourceDirectory, string zipFilePath)
        {
            using (var zipOutputStream = new ZipOutputStream(File.Create(zipFilePath)))
            {
                zipOutputStream.SetLevel(5); // Compression level (0-9)
                // Recursively add files in the source directory to the ZIP file
                AddDirectoryFilesToZip(sourceDirectory, zipOutputStream);
                zipOutputStream.Finish();
                zipOutputStream.Close();
            }
        }
        static void AddDirectoryFilesToZip(string sourceDirectory, ZipOutputStream zipOutputStream)
        {
            string[] files = Directory.GetFiles(sourceDirectory);
            foreach (string file in files)
            {
                var entry = new ZipEntry(Path.GetFileName(file));
                zipOutputStream.PutNextEntry(entry);
                using (var fileStream = File.OpenRead(file))
                {
                    byte[] buffer = new byte[4096];
                    int sourceBytes;
                    while ((sourceBytes = fileStream.Read(buffer, 0, buffer.Length)) > 0)
                    {
                        zipOutputStream.Write(buffer, 0, sourceBytes);
                    }
                }
            }
            string[] subdirectories = Directory.GetDirectories(sourceDirectory);
            foreach (string subdirectory in subdirectories)
            {
                AddDirectoryFilesToZip(subdirectory, zipOutputStream);
            }
        }
        static void Decompress(string zipFilePath, string extractPath)
        {
            using (var zipInputStream = new ZipInputStream(File.OpenRead(zipFilePath)))
            {
                ZipEntry entry;
                while ((entry = zipInputStream.GetNextEntry()) != null)
                {
                    string entryPath = Path.Combine(extractPath, entry.Name);
                    if (entry.IsFile)
                    {
                        string directoryName = Path.GetDirectoryName(entryPath);
                        if (!Directory.Exists(directoryName))
                            Directory.CreateDirectory(directoryName);
                        using (var fileStream = File.Create(entryPath))
                        {
                            byte[] buffer = new byte[4096];
                            int bytesRead;
                            while ((bytesRead = zipInputStream.Read(buffer, 0, buffer.Length)) > 0)
                            {
                                fileStream.Write(buffer, 0, bytesRead);
                            }
                        }
                    }
                    else if (entry.IsDirectory)
                    {
                        Directory.CreateDirectory(entryPath);
                    }
                }
            }
        }
    }
}

Imports ICSharpCode.SharpZipLib.Zip
Imports System
Imports System.IO
Namespace SharpZipLibExample
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			Dim sourceDirectory As String = "C:\SourceDirectory"
			Dim zipFilePath As String = "C:\OutputDirectory\compressed.zip"
			' Compress files
			CompressDirectory(sourceDirectory, zipFilePath)
			Console.WriteLine("Files compressed successfully.")
			Dim extractPath As String = "C:\OutputDirectory\extracted"
			' Decompress files
			Decompress(zipFilePath, extractPath)
			Console.WriteLine("Files decompressed successfully.")
		End Sub
		Private Shared Sub CompressDirectory(ByVal sourceDirectory As String, ByVal zipFilePath As String)
			Using zipOutputStream As New ZipOutputStream(File.Create(zipFilePath))
				zipOutputStream.SetLevel(5) ' Compression level (0-9)
				' Recursively add files in the source directory to the ZIP file
				AddDirectoryFilesToZip(sourceDirectory, zipOutputStream)
				zipOutputStream.Finish()
				zipOutputStream.Close()
			End Using
		End Sub
		Private Shared Sub AddDirectoryFilesToZip(ByVal sourceDirectory As String, ByVal zipOutputStream As ZipOutputStream)
			Dim files() As String = Directory.GetFiles(sourceDirectory)
			For Each file As String In files
				Dim entry = New ZipEntry(Path.GetFileName(file))
				zipOutputStream.PutNextEntry(entry)
				Using fileStream = System.IO.File.OpenRead(file)
					Dim buffer(4095) As Byte
					Dim sourceBytes As Integer
					sourceBytes = fileStream.Read(buffer, 0, buffer.Length)
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: while ((sourceBytes = fileStream.Read(buffer, 0, buffer.Length)) > 0)
					Do While sourceBytes > 0
						zipOutputStream.Write(buffer, 0, sourceBytes)
						sourceBytes = fileStream.Read(buffer, 0, buffer.Length)
					Loop
				End Using
			Next file
			Dim subdirectories() As String = Directory.GetDirectories(sourceDirectory)
			For Each subdirectory As String In subdirectories
				AddDirectoryFilesToZip(subdirectory, zipOutputStream)
			Next subdirectory
		End Sub
		Private Shared Sub Decompress(ByVal zipFilePath As String, ByVal extractPath As String)
			Using zipInputStream As New ZipInputStream(File.OpenRead(zipFilePath))
				Dim entry As ZipEntry
				entry = zipInputStream.GetNextEntry()
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: while ((entry = zipInputStream.GetNextEntry()) != null)
				Do While entry IsNot Nothing
					Dim entryPath As String = Path.Combine(extractPath, entry.Name)
					If entry.IsFile Then
						Dim directoryName As String = Path.GetDirectoryName(entryPath)
						If Not Directory.Exists(directoryName) Then
							Directory.CreateDirectory(directoryName)
						End If
						Using fileStream = File.Create(entryPath)
							Dim buffer(4095) As Byte
							Dim bytesRead As Integer
							bytesRead = zipInputStream.Read(buffer, 0, buffer.Length)
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: while ((bytesRead = zipInputStream.Read(buffer, 0, buffer.Length)) > 0)
							Do While bytesRead > 0
								fileStream.Write(buffer, 0, bytesRead)
								bytesRead = zipInputStream.Read(buffer, 0, buffer.Length)
							Loop
						End Using
					ElseIf entry.IsDirectory Then
						Directory.CreateDirectory(entryPath)
					End If
					entry = zipInputStream.GetNextEntry()
				Loop
			End Using
		End Sub
	End Class
End Namespace

VB C#

SharpZipLib ist seit langem ein Grundnahrungsmittel in der .NET Sprachentwicklungsgemeinschaft und bietet wesentliche Funktionen für die Arbeit mit komprimierten Archiven wie ZIP, GZip, Tar und BZip2. Da sich die Technologie jedoch weiterentwickelt und Entwickler nach fortschrittlicheren Lösungen suchen, sind bestimmte Einschränkungen von SharpZipLib offensichtlich geworden.

Beschränkungen der SharpZipLib

Komplexität: Die API von SharpZipLib kann umständlich und langatmig sein, so dass Entwickler langen Code schreiben müssen, um einfache Aufgaben wie das Erstellen oder Extrahieren von ZIP-Archiven durchzuführen.
Mangel an modernen Funktionen: SharpZipLib fehlt die Unterstützung für moderne .NET-Funktionen und -Plattformen, wodurch es für moderne Entwicklungsumgebungen weniger geeignet ist.
Eingeschränkte Dokumentation: Obwohl es SharpZipLib schon seit langem gibt, ist die Dokumentation oft spärlich und veraltet, was es für Entwickler schwierig macht, den Einstieg zu finden oder Probleme zu beheben.
Leistung: Die Leistung von SharpZipLib entspricht möglicherweise nicht immer den Erwartungen der Entwickler, insbesondere bei großen oder komplexen Archiven.

IronZIP: Überbrückung der Kluft

IronZIP, entwickelt von Iron Softwareist eine moderne und effiziente Lösung für die Verwaltung von ZIP-Archiven in .NET-Anwendungen. Mit seiner intuitiven API können Entwickler ZIP-Dateien problemlos erstellen, lesen und bearbeiten. IronZIP bietet fortschrittliche Funktionen wie anpassbare Komprimierungsstufen und Passwortschutz, die Flexibilität und Datensicherheit gewährleisten. IronZIP ist mit den neuesten .NET-Versionen kompatibel und auf Leistung optimiert und rationalisiert Archivverwaltungsaufgaben mit Leichtigkeit und Effizienz.

Sharpziplib ZIP extrahieren C# (Wie es für Entwickler funktioniert): Abbildung 4 - IronZIP for .NET: Die C#-Zip-Archivbibliothek

IronZIP entpuppt sich als robuste und moderne Lösung, die die Unzulänglichkeiten von SharpZipLib beseitigt. So füllt IronZIP die Lücken:

Erweiterte API: IronZIP bietet eine intuitive und entwicklerfreundliche API, die Archivverwaltungsaufgaben vereinfacht. Mit IronZIP können Entwickler komplexe Vorgänge mit nur wenigen Codezeilen ausführen und so die Entwicklungszeit und den Aufwand reduzieren.
Vollständige .NET-Unterstützung: IronZIP unterstützt die neuesten .NET-Versionen, einschließlich .NET Core, .NET Standard und .NET-Framework, und gewährleistet so die Kompatibilität mit modernen Entwicklungsumgebungen und Plattformen.
Umfassende Dokumentation: IronZIP wird mit einer umfassenden Dokumentation und Beispielen geliefert, die es Entwicklern ermöglichen, die Funktionen und Möglichkeiten von IronZIP schnell zu erfassen. Die umfangreiche Dokumentation trägt dazu bei, die Lernkurve zu straffen und erleichtert die schnelle Integration in Projekte.
Kontrolle der Komprimierungsstufe: IronZIP bietet Entwicklern die Kontrolle über die Komprimierungsstufe, so dass sie den Grad der Komprimierung an ihre Anforderungen anpassen können. Mit dieser Funktion können Entwickler ein Gleichgewicht zwischen der Verringerung der Dateigröße und der Komprimierungsgeschwindigkeit herstellen.
Passwortschutz: IronZIP unterstützt den Passwortschutz für ZIP-Archive und erhöht damit die Sicherheit für sensible Daten. Entwickler können ZIP-Archive einfach mit herkömmlichen, AES128- und AES256-Passwörtern verschlüsseln und so sicherstellen, dass nur autorisierte Benutzer auf den Inhalt des Archivs zugreifen können.
Leistungsoptimierung: IronZIP ist auf Leistung optimiert und bietet im Vergleich zu SharpZipLib schnellere Komprimierungs- und Extraktionsgeschwindigkeiten. Diese Optimierung stellt sicher, dass Entwickler große Datenmengen ohne Leistungseinbußen effizient verarbeiten können.

Sie bietet auch eine Dokumentation seite, wie Sie mit IronZIP beginnen können. Die gebrauchsfertige Codebeispiele hilft Ihnen, ohne Probleme zu starten.

IronZIP-Installation

Hier sind die Schritte zur Integration von XDocument in IronPDF:

Öffnen Sie Visual Studio oder Ihre bevorzugte IDE.
Navigieren Sie über das Menü Tools zur NuGet Package Manager Console.
Führen Sie den folgenden Befehl aus, um das IronZIP-Paket zu installieren:

  :ProductInstall

Alternativ können Sie es auch über den NuGet Package Manager for Solutions installieren.
Wählen Sie IronZIP auf der Registerkarte "NuGet" aus und klicken Sie auf "Installieren":

Code-Beispiel

Der folgende Quellcode zeigt, wie IronZIP effizient arbeitet erstellt eine ZIP-Datei mit Leichtigkeit und mit nur ein paar Zeilen Code. Hier können Sie mehrere Dateien in die passwortgeschütztes ZIP archiv, indem Sie die Dateinamen im angegebenen Ordner angeben. Bei der Erstellung des "IronZipArchive"-Objekts können Sie auch die Komprimierungsstufe angeben, um die Größe der Ausgabedatei zu verringern.

using IronZip;
using IronZip.Enum;
class Program
{
    static void Main()
    {
        // Create an empty ZIP with the highest compression
        using (var archive = new IronZipArchive(9))
        {
            // Password protect the ZIP (Support AES128 & AES256)
            archive.SetPassword("P@ssw0rd", EncryptionMethods.Traditional);
            archive.AddArchiveEntry("./assets/file1.txt");
            archive.AddArchiveEntry("./assets/file2.txt");
            // Export the ZIP
            archive.SaveAs("output.zip");
        }
    }
}

using IronZip;
using IronZip.Enum;
class Program
{
    static void Main()
    {
        // Create an empty ZIP with the highest compression
        using (var archive = new IronZipArchive(9))
        {
            // Password protect the ZIP (Support AES128 & AES256)
            archive.SetPassword("P@ssw0rd", EncryptionMethods.Traditional);
            archive.AddArchiveEntry("./assets/file1.txt");
            archive.AddArchiveEntry("./assets/file2.txt");
            // Export the ZIP
            archive.SaveAs("output.zip");
        }
    }
}

Imports IronZip
Imports IronZip.Enum
Friend Class Program
	Shared Sub Main()
		' Create an empty ZIP with the highest compression
		Using archive = New IronZipArchive(9)
			' Password protect the ZIP (Support AES128 & AES256)
			archive.SetPassword("P@ssw0rd", EncryptionMethods.Traditional)
			archive.AddArchiveEntry("./assets/file1.txt")
			archive.AddArchiveEntry("./assets/file2.txt")
			' Export the ZIP
			archive.SaveAs("output.zip")
		End Using
	End Sub
End Class

VB C#

Zip-Datei ausgeben

Sharpziplib ZIP extrahieren C# (Wie es für Entwickler funktioniert): Abbildung 6 - Ausgabe: Mit IronZIP erstelltes passwortgeschütztes ZIP-Archiv.

Schlussfolgerung

SharpZipLib entpuppt sich als eine leistungsstarke Kompressionsbibliothek für .NET, die eine Vielzahl von Funktionen und Möglichkeiten zur effizienten Handhabung komprimierter Dateien bietet. Ob es um die Komprimierung von Daten für die Speicherung, die Archivierung von Dateien oder die Optimierung der Bandbreitennutzung in Webdiensten geht, SharpZipLib bietet die notwendigen Werkzeuge, um Komprimierungs- und Dekomprimierungsvorgänge zu rationalisieren. Mit seinem Open-Source-Charakter, seiner plattformübergreifenden Kompatibilität und seiner robusten Funktionalität bleibt SharpZipLib die erste Wahl für Entwickler, die eine zuverlässige Lösung für Komprimierungsaufgaben in ihren .NET-Anwendungen suchen.

Während SharpZipLib eine zuverlässige Wahl für die Arbeit mit komprimierten Archiven in .NET-Anwendungen gewesen ist, sind seine Grenzen in der heutigen Entwicklungslandschaft immer deutlicher geworden. IronZIP füllt die Lücken, die SharpZipLib hinterlassen hat, und bietet eine moderne und funktionsreiche Alternative, bei der Benutzerfreundlichkeit, Leistung und Kompatibilität im Vordergrund stehen. Mit IronZIP können Entwickler neue Möglichkeiten für die Archivverwaltung erschließen und ihren Entwicklungs-Workflow mit fortschrittlichen Funktionen und intuitiven Funktionen optimieren API.

IronZIP bietet eine kostenloser Test seite. Laden Sie die Bibliothek herunter von diese link und probieren Sie es aus.

< PREVIOUS
Xceed.Document .NET (Wie es für Entwickler funktioniert)

NÄCHSTES >
Xdocument C# (Wie es für Entwickler funktioniert)