码迷，mamicode.com
首页 > Windows程序 > 详细

05.C#常用IO流与读写文件

时间：2015-03-05 16:36:01      阅读：198      评论：0      收藏：0      [点我收藏+]

标签：

1.文件系统

(1)文件系统类的介绍
    文件操作类大都在System.IO命名空间里。FileSystemInfo类是任何文件系统类的基类；FileInfo与File表示文件系统中的文件；DirectoryInfo与Directory表示文件系统中的文件夹；Path表示文件系统中的路径；DriveInfo提供对有关驱动器的信息的访问。注意，XXXInfo与XXX类的区别是：XXX是静态类，XXXInfo类可以实例化。
    还有个较为特殊的类System.MarshalByRefObject允许在支持远程处理的应用程序中跨应用程序域边界访问对象。 
(2)FileInfo与File类
  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         FileInfo file = new FileInfo(@"E:\学习笔记\C#平台\test.txt");//创建文件
  6.         Console.WriteLine("创建时间：" + file.CreationTime);
  7.         Console.WriteLine("路径：" + file.DirectoryName);
  8.         StreamWriter sw = file.AppendText();//打开追加流
  9.         sw.Write("李志伟");//追加数据
  10.         sw.Dispose();//释放资源,关闭文件
  11.         File.Move(file.FullName, @"E:\学习笔记\test.txt");//移动
  12.         Console.WriteLine("完成！");
  13.         Console.Read();
  14.     }
  15. }
(3)DirectoryInfo与Directory类
  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         //创建文件夹
  6.         DirectoryInfo directory = new DirectoryInfo(@"E:\学习笔记\C#平台\test");
  7.         directory.Create();
  8.         Console.WriteLine("父文件夹：" + directory.Parent.FullName);
  9.         //输出父目录下的所有文件与文件夹
  10.         FileSystemInfo[] files = directory.Parent.GetFileSystemInfos();
  11.         foreach (FileSystemInfo fs in files)
  12.         {
  13.             Console.WriteLine(fs.Name);
  14.         }
  15.         Directory.Delete(directory.FullName);//删除文件夹
  16.         Console.WriteLine("完成！");
  17.         Console.Read();
  18.     }
  19. }
(4)Path类
  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         Console.WriteLine(Path.Combine(@"E:\学习笔记\C#平台", @"Test\Test.TXT"));//连接
  6.         Console.WriteLine("平台特定的字符：" + Path.DirectorySeparatorChar);
  7.         Console.WriteLine("平台特定的替换字符：" + Path.AltDirectorySeparatorChar);
  8.         Console.Read();
  9.     }
  10. }
(5)DriveInfo类
  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         DriveInfo[] drives = DriveInfo.GetDrives();
  6.         foreach (DriveInfo d in drives)
  7.         {
  8.             if (d.IsReady)
  9.             {
  10.                 Console.WriteLine("总容量：" + d.TotalFreeSpace);
  11.                 Console.WriteLine("可用容量：" + d.AvailableFreeSpace);
  12.                 Console.WriteLine("驱动器类型：" + d.DriveFormat);
  13.                 Console.WriteLine("驱动器的名称：" + d.Name + "\n");
  14.             }
  15.         }
  16.         Console.WriteLine("OK!");
  17.         Console.Read();
  18.     }
  19. }

2.文件操作

(1)移动、复制、删除文件
  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         string path = @"E:\学习笔记\C#平台\Test.txt";
  6.         File.WriteAllText(path, "测试数据");
  7.         Console.WriteLine("文件已创建，请查看！");
  8.         Console.ReadLine();
  9.         File.Move(path, @"E:\学习笔记\Test.txt");
  10.         Console.WriteLine("移动完成，请查看！");
  11.         Console.ReadLine();
  12.         File.Copy(@"E:\学习笔记\Test.txt", path);
  13.         Console.WriteLine("文件已复制，请查看！");
  14.         Console.ReadLine();
  15.         File.Delete(path);
  16.         File.Delete(@"E:\学习笔记\Test.txt");
  17.         Console.WriteLine("文件已删除，请查看！\nOK!");
  18.         Console.Read();
  19.     }
  20. }
(2)判断是文件还是文件夹
  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         IsFile(@"E:\学习笔记\C#平台\Test.txt");
  6.         IsFile(@"E:\学习笔记\");
  7.         IsFile(@"E:\学习笔记\XXXXXXX");
  8.         Console.Read();
  9.     }
  10.     //判断路径是否是文件或文件夹
  11.     static void IsFile(string path)
  12.     {
  13.         if (Directory.Exists(path))
  14.         {
  15.             Console.WriteLine("是文件夹！");
  16.         }
  17.         else if (File.Exists(path))
  18.         {
  19.             Console.WriteLine("是文件！");
  20.         }
  21.         else
  22.         {
  23.             Console.WriteLine("路径不存在！");
  24.         }
  25.     }
  26. }

