Aspose.ZIP for .NET

Examples-CSharp-CompressingAndDecompressingFiles-CompressFilesByFileInfo-CompressFilesByFileInfo.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream zipFile = File.Open(dataDir + "CompressFilesByFileInfo_out.zip", FileMode.Create))
{
    FileInfo fi1 = new FileInfo(dataDir + "alice29.txt");
    FileInfo fi2 = new FileInfo(dataDir + "fields.c");

    using (var archive = new Archive())
    {
        archive.CreateEntry("alice29.txt", fi1);
        archive.CreateEntry("fields.c", fi2);
        archive.Save(zipFile, new ArchiveSaveOptions() { Encoding = Encoding.ASCII });
    }
}

Examples-CSharp-CompressingAndDecompressingFiles-CompressionSettings-UsingBzip2CompressionSettings.cs

using (FileStream zipFile = File.Open(dataDir + "Bzip2Compression_out.zip", FileMode.Create))
{
    using (Archive archive = new Archive(new ArchiveEntrySettings(new Bzip2CompressionSettings())))
    {
        archive.CreateEntry("sample.txt", dataDir + "sample.txt");
        archive.Save(zipFile);
    }
}

Examples-CSharp-CompressingAndDecompressingFiles-CompressionSettings-UsingLZMACompressionSettings.cs

using (FileStream zipFile = File.Open(dataDir + "LZMACompression_out.zip", FileMode.Create))
{
    using (Archive archive = new Archive(new ArchiveEntrySettings(new LzmaCompressionSettings())))
    {
        archive.CreateEntry("sample.txt", dataDir + "sample.txt");
        archive.Save(zipFile);
    }
}

Examples-CSharp-CompressingAndDecompressingFiles-CompressionSettings-UsingPPMdCompressionSettings.cs

using (FileStream zipFile = File.Open(dataDir + "PPMdCompression_out.zip", FileMode.Create))
{
    using (Archive archive = new Archive(new ArchiveEntrySettings(new PPMdCompressionSettings())))
    {
        archive.CreateEntry("sample.txt", dataDir + "sample.txt");
        archive.Save(zipFile);
    }
}

Examples-CSharp-CompressingAndDecompressingFiles-CompressMultipleFiles-CompressMultipleFiles.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream zipFile = File.Open(dataDir + "CompressMultipleFiles_out.zip", FileMode.Create))
{
    using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
    {
        using (FileStream source2 = File.Open(dataDir + "asyoulik.txt", FileMode.Open, FileAccess.Read))
        {
            using (var archive = new Archive())
            {
                archive.CreateEntry("alice29.txt", source1);
                archive.CreateEntry("asyoulik.txt", source2);
                archive.Save(zipFile, new ArchiveSaveOptions() { Encoding = Encoding.ASCII, ArchiveComment = "There are two poems from Canterbury corpus" });
            }
        }
    }
}

Examples-CSharp-CompressingAndDecompressingFiles-CompressSingleFile-CompressSingleFile.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream zipFile = File.Open(dataDir + "CompressSingleFile_out.zip", FileMode.Create))
{
    //File to be added to archive
    using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
    {
        using (var archive = new Archive(new ArchiveEntrySettings()))
        {
            archive.CreateEntry("alice29.txt", source1);
            
            archive.Save(zipFile);
        }
    }
}

Examples-CSharp-CompressingAndDecompressingFiles-DecompressMultipleFiles-DecompressMultipleFiles.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream zipFile = File.Open(dataDir + "CompressMultipleFiles_out.zip", FileMode.Open))
{
    StringBuilder sb = new StringBuilder("Entries are: ");
    int percentReady = 0;
    using (Archive archive = new Archive(zipFile,
        new ArchiveLoadOptions()
        {
            EntryListed = (s, e) => { sb.AppendFormat("{0}, ", e.Entry.Name); },
            EntryExtractionProgressed = (s, e) =>
            {
                int percent = (int)((100 * e.ProceededBytes) / ((ArchiveEntry)s).UncompressedSize);
                if (percent > percentReady)
                {
                    Console.WriteLine(string.Format("{0}% compressed", percent)); percentReady = percent;
                }
            }
        }))
    {
        Console.WriteLine(sb.ToString(0, sb.Length - 2));
        using (var extracted = File.Create(dataDir + "alice_extracted_out.txt"))
        {
            using (var decompressed = archive.Entries[0].Open())
            {
                byte[] buffer = new byte[8192];
                int bytesRead;
                while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
                {
                    extracted.Write(buffer, 0, bytesRead);
                }
                // Read from decompressed stream to extracting file.
            }
        }
        percentReady = 0;
        archive.Entries[1].Extract(dataDir + "asyoulik_extracted_out.txt");
    }
}

