C#中文件与文件夹相关的操作

1. /// <summary> 
2. /// 文件有关的操作类 
3. /// </summary> 
4. public class FileOperate 
5. { 
6.     /// <summary> 
7.     /// 删除文件 
8.     /// </summary> 
9.     /// <param name="FileFullPath">文件的全路径.</param> 
10.     /// <returns>bool</returns> 
11.     public bool DeleteFile(string FileFullPath) 
12.     { 
13.         if (File.Exists(FileFullPath) == true) //用静态类判断文件是否存在 
14.         { 
15.             File.SetAttributes(FileFullPath, FileAttributes.Normal); //设置文件的属性为正常（如果文件为只读的话直接删除会报错） 
16.             File.Delete(FileFullPath); //删除文件 
17.             return true; 
18.         } 
19.         else  //文件不存在 
20.         { 
21.             return false; 
22.         } 
23.     } 
24.     /// <summary> 
25.     /// 获取文件名（包含扩展名） 
26.     /// </summary> 
27.     /// <param name="FileFullPath">文件全路径</param> 
28.     /// <returns>string</returns> 
29.     public string GetFileName(string FileFullPath) 
30.     { 
31.         if (File.Exists(FileFullPath) == true) 
32.         { 
33.             FileInfo F = new FileInfo(FileFullPath);  //FileInfo类为提供创建、复制、删除等方法 
34.             return F.Name;  //获取文件名（包含扩展名） 
35.         } 
36.         else 
37.         { 
38.             return null; 
39.         } 
40.     } 
41.     /// <summary> 
42.     /// 获取文件文件扩展名 
43.     /// </summary> 
44.     /// <param name="FileFullPath">文件全路径</param> 
45.     /// <returns>string</returns> 
46.     public string GetFileExtension(string FileFullPath) 
47.     { 
48.         if (File.Exists(FileFullPath) == true) 
49.         { 
50.             FileInfo F = new FileInfo(FileFullPath); 
51.             return F.Extension;  //获取文件扩展名（包含".",如：".mp3"） 
52.              
53.         } 
54.         else 
55.         { 
56.             return null; 
57.         } 
58.     } 
59.     /// <summary> 
60.     /// 获取文件名（可包含扩展名） 
61.     /// </summary> 
62.     /// <param name="FileFullPath">文件全路径</param> 
63.     /// <param name="IncludeExtension">是否包含扩展名</param> 
64.     /// <returns>string</returns> 
65.     public string GetFileName(string FileFullPath, bool IncludeExtension) 
66.     { 
67.         if (File.Exists(FileFullPath) == true) 
68.         { 
69.             FileInfo F = new FileInfo(FileFullPath); 
70.             if (IncludeExtension == true) 
71.             { 
72.                 return F.Name;   //返回文件名（包含扩展名） 
73.             } 
74.             else 
75.             { 
76.                 return F.Name.Replace(F.Extension, "");  //把扩展名替换为空字符 
77.             } 
78.         } 
79.         else 
80.         { 
81.             return null; 
82.         } 
83.     } 
84.     /// <summary> 
85.     /// 根据传来的文件全路径，外部打开文件，默认用系统注册类型关联软件打开 
86.     /// </summary> 
87.     /// <param name="FileFullPath">文件的全路径</param> 
88.     /// <returns>bool</returns> 
89.     public bool OpenFile(string FileFullPath) 
90.     { 
91.         if (File.Exists(FileFullPath) == true) 
92.         { 
93.             System.Diagnostics.Process.Start(FileFullPath);  //打开文件，默认用系统注册类型关联软件打开 
94.             return true; 
95.         } 
96.         else 
97.         { 
98.             return false; 
99.         } 
100.     } 
101.     /// <summary> 
102.     /// 获取文件大小 
103.     /// </summary> 
104.     /// <param name="FileFullPath">文件全路径</param> 
105.     /// <returns>string</returns> 
106.     public string GetFileSize(string FileFullPath) 
107.     { 
108.         if (File.Exists(FileFullPath) == true) 
109.         { 
110.             FileInfo F = new FileInfo(FileFullPath); 
111.             long FL = F.Length; 
112.             if (FL > (1024 * 1024 * 1024))  //由大向小来判断文件的大小 
113.             { 
114.                 return Math.Round((FL + 0.00) / (1024 * 1024 * 1024), 2).ToString() + " GB";  //将双精度浮点数舍入到指定的小数（long类型与double类型运算，结果会是一个double类型） 
115.             } 
116.             else if (FL > (1024 * 1024)) 
117.             { 
118.                 return Math.Round((FL + 0.00) / (1024 * 1024), 2).ToString() + " MB"; 
119.             } 
120.             else if (FL > 1024) 
121.             { 
122.                 return Math.Round((FL + 0.00) / 1024, 2).ToString() + " KB"; 
123.             } 
124.             else 
125.             { 
126.                 return FL.ToString(); 
127.             } 
128.         } 
129.         else 
130.         { 
131.             return null; 
132.         } 
133.     } 
134.     /// <summary> 
135.     /// 文件转换成二进制，返回二进制数组Byte 
136.     /// </summary> 
137.     /// <param name="FileFullPath">文件全路径</param> 
138.     /// <returns>byte 包含文件流的二进制数组</returns> 
139.     public byte FileToStreamByte(string FileFullPath) 
140.     { 
141.         if (File.Exists(FileFullPath) == true) 
142.         { 
143.             FileStream FS = new FileStream(FileFullPath, FileMode.Open); //创建一个文件流 
144.             byte fileData = new byte[FS.Length];                       //创建一个字节数组，用于保存流 
145.             FS.Read(fileData, 0, fileData.Length);                       //从流中读取字节块，保存到缓存中 
146.             FS.Close();                                                  //关闭流（一定得关闭，否则流一直存在） 
147.             return fileData;                                             //返回字节数组 
148.         } 
149.         else 
150.         { 
151.             return null; 
152.         } 
153.     } 
154.     /// <summary> 
155.     /// 二进制数组Byte生成文件 
156.     /// </summary> 
157.     /// <param name="FileFullPath">要生成的文件全路径</param> 
158.     /// <param name="StreamByte">要生成文件的二进制 Byte 数组</param> 
159.     /// <returns>bool 是否生成成功</returns> 
160.     public bool ByteStreamToFile(string FileFullPath, byte StreamByte) 
161.     { 
162.         try 
163.         { 
164.             if (File.Exists(FileFullPath) == true)  //判断要创建的文件是否存在，若存在则先删除 
165.             { 
166.                 File.Delete(FileFullPath); 
167.             } 
168.             FileStream FS = new FileStream(FileFullPath, FileMode.OpenOrCreate);  //创建文件流(打开或创建的方式) 
169.             FS.Write(StreamByte, 0, StreamByte.Length);  //把文件流写到文件中 
170.             FS.Close(); 
171.             return true; 
172.         } 
173.         catch 
174.         { 
175.             return false; 
176.         } 
177.     } 
178.     /// <summary> 
179.     /// 将Xml文件序列化(可起到加密和压缩XML文件的目的) 
180.     /// </summary> 
181.     /// <param name="FileFullPath">要序列化的XML文件全路径</param> 
182.     /// <returns>bool 是否序列化成功</returns> 
183.     public bool SerializeXml(string FileFullPath)   //序列化： 
184.     { 
185.         try 
186.         { 
187.             System.Data.DataSet DS = new System.Data.DataSet();  //创建数据集，用来临时存储XML文件 
188.             DS.ReadXml(FileFullPath);  //将XML文件读入到数据集中 
189.             FileStream FS = new FileStream(FileFullPath + ".tmp", FileMode.OpenOrCreate);  //创建一个.tmp的临时文件 
190.             System.Runtime.Serialization.Formatters.Binary.BinaryFormatter FT = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();  //使用二进制格式化程序进行序列化 
191.             FT.Serialize(FS, DS);  //把数据集序列化后存入文件中 
192.             FS.Close();  //一定要关闭文件流，否则文件改名会报错（文件正在使用错误） 
193.             DeleteFile(FileFullPath);  //删除原XML文件 
194.             File.Move(FileFullPath + ".tmp", FileFullPath);  //改名(把临时文件名改成原来的xml文件名) 
195.             return true; 
196.         } 
197.         catch 
198.         { 
199.             return false; 
200.         } 
201.     } 
202.     /// <summary> 
203.     /// 反序列化XML文件 
204.     /// </summary> 
205.     /// <param name="FileFullPath">要反序列化XML文件的全路径</param> 
206.     /// <returns>bool 是否反序列化XML文件</returns> 
207.     public bool DeSerializeXml(string FileFullPath) 
208.     { 
209.         FileStream FS = new FileStream(FileFullPath, FileMode.Open);  //打开XML文件流 
210.         System.Runtime.Serialization.Formatters.Binary.BinaryFormatter FT = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();  //使用二进制格式化程序进行序列化 
211.         ((System.Data.DataSet)FT.Deserialize(FS)).WriteXml(FileFullPath + ".tmp");  //把文件反序列化后存入.tmp临时文件中 
212.         FS.Close();  //关闭并释放流 
213.         DeleteFile(FileFullPath);  //删除原文件 
214.         File.Move(FileFullPath + ".tmp", FileFullPath);  //改名(把临时文件改成原来的xml文件) 
215.         return true; 
216.     } 
217. } 
218. /// <summary> 
219. /// 与文件夹有关的操作类 
220. /// </summary> 
221. public class DirOperate 
222. { 
223.     public enum OperateOption 
224.     { 
225.         /// <summary> 
226.         /// 当被创建的文件夹存在时，先删除该文件夹 
227.         /// </summary> 
228.         ExistDelete, 
229.         /// <summary> 
230.         /// 当文件夹存在时，直接返回，不进行其它操作 
231.         /// </summary> 
232.         ExistReturn 
233.     } 
234.     /// <summary> 
235.     /// 创建文件夹 
236.     /// </summary> 
237.     /// <param name="DirFullPath">要创建的文件夹全路径</param> 
238.     /// <param name="Option">创建文件夹时的操作选项</param> 
239.     /// <returns>bool 是否创建成功</returns> 
240.     public bool CreateDir(string DirFullPath, OperateOption Option) 
241.     { 
242.         try 
243.         { 
244.             if (Directory.Exists(DirFullPath) == false)  //判断文件夹是否存在 
245.             { 
246.                 Directory.CreateDirectory(DirFullPath); 
247.             } 
248.             else if (Option == OperateOption.ExistDelete)  //如果存在且选项为“存在删除” 
249.             { 
250.                 Directory.Delete(DirFullPath);  //删除目录，并删除此目录下的所以子目录 
251.                 Directory.CreateDirectory(DirFullPath);  //创建目录 
252.             } 
253.             return true; 
254.         } 
255.         catch 
256.         { 
257.             return false; 
258.         } 
259.     } 
260.     public bool DeleteDir(string DirFullPath) 
261.     { 
262.         if (Directory.Exists(DirFullPath) == true) 
263.         { 
264.             Directory.Delete(DirFullPath, true); 
265.             return true; 
266.         } 
267.         else 
268.         { 
269.             return false; 
270.         }         
271.     } 
272.     /// <summary> 
273.     /// 得到当前文件夹中所有文件列表 
274.     /// </summary> 
275.     /// <param name="DirFullPath">文件夹全路径</param> 
276.     /// <returns>string 文件列表</returns> 
277.     public string GetDirFiles(string DirFullPath) 
278.     { 
279.         if (Directory.Exists(DirFullPath) == true) 
280.         { 
281.             string s = Directory.GetFiles(DirFullPath, "*.*", SearchOption.TopDirectoryOnly);  //获取当前目录下的所有文件 
282.             return s; 
283.         } 
284.         else 
285.         { 
286.             return null; 
287.         } 
288.     } 
289.     /// <summary> 
290.     /// 得到当前文件夹及下级文件夹中所有文件列表 
291.     /// </summary> 
292.     /// <param name="DirFullPath">文件夹全路径</param> 
293.     /// <param name="SO">搜索选项</param> 
294.     /// <returns>string 文件列表</returns> 
295.     public string GetDirFiles(string DirFullPath, SearchOption SO) 
296.     { 
297.         if (Directory.Exists(DirFullPath) == true) 
298.         { 
299.             string s = Directory.GetFiles(DirFullPath, "*.*", SearchOption.AllDirectories);  //获取当前目录下的所有文件(包含子文件夹中的文件) 
300.             return s; 
301.         } 
302.         else 
303.         { 
304.             return null; 
305.         } 
306.     } 
307.     /// <summary> 
308.     /// 得到当前文件夹中指定文件类型［扩展名］文件列表 
309.     /// </summary> 
310.     /// <param name="DirFullPath">文件夹的全路径</param> 
311.     /// <param name="SearchPattern">查找哪种类型的文件</param> 
312.     /// <returns>string 文件列表</returns> 
313.     public string GetDirFiles(string DirFullPath, string SearchPattern) 
314.     { 
315.         if (Directory.Exists(DirFullPath) == true) 
316.         { 
317.             string s = Directory.GetFiles(DirFullPath, SearchPattern);  //获取当前目录下指定文件类型的文件列表 
318.             return s; 
319.         } 
320.         else 
321.         { 
322.             return null; 
323.         } 
324.     } 
325.     /// <summary> 
326.     /// 得到当前文件夹及下级文件夹中指定文件类型［扩展名］文件列表 
327.     /// </summary> 
328.     /// <param name="DirFullPath">目录全路径</param> 
329.     /// <param name="SearchPattern">查找哪种类型的文件</param> 
330.     /// <param name="SO">搜索选项</param> 
331.     /// <returns>string 文件列表</returns> 
332.     public string GetDirFiles(string DirFullPath, string SearchPattern, SearchOption SO) 
333.     { 
334.         if (Directory.Exists(DirFullPath) == true) 
335.         { 
336.             string s = Directory.GetFiles(DirFullPath, SearchPattern, SO);  //获取当前目录下的文件 
337.             return s; 
338.         } 
339.         else 
340.         { 
341.             return null; 
342.         } 
343.     } 
344. }