RDIFramework.NET ━ .NET快速信息化系统开发框架 V3.2 新增解压缩工具类ZipHelper

　　在项目对文件进行解压缩是非常常用的功能，对文件进行压缩存储或传输可以节省流量与空间。压缩文件的格式与方法都比较多，比较常用的国际标准是zip格式。压缩与解压缩的方法也很多，在.NET 2.0开始，在System.IO.Compression中微软已经给我们提供了解压缩的方法GZipStream。对于GZipStream的使用以及优缺点网上已经有非常多的文章，本文主要讲的是利用三方开源组件ICSharpCode.SharpZipLib进行文件的解压缩。

　　SharpZipLib地址：http://www.icsharpcode.net/OpenSource/SharpZipLib/Default.aspx

　　SharpZipLib是一个使用C#编写的Zip操作类库，是一个开源的C#压缩解压库，应用非常广泛。在VB.NET、C#或其他的.NET语言中都可以使用它创建Zip文件、并进行读取和更新等操作。SharpZipLib是一个完全由c#编写的Zip, GZip, Tar and BZip2 library,可以方便地支持这几种格式的压缩解压缩。SharpZipLib目前的版本为0.86，我们可以直接从上面提供的网站下载dll文件再添加到项目引用中，也可以通过VS提供的包管理工具NuGet把SharpZipLib添加到项目中。NuGet能更方便地把一些dll和文件添加到项目中,而不需要从文件中复制拷贝，推荐使用。使用NuGet添加SharpZipLib到项目中的方法如下图所示，在我们需要SharpZipLib的项目中右键单击“引用”，在弹出的快捷菜单中选择“管理NuGet程序包(N)…”。

　　在打开的“管理NuGet程序包”对话框，搜索SharpZipLib找到后单击安装即可。

　　引用SharpZipLib到项目中后，我们就可以编写相应的加压缩方法，下面将对常用的方法一一分享。

　　在使用前必须先添加引用如下：

1 2	`using` `ICSharpCode.SharpZipLib.Checksums;` `using` `ICSharpCode.SharpZipLib.Zip;`

　　一、压缩文件夹