3.读写文件与数据流

(1)读文件
  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         string path = @"E:\学习笔记\C#平台\Test.txt";
  6.         byte[] b = File.ReadAllBytes(path);
  7.         Console.WriteLine("ReadAllBytes读二进制:");
  8.         foreach (byte temp in b)
  9.         {
  10.             Console.Write((char)temp+" ");
  11.         }
  12.         string[] s = File.ReadAllLines(path, Encoding.UTF8);
  13.         Console.WriteLine("\nReadAllLines读所有行:");
  14.         foreach (string temp in s)
  15.         {
  16.             Console.WriteLine("行："+temp);
  17.         }
  18.         string str = File.ReadAllText(path, Encoding.UTF8);
  19.         Console.WriteLine("ReadAllText读所有行:\n" + str);
  20.         Console.Read();
  21.     }
  22. }
(2)写文件
  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         string path = @"E:\学习笔记\C#平台\Test.txt";
  6.         File.WriteAllBytes(path,new byte[] {0,1,2,3,4,5,6,7,8,9});//写入二进制
  7.         Console.WriteLine("WriteAllBytes写入二进制成功");
  8.         Console.ReadLine();
  9.         string[] array = {"123","456","7890"};
  10.         File.WriteAllLines(path, array, Encoding.UTF8);//写入所有行
  11.         Console.WriteLine("WriteAllLines写入所有行成功");
  12.         Console.ReadLine();
  13.         File.WriteAllText(path, "abcbefghijklmn",Encoding.UTF8);//写入字符串
  14.         Console.WriteLine("WriteAllText写入字符串成功\nOK!");
  15.         Console.Read();
  16.     }
  17. }
(3)数据流
    最常用的流类如下：
        FileStream：     文件流，可以读写二进制文件。 
        StreamReader：   流读取器，使其以一种特定的编码从字节流中读取字符。 
        StreamWriter：   流写入器，使其以一种特定的编码向流中写入字符。 
        BufferedStream： 缓冲流，给另一流上的读写操作添加一个缓冲层。
    数据流类的层次结构：
 技术分享
(4)使用FileStream读写二进制文件
  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         string path = @"E:\学习笔记\C#平台\Test.txt";
  6.         //以写文件的方式创建文件
  7.         FileStream file = new FileStream(path, FileMode.CreateNew, FileAccess.Write);
  8.         string str = "测试文件--李志伟";
  9.         byte[] bytes = Encoding.Unicode.GetBytes(str);
  10.         file.Write(bytes, 0, bytes.Length);//写入二进制
  11.         file.Dispose();
  12.         Console.WriteLine("写入数据成功！！！");
  13.         Console.ReadLine();
  14.         //以读文件的方式打开文件
  15.         file = new FileStream(path, FileMode.Open, FileAccess.Read);
  16.         byte[] temp = new byte[bytes.Length];
  17.         file.Read(temp, 0, temp.Length);//读取二进制
  18.         Console.WriteLine("读取数据：" + Encoding.Unicode.GetString(temp));
  19.         file.Dispose();
  20.         Console.Read();
  21.     }
  22. }
(5)StreamWriter与StreamReader
    使用StreamWriterStreamReader就不用担心文本文件的编码方式，所以它们很适合读写文本文件。
  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         string path = @"E:\学习笔记\C#平台\Test.txt";
  6.         //以写文件的方式创建文件
  7.         FileStream file = new FileStream(path, FileMode.Create, FileAccess.Write);
  8.         StreamWriter sw = new StreamWriter(file);
  9.         sw.WriteLine("测试文件--李志伟");
  10.         sw.Dispose();
  11.         Console.WriteLine("写入数据成功！！！");
  12.         Console.ReadLine();
  13.         //以读文件的方式打开文件
  14.         file = new FileStream(path, FileMode.Open, FileAccess.Read);
  15.         StreamReader sr = new StreamReader(file);
  16.         Console.WriteLine("读取数据:"+sr.ReadToEnd());
  17.         sr.Dispose();
  18.         Console.Read();
  19.     }
  20. }

4.映射内存的文件

(1)MemoryMappedFile类(.NET4新增)
    应用程序需要频繁地或随机地访问文件时，最好使用MemoryMappedFile类(映射内存的文件)。使用这种方式允许把文件的一部分或者全部加载到一段虚拟内存上，这些文件内容会显示给应用程序，就好像这个文件包含在应用程序的主内存中一样。
