文件分割器

程序预览：

窗体代码：

1. using System;
2. using System.Collections.Generic;
3. using System.ComponentModel;
4. using System.Data;
5. using System.Drawing;
6. //using System.Linq;
7. using System.Text;
8. using System.Windows.Forms;
9. using System.IO;
10. using System.Threading;
12. namespace 文件分割器
13. {
14.     public partial class fmMain : Form
15.     {
16.         private string SplitFileName ="";
17.         private string CombineFileName = "";
18.         public fmMain()
19.         {
20.             InitializeComponent();
21.         }
23.         /// <summary>
24.         /// 选择要分割的文件
25.         /// </summary>
26.         /// <param name="sender"></param>
27.         /// <param name="e"></param>
28.         private void btnSSelect_Click(object sender, EventArgs e)
29.         {
30.             try
31.             {
32.                 OpenFileDialog ofd = new OpenFileDialog();
33.                 ofd.Filter = "所有文件(*.*)|*.*";
34.                 pgbSplit.Value = 0;
35.                 if (ofd.ShowDialog().Equals(DialogResult.OK))
36.                 {
37.                     SplitFileName = ofd.FileName;
38.                     FileInfo fi = new FileInfo(SplitFileName);
39.                     lblSFileInfo.Text = "文件信息：/n" +
40.                                         "文件名：" + fi.Name + "/n" +
41.                                         "路径：" + fi.DirectoryName + "/n" +
42.                                         "大小：" + fi.Length.ToString("#,###") + "Bytes(" + (fi.Length/1024/1024).ToString("#,###") + "MB）/n" +
43.                                         "属性：" + (fi.IsReadOnly ? "只读/n" : "/n") +
44.                                         "创建时间：" + fi.CreationTime.ToLongDateString() + " " + fi.CreationTime.ToLongTimeString();
45.                     btnSplit.Enabled = true;                   
46.                 }
47.                 ofd.Dispose();
48.             }
49.             catch (Exception ex)
50.             {
51.                 MessageBox.Show(ex.Message);
52.             }
53.         }
54.         /// <summary>
55.         /// 初始化
56.         /// </summary>
57.         /// <param name="sender"></param>
58.         /// <param name="e"></param>
59.         private void fmMain_Load(object sender, EventArgs e)
60.         {
61.             try
62.             {
63.                 btnSplit.Enabled = false;
64.                 lblAbout.Links.Add(113, 24, "mailto:Vicoman(MSN Email)<greatvicoman@hotmail.com>");
65.                 lblAbout.Links.Add(146, 15, "mailto:Vicoman<vicoman@163.com>");
66.                 lblAbout.Links.Add(174, 28, "http://blog.csdn.net/vicoman");
67.             }
68.             catch(Exception ex)
69.             {
70.                 MessageBox.Show(ex.Message);
71.             }
72.         }
74.         /// <summary>
75.         /// 分割选定文件
76.         /// </summary>
77.         /// <param name="sender"></param>
78.         /// <param name="e"></param>
79.         private void btnSplit_Click(object sender, EventArgs e)
80.         {
81.             try
82.             {
83.                 if (txtSBlockName.Text.Trim().Equals(string.Empty))
84.                 {
85.                     MessageBox.Show(this,"请输入分块文件的扩展名。", "【分块扩展名】不能为空", MessageBoxButtons.OK, MessageBoxIcon.Error);
86.                     txtSBlockName.Focus();
87.                     return;
88.                 }
89.                 if (cmbSize.Text.Trim().Equals(string.Empty))
90.                 {
91.                     MessageBox.Show(this, "请输入分块文件的大小。", "【分块大小】不能为空", MessageBoxButtons.OK, MessageBoxIcon.Error);
92.                     cmbSize.Focus();
93.                     return;
94.                 }
95.                 pnlST.Enabled = false;
96.                 this.Cursor = Cursors.WaitCursor;
97.                 if (File.Exists(SplitFileName))
98.                 {
99.                     FileSpliter fs = new FileSpliter(SplitFileName);
100.                     fs.ExtName = txtSBlockName.Text.Trim();
101.                     fs.BlockSize = int.Parse((cmbSize.Text.Replace(",", "")));
102.                     string sInfo = lblSFileInfo.Text;
103.                     ThreadStart myThreadDelegate = new ThreadStart(fs.Split);
104.                     Thread newThread = new Thread(myThreadDelegate);
105.                     newThread.Start();
106.                     while (!newThread.IsAlive);
107.                     while (newThread.IsAlive)
108.                     {
109.                         Application.DoEvents();
110.                         pgbSplit.Value=fs.Progress;
111.                         lblSFileInfo.Text = sInfo + "/n正在分割，已完成" + pgbSplit.Value + "%";
112.                     }
113.                     newThread.Join();
114.                     lblSFileInfo.Text = sInfo + "/n分割完成！分块数：" + fs.BlockCount;
115.                 }
116.             }
117.             catch (Exception ex)
118.             {
119.                 MessageBox.Show(ex.Message);
120.             }
121.             finally
122.             {
123.                 pnlST.Enabled = true;
124.                 this.Cursor = Cursors.Default;
125.             }
127.         }
129.         /// <summary>
130.         /// 选择合并文件的第一分块，并检查所有分块的完整性
131.         /// </summary>
132.         /// <param name="sender"></param>
133.         /// <param name="e"></param>
134.         private void btnCSelect_Click(object sender, EventArgs e)
135.         {
136.             try
137.             {
138.                 OpenFileDialog ofd = new OpenFileDialog();
139.                 ofd.Filter = "第一个分块文件(*." + txtCBlockName.Text + "1)|*." + txtCBlockName.Text + "1";
140.                 if (ofd.ShowDialog().Equals(DialogResult.OK))
141.                 {
142.                     CombineFileName = ofd.FileName;
144.                     lblCFileInfo.Text = "正在检查分块文件完整性......";
145.                     FileSpliter fs = new FileSpliter(CombineFileName);
146.                     ThreadStart myThreadDelegate = new ThreadStart(fs.CheckBlockEntire);
147.                     Thread newThread = new Thread(myThreadDelegate);
148.                     newThread.Start();
149.                     while (!newThread.IsAlive) ;
150.                     while (newThread.IsAlive)
151.                     {
152.                         Application.DoEvents();
153.                         pgbCombine.Value = fs.Progress;
154.                     }
155.                     newThread.Join();
156.                     FileInfo fi = new FileInfo(CombineFileName);
157.                     string sInfo = "文件信息：/n" +
158.                                 "文件名：" + fi.Name + "/n" +
159.                                 "路径：" + fi.DirectoryName + "/n" +
160.                                 "大小：" + fi.Length.ToString("#,###") + "Bytes(" +
161.                                 (fi.Length / 1024 / 1024).ToString("#,###") + "MB）/n" +
162.                                 "创建时间：" + fi.CreationTime.ToLongDateString() + " " +
163.                                 fi.CreationTime.ToLongTimeString();
164.                     if (fs.ErrMsg.Length > 0)
165.                     {
166.                         lblCFileInfo.Text = sInfo + fs.ErrMsg;
167.                         btnCombine.Enabled = false;
168.                     }
169.                     else
170.                     {
171.                         lblCFileInfo.Text = sInfo + "/n分块文件完整性检查成功，分块数：" + 
172.                                             fs.BlockCount + "，请点击/"开始合并/"进行合并。";
173.                         btnCombine.Enabled = true;
174.                     }
175.                     pgbCombine.Value = 0;
176.                 }
177.                 ofd.Dispose();
178.             }
179.             catch (Exception ex)
180.             {
181.                 MessageBox.Show(ex.Message);
182.             }
183.         }
185.         /// <summary>
186.         /// 合并所选文件
187.         /// </summary>
188.         /// <param name="sender"></param>
189.         /// <param name="e"></param>
190.         private void btnCombine_Click(object sender, EventArgs e)
191.         {
192.             try
193.             {
194.                 if (txtCBlockName.Text.Trim().Equals(string.Empty))
195.                 {
196.                     MessageBox.Show(this, "请输入分块文件的扩展名。", "【分块扩展名】不能为空", MessageBoxButtons.OK, MessageBoxIcon.Error);
197.                     txtCBlockName.Focus();
198.                     return;
199.                 }
200.                 if (txtRename.Text.Trim().Equals(string.Empty))
201.                 {
202.                     MessageBox.Show(this, "请输入重命名文件时的后缀。", "【重命名后缀】不能为空", MessageBoxButtons.OK, MessageBoxIcon.Error);
203.                     txtRename.Focus();
204.                     return;
205.                 }
206.                 pnlCT.Enabled = false;
207.                 this.Cursor = Cursors.WaitCursor;
208.                 if (File.Exists(CombineFileName))
209.                 {
210.                     FileSpliter fs = new FileSpliter(CombineFileName);
211.                     fs.ExtName = txtCBlockName.Text;
212.                     fs.RecogniseChars = txtRename.Text;
213.                     fs.DeleteBlockFiles = chkDel.Checked;
214.                     string sInfo = lblCFileInfo.Text;
215.                     ThreadStart myThreadDelegate = new ThreadStart(fs.Combine);
216.                     Thread newThread = new Thread(myThreadDelegate);
217.                     newThread.Start();
218.                     while (!newThread.IsAlive) ;
219.                     while (newThread.IsAlive)
220.                     {
221.                         Application.DoEvents();
222.                         pgbCombine.Value = fs.Progress;
223.                         lblCFileInfo.Text = sInfo + "/n正在合并，已完成" + pgbCombine.Value + "%";
224.                     }
225.                     newThread.Join();
226.                     lblCFileInfo.Text = sInfo + "/n合并成功！生成文件：" + fs.Destination;
227.                 }
228.             }
229.             catch (Exception ex)
230.             {
231.                 MessageBox.Show(ex.Message);
232.             }
233.             finally
234.             {
235.                 pnlCT.Enabled = true;
236.                 this.Cursor = Cursors.Default;
237.             }
238.         }
240.         private void Link_Clik(object sender, LinkLabelLinkClickedEventArgs e)
241.         {
242.             try
243.             {
244.                 e.Link.Visited = true;
245.                 System.Diagnostics.Process.Start(e.Link.LinkData.ToString());
246.             }
247.             catch (Exception ex)
248.             {
249.                 MessageBox.Show(ex.Message);
250.             }
251.         }
252.     }
253. }