Examples-CSharp-CompressingAndDecompressingFiles-DecompressSingleFile-DecompressSingleFile.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream fs = File.OpenRead(dataDir + "CompressSingleFile_out.zip"))
{
    using (Archive archive = new Archive(fs))
    {
        int percentReady = 0;
        archive.Entries[0].ExtractionProgressed += (s, e) =>
        {
            int percent = (int)((100 * e.ProceededBytes) / ((ArchiveEntry)s).UncompressedSize);
            if (percent > percentReady)
            {
                Console.WriteLine(string.Format("{0}% decompressed", percent));
                percentReady = percent;
            }
        };
        archive.Entries[0].Extract(dataDir + "alice_extracted_out.txt");
    }
}

Examples-CSharp-CompressingAndDecompressingFiles-DecompressStoredFile-DecompressStoredFile.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream zipFile = File.Open(dataDir + "StoreMultipleFilesWithoutCompression_out.zip", FileMode.Open))
{
    using (Archive archive = new Archive(zipFile))
    {
        using (var extracted = File.Create(dataDir + "alice_extracted_store_out.txt"))
        {
            using (var decompressed = archive.Entries[0].Open())
            {
                byte[] buffer = new byte[8192];
                int bytesRead;
                while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
                {
                    extracted.Write(buffer, 0, bytesRead);
                }
                // Read from decompressed stream to extracting file.
            }
        }

        using (var extracted = File.Create(dataDir + "asyoulik_extracted_store_out.txt"))
        {
            using (var decompressed = archive.Entries[1].Open())
            {
                byte[] buffer = new byte[8192];
                int bytesRead;
                while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
                {
                    extracted.Write(buffer, 0, bytesRead);
                }
                // Read from decompressed stream to extracting file.
            }
        }
    }
}

Examples-CSharp-CompressingAndDecompressingFiles-ModifyingZipFile-ModifyingZipFile.cs

string dataDir = RunExamples.GetDataDir_Data();
            
using (Archive outer = new Archive(dataDir + "outer.zip"))
{
    List<ArchiveEntry> entriesToDelete = new List<ArchiveEntry>();
    List<string> namesToInsert = new List<string>();
    List<MemoryStream> contentToInsert = new List<MemoryStream>();

    foreach (ArchiveEntry entry in outer.Entries)
    {
        // Find an entry which is an archive itself
        if (entry.Name.EndsWith(".zip", StringComparison.InvariantCultureIgnoreCase) /* or another condition */ ) 
        {
            // Keep reference to the entry in order to remove it from the archive later
            entriesToDelete.Add(entry); 
            MemoryStream innerCompressed = new MemoryStream();

            //This extracts the entry to a memory stream
            entry.Open().CopyTo(innerCompressed);

            // We know that content of the entry is an zip archive so we may extract
            using (Archive inner = new Archive(innerCompressed)) 
            {
                // Loop over entries of inner archive
                foreach (ArchiveEntry ie in inner.Entries) 
                {
                    // Keep the name of inner entry.
                    namesToInsert.Add(ie.Name); 
                    MemoryStream content = new MemoryStream();
                    ie.Open().CopyTo(content);

                    // Keep the content of inner entry.
                    contentToInsert.Add(content); 
                }
            }
        }
    }

    // Delete all the entries which are archives itself
    foreach (ArchiveEntry e in entriesToDelete)
    {
        outer.DeleteEntry(e);
    }

    for (int i = 0; i < namesToInsert.Count; i++)
    {
        // Adds entries which were entries of inner archives
        outer.CreateEntry(namesToInsert[i], contentToInsert[i]); 
    }

    outer.Save(dataDir + "flatten.zip");
}

