[C#]实现文件复制[更新]实时显示进度条

在复制更新文件时,如果想要实时的获得文件复制的进度,并显示在窗体的进度条上有许多方法,在寻找了一段资料后,我整理了一些别人的代码,获得到本篇的代码,代码实现了根据配置文件,复制文件列表的效果.思路其实很简单,就是异步的读取和写入流,在异步回调的方法中,响应窗体的进度条控件,所有注释都写在代码中了.

 

相关代码:http://download.csdn.net/source/880686

程序界面:

1.         int totalSize;                 //读取文件总大小
2.         int position;                  //当前读取位置
3.         int BUFFER_SIZE = 1024;        //缓存大小
5.         XmlDocument xmldoc;            //配置XML文件上下文
7.         private class _Copy
8.         {
9.             public string SrcFile;  //源文件
10.             public string DstFile;  //目标文件
11.             public Stream stream;   //流文件
12.             public byte[] buffer;   //缓存
13.             public int position;    //当前文件复制位置
14.             public int Size;        //当前文件总大小
15.         }
17.         List<_Copy> CopyList;       //复制列表
19.         public Form1()
20.         {
21.             InitializeComponent();
22.         }
24.         private void Form1_Load(object sender, EventArgs e)
25.         {
26.             xmldoc = new XmlDocument();
27.             xmldoc.Load("config.xml");     //配置文件
28.             CopyList = new List<_Copy>();  //复制列表
30.             //获取所有更新列表
31.             XmlNodeList list;
32.             list = xmldoc.GetElementsByTagName("update");
34.             foreach (XmlNode node in list)
35.             {
36.                 _Copy copy = new _Copy();
37.                 //如果路径末尾没有/符号，则自动加上
38.                 if (node["Path"].InnerText.Substring(node["Path"].InnerText.Length - 1, 1) != @"/")
39.                 {
40.                     copy.SrcFile = node["Path"].InnerText + @"/" + node["Name"].InnerText;
41.                 }
42.                 else
43.                 {
44.                     copy.SrcFile = node["Path"].InnerText + node["Name"].InnerText;
45.                 }
46.                 //目标文件地址
47.                 copy.DstFile = Application.StartupPath + @"/" + node["Name"].InnerText;
48.                 CopyList.Add(copy);
49.             }
51.             //如果更新列表没有值，则退出,运行程序
52.             if (CopyList.Count <= 0)
53.             {
54.                 this.Close();
55.                 return;
56.             }
58.             totalSize = 0;
59.             for (int i = 0; i < CopyList.Count; i++)
60.             {
61.                 try
62.                 {
63.                     //文件不存在，继续下个文件
64.                     if (!File.Exists(CopyList[i].SrcFile)) continue;
65.                     //目标文件已经存在，先复制一个备份
66.                     if (File.Exists(CopyList[i].DstFile))
67.                     {
68.                         File.Copy(CopyList[i].DstFile, CopyList[i].DstFile + "_upgrade", true);
69.                         File.Delete(CopyList[i].DstFile);
70.                     }
72.                     FileStream fs = new FileStream(CopyList[i].SrcFile, FileMode.Open, FileAccess.Read);
73.                     totalSize += (int)fs.Length;
74.                     CopyList[i].Size = (int)fs.Length;
75.                     CopyList[i].stream = fs;
77.                     //这里是设置缓存的大小，可以根据需要修改逻辑
78.                     BUFFER_SIZE = CopyList[i].Size / 50;
79.                     if (BUFFER_SIZE < 10 * 1024)
80.                     {
81.                         BUFFER_SIZE = CopyList[i].Size / 2;
82.                     }
84.                     //缓存的大小要设置的比总大小要小，否则无法读取
85.                     if (totalSize > BUFFER_SIZE)
86.                     {
87.                         CopyList[i].buffer = new byte[BUFFER_SIZE];
88.                         //异步调用读取文件流
89.                         CopyList[i].stream.BeginRead(CopyList[i].buffer, 0, BUFFER_SIZE,
90.                             new AsyncCallback(AsyncCopyFile), CopyList[i]);
91.                     }
92.                     else
93.                     {
94.                         fs.Close();
95.                     }
96.                 }
97.                 catch (Exception Ex)
98.                 {
99.                     //出错，恢复备份文件
100.                     File.Copy(CopyList[i].DstFile + "_upgrade", CopyList[i].DstFile, true);
101.                     MessageBox.Show("更新出错" + Ex.ToString());
102.                 }
103.             }
104.         }
106.         private void AsyncCopyFile(IAsyncResult ar)
107.         {
108.             int readedLength;
109.             _Copy copy = (_Copy)ar.AsyncState;
110.             try
111.             {
112.                 //锁顶文件流
113.                 lock (copy.stream)
114.                 {
115.                     //当文件流读取完毕，获得读取的大小
116.                     readedLength = copy.stream.EndRead(ar); 
117.                 }
119.                 //写入文件
120.                 FileStream fsWriter = new FileStream(copy.DstFile, FileMode.Append, FileAccess.Write);
121.                 fsWriter.Write(copy.buffer, 0, copy.buffer.Length);
122.                 fsWriter.Close();
124.                 //当前文件流位置
125.                 lock (copy.stream)
126.                 {
127.                     copy.position += readedLength;
128.                     position += readedLength;
129.                 }
131.                 //响应进度条
132.                 MethodInvoker m = new MethodInvoker(SynchProgressBar);
133.                 m.BeginInvoke(null, null);
135.                 //读取完毕
136.                 if (copy.position >= copy.Size)
137.                 {
138.                     //关闭文件流
139.                     copy.stream.Close(); 
140.                     //删除备份文件
141.                     File.Delete(copy.DstFile + "_upgrade");
142.                     return;
143.                 }
145.                 //继续读取下个缓存
146.                 lock (copy.stream)
147.                 {
148.                     //剩下的文件大小
149.                     int leftSize = copy.Size - copy.position;
151.                     //如果比缓存小，就将缓存大小设置为剩下的文件大小
152.                     if (leftSize < BUFFER_SIZE)
153.                         copy.buffer = new byte[leftSize];
155.                     //继续异步读取
156.                     copy.stream.BeginRead(copy.buffer, 0, copy.buffer.Length, new AsyncCallback(AsyncCopyFile), copy);
157.                 }
158.             }
159.             catch (Exception Ex)
160.             {
161.                 //出错，恢复备份文件
162.                 File.Copy(copy.DstFile + "_upgrade", copy.DstFile, true);
163.                 MessageBox.Show("更新出错" + Ex.ToString());
164.             }
165.         }
167.         public delegate void delegate_SynProgress();
169.         private void SynchProgressBar()
170.         {
171.             if (this.InvokeRequired)
172.             {
173.                 this.Invoke(new delegate_SynProgress(SynchProgressBar));
174.             }
175.             else
176.             {
177.                 if (position >= totalSize)
178.                 {
179.                     this.Close();
181.                     //下列为复制完毕后的操作，这里是启动复制文件中的第一个文件
182.                     Process p = new Process();
183.                     ProcessStartInfo si = new ProcessStartInfo();
184.                     si.FileName = CopyList[0].DstFile;
185.                     si.WindowStyle = ProcessWindowStyle.Normal;
186.                     //为true，则用默认的打开方式打开，如果是exe等，设置为false
187.                     si.UseShellExecute = false;  
189.                     p.StartInfo = si;
190.                     p.Start();
191.                 }
192.                 this.progressBar1.Maximum = totalSize;
193.                 this.progressBar1.Value = position;
194.             }
195.         }

配置文件说明

程序的配置文件为config.xml,格式如下:

1. <config>
2.     <update>
3.         <Path>C:/</Path>
4.         <Name>1.exe</Name>
5.     </update>
6.     <update>
7.         <Path>D:/</Path>
8.         <Name>2.rar</Name>
9.     </update>   
10. </config>

<Path>填写复制的源路径<Name>是源文件的文件名,<update>节点可以有多个.

 

小结

程序在复制失败上做了一个备份恢复的功能,没有进行详细的测试,在异步程序中,异常的捕获要在程序块的最里层(这个和线程很相似,否则程序会因为捕获不到异常而出现程序崩溃的情况,就执行不到文件恢复了.),所以我在异步调用的回调方法中些了文件恢复的功能.程序还有很多功能没有考虑,比如,目标文件名不能更改,路径也不能更改等.