C#实现多级子目录Zip压缩解压实例

     

参考

https://blog.csdn.net/lki_suidongdong/article/details/20942977

重点：

实现多级子目录的压缩，类似winrar，可以选择是否排除基准目录

     

     

     

     

     

   

   

   

 1
				public
				void ZipDirectoryTest()   

 2
				{   

 3
				string path = System.IO.Path.Combine(System.IO.Path.GetTempPath(), DateTime.Now.Ticks.ToString());   

 4
				foreach (string sub in
				new
				string[] { "bin", "release", "test", "test\\bin", "" })   

 5
				{   

 6
				string subPath = System.IO.Path.Combine(path, sub);   

 7
				if (!System.IO.Directory.Exists(subPath))   

 8
				System.IO.Directory.CreateDirectory(subPath);   

 9 System.IO.File.WriteAllText(System.IO.Path.Combine(subPath, "1.cs"), "");   

10 System.IO.File.WriteAllText(System.IO.Path.Combine(subPath, "1.txt"), "");   

11 System.IO.File.WriteAllText(System.IO.Path.Combine(subPath, "1.html"), "");   

12 System.IO.File.WriteAllText(System.IO.Path.Combine(subPath, "1.bin"), "");   

13
			

14
				}   

15
				Console.WriteLine(path);   

16
			

17
				new ZipHelper().ZipDirectory(path, "e:\\temp\\tt.zip",false);   

18 ZipHelper.UnZip("e:\\temp\\tt.zip", "e:\\temp\\tt2");   

19
				//System.IO.Directory.Delete(path, true);   

20
				//Q.Helper.FileHelper.SelectFile(path);   
			

21 }  

   