Examples-CSharp-CompressingAndDecompressingFiles-StoreMultipleFilesWithoutCompression-StoreMultipleFilesWithoutCompression.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
//Creates zip archive without compressing files
using (FileStream zipFile = File.Open(dataDir + "StoreMultipleFilesWithoutCompression_out.zip", FileMode.Create))
{
    FileInfo fi1 = new FileInfo(dataDir + "alice29.txt");
    FileInfo fi2 = new FileInfo(dataDir + "lcet10.txt");

    using (Archive archive = new Archive(new ArchiveEntrySettings(new StoreCompressionSettings())))
    {
        archive.CreateEntry("alice29.txt", fi1);
        archive.CreateEntry("lcet10.txt", fi2);
        archive.Save(zipFile, new ArchiveSaveOptions() { Encoding = Encoding.ASCII });
    }

}

Examples-CSharp-CompressingAndDecompressingFiles-UsingParallelismToCompressFiles-UsingParallelismToCompressFiles.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream zipFile = File.Open(dataDir + "UsingParallelismToCompressFiles_out.zip", FileMode.Create))
{
    using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
    {
        using (FileStream source2 = File.Open(dataDir + "asyoulik.txt", FileMode.Open, FileAccess.Read))
        {
            using (var archive = new Archive())
            {
                archive.CreateEntry("alice29.txt", source1);
                archive.CreateEntry("asyoulik.txt", source2);
                //Define the parallelism criterion
                var parallelOptions = new ParallelOptions
                {
                    ParallelCompressInMemory = ParallelCompressionMode.Always
                };
                archive.Save(zipFile,
                    new ArchiveSaveOptions()
                    {
                        ParallelOptions = parallelOptions,
                        Encoding = Encoding.ASCII,
                        ArchiveComment = "There are two poems from Canterbury corpus"
                    });
            }
        }
    }
}

Examples-CSharp-CompressingAndDecompressingFolders-CompressDirectory-DeCompressDirectory.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
string dataDir = RunExamples.GetDataDir_Data();

using (FileStream zipFile = File.Open(dataDir + "CompressDirectory_out.zip", FileMode.Create))
{
    using (FileStream zipFile2 = File.Open(dataDir + "CompressDirectory2_out.zip", FileMode.Create))
    {
        using (Archive archive = new Archive())
        {
            DirectoryInfo corpus = new DirectoryInfo(dataDir + "CanterburyCorpus");
            archive.CreateEntries(corpus);
            archive.Save(zipFile);
            archive.Save(zipFile2);
        }
    }
}

Examples-CSharp-CompressingAndDecompressingFolders-DecompressFolder-DecompressFolder.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream zipFile = File.Open(dataDir + "CompressDirectory_out.zip", FileMode.Open))
{
    using (var archive = new Archive(zipFile))
    {
        archive.ExtractToDirectory(dataDir + "DecompressFolder_out");
    }
}

Examples-CSharp-CompressingAndDecompressingFolders-ExtractArchiveWithEntriesHavingDifferentPasswords-ExtractArchiveWithEntriesHavingDifferentPasswords.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream zipFile = File.Open(dataDir + "\\different_password.zip", FileMode.Open))
{
    using (Archive archive = new Archive(zipFile))
    {
        archive.Entries[0].Extract(dataDir + "alice29_extracted_pass_out.txt", "first_pass");
        archive.Entries[1].Extract(dataDir + "asyoulik_extracted_pass_out.txt", "second_pass");
    }
}

Examples-CSharp-WorkingWithGZip-CompressFile-CompressFile.cs

using (GzipArchive archive = new GzipArchive())
{
    archive.SetSource(dataDir + "data.bin");
    archive.Save(dataDir + "archive.gz");
}

Examples-CSharp-WorkingWithGZip-ExtractToMemoryStream-ExtractToMemoryStream.cs

//Open an archive from a stream and extract it to a MemoryStream
var ms = new MemoryStream();
using (GzipArchive archive = new GzipArchive(File.OpenRead(dataDir + "sample.gz")))
{
    archive.Open().CopyTo(ms);
    Console.WriteLine(archive.Name);
}

Examples-CSharp-WorkingWithGZip-OpenGZipArchive-OpenGZipArchive.cs

//Extracts the archive and copies extracted content to file stream.
using (var archive = new GzipArchive(dataDir + "archive.gz"))
{
    using (var extracted = File.Create(dataDir + "data.bin"))
    {
        var unpacked = archive.Open();
        byte[] b = new byte[8192];
        int bytesRead;
        while (0 < (bytesRead = unpacked.Read(b, 0, b.Length)))
            extracted.Write(b, 0, bytesRead);
    }
}