/// <summary>
   /// 压缩文件夹
   /// </summary>
   /// <param name="dirToZip"></param>
   /// <param name="zipedFileName"></param>
   /// <param name="compressionLevel">压缩率0（无压缩）9（压缩率最高）</param>
   public static void ZipDir(string dirToZip, string zipedFileName, int compressionLevel = 9)
   {
       if (Path.GetExtension(zipedFileName) != ".zip")
       {
           zipedFileName = zipedFileName + ".zip";
       }
       using (var zipoutputstream = new ZipOutputStream(File.Create(zipedFileName)))
       {
           zipoutputstream.SetLevel(compressionLevel);
           Crc32 crc = new Crc32();
           Hashtable fileList = GetAllFies(dirToZip);
           foreach (DictionaryEntry item in fileList)
           {
               FileStream fs = new FileStream(item.Key.ToString(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
               byte[] buffer = new byte[fs.Length];
               fs.Read(buffer, 0, buffer.Length);;
               ZipEntry entry = new ZipEntry(Path.GetFileName(item.Key.ToString()))
               {
                   DateTime = (DateTime)item.Value,
                   Size = fs.Length
               };
               fs.Close();
               crc.Reset();
               crc.Update(buffer);
               entry.Crc = crc.Value;
               zipoutputstream.PutNextEntry(entry);
               zipoutputstream.Write(buffer, 0, buffer.Length);
           }
       }
   }

　　二、解压文件夹

/// <summary>  
   /// 功能：解压zip格式的文件。  
   /// </summary>  
   /// <param name="zipFilePath">压缩文件路径</param>  
   /// <param name="unZipDir">解压文件存放路径,为空时默认与压缩文件同一级目录下，跟压缩文件同名的文件夹</param>  
   /// <returns>解压是否成功</returns>  
   public static void UnZip(string zipFilePath, string unZipDir)
   {
       if (zipFilePath == string.Empty)
       {
           throw new Exception("压缩文件不能为空！");
       }
       if (!File.Exists(zipFilePath))
       {
           throw new FileNotFoundException("压缩文件不存在！");
       }
       //解压文件夹为空时默认与压缩文件同一级目录下，跟压缩文件同名的文件夹  
       if (unZipDir == string.Empty)
           unZipDir = zipFilePath.Replace(Path.GetFileName(zipFilePath), Path.GetFileNameWithoutExtension(zipFilePath));
       if (!unZipDir.EndsWith("/"))
           unZipDir += "/";
       if (!Directory.Exists(unZipDir))
           Directory.CreateDirectory(unZipDir);
 
       using (var s = new ZipInputStream(File.OpenRead(zipFilePath)))
       {
 
           ZipEntry theEntry;
           while ((theEntry = s.GetNextEntry()) != null)
           {
               string directoryName = Path.GetDirectoryName(theEntry.Name);
               string fileName = Path.GetFileName(theEntry.Name);
               if (!string.IsNullOrEmpty(directoryName))
               {
                   Directory.CreateDirectory(unZipDir + directoryName);
               }
               if (directoryName != null && !directoryName.EndsWith("/"))
               {
               }
               if (fileName != String.Empty)
               {
                   using (FileStream streamWriter = File.Create(unZipDir + theEntry.Name))
                   {
 
                       int size;
                       byte[] data = new byte[2048];
                       while (true)
                       {
                           size = s.Read(data, 0, data.Length);
                           if (size > 0)
                           {
                               streamWriter.Write(data, 0, size);
                           }
                           else
                           {
                               break;
                           }
                       }
                   }
               }
           }
       }
   }

　　三、压缩单个文件

/// <summary> 
  /// 压缩单个文件 
  /// </summary> 
  /// <param name="fileToZip">要进行压缩的文件名，全路径</param> 
  /// <param name="zipedFile">压缩后生成的压缩文件名,全路径</param> 
  public static void ZipFile(string fileToZip, string zipedFile)
  {
      // 如果文件没有找到，则报错 
      if (!File.Exists(fileToZip))
      {
          throw new FileNotFoundException("指定要压缩的文件: " + fileToZip + " 不存在!");
      }
      using (FileStream fileStream = File.OpenRead(fileToZip))
      {
          byte[] buffer = new byte[fileStream.Length];
          fileStream.Read(buffer, 0, buffer.Length);
          fileStream.Close();
          using (FileStream zipFile = File.Create(zipedFile))
          {
              using (ZipOutputStream zipOutputStream = new ZipOutputStream(zipFile))
              {
                  // string fileName = fileToZip.Substring(fileToZip.LastIndexOf("\\") + 1);
                  string fileName = Path.GetFileName(fileToZip);
                  var zipEntry = new ZipEntry(fileName)
                  {
                      DateTime = DateTime.Now,
                      IsUnicodeText = true
                  };
                  zipOutputStream.PutNextEntry(zipEntry);
                  zipOutputStream.SetLevel(5);
                  zipOutputStream.Write(buffer, 0, buffer.Length);
                  zipOutputStream.Finish();
                  zipOutputStream.Close();
              }
          }
      }
  }

　　三、压缩单个文件

/// <summary>
   /// 压缩多个目录或文件
   /// </summary>
   /// <param name="folderOrFileList">待压缩的文件夹或者文件，全路径格式,是一个集合</param>
   /// <param name="zipedFile">压缩后的文件名，全路径格式</param>
   /// <param name="password">压宿密码</param>
   /// <returns></returns>
   public static bool ZipManyFilesOrDictorys(IEnumerable<string> folderOrFileList, string zipedFile, string password)
   {
       bool res = true;
       using (var s = new ZipOutputStream(File.Create(zipedFile)))
       {
           s.SetLevel(6);
           if (!string.IsNullOrEmpty(password))
           {
               s.Password = password;
           }
           foreach (string fileOrDir in folderOrFileList)
           {
               //是文件夹
               if (Directory.Exists(fileOrDir))
               {
                   res = ZipFileDictory(fileOrDir, s, "");
               }
               else
               {
                   //文件
                   res = ZipFileWithStream(fileOrDir, s);
               }
           }
           s.Finish();
           s.Close();
           return res;
       }
   }

　　五、递归压缩文件夹

/// <summary>
   /// 递归压缩文件夹方法
   /// </summary>
   /// <param name="folderToZip"></param>
   /// <param name="s"></param>
   /// <param name="parentFolderName"></param>
   private static bool ZipFileDictory(string folderToZip, ZipOutputStream s, string parentFolderName)
   {
       bool res = true;
       ZipEntry entry = null;
       FileStream fs = null;
       Crc32 crc = new Crc32();
       try
       {
           //创建当前文件夹
           entry = new ZipEntry(Path.Combine(parentFolderName, Path.GetFileName(folderToZip) + "/")); //加上 “/” 才会当成是文件夹创建
           s.PutNextEntry(entry);
           s.Flush();
           //先压缩文件，再递归压缩文件夹
           var filenames = Directory.GetFiles(folderToZip);
           foreach (string file in filenames)
           {
               //打开压缩文件
               fs = File.OpenRead(file);
               byte[] buffer = new byte[fs.Length];
               fs.Read(buffer, 0, buffer.Length);
               entry = new ZipEntry(Path.Combine(parentFolderName, Path.GetFileName(folderToZip) + "/" + Path.GetFileName(file)));
               entry.DateTime = DateTime.Now;
               entry.Size = fs.Length;
               fs.Close();
               crc.Reset();
               crc.Update(buffer);
               entry.Crc = crc.Value;
               s.PutNextEntry(entry);
               s.Write(buffer, 0, buffer.Length);
           }
       }
       catch
       {
           res = false;
       }
       finally
       {
           if (fs != null)
           {
               fs.Close();
           }
           if (entry != null)
           {
           }
           GC.Collect();
           GC.Collect(1);
       }
       var folders = Directory.GetDirectories(folderToZip);
       foreach (string folder in folders)
       {
           if (!ZipFileDictory(folder, s, Path.Combine(parentFolderName, Path.GetFileName(folderToZip))))
           {
               return false;
           }
       }
       return res;
   }

　　利用ICSharpCode.SharpZipLib解压缩辅助类全部代码如下：

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
 
namespace RDIFramework.Utilities
{
    using ICSharpCode.SharpZipLib.Checksums;
    using ICSharpCode.SharpZipLib.Zip;
 
    /// <summary>
    /// ZipHelper.cs
    /// Zip解压缩帮助类
    ///
    /// 修改纪录
    ///     
    ///     2017-03-05 EricHu   创建。
    /// 
    /// 版本：1.0
    ///
    /// <author>
    ///        <name>EricHu</name>
    ///        <date>2017-03-05</date>
    /// </author>
    /// </summary>
    public class ZipHelper
    {
        /// <summary>
        /// 压缩文件夹
        /// </summary>
        /// <param name="dirToZip"></param>
        /// <param name="zipedFileName"></param>
        /// <param name="compressionLevel">压缩率0（无压缩）9（压缩率最高）</param>
        public static void ZipDir(string dirToZip, string zipedFileName, int compressionLevel = 9)
        {
            if (Path.GetExtension(zipedFileName) != ".zip")
            {
                zipedFileName = zipedFileName + ".zip";
            }
            using (var zipoutputstream = new ZipOutputStream(File.Create(zipedFileName)))
            {
                zipoutputstream.SetLevel(compressionLevel);
                Crc32 crc = new Crc32();
                Hashtable fileList = GetAllFies(dirToZip);
                foreach (DictionaryEntry item in fileList)
                {
                    FileStream fs = new FileStream(item.Key.ToString(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                    byte[] buffer = new byte[fs.Length];
                    fs.Read(buffer, 0, buffer.Length);;
                    ZipEntry entry = new ZipEntry(Path.GetFileName(item.Key.ToString()))
                    {
                        DateTime = (DateTime)item.Value,
                        Size = fs.Length
                    };
                    fs.Close();
                    crc.Reset();
                    crc.Update(buffer);
                    entry.Crc = crc.Value;
                    zipoutputstream.PutNextEntry(entry);
                    zipoutputstream.Write(buffer, 0, buffer.Length);
                }
            }
        }
 
        /// <summary>  
        /// 获取所有文件  
        /// </summary>  
        /// <returns></returns>  
        public static Hashtable GetAllFies(string dir)
        {
            Hashtable filesList = new Hashtable();
            DirectoryInfo fileDire = new DirectoryInfo(dir);
            if (!fileDire.Exists)
            {
                throw new FileNotFoundException("目录:" + fileDire.FullName + "没有找到!");
            }
 
            GetAllDirFiles(fileDire, filesList);
            GetAllDirsFiles(fileDire.GetDirectories(), filesList);
            return filesList;
        }
 
        /// <summary>  
        /// 获取一个文件夹下的所有文件夹里的文件  
        /// </summary>  
        /// <param name="dirs"></param>  
        /// <param name="filesList"></param>  
        public static void GetAllDirsFiles(IEnumerable<DirectoryInfo> dirs, Hashtable filesList)
        {
            foreach (DirectoryInfo dir in dirs)
            {
                foreach (FileInfo file in dir.GetFiles("*.*"))
                {
                    filesList.Add(file.FullName, file.LastWriteTime);
                }
                GetAllDirsFiles(dir.GetDirectories(), filesList);
            }
        }
 
        /// <summary>  
        /// 获取一个文件夹下的文件  
        /// </summary>  
        /// <param name="dir">目录名称</param>
        /// <param name="filesList">文件列表HastTable</param>  
        public static void GetAllDirFiles(DirectoryInfo dir, Hashtable filesList)
        {
            foreach (FileInfo file in dir.GetFiles("*.*"))
            {
                filesList.Add(file.FullName, file.LastWriteTime);
            }
        }
 
        /// <summary>  
        /// 功能：解压zip格式的文件。  
        /// </summary>  
        /// <param name="zipFilePath">压缩文件路径</param>  
        /// <param name="unZipDir">解压文件存放路径,为空时默认与压缩文件同一级目录下，跟压缩文件同名的文件夹</param>  
        /// <returns>解压是否成功</returns>  
        public static void UnZip(string zipFilePath, string unZipDir)
        {
            if (zipFilePath == string.Empty)
            {
                throw new Exception("压缩文件不能为空！");
            }
            if (!File.Exists(zipFilePath))
            {
                throw new FileNotFoundException("压缩文件不存在！");
            }
            //解压文件夹为空时默认与压缩文件同一级目录下，跟压缩文件同名的文件夹  
            if (unZipDir == string.Empty)
                unZipDir = zipFilePath.Replace(Path.GetFileName(zipFilePath), Path.GetFileNameWithoutExtension(zipFilePath));
            if (!unZipDir.EndsWith("/"))
                unZipDir += "/";
            if (!Directory.Exists(unZipDir))
                Directory.CreateDirectory(unZipDir);
 
            using (var s = new ZipInputStream(File.OpenRead(zipFilePath)))
            {
 
                ZipEntry theEntry;
                while ((theEntry = s.GetNextEntry()) != null)
                {
                    string directoryName = Path.GetDirectoryName(theEntry.Name);
                    string fileName = Path.GetFileName(theEntry.Name);
                    if (!string.IsNullOrEmpty(directoryName))
                    {
                        Directory.CreateDirectory(unZipDir + directoryName);
                    }
                    if (directoryName != null && !directoryName.EndsWith("/"))
                    {
                    }
                    if (fileName != String.Empty)
                    {
                        using (FileStream streamWriter = File.Create(unZipDir + theEntry.Name))
                        {
 
                            int size;
                            byte[] data = new byte[2048];
                            while (true)
                            {
                                size = s.Read(data, 0, data.Length);
                                if (size > 0)
                                {
                                    streamWriter.Write(data, 0, size);
                                }
                                else
                                {
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
 
        /// <summary>
        /// 压缩单个文件
        /// </summary>
        /// <param name="filePath">被压缩的文件名称(包含文件路径)，文件的全路径</param>
        /// <param name="zipedFileName">压缩后的文件名称(包含文件路径)，保存的文件名称</param>
        /// <param name="compressionLevel">压缩率0（无压缩）到 9（压缩率最高）</param>
        public static void ZipFile(string filePath, string zipedFileName, int compressionLevel = 9)
        {
            // 如果文件没有找到，则报错 
            if (!File.Exists(filePath))
            {
                throw new FileNotFoundException("文件：" + filePath + "没有找到！");
            }
            // 如果压缩后名字为空就默认使用源文件名称作为压缩文件名称
            if (string.IsNullOrEmpty(zipedFileName))
            {
                string oldValue = Path.GetFileName(filePath);
                if (oldValue != null)
                {
                    zipedFileName = filePath.Replace(oldValue, "") + Path.GetFileNameWithoutExtension(filePath) + ".zip";
                }
            }
            // 如果压缩后的文件名称后缀名不是zip，就是加上zip，防止是一个乱码文件
            if (Path.GetExtension(zipedFileName) != ".zip")
            {
                zipedFileName = zipedFileName + ".zip";
            }
            // 如果指定位置目录不存在，创建该目录  C:\Users\yhl\Desktop\大汉三通
            string zipedDir = zipedFileName.Substring(0, zipedFileName.LastIndexOf("\\", StringComparison.Ordinal));
            if (!Directory.Exists(zipedDir))
            {
                Directory.CreateDirectory(zipedDir);
            }
            // 被压缩文件名称
            string filename = filePath.Substring(filePath.LastIndexOf("\\", StringComparison.Ordinal) + 1);
            var streamToZip = new FileStream(filePath, FileMode.Open, FileAccess.Read);
            var zipFile = File.Create(zipedFileName);
            var zipStream = new ZipOutputStream(zipFile);
            var zipEntry = new ZipEntry(filename);
            zipStream.PutNextEntry(zipEntry);
            zipStream.SetLevel(compressionLevel);
            var buffer = new byte[2048];
            Int32 size = streamToZip.Read(buffer, 0, buffer.Length);
            zipStream.Write(buffer, 0, size);
            try
            {
                while (size < streamToZip.Length)
                {
                    int sizeRead = streamToZip.Read(buffer, 0, buffer.Length);
                    zipStream.Write(buffer, 0, sizeRead);
                    size += sizeRead;
                }
            }
            finally
            {
                zipStream.Finish();
                zipStream.Close();
                streamToZip.Close();
            }
        }
 
        /// <summary> 
        /// 压缩单个文件 
        /// </summary> 
        /// <param name="fileToZip">要进行压缩的文件名，全路径</param> 
        /// <param name="zipedFile">压缩后生成的压缩文件名,全路径</param> 
        public static void ZipFile(string fileToZip, string zipedFile)
        {
            // 如果文件没有找到，则报错 
            if (!File.Exists(fileToZip))
            {
                throw new FileNotFoundException("指定要压缩的文件: " + fileToZip + " 不存在!");
            }
            using (FileStream fileStream = File.OpenRead(fileToZip))
            {
                byte[] buffer = new byte[fileStream.Length];
                fileStream.Read(buffer, 0, buffer.Length);
                fileStream.Close();
                using (FileStream zipFile = File.Create(zipedFile))
                {
                    using (ZipOutputStream zipOutputStream = new ZipOutputStream(zipFile))
                    {
                        // string fileName = fileToZip.Substring(fileToZip.LastIndexOf("\\") + 1);
                        string fileName = Path.GetFileName(fileToZip);
                        var zipEntry = new ZipEntry(fileName)
                        {
                            DateTime = DateTime.Now,
                            IsUnicodeText = true
                        };
                        zipOutputStream.PutNextEntry(zipEntry);
                        zipOutputStream.SetLevel(5);
                        zipOutputStream.Write(buffer, 0, buffer.Length);
                        zipOutputStream.Finish();
                        zipOutputStream.Close();
                    }
                }
            }
        }
 
        /// <summary>
        /// 压缩多个目录或文件
        /// </summary>
        /// <param name="folderOrFileList">待压缩的文件夹或者文件，全路径格式,是一个集合</param>
        /// <param name="zipedFile">压缩后的文件名，全路径格式</param>
        /// <param name="password">压宿密码</param>
        /// <returns></returns>
        public static bool ZipManyFilesOrDictorys(IEnumerable<string> folderOrFileList, string zipedFile, string password)
        {
            bool res = true;
            using (var s = new ZipOutputStream(File.Create(zipedFile)))
            {
                s.SetLevel(6);
                if (!string.IsNullOrEmpty(password))
                {
                    s.Password = password;
                }
                foreach (string fileOrDir in folderOrFileList)
                {
                    //是文件夹
                    if (Directory.Exists(fileOrDir))
                    {
                        res = ZipFileDictory(fileOrDir, s, "");
                    }
                    else
                    {
                        //文件
                        res = ZipFileWithStream(fileOrDir, s);
                    }
                }
                s.Finish();
                s.Close();
                return res;
            }
        }
 
        /// <summary>
        /// 带压缩流压缩单个文件
        /// </summary>
        /// <param name="fileToZip">要进行压缩的文件名</param>
        /// <param name="zipStream"></param>
        /// <returns></returns>
        private static bool ZipFileWithStream(string fileToZip, ZipOutputStream zipStream)
        {
            //如果文件没有找到，则报错
            if (!File.Exists(fileToZip))
            {
                throw new FileNotFoundException("指定要压缩的文件: " + fileToZip + " 不存在!");
            }
            //FileStream fs = null;
            FileStream zipFile = null;
            ZipEntry zipEntry = null;
            bool res = true;
            try
            {
                zipFile = File.OpenRead(fileToZip);
                byte[] buffer = new byte[zipFile.Length];
                zipFile.Read(buffer, 0, buffer.Length);
                zipFile.Close();
                zipEntry = new ZipEntry(Path.GetFileName(fileToZip));
                zipStream.PutNextEntry(zipEntry);
                zipStream.Write(buffer, 0, buffer.Length);
            }
            catch
            {
                res = false;
            }
            finally
            {
                if (zipEntry != null)
                {
                }
 
                if (zipFile != null)
                {
                    zipFile.Close();
                }
                GC.Collect();
                GC.Collect(1);
            }
            return res;
 
        }
 
        /// <summary>
        /// 递归压缩文件夹方法
        /// </summary>
        /// <param name="folderToZip"></param>
        /// <param name="s"></param>
        /// <param name="parentFolderName"></param>
        private static bool ZipFileDictory(string folderToZip, ZipOutputStream s, string parentFolderName)
        {
            bool res = true;
            ZipEntry entry = null;
            FileStream fs = null;
            Crc32 crc = new Crc32();
            try
            {
                //创建当前文件夹
                entry = new ZipEntry(Path.Combine(parentFolderName, Path.GetFileName(folderToZip) + "/")); //加上 “/” 才会当成是文件夹创建
                s.PutNextEntry(entry);
                s.Flush();
                //先压缩文件，再递归压缩文件夹
                var filenames = Directory.GetFiles(folderToZip);
                foreach (string file in filenames)
                {
                    //打开压缩文件
                    fs = File.OpenRead(file);
                    byte[] buffer = new byte[fs.Length];
                    fs.Read(buffer, 0, buffer.Length);
                    entry = new ZipEntry(Path.Combine(parentFolderName, Path.GetFileName(folderToZip) + "/" + Path.GetFileName(file)));
                    entry.DateTime = DateTime.Now;
                    entry.Size = fs.Length;
                    fs.Close();
                    crc.Reset();
                    crc.Update(buffer);
                    entry.Crc = crc.Value;
                    s.PutNextEntry(entry);
                    s.Write(buffer, 0, buffer.Length);
                }
            }
            catch
            {
                res = false;
            }
            finally
            {
                if (fs != null)
                {
                    fs.Close();
                }
                if (entry != null)
                {
                }
                GC.Collect();
                GC.Collect(1);
            }
            var folders = Directory.GetDirectories(folderToZip);
            foreach (string folder in folders)
            {
                if (!ZipFileDictory(folder, s, Path.Combine(parentFolderName, Path.GetFileName(folderToZip))))
                {
                    return false;
                }
            }
            return res;
        }
    }
}