(2)使用示例
  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         MemoryMappedFile mmfile = MemoryMappedFile.CreateFromFile(@"E:\Test.txt", FileMode.OpenOrCreate, "MapName", 1024 * 1024);
  6.         MemoryMappedViewAccessor view = mmfile.CreateViewAccessor();//内存映射文件的视图
  7.         //或使用数据流操作内存文件
  8.         //MemoryMappedViewStream stream = mmfile.CreateViewStream();
  9.         string str = "测试数据：李志伟!";
  10.         int length = Encoding.UTF8.GetByteCount(str);
  11.         view.WriteArray<byte>(0, Encoding.UTF8.GetBytes(str), 0, length);//写入数据
  12.         byte[] b = new byte[length];
  13.         view.ReadArray<byte>(0, b, 0, b.Length);
  14.         Console.WriteLine(Encoding.UTF8.GetString(b));
  15.         mmfile.Dispose();//释放资源
  16.         Console.Read();
  17.     }
  18. }

5.文件安全

(1)ACL介绍
    ACL是存在于计算机中的一张表(访问控制表)，它使操作系统明白每个用户对特定系统对象，例如文件目录或单个文件的存取权限。每个对象拥有一个在访问控制表中定义的安全属性。这张表对于每个系统用户有拥有一个访问权限。最一般的访问权限包括读文件（包括所有目录中的文件），写一个或多个文件和执行一个文件（如果它是一个可执行文件或者是程序的时候）。
(2)读取文件的ACL
  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         FileStream file = new FileStream(@"E:\Test.txt", FileMode.Open, FileAccess.Read);
  6.         FileSecurity filesec = file.GetAccessControl();//得到文件访问控制属性
  7.         //输出文件的访问控制项
  8.         foreach (FileSystemAccessRule filerule in filesec.GetAccessRules(true, true, typeof(NTAccount)))
  9.         {
  10.             Console.WriteLine(filerule.AccessControlType + "--" + filerule.FileSystemRights + "--" + filerule.IdentityReference);
  11.         }
  12.         file.Dispose();
  13.         Console.Read();
  14.     }
  15. }
(3)读取文件夹的ACL
  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         DirectoryInfo dir= new DirectoryInfo(@"E:\学习笔记\C#平台");
  6.         DirectorySecurity filesec = dir.GetAccessControl();//得到文件访问控制属性
  7.         //输出文件的访问控制项
  8.         foreach (FileSystemAccessRule filerule in filesec.GetAccessRules(true, true, typeof(NTAccount)))
  9.         {
  10.             Console.WriteLine(filerule.AccessControlType + "--" + filerule.FileSystemRights + "--" + filerule.IdentityReference);
  11.         }
  12.         Console.Read();
  13.     }
  14. }
(4)修改ACL
  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         FileStream file = new FileStream(@"E:\Test.txt", FileMode.Open, FileAccess.Read);
  6.         FileSecurity filesec = file.GetAccessControl();//得到文件访问控制属性
  7.         Print(filesec.GetAccessRules(true, true, typeof(NTAccount)));//输出文件访问控制项
  8.         FileSystemAccessRule rule = new FileSystemAccessRule(
  9.             new NTAccount(@"CENTER-YFB-512\LiZW"), //计算机账户名
  10.             FileSystemRights.Delete, //操作权限
  11.             AccessControlType.Allow);//能否访问受保护的对象
  12.         filesec.AddAccessRule(rule);//增加ACL项
  13.         Print(filesec.GetAccessRules(true, true, typeof(NTAccount)));//输出文件访问控制项
  14.         filesec.RemoveAccessRule(rule);//移除ACL项
  15.         Print(filesec.GetAccessRules(true, true, typeof(NTAccount)));//输出文件访问控制项
  16.         file.Dispose();
  17.         Console.Read();
  18.     }
  19.     //输出文件访问控制项
  20.     static void Print(AuthorizationRuleCollection rules)
  21.     {
  22.         foreach (FileSystemAccessRule filerule in rules)
  23.         {
  24.             Console.WriteLine(filerule.AccessControlType + "--" + filerule.FileSystemRights + "--" + filerule.IdentityReference);
  25.         }
  26.         Console.WriteLine("================================================");
  27.     }
  28. }

6.读写注册表

(1)注册表介绍
    Windows注册表是帮助Windows控制硬件、软件、用户环境和Windows界面的一套数据文件，运行regedit可以看到5个注册表配置单元(实际有7个)：
        HKEY-CLASSES-ROOT：      文件关联和COM信息
        HKEY-CURRENT-USER：      用户轮廓
        HKEY-LOCAL-MACHINE：     本地机器系统全局配置子键
        HKEY-USERS：             已加载用户轮廓子键
        HKEY-CURRENT-CONFIG：    当前硬件配置