Examples-CSharp-WorkingWithGZip-SaveToStream-SaveToStream.cs

//Writes compressed data to http response stream.
var ms = new MemoryStream();
using (var archive = new GzipArchive())
{
    archive.SetSource(new FileInfo(dataDir + "data.bin"));
    archive.Save(ms);
}

Examples-CSharp-WorkingWithPasswordProtectedArchives-CompressFilesWithIndividualPasswords-CompressFilesWithIndividualPasswords.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream zipFile = File.Open(dataDir + "CompressFilesWithIndividualPasswords_out.zip", FileMode.Create))
{
    FileInfo source1 = new FileInfo(dataDir + "alice29.txt");
    FileInfo source2 = new FileInfo(dataDir + "asyoulik.txt");
    FileInfo source3 = new FileInfo(dataDir + "fields.c");

    using (var archive = new Archive())
    {
        archive.CreateEntry("alice29.txt", source1, true, new ArchiveEntrySettings(new DeflateCompressionSettings(), new TraditionalEncryptionSettings("pass1")));
        archive.CreateEntry("asyoulik.txt", source2, true, new ArchiveEntrySettings(new DeflateCompressionSettings(), new AesEcryptionSettings("pass2", EncryptionMethod.AES128)));
        archive.CreateEntry("fields.c", source3, true, new ArchiveEntrySettings(new DeflateCompressionSettings(), new AesEcryptionSettings("pass3", EncryptionMethod.AES256)));
        archive.Save(zipFile);
    }
}

Examples-CSharp-WorkingWithPasswordProtectedArchives-CompressMultipleFilesWithTraditionalEncryption-CompressMultipleFilesWithTraditionalEncryption.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream zipFile = File.Open(".\\CompressMultipleFilesWithTraditionalEncryption_out.zip", FileMode.Create))
{
    FileInfo source1 = new FileInfo(".\\CanterburyCorpus\\alice29.txt");
    FileInfo source2 = new FileInfo(".\\CanterburyCorpus\\asyoulik.txt");
    FileInfo source3 = new FileInfo(".\\CanterburyCorpus\\fields.c");

    using (var archive = new Archive(new ArchiveEntrySettings(null, new TraditionalEncryptionSettings("p@s$"))))
    {
        archive.CreateEntry("alice29.txt", source1);
        archive.CreateEntry("asyoulik.txt", source2);
        archive.CreateEntry("fields.c", source3);
        archive.Save(zipFile);
    }
}

Examples-CSharp-WorkingWithPasswordProtectedArchives-DecompressAESEncryptedFile-DecompressAESEncryptedFile.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream fs = File.OpenRead(dataDir + "PasswordProtectWithAES256_out.zip"))
{
    using (var extracted = File.Create(dataDir + "alice_aesextracted_out.txt"))
    {
        using (Archive archive = new Archive(fs))
        {
            using (var decompressed = archive.Entries[0].Open("p@s$"))
            {
                byte[] b = new byte[8192];
                int bytesRead;
                while (0 < (bytesRead = decompressed.Read(b, 0, b.Length)))
                {
                    extracted.Write(b, 0, bytesRead);
                }
            }
        }
    }
}

Examples-CSharp-WorkingWithPasswordProtectedArchives-DecompressAESEncryptedStoredFile-DecompressAESEncryptedStoredFile.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream fs = File.OpenRead(dataDir + "StoreMutlipleFilesWithoutCompressionWithPassword_out.zip"))
{
    using (var extracted = File.Create(dataDir + "alice_aesextracted_out.txt"))
    {
        using (Archive archive = new Archive(fs, new ArchiveLoadOptions() { DecryptionPassword = "p@s$" }))
        {
            using (var decompressed = archive.Entries[0].Open())
            {
                byte[] b = new byte[8192];
                int bytesRead;
                while (0 < (bytesRead = decompressed.Read(b, 0, b.Length)))
                {
                    extracted.Write(b, 0, bytesRead);
                }
            }
        }
    }
}