FileSpliter类：

1. using System;
2. using System.IO;
3. using System.Threading;
5. namespace 文件分割器
6. { 
7.     public class FileSpliter 
8.     { 
9.         private int progress; 
10.         private string lFileName; 
11.         private string extname = "part"; 
12.         private string recchars = "_C"; 
13.         private int blocksize = 1024; 
14.         private bool pDeleteAfterCombine = false;
15.         private string ErrorMessage = "";
16.         private int Part_Size;
17.         private int mBlockCount;
18.         private string lDesFileName = "";
20.         /// <summary>
21.         /// 构造函数
22.         /// </summary>
23.         public FileSpliter()
24.         {
25.         }
27.         /// <summary> 
28.         /// 构造函数 
29.         /// </summary> 
30.         /// <param name="pFileName">设定欲分割或者合并的文件名</param> 
31.         public FileSpliter(string pFileName)
32.         {
33.             this.lFileName = pFileName;
34.         } 
36.         /// <summary> 
37.         /// 获取或者设定要分割/合并的文件名，包含完整路径和文件名。 
38.         /// </summary> 
39.         public string FileName 
40.         { 
41.             get { return lFileName; } 
42.             set { lFileName = value; } 
43.         }
45.         /// <summary> 
46.         /// 获取合并后的目标文件名。
47.         /// </summary> 
48.         public string Destination
49.         {
50.             get { return lDesFileName; }
51.         }
52.         
53.         /// <summary> 
54.         /// 获取或者设定分块文件的扩展名，默认值：part（即分割后的分块文件将以*.part1,*.part2.....命名） 
55.         /// </summary> 
56.         public string ExtName 
57.         { 
58.             get { return extname; } 
59.             set { extname = value; } 
60.         } 
62.         /// <summary> 
63.         /// 获取或者设定合并后是否删除源文件。（true:删除，false:不删除） 
64.         /// </summary> 
65.         public bool DeleteBlockFiles 
66.         { 
67.             get { return pDeleteAfterCombine; } 
68.             set { pDeleteAfterCombine = value; } 
69.         } 
71.         /// <summary> 
72.         /// 获取或设定分块文件大小，默认值 1024
73.         /// </summary> 
74.         public int BlockSize 
75.         { 
76.             get { return blocksize; } 
77.             set { blocksize = value; } 
78.         }
80.         /// <summary> 
81.         /// 获取分块数
82.         /// </summary> 
83.         public int BlockCount
84.         {
85.             get { return mBlockCount; }
86.         }
87.         
88.         /// <summary> 
89.         /// 重命名文件标识字符（默认值:_C）
90.         /// </summary> 
91.         public string RecogniseChars 
92.         { 
93.             get { return recchars; } 
94.             set { recchars = value; } 
95.         }
97.         /// <summary>
98.         /// 获取错误信息
99.         /// </summary>
100.         public string ErrMsg
101.         {
102.             get { return ErrorMessage.Trim(); }            
103.         }
105.         /// <summary>
106.         /// 获取处理进度（0-100）
107.         /// </summary>
108.         public int Progress
109.         {
110.             get { return progress; }
111.         }
113.         /// <summary> 
114.         /// 将2个byte型变量合并到一个int型变量里 
115.         /// </summary> 
116.         /// <param name="byteL">第一个byte变量，合并后的高字节</param> 
117.         /// <param name="byteR">第二个byte变量，合并后的低字节</param> 
118.         /// <returns></returns> 
119.         private int toInt(byte byteL, byte byteR) 
120.         { 
121.             return (byteL << 8) + byteR; 
122.         } 
124.         /// <summary> 
125.         /// 把1个int型变量（不超过65535）存到2个byte型变量中
126.         /// </summary> 
127.         /// <param name="orgInt">要保存的int变量</param> 
128.         /// <param name="byteL">第一个byte(存储原int的高字节) 输出参数</param> 
129.         /// <param name="byteR">第二个byte(存储原int的低字节) 输出参数</param> 
130.         /// <returns></returns> 
131.         private int toByte(int orgInt, out byte byteL, out byte byteR) 
132.         { 
133.             if (orgInt > 65535) 
134.             { 
135.                 throw (new System.ArgumentOutOfRangeException("BlockSize", BlockSize, "分块数超过 65535,请重新定义分块单位大小（BlockSize）")); 
136.             } 
137.             byteL = (byte)(orgInt >> 8); 
138.             byteR = (byte)((orgInt) << 8 >> 8); 
139.             return 0; 
140.         } 
141.         
142.         /// <summary>
143.         /// 开始分割
144.         /// </summary>
145.         public void Split() 
146.         { 
147.             //ThreadStart myThreadDelegate = new ThreadStart(this.pSplit); 
148.             //Thread newThread = new Thread(myThreadDelegate); 
149.             //newThread.Start();
151.             this.pSplit();
153.         } 
155.         /// <summary>
156.         /// 开始合并
157.         /// </summary>
158.         public void Combine() 
159.         { 
160.             //ThreadStart myThreadDelegate = new ThreadStart(this.pCombine); 
161.             //Thread newThread = new Thread(myThreadDelegate); 
162.             //newThread.Start();
164.             this.pCombine();
165.         } 
168.         /// <summary> 
169.         /// 分割文件. 
170.         /// </summary> 
171.         /// <returns></returns> 
172.         private void pSplit() 
173.         { 
174.             try 
175.             { 
176.                 if (File.Exists(lFileName)) 
177.                 { 
178.                     int i = 1; 
179.                     string newFileName = lFileName + "." + extname; 
180.                     FileInfo fi = new FileInfo(lFileName); 
181.                     FileStream fs = fi.OpenRead(); 
182.                     Part_Size = blocksize * 1024; 
183.                     long lPartCnt = (fs.Length + 1) / Part_Size + 1; 
185.                     if (lPartCnt > 65535) 
186.                     { 
187.                         throw (new System.ArgumentOutOfRangeException("BlockSize", BlockSize, "The block files is much than 65535,need redefine BlockSize")); 
188.                     }
189.                     mBlockCount = (int)lPartCnt; 
190.                     byte[] ByteArray = new byte[Part_Size];
191.                     toByte(mBlockCount, out ByteArray[0], out ByteArray[1]); 
192.                     int nBytesRead = fs.Read(ByteArray, 2, Part_Size - 2); 
193.                     byte[] part = new byte[nBytesRead + 2]; 
194.                     Array.Copy(ByteArray, 0, part, 0, part.Length); 
195.                     FileInfo fo = new FileInfo(newFileName + i++.ToString()); 
196.                     FileStream fso = fo.OpenWrite(); 
197.                     fso.Write(part, 0, part.Length); 
198.                     fso.Close(); 
199.                     fso.Dispose();
201.                     progress = (int)((1.0 / mBlockCount) * 100); 
203.                     while (part.Length == Part_Size) 
204.                     { 
205.                         nBytesRead = fs.Read(ByteArray, 0, Part_Size); 
206.                         if (nBytesRead > 0) 
207.                         { 
208.                             part = new byte[nBytesRead]; 
209.                             Array.Copy(ByteArray, 0, part, 0, nBytesRead); 
210.                             fo = new FileInfo(newFileName + i.ToString()); 
211.                             fso = fo.OpenWrite(); 
212.                             fso.Write(part, 0, part.Length); 
213.                             fso.Close(); 
214.                             fso.Dispose();
215.                             progress = (int)((i++ * 1.0 / mBlockCount) * 100); 
216.                         } 
217.                     } 
218.                     fs.Close(); 
219.                     fs.Dispose(); 
220.                 } 
221.                 else 
222.                 { 
223.                     throw (new ArgumentNullException("FileName", "FileName not set or the file doesnot exist.")); 
224.                 } 
225.             } 
226.             catch (Exception ex) 
227.             { 
228.                 throw (ex); 
229.             } 
230.         }
232.         /// <summary>
233.         /// 检查所有分块文件是否完整
234.         /// </summary>
235.         public void CheckBlockEntire()
236.         {
237.             try
238.             {
239.                 FileInfo fi = new FileInfo(lFileName);
240.                 FileStream fsi = fi.OpenRead();
241.                 byte[] part = new byte[2];
242.                 string errmsg = "缺少文件：";
243.                 int errcnt = 0;
244.                 fsi.Read(part, 0, 2);
245.                 fsi.Close();
246.                 fsi.Dispose();
247.                 mBlockCount = toInt(part[0], part[1]);
248.                 progress = 1;
249.                 for (int i = 2; i <= mBlockCount; i++)
250.                 {
251.                     if (!File.Exists(lFileName.Substring(0, lFileName.Length - 1) + i))
252.                     {
253.                         errmsg += " " + lFileName.Substring(0, lFileName.Length - 1) + i;
254.                         errcnt++;
255.                     }
256.                     progress = (int)(i * 1.0 / mBlockCount) * 100;
257.                 }
258.                 if (errcnt > 0)
259.                 {
260.                     ErrorMessage = errmsg;
261.                 }
262.                 else
263.                 {
264.                     ErrorMessage = "";
265.                 }                
266.             }
267.             catch (Exception ex)
268.             {
269.                 ErrorMessage = ex.Message;
270.             }
271.         }
273.         /// <summary>
274.         /// 合并指定分块文件
275.         /// </summary>
276.         private void pCombine() 
277.         { 
278.             try 
279.             { 
280.                 if (File.Exists(lFileName)) 
281.                 { 
282.                     int i; 
283.                     string NewFn = lFileName.Substring(0, lFileName.LastIndexOf("." + extname)); 
285.                     if (File.Exists(NewFn)) 
286.                     { 
287.                         string sNameX = NewFn.Substring(0, NewFn.LastIndexOf(".")); 
288.                         string sExtName = NewFn.Substring(sNameX.Length); 
289.                         NewFn = sNameX + recchars + sExtName; 
290.                         i = 1; 
291.                         while (File.Exists(NewFn)) 
292.                         { 
293.                             NewFn = sNameX + recchars + i++ + sExtName; 
294.                         } 
295.                     } 
297.                     FileInfo fi = new FileInfo(lFileName); 
298.                     FileStream fsi = fi.OpenRead(); 
299.                     byte[] part = new byte[fsi.Length]; 
300.                     fsi.Read(part, 0, part.Length); 
301.                     fsi.Close(); 
302.                     fsi.Dispose(); 
304.                     int FileCnt = toInt(part[0], part[1]);
306.                     progress = 0;
308.                     for (i = 2; i <= FileCnt; i++) 
309.                     { 
310.                         if (!File.Exists(lFileName.Substring(0, lFileName.Length - 1) + i)) 
311.                         { 
312.                             throw (new System.ArgumentNullException("FileName", "缺少文件：" + lFileName.Substring(0, lFileName.Length - 1) + i));                             
313.                         } 
314.                     } 
316.                     FileInfo fo = new FileInfo(NewFn); 
317.                     FileStream fso = fo.OpenWrite();
318.                     lDesFileName = NewFn;
319.                     fso.Write(part, 2, part.Length - 2);
321.                     progress = (int)((1.0 / FileCnt) * 100);
323.                     for (i = 2; i <= FileCnt; i++) 
324.                     { 
325.                         fi = new FileInfo(lFileName.Substring(0, lFileName.Length - 1) + i); 
326.                         fsi = fi.OpenRead(); 
327.                         part = new byte[fsi.Length]; 
328.                         fsi.Read(part, 0, part.Length); 
329.                         fsi.Close(); 
330.                         fsi.Dispose(); 
331.                         fso.Write(part, 0, part.Length);
332.                         progress = (int)((i * 1.0 / FileCnt) * 100);
333.                     } 
334.                     fso.Close(); 
335.                     fso.Dispose(); 
337.                     if (pDeleteAfterCombine) 
338.                     { 
339.                         for (i = 1; i <= FileCnt; i++) 
340.                         { 
341.                             File.Delete(lFileName.Substring(0, lFileName.Length - 1) + i); 
342.                         } 
343.                     }
344.                 } 
345.                 else 
346.                 { 
347.                     throw (new ArgumentNullException("FileName", "FileName not set or the file doesnot exist.")); 
348.                 } 
349.             } 
350.             catch (Exception ex) 
351.             {
352.                 ErrorMessage = ex.Message;
353.             } 
354.         } 
355.     } 
356. }