代码

    

  1
				using System;

  2
			

  3
				using System.Collections.Generic;

  4
			

  5
				using System.Linq;

  6
			

  7
				using System.Text;

  8
			

  9
				using System.IO;

 10
			

 11
				using ICSharpCode.SharpZipLib;

 12
			

 13
				using ICSharpCode.SharpZipLib.Zip;

 14
			

 15
				#if NETSTANDARD2_0

 16
			

 17
				using ICSharpCode.SharpZipLib.Checksum;

 18
			

 19
				#else
			

 20
			

 21
				using ICSharpCode.SharpZipLib.Checksums;

 22
			

 23
				#endif
			

 24
			

 25
			

 26
			

 27
				namespace Q.Helper.Zip

 28
			

 29
				{

 30
			

 31
			

 32
			

 33
				///
				

			

 34
			

 35
				/// 适用与ZIP压缩

 36
			

 37
				///
				
			

 38
			

 39
				public
				class ZipHelper

 40
			

 41
				{

 42
			

 43
				public
				int Level

 44
			

 45
				{

 46
			

 47
				get; set;

 48
			

 49
				}

 50
			

 51
				#region 压缩

 52
			

 53
			

 54
			

 55
				///
				

			

 56
			

 57
				/// 递归压缩文件夹的内部方法(排除相对路径)

 58
			

 59
				///
				
			

 60
			

 61
				///
				要压缩的文件夹路径
					

 62
			

 63
				///
				压缩输出流
					

 64
			

 65
				///
				此文件夹的上级文件夹
					

 66
			

 67
				///
				是否包含目录名
					

 68
			

 69
				///
				
			

 70
			

 71
				private
				bool ZipDirectory(string folderToZip, ZipOutputStream zipStream, string parentFolderName, bool createBaseFolder = true)

 72
			

 73
				{

 74
			

 75 folderToZip = folderToZip.Replace("\\", "/");

 76
			

 77
				bool result = true;

 78
			

 79
				string[] folders, files;

 80
			

 81 ZipEntry ent = null;

 82
			

 83 FileStream fs = null;

 84
			

 85 Crc32 crc = new Crc32();

 86
			

 87
			

 88
			

 89
				try
			

 90
			

 91
				{

 92
			

 93
				string entPath = Path.Combine(parentFolderName, Path.GetFileName(folderToZip) + "/").Replace("\\", "/");

 94
			

 95
				if (!createBaseFolder)

 96
			

 97 entPath = entPath.Substring(entPath.IndexOf("/") + 1);

 98
			

 99
				if (!string.IsNullOrEmpty(entPath))

100
			

101
				{

102
			

103 ent = new ZipEntry(entPath);

104
			

105
				Console.WriteLine(entPath);

106
			

107
				zipStream.PutNextEntry(ent);

108
			

109
				zipStream.Flush();

110
			

111
				}

112
			

113 files = Directory.GetFiles(folderToZip);

114
			

115
				foreach (string file in files)

116
			

117
				{

118
			

119 fs = File.OpenRead(file);

120
			

121
			

122
			

123
				byte[] buffer = new
				byte[fs.Length];

124
			

125 fs.Read(buffer, 0, buffer.Length);

126
			

127 entPath = Path.Combine(parentFolderName, Path.GetFileName(folderToZip) + "/" + Path.GetFileName(file)).Replace("\\", "/");

128
			

129
				if (!createBaseFolder)

130
			

131 entPath = entPath.Substring(entPath.IndexOf("/") + 1);

132
			

133
				Console.WriteLine(entPath);

134
			

135 ent = new ZipEntry(entPath);

136
			

137 ent.DateTime = DateTime.Now;

138
			

139 ent.Size = fs.Length;

140
			

141
			

142
			

143
				fs.Close();

144
			

145
			

146
			

147
				crc.Reset();

148
			

149
				crc.Update(buffer);

150
			

151
			

152
			

153 ent.Crc = crc.Value;

154
			

155
				zipStream.PutNextEntry(ent);

156
			

157 zipStream.Write(buffer, 0, buffer.Length);

158
			

159
				}

160
			

161
			

162
			

163
				}

164
			

165
				catch (Exception ex)

166
			

167
				{

168
			

169 result = false;

170
			

171
				throw ex;

172
			

173
				}

174
			

175
				finally
			

176
			

177
				{

178
			

179
				if (fs != null)

180
			

181
				{

182
			

183
				fs.Close();

184
			

185
				fs.Dispose();

186
			

187
				}

188
			

189
				if (ent != null)

190
			

191
				{

192
			

193 ent = null;

194
			

195
				}

196
			

197
				GC.Collect();

198
			

199 GC.Collect(1);

200
			

201
				}

202
			

203
			

204
			

205 folders = Directory.GetDirectories(folderToZip);

206
			

207
				//多级递归时需要记住相对目录
			

208
			

209
				foreach (string folder in folders)

210
			

211
				{

212
			

213
				if (!ZipDirectory(folder, zipStream, Path.Combine(parentFolderName, Path.GetFileName(folderToZip)), createBaseFolder))

214
			

215
				return
				false;

216
			

217
				}

218
			

219
				return result;

220
			

221
				}

222
			

223
			

224
			

225
				///
				

			

226
			

227
				/// 压缩文件夹

228
			

229
				///
				
			

230
			

231
				///
				要压缩的文件夹路径
					

232
			

233
				///
				压缩文件完整路径
					

234
			

235
				///
				密码
					

236
			

237
				///
				是否压缩成功
					

238
			

239
				public
				bool ZipDirectory(string folderToZip, string zipedFile, string password, bool includeFloderName = true)

240
			

241
				{

242
			

243
				bool result = false;

244
			

245
				if (!Directory.Exists(folderToZip))

246
			

247
				return result;

248
			

249
			

250
			

251 ZipOutputStream zipStream = new ZipOutputStream(File.Create(zipedFile));

252
			

253
				zipStream.SetLevel(Level);

254
			

255
				if (!string.IsNullOrEmpty(password)) zipStream.Password = password;

256
			

257
			

258
			

259 result = ZipDirectory(folderToZip, zipStream, "", includeFloderName);

260
			

261
			

262
			

263
				zipStream.Finish();

264
			

265
				zipStream.Close();

266
			

267
			

268
			

269
				return result;

270
			

271
				}

272
			

273
			

274
			

275
				///
				

			

276
			

277
				/// 压缩文件夹

278
			

279
				///
				
			

280
			

281
				///
				要压缩的文件夹路径
					

282
			

283
				///
				压缩文件完整路径
					

284
			

285
				///
				是否压缩成功
					

286
			

287
				public
				bool ZipDirectory(string folderToZip, string zipedFile, bool includeFloderName = true)

288
			

289
				{

290
			

291
				bool result = ZipDirectory(folderToZip, zipedFile, "", includeFloderName);

292
			

293
				return result;

294
			

295
				}

296
			

297
			

298
			

299
				///
				

			

300
			

301
				/// 压缩文件

302
			

303
				///
				
			

304
			

305
				///
				要压缩的文件全名
					

306
			

307
				///
				压缩后的文件名
					

308
			

309
				///
				密码
					

310
			

311
				///
				压缩结果
					

312
			

313
				public
				bool ZipFile(string fileToZip, string zipedFile, string password)

314
			

315
				{

316
			

317
				bool result = true;

318
			

319 ZipOutputStream zipStream = null;

320
			

321 FileStream fs = null;

322
			

323 ZipEntry ent = null;

324
			

325
			

326
			

327
				if (!File.Exists(fileToZip))

328
			

329
				return
				false;

330
			

331
			

332
			

333
				try
			

334
			

335
				{

336
			

337 fs = File.OpenRead(fileToZip);

338
			

339
				byte[] buffer = new
				byte[fs.Length];

340
			

341 fs.Read(buffer, 0, buffer.Length);

342
			

343
				fs.Close();

344
			

345
			

346
			

347 fs = File.Create(zipedFile);

348
			

349 zipStream = new ZipOutputStream(fs);

350
			

351
				if (!string.IsNullOrEmpty(password)) zipStream.Password = password;

352
			

353 ent = new ZipEntry(Path.GetFileName(fileToZip));

354
			

355
				zipStream.PutNextEntry(ent);

356
			

357
				zipStream.SetLevel(Level);

358
			

359
			

360
			

361 zipStream.Write(buffer, 0, buffer.Length);

362
			

363
			

364
			

365
				}

366
			

367
				catch
			

368
			

369
				{

370
			

371 result = false;

372
			

373
				}

374
			

375
				finally
			

376
			

377
				{

378
			

379
				if (zipStream != null)

380
			

381
				{

382
			

383
				zipStream.Finish();

384
			

385
				zipStream.Close();

386
			

387
				}

388
			

389
				if (ent != null)

390
			

391
				{

392
			

393 ent = null;

394
			

395
				}

396
			

397
				if (fs != null)

398
			

399
				{

400
			

401
				fs.Close();

402
			

403
				fs.Dispose();

404
			

405
				}

406
			

407
				}

408
			

409
				GC.Collect();

410
			

411 GC.Collect(1);

412
			

413
			

414
			

415
				return result;

416
			

417
				}

418
			

419
			

420
			

421
				///
				

			

422
			

423
				/// 压缩文件

424
			

425
				///
				
			

426
			

427
				///
				要压缩的文件全名
					

428
			

429
				///
				压缩后的文件名
					

430
			

431
				///
				压缩结果
					

432
			

433
				public
				bool ZipFile(string fileToZip, string zipedFile)

434
			

435
				{

436
			

437
				bool result = ZipFile(fileToZip, zipedFile, null);

438
			

439
				return result;

440
			

441
				}

442
			

443
			

444
			

445
				///
				

			

446
			

447
				/// 压缩文件或文件夹

448
			

449
				///
				
			

450
			

451
				///
				要压缩的路径
					

452
			

453
				///
				压缩后的文件名
					

454
			

455
				///
				密码
					

456
			

457
				///
				压缩结果
					

458
			

459
				public
				bool Zip(string fileToZip, string zipedFile, string password)

460
			

461
				{

462
			

463
				bool result = false;

464
			

465
				if (Directory.Exists(fileToZip))

466
			

467 result = ZipDirectory(fileToZip, zipedFile, password);

468
			

469
				else
				if (File.Exists(fileToZip))

470
			

471 result = ZipFile(fileToZip, zipedFile, password);

472
			

473
			

474
			

475
				return result;

476
			

477
				}

478
			

479
			

480
			

481
				///
				

			

482
			

483
				/// 压缩文件或文件夹

484
			

485
				///
				
			

486
			

487
				///
				要压缩的路径
					

488
			

489
				///
				压缩后的文件名
					

490
			

491
				///
				压缩结果
					

492
			

493
				public
				bool Zip(string fileToZip, string zipedFile)

494
			

495
				{

496
			

497
				bool result = Zip(fileToZip, zipedFile, null);

498
			

499
				return result;

500
			

501
			

502
			

503
				}

504
			

505
			

506
			

507
				#endregion
			

508
			

509
			

510
			

511
				#region 解压

512
			

513
			

514
			

515
				///
				

			

516
			

517
				/// 解压功能(解压压缩文件到指定目录)

518
			

519
				///
				
			

520
			

521
				///
				待解压的文件
					

522
			

523
				///
				指定解压目标目录
					

524
			

525
				///
				密码
					

526
			

527
				///
				解压结果
					

528
			

529
				public
				static
				bool UnZip(string fileToUnZip, string zipedFolder, string password)

530
			

531
				{

532
			

533
				bool result = true;

534
			

535
			

536
			

537 ZipInputStream zipStream = null;

538
			

539 ZipEntry ent = null;

540
			

541
				string fileName;

542
			

543
			

544
			

545
				if (!File.Exists(fileToUnZip))

546
			

547
				return
				false;

548
			

549
			

550
			

551
				if (!Directory.Exists(zipedFolder))

552
			

553
				Directory.CreateDirectory(zipedFolder);

554
			

555
			

556
			

557
				try
			

558
			

559
				{

560
			

561 zipStream = new ZipInputStream(File.OpenRead(fileToUnZip));

562
			

563
				if (!string.IsNullOrEmpty(password)) zipStream.Password = password;

564
			

565
				while ((ent = zipStream.GetNextEntry()) != null)

566
			

567
				{

568
			

569
				if (!string.IsNullOrEmpty(ent.Name))

570
			

571
				{

572
			

573 fileName = Path.Combine(zipedFolder, ent.Name);

574
			

575 fileName = fileName.Replace('/', '\\');//change by Mr.HopeGi
			

576
			

577
			

578
			

579
				if (fileName.EndsWith("\\"))

580
			

581
				{

582
			

583
				Directory.CreateDirectory(fileName);

584
			

585
				continue;

586
			

587
				}

588
			

589
				using (FileStream fs = File.Create(fileName))

590
			

591
				{

592
			

593
				int size = 2048;

594
			

595
				byte[] data = new
				byte[size];

596
			

597
				while (true)

598
			

599
				{

600
			

601
			

602
			

603 size = zipStream.Read(data, 0, data.Length);

604
			

605
				if (size > 0)

606
			

607 fs.Write(data, 0, data.Length);

608
			

609
				else
			

610
			

611
				break;

612
			

613
				}

614
			

615
				fs.Flush();

616
			

617
			

618
			

619
				fs.Close();

620
			

621
				new FileInfo(fileName).LastWriteTime = ent.DateTime;

622
			

623
				}

624
			

625
			

626
			

627
				}

628
			

629
				}

630
			

631
				}

632
			

633
				catch
			

634
			

635
				{

636
			

637 result = false;

638
			

639
				}

640
			

641
				finally
			

642
			

643
				{

644
			

645
			

646
			

647
				if (zipStream != null)

648
			

649
				{

650
			

651
				zipStream.Close();

652
			

653
				zipStream.Dispose();

654
			

655
				}

656
			

657
				if (ent != null)

658
			

659
				{

660
			

661 ent = null;

662
			

663
				}

664
			

665
				GC.Collect();

666
			

667 GC.Collect(1);

668
			

669
				}

670
			

671
				return result;

672
			

673
				}

674
			

675
			

676
			

677
				///
				

			

678
			

679
				/// 解压功能(解压压缩文件到指定目录)

680
			

681
				///
				
			

682
			

683
				///
				待解压的文件
					

684
			

685
				///
				指定解压目标目录
					

686
			

687
				///
				解压结果
					

688
			

689
				public
				static
				bool UnZip(string fileToUnZip, string zipedFolder)

690
			

691
				{

692
			

693
				bool result = UnZip(fileToUnZip, zipedFolder, null);

694
			

695
				return result;

696
			

697
				}

698
			

699
			

700
			

701
				#endregion
			

702
			

703
				}

704
			

705 }