Examples-CSharp-WorkingWithPasswordProtectedArchives-DecompressCompressedFolderToDirectory-DecompressCompressedFolderToDirectory.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream zipFile = File.Open(".\\all_corpus_encrypted.zip", FileMode.Open))
{
    new Archive(zipFile, new ArchiveLoadOptions() { DecryptionPassword = "p@s$" }).ExtractToDirectory(".\\all_corpus_decrypted");
}

Examples-CSharp-WorkingWithPasswordProtectedArchives-DecompressTraditionallyPasswordProtectedFile-DecompressTraditionallyPasswordProtectedFile.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream fs = File.OpenRead(dataDir + "CompressWithTraditionalEncryption_out.zip"))
{
    using (var extracted = File.Create(dataDir + "alice_extracted_out.txt"))
    {
        using (Archive archive = new Archive(fs, new ArchiveLoadOptions() { DecryptionPassword = "p@s$" }))
        {
            using (var decompressed = archive.Entries[0].Open())
            {
                byte[] b = new byte[8192];
                int bytesRead;
                while (0 < (bytesRead = decompressed.Read(b, 0, b.Length)))
                {
                    extracted.Write(b, 0, bytesRead);
                }
            }
        }
    }
}

Examples-CSharp-WorkingWithPasswordProtectedArchives-PasswordProtectDirectory-PasswordProtectDirectory.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream zipFile = File.Open(".\\all_corpus_encrypted_out.zip", FileMode.Create))
{
    DirectoryInfo corpus = new DirectoryInfo(".\\CanterburyCorpus");
    using (var archive = new Archive(new ArchiveEntrySettings(null, new TraditionalEncryptionSettings("p@s$"))))
    {
        archive.CreateEntries(corpus);
        archive.Save(zipFile);

Examples-CSharp-WorkingWithPasswordProtectedArchives-PasswordProtectWithAES-PasswordProtectWithAES128.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream zipFile = File.Open(dataDir + "PasswordProtectWithAES128_out.zip", FileMode.Create))
{
    using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
    {
        using (var archive = new Archive(new ArchiveEntrySettings(null, new AesEcryptionSettings("p@s$", EncryptionMethod.AES128))))
        {
            archive.CreateEntry("alice29.txt", source1);
            archive.Save(zipFile);
        }
    }
}

Examples-CSharp-WorkingWithPasswordProtectedArchives-PasswordProtectWithAES-PasswordProtectWithAES192.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream zipFile = File.Open(dataDir + "PasswordProtectWithAES192_out.zip", FileMode.Create))
{
    using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
    {
        using (var archive = new Archive(new ArchiveEntrySettings(null, new AesEcryptionSettings("p@s$", EncryptionMethod.AES192))))
        {
            archive.CreateEntry("alice29.txt", source1);
            archive.Save(zipFile);
        }
    }
}

Examples-CSharp-WorkingWithPasswordProtectedArchives-PasswordProtectWithAES-PasswordProtectWithAES256.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream zipFile = File.Open(dataDir + "PasswordProtectWithAES256_out.zip", FileMode.Create))
{
    using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
    {
        using (var archive = new Archive(new ArchiveEntrySettings(null, new AesEcryptionSettings("p@s$", EncryptionMethod.AES256))))
        {
            archive.CreateEntry("alice29.txt", source1);
            archive.Save(zipFile);
        }
    }
}

Examples-CSharp-WorkingWithPasswordProtectedArchives-PasswordPrtoectArchiveWithTraditionalPassword-PasswordPrtoectArchiveWithTraditionalPassword.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream zipFile = File.Open(dataDir + "CompressWithTraditionalEncryption_out.zip", FileMode.Create))
{
    using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
    {
        var archive = new Archive(new ArchiveEntrySettings(null, new TraditionalEncryptionSettings("p@s$")));
        archive.CreateEntry("alice29.txt", source1);
        archive.Save(zipFile);
    }
}

Examples-CSharp-WorkingWithPasswordProtectedArchives-StoreMutlipleFilesWithoutCompressionWithPassword-StoreMutlipleFilesWithoutCompressionWithPassword.cs

// For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
using (FileStream zipFile = File.Open(dataDir + "StoreMutlipleFilesWithoutCompressionWithPassword_out.zip", FileMode.Create))
{
    using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
    {
        using (var archive = new Archive(new ArchiveEntrySettings(new StoreCompressionSettings(), new AesEcryptionSettings("p@s$", EncryptionMethod.AES256))))
        {
            archive.CreateEntry("alice29.txt", source1);
            archive.Save(zipFile);
        }
    }
}