(2).NET操作注册表的类
    在.NET中提供了Registry类、RegistryKey类来实现对注册表的操作。其中Registry类封装了注册表的七个基本主健：
        Registry.ClassesRoot    对应于HKEY_CLASSES_ROOT主键 
        Registry.CurrentUser    对应于HKEY_CURRENT_USER主键 
        Registry.LocalMachine   对应于 HKEY_LOCAL_MACHINE主键 
        Registry.User           对应于 HKEY_USER主键 
        Registry.CurrentConfig  对应于HEKY_CURRENT_CONFIG主键 
        Registry.DynDa          对应于HKEY_DYN_DATA主键 
        Registry.PerformanceData 对应于HKEY_PERFORMANCE_DATA主键
    RegistryKey类封装了对注册表的基本操作，包括读取，写入，删除。其中读取的主要函数有：　
        OpenSubKey()        主要是打开指定的子键。 
        GetSubKeyNames()    获得主键下面的所有子键的名称，它的返回值是一个字符串数组。 
        GetValueNames()     获得当前子键中的所有的键名称，它的返回值也是一个字符串数组。 
        GetValue()          指定键的键值。
    写入的函数：
　　 CreateSubKey()  增加一个子键 
　　 SetValue()      设置一个键的键值
    删除的函数：
　　 DeleteSubKey()      删除一个指定的子键。
　　 DeleteSubKeyTree()  删除该子键以及该子键以下的全部子键。
(3)示例
  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         string path = @"SOFTWARE\Microsoft\Internet Explorer\Extensions";
  6.         RegistryKey pregkey = Registry.LocalMachine.OpenSubKey(path, true);//以只读方式
  7.         if (pregkey != null)
  8.         {
  9.             Console.WriteLine(pregkey.Name + "--" + pregkey.SubKeyCount + "--" + pregkey.ValueCount);
  10.             string preName = System.Guid.NewGuid().ToString();
  11.             pregkey.CreateSubKey(preName);//增加一个子键
  12.             RegistryKey new_pregkey = Registry.LocalMachine.OpenSubKey(path + @"\" + preName, true);
  13.             new_pregkey.SetValue("姓名", "李志伟");//设置一个键的键值
  14.             new_pregkey.SetValue("键名", "值内容");//设置一个键的键值
  15.             Console.WriteLine(pregkey.Name + "--" + pregkey.SubKeyCount + "--" + pregkey.ValueCount);
  16.             pregkey.Close();
  17.             new_pregkey.Close();
  18.         }
  19.         Console.Read();
  20.     }
  21. }

7.读写独立的存储器

(1)IsolatedStorageFile类
    使用IsolatedStorageFile类可以读写独立的存储器，独立的存储器可以看成一个虚拟磁盘，在其中可以保存只由创建他们的应用程序或其应用程序程序实例共享的数据项。
    独立的存储器的访问类型有两种(如下图)：第一种是一个应用程序的多个实例在同一个独立存储器中工作，第二种是一个应用程序的多个实例在各自不同的独立存储器中工作。
技术分享
(2)示例
  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         //写文件
  6.         IsolatedStorageFileStream storStream = new IsolatedStorageFileStream(@"Test.txt", FileMode.Create, FileAccess.Write);
  7.         string str = "测试数据：李志伟！ABCD";
  8.         byte[] bs = Encoding.UTF8.GetBytes(str);
  9.         storStream.Write(bs, 0, bs.Length);//写数据
  10.         storStream.Dispose();
  11.         //读文件
  12.         IsolatedStorageFile storFile = IsolatedStorageFile.GetUserStoreForDomain();
  13.         string[] files=storFile.GetFileNames(@"Test.txt");
  14.         foreach (string t in files)
  15.         {
  16.             Console.WriteLine(t);
  17.             storStream = new IsolatedStorageFileStream(t, FileMode.Open, FileAccess.Read);
  18.             StreamReader sr=new StreamReader(storStream);
  19.             Console.WriteLine("读取文件："+sr.ReadToEnd());
  20.             sr.Dispose();
  21.             storFile.DeleteFile(t);//删除文件
  22.         }
  23.         storFile.Dispose();
  24.         Console.WriteLine("OK!");
  25.         Console.Read();
  26.     }
  27. }
-------------------------------------------------------------------------------------------------------------------------------




05.C#常用IO流与读写文件

标签：

原文地址：http://www.cnblogs.com/LiZhiW/p/4315716.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！