Examples-CSharp-WorkingWithRAR-ExtractEncryptedEntry.cs

FileInfo fi = new FileInfo("encrypted.rar");
using (RarArchive archive = new RarArchive(fi.OpenRead()))
{
    using (var destination = File.Create(dataDir + "firstEntry.txt"))
    {
         archive.Entries[0].Extract(destination, "p@s$w0rd");                
    }
}

Examples-CSharp-WorkingWithRAR-ExtractEntry.cs

using (RarArchive archive = new RarArchive("archive.rar")))
{
      using (var destination = File.Create(dataDir + "firstEntry.txt"))
      {
            using (var source = archive.Entries[0].Open())
            {
                  byte[] buffer = new byte[1024];
                  int bytesRead;
                  while ((bytesRead = source.Read(buffer, 0, buffer.Length)) > 0)                       
                      destination.Write(buffer, 0, bytesRead);
                        
             }                    
       }
}

Examples-CSharp-WorkingWithRAR-ExtractToDirectory.cs

using (RarArchive archive = new RarArchive("archive.rar")))
{
    archive.ExtractToDirectory("extracted");
}

Examples-CSharp-WorkingWithSevenZip-AESEncryptionSettings-AESEncryptionSettings.cs

using (var archive = new SevenZipArchive(new SevenZipEntrySettings(null, new SevenZipAESEncryptionSettings("p@s$"))))
{
    archive.CreateEntry("data.bin", new MemoryStream(new byte[] { 0x00, 0xFF }));
    archive.Save("archive.7z");
}

Examples-CSharp-WorkingWithSevenZip-ArchiveWithEncryptedEntry-ArchiveWithEncryptedEntry.cs

using (FileStream sevenZipFile = File.Open("archive.7z", FileMode.Create))
{
    using (var archive = new SevenZipArchive())
    {
        archive.CreateEntry("entry1.bin", 
            new MemoryStream(new byte[] { 0x00, 0xFF }), 
            new SevenZipEntrySettings(new SevenZipLZMACompressionSettings(), 
            new SevenZipAESEncryptionSettings("test1")), 
            new FileInfo("data1.bin"));
        archive.Save(sevenZipFile);
    }
}

Examples-CSharp-WorkingWithSevenZip-CreateSevenZipEntries-CreateSevenZipEntries.cs

using (SevenZipArchive archive = new SevenZipArchive())
{
    archive.CreateEntries(dataDir);
    archive.Save("SevenZip.7z");
}

Examples-CSharp-WorkingWithSevenZip-CreateSevenZipEntry-CreateSevenZipEntry.cs

using (FileStream sevenZipFile = File.Open("archive.7z", FileMode.Create))
{
    using (var archive = new SevenZipArchive())
    {
        archive.CreateEntry("data.bin", "file.dat");
        archive.Save(sevenZipFile);
    }
}

Examples-CSharp-WorkingWithSevenZip-EntriesWithDifferentPasswords-EntriesWithDifferentPasswords.cs

using (FileStream sevenZipFile = File.Open("archive.7z", FileMode.Create))
{
    FileInfo fi1 = new FileInfo("data1.bin");
    FileInfo fi2 = new FileInfo("data2.bin");
    FileInfo fi3 = new FileInfo("data3.bin");
    using (var archive = new SevenZipArchive())
    {
        archive.CreateEntry("entry1.bin", fi1, false, new SevenZipEntrySettings(new SevenZipStoreCompressionSettings(), new SevenZipAESEncryptionSettings("test1")));
        archive.CreateEntry("entry2.bin", fi2, false, new SevenZipEntrySettings(new SevenZipStoreCompressionSettings(), new SevenZipAESEncryptionSettings("test2")));
        archive.CreateEntry("entry3.bin", fi3, false, new SevenZipEntrySettings(new SevenZipStoreCompressionSettings(), new SevenZipAESEncryptionSettings("test3")));
        archive.Save(sevenZipFile);
    }
}

Examples-CSharp-WorkingWithSevenZip-ExtractArchviveByPath.cs

using (SevenZipArchive archive = new SevenZipArchive("archive.7z"))
{
    archive.ExtractToDirectory("ExtractionFolder");
}

Iceymann18777