• C#IO流文件操作

    2017-08-21 10:36:47
    我们知道,程序中的数据通常保存在内存中,当程序关闭时其对应的内存空间就会被释放掉,也就是说我们在程序中所作的操作或对数据的更改会在程序结束时自动删除,没办法永久的保存,如果你想永久的保存这些数据,则...

    文件概述

    我们知道,程序中的数据通常保存在内存中,当程序关闭时其对应的内存空间就会被释放掉,也就是说我们在程序中所作的操作或对数据的更改会在程序结束时自动删除,没办法永久的保存,如果你想永久的保存这些数据,则可以考虑使用数据库或文件对这些数据在磁盘上进行存储,数据库适合存储比较庞大的数据量当数据比较简单时使用数据库存储操作复杂,且成本较高。而文件则适合对简单数据进行存储。比如很多程序的用户配置信息都保存在文件中!

    如何对写文件

    通常来讲,用C#程序对鞋一个文件需要以下5个步骤

    1. 创建一个文件流
    2. 创建阅读器或写入器
    3. 执行读写操作
    4. 关闭阅读器或写入器
    5. 关闭文件流

    注意:在对文件进行操作之前需要引入IO命名空间

    using System.IO;

    这个命名空间用于对文件和文件流的处理

    文件流

    创建文件流

    读写文件的第一步就是创建文件流,流是一个用于数据传输的个对象,它是FileStream类型,在创建一个文件流是需要在他的构造中指定参数

    语法:

    FileStream 文件流对象=new FileStream( String filePath,FileMode fileMode);

    其中filePath用于指定要操作的文件,fileMode用于指定文件的打开方式,它是一个枚举类型,

    fileMode的常用成员如下:

    • Create:用指定的名称新建一个文件,如果文件已存在则覆盖原有的文件
    • CreateNew:新建一个文件,如果文件已存在会报异常提示文件已存在
    • Open:打开一个文件,使用这个枚举是文件必须已存在,否则会报异常
    • OpenOrCreate:与Open成员类似,如果文件不存在则用指定的名称新建一个文件并打开它
    • Appen:打开现有文件,并在末尾追加新的内容。

    小提示:“\”在C#中表示转译,所以我们在写文件路径是不能直接以这样的形式写(“D:\files”),我们可以在“”号的前面加一个@符号来取消转译,也可以用”\\”来代替“\”

    文件读写器

    创建文件流之后,我们要创建读取器或者写入器,StreamWrite被称为写入器只要将创建好的文件流传入就可以创建它的实例

    StreamWriter sw=New StreamWriter(文件流对象);

    创建好写入器之后我们就可以调用他的方法向文件类文件流,其主要方法如下:

    • StreamWriter.Write():用于写入流,这个流是我们创建好的流
    • StreamWriter.WriteLine():用于写入一行数据,写入某些数据后跟换行符
    • StreamWriter.Close():用于关闭写入器

    注意:当写入器使用完毕后一定要调用Close()方法关闭写入器,否则会发生要写的内容无法写入文件的情况。

    StreamReader读取器

    StreamReader主要用于读取流中的数据,它主要包含以下方法:

    • StreamReader.ReadLIne():读取文件流中的一行数据,并返回字符串
    • StreamReader.ReadToEnd():从当前位置读到末尾,返回字符串
    • StreamReader.Close();用于关闭读取器。

    解决乱码问题

    用StreamReader读取文件中的中文文本,有事会出现乱码问题。这并不是C#语言的问题,有可能是因为编码格式的问题。在读取文件是指定对应的编码格式已解决乱码问题。

    如:StreamReader myfil=new StreamReader(文件流对象,Encoding.Default);

    Encoding的静态成员指定编码格式。如:

    • Default表示获取操作系统当前的编码格式
    • UTF-8表示获取UTF-8格式的编码

    文件和目录操作

    File和Directory类

    File类的常用方法

    返回值类型 方法名称 说明
    bool Exists(string path) 用于检查指定文件是否存在
    void Copy(string sourceFilePath,string destinationFilePath) 将指定路径的原文件中的内容复制到目标文件中,如果目标文件不存在,则在指定路径中新建一个文件
    void Move(string sourceFilePath,string  destFileName) 将制定问价移动到一个新的路径
    void Delete(string path) 删除指定的文件,如果指定的文件不存在,则不引发异常

    File类对文件进行操作而Directory类对目录进行操作(文件夹)

    Directory类的常用方法

    返回值类型 方法名称 说明
    bool Exists(string path) 用于检查指定文件夹在磁盘上是否存在
    void Move(string sourceDirName,string destDirName) 用于将文件或目录文件及其内容移到新位置
    void Delete(string path,bool recursive) 删除指定目录,如果recursive值为true,则删除子目录中的所有目录内容

    静态类和静态方法

    静态类只含有静态方法,不能使用new关键字创建静态类的实例。

    静态类与非静态类的区别

    静态类 非静态类
    用static修饰 不用static修饰
    只包含静态成员 可以包含静态成员
    不可以包含实例成员 可以包含实例成员
    使用类名调用静态成员 使用实例对象调用非静态成员
    不能被实例化 可以被实例化
    不能包含实例构造函数 包含实例构造函数

     

    提供实例方法的文件和目录操作

    前面的File类和Directory类都用静态方法操作文件和目录,其实.NET框架提供了用实例方法操作文件和目录的类

    FileInfo、DirectoryInfo和File、Directory类似都可以完成同样的对文件或目录的操作,但是FileInfo和DirectoryInfo类必须实例化对象,使用对象调用方法!

    展开全文
  • C#IO流详解

    2018-08-10 23:17:47
    文件和数据  不同的可能有不同的存储介质,比如磁盘、内存等。.NET类库中定义了一个抽象类Stream,表示对所有的抽象,而每种具体的存储介质都可以通过Stream的派生类来实现自己的操作。 FileStream是对...

    文件流和数据流 

    不同的流可能有不同的存储介质,比如磁盘、内存等。.NET类库中定义了一个抽象类
    Stream,表示对所有流的抽象,而每种具体的存储介质都可以通过Stream的派生类来实现
    自己的流操作。 
    FileStream是对文件流的具体实现。通过它可以以字节方式对流进行读写,这种方式是
    面向结构的,控制能力较强,但使用起来稍显麻烦。 
    此外,System.IO命名空间中提供了不同的读写器来对流中的数据进行操作,这些类通
    常成对出现,一个用于读、另一个用于写。例如,TextReader和TextWriter以文本方式(即
    ASCII方式)对流进行读写;而BinaryReader和BinaryWriter采用的则是二进制方式。
    TextReader和TextWriter都是抽象类,它们各有两个派生类:StreamReader、StringReader以
    及StreamWriter、StringWriter。


    17.3.1 抽象类Stream 
    Stream支持同步和异步的数据读写。它和它的派生类共同组成了.NET Framework上IO
    操作的抽象视图,这使得开发人员不必去了解IO操作的细节,就能够以统一的方式处理不
    同介质上的流对象。 
    Stream类提供的公有属性见表17.4所示。 
    表17.4 Stream类的公有属性 
    属性名 类型 含义 
    CanRead bool 是否可以读取流中的数据 
    CanWrite bool 是否可以修改流中的数据 
    CanSeek bool 是否可以在流中进行定位 
    CanTimeout bool 流是否支持超时机制 
    Length long 流的长度 
    Position long 流的当前位置 
    ReadTimeout int 读超时限制 
    WriteTimeout int 写超时限制 
    其中前4个布尔类型的属性都是只读的。也就是说,一旦建立了一个流对象之后,流的
    这些特性就不能被修改了。由于流是以序列的方式对数据进行操作,因而支持长度和当前
    位置的概念。在同步操作中,一个流对象只有一个当前位置,不同的程序或进程都在当前
    位置进行操作;而在异步操作中,不同的程序或进程可以在不同位置上进行操作,当然这
    需要文件的共享支持。最后,流的超时机制是指在指定的时间限制内没有对流进行读或写
    操作,当前流对象将自动失效。 
    Stream类提供的公有方法则用于流的各项基本操作,请参看表17.5。 
    表17.5 Stream类的公有方法 
    方法标识 返回类型 用途 
    Read(byte[], int, int) int 从流中读取一个字节序列 
    Write(byte[], int, int) void 向流中写入一个字节序列 
    ReadByte() int 从流中读取一个字节 
    WriteByte(byte) void 向流中写入一个字节 
    Seek(long, SeekOrigin) long 设置流的当前位置 
    SetLength(long) void 设置流的长度 
    Flush() void 强制清空流的所有缓冲区 
    (续表) 
    方法标识 返回类型 用途 
    Close() void 关闭流 
    BeginRead(byte[], int, int, AsyncCallBack) IAsyncResult 开始流对象的异步读取 
    EndRead(IAsyncResult) int 结束流对象的异步读取 
    IAsyncResult BeginWrite(byte[], int, int, 
    AsyncCallBack, object) 
    IAsyncResult 开始流对象的异步写入 
    EndWrite(IAsyncResult) void 结束流对象的异步写入 
    在不同的情况下,Stream的派生类可能只支持这些成员的部分实现。例如,网络流一
    般不支持位置的概念,系统也可能禁止对缓冲区的使用。 
    新建一个流时,当前位置位于流的开始,即属性Position的值为0。每次对流进行读写,
    都将改变流的当前位置。可以将流的当前位置理解成“光标”的概念,它类似于字处理软
    件中的光标。读操作从流的当前位置开始进行,读入指定的字节数,光标就向后移动对应
    的字节数。写操作也是从流的当前位置开始进行,写入指定的字节数,光标然后停留在写
    完的地方。 
    根据需要,可以使用Position属性或Seek方法来改变流的当前位置。不过Position属性指
    的都是流的绝对位置,即从流的起始位置开始计算。该值为0时表示在起始位置,等于Length
    的值减1时表示在结束位置。Seek方法则需要通过SeekOrigin枚举类型来指定偏移基准,即
    是从开始位置、结束位置还是当前位置进行偏移。如果指定为SeekOrigin.End,那么偏移量
    就应该为负数,表示将当前位置向前移动。看下面的代码: 
    //打开流,当前位置为0 
    Stream s = File.Open("C:\\bootlog.txt", FileMode.Open, FileAccess.Read); 
    //将当前位置移动到5 
    s.Seek(5, SeekOrigin.Begin); 
    //读取1个字节后,当前位置移动到6 
    s.ReadByte(); 
    //读取10个字节后,当前位置移动到16 
    s.Read(new byte[20], 6, 10); 
    //将当前位置向前移动3个单位,移动到13 
    s.Seek(-3, SeekOrigin.Current); 
    //关闭流 
    s.Close(); 
    如果指定的读写操作位置超出了流的有效范围,将引发一个EndOfStreamException异常。


    17.3.2 文件流FileStream 
    作为文件流,FileStream支持同步和异步文件读写,也能够对输入输出进行缓存以提高
    性能。 
    FileStream类提供了多达14个构造函数,能够以多种方式来构造FileStream对象,并在
    构造的同时指定文件流的多个属性。当然,其中有一些构造函数是为了兼容旧版本的程序
    而保留的。对于文件的来源,可以使用文件路径名,也可以使用文件句柄来指定。以文件
    路径名为例,构造FileStream对象时至少需要指定文件的名称和打开方式两个参数,其他参
    数如文件的访问权限、共享设置以及使用的缓存区大小等,则是可选的;如不指定则使用
    系统的默认值,如默认访问权限为FileAccess.ReadWrite,共享设置为FileShare.Read。 
    下面的代码以只读方式打开一个现有文件,并且在关闭文件之前禁止任何形式的共享。
    如果文件不存在,将引发一个FileNotFoundException: 
    FileStream fs = new FileStream("c:\\MyFile.txt", FileMode.Open, 
    FileAccess.Read, FileShare.None); 
    fs.Close(); 
    除了使用FileStream的构造函数,也可以使用File的静态方法来获得文件流对象。File
    类的静态方法Open和FileStream构造函数的参数类型基本一致,使用效果相同。例如上面的
    代码等价于: 
    FileStream fs = File.Open("c:\\MyFile.txt", FileMode.Open, FileAccess.Read, 
    FileShare.None); 
    fs.Close(); 
    File类的静态方法OpenRead和OpenWrite也能够返回一个FileStream对象,但它们只接受
    文件名这一个参数。对于OpenRead方法,文件的打开方式为FileMode.Open,共享设置为
    FileShare.Read,访问权限为 FileAccess.Read;而对于 OpenWrite方法,打开方式为
    FileMode.OpenOrCreate,共享设置为FileShare.None,访问权限为FileAccess.Write。下面两
    行代码是等价的: 
    FileStream fs = new FileStream("c:\\MyFile.txt", FileMode.OpenOrCreate, 
    FileAccess.Write, FileShare.None); 
    FileStream fs = File.OpenWrite("c:\\MyFile.txt"); 
    FileStream类的ReadByte和WriteByte方法都只能用于单字节操作。要一次处理一个字节
    序列,需要使用Read和Write方法,而且读写的字节序列都位于一个byte数组类型的参数中。
    看下面的程序: 
    //程序清单P17_4.cs:using System; 
    using System.IO; 
    namespace P17_4 

    class FileStreamSamle 

    static void Main() 

    //创建一个文件流 
    FileStream fs = new FileStream("c:\\MyFile.txt", 
    FileMode.Create); 
    //将字符串的内容放入缓冲区 
    string str = "Welcome to the Garden!"; 
    byte[] buffer = new byte[str.Length]; 
    for (int i = 0; i < str.Length; i++) 

    buffer[i] = (byte)str[i]; 

    //写入文件流 
    fs.Write(buffer, 0, buffer.Length); 
    string msg = ""; 
    //定位到流的开始位置 
    fs.Seek(0, SeekOrigin.Begin); 
    //读取流中前7个字符 
    for (int i = 0; i < 7; i++) 

    msg += (char)fs.ReadByte(); 

    //显示读取的信息和流的长度 
    Console.WriteLine("读取内容为:{0}", msg); 
    Console.WriteLine("文件长度为:{0}", fs.Length); 
    //关闭文件流 
    fs.Close(); 



    程序的输出为: 
    读取内容为:Welcome 
    文件长度为:22 
    最后还是要提醒一句,使用完FileStream对象后,一定不能忘记使用Close方法关闭文
    件流,否则不仅会使别的程序不能访问该文件,还可能导致文件损坏。


    17.3.3 流的文本读写器 
    StreamReader和StreamWriter主要用于以文本方式对流进行读写操作,它们以字节流为
    操作对象,并支持不同的编码格式。 
    StreamReader和StreamWriter通常成对使用,它们的构造函数形式也一一对应。可以通
    过指定文件名或指定另一个流对象来创建StreamReader和StreamWriter对象。如有必要,还
    可以指定文本的字符编码、是否在文件头查找字节顺序标记,以及使用的缓存区大小。 
    文本的字符编码默认为UTF-8格式。在命名空间System.Text中定义的Encoding类对字符
    编码进行了抽象,它的5个静态属性分别代表了5种编码格式: 
    ? ASCII 
    ? Default 
    ? Unicode 
    ? UTF-7 
    ? UTF-8 
    不过, Encoding类的Default属性表示系统的编码,默认为ANSI代码页,这和
    StreamReader和 StreamWriter中默认的 UTF-8编码是不一样的。通过 StreamReader和
    StreamWriter类的公有属性Encoding可以获得当前使用的字符编码。StreamReader类还有一
    个布尔类型的公有属性EndOfStream,用于指示读取的位置是否已经到达流的末尾。 
    下面的代码从一个文件流构造了一个 StreamReader对象和 StreamWriter对象,还为
    StreamWriter对象指定了Unicode字符编码。不过在实际应用中,为同一文件进行读写操作
    所构造的两个对象通常使用同样的字符编码格式: 
    FileStream fs = new FileStream("c:\\MyFile.txt", FileMode.Create); 
    StreamReader sr = new StreamReader(fs); 
    StreamWriter sw = new StreamWriter(fs, System.Text.Encoding.Unicode); 
    sw.Close(); 
    sr.Close(); 
    fs.Close(); 
    注意在关闭文件时,要先关闭读写器对象,再关闭文件流对象。如果对同一个文件同
    时创建了 StreamReader和 StreamWriter对象,则应先关闭 StreamWriter对象,再关闭
    StreamReader对象。否则将引发ObjectDisposedException异常。 
    即使是直接使用文件名来构造StreamReader或StreamWriter对象,或是使用File类的静
    态方法OpenText和AppendText来创建StreamReader或StreamWriter对象,过程当中系统都会
    自动生成隐含的文件流,读写器对文件的读写还是通过流对象进行的。该文件流对象可以
    通过StreamReader或StreamWriter对象的BaseStream属性获得。 
    不通过文件流而直接创建StreamReader对象时,默认的文件流对象是只读的。以同样
    的方式来创建StreamWriter对象的话,默认的文件流对象是只写的。下面的程序说明了这一
    点: 
    //程序清单P17_5.cs: 
    using System; 
    using System.IO; 
    namespace P17_5 

    class BaseStreamSample 

    static void Main() 

    StreamReader sr = new StreamReader("c:\\MyFile.txt"); 
    Console.WriteLine("CanRead:{0}", sr.BaseStream.CanRead); 
    Console.WriteLine("CanWrite:{0}", sr.BaseStream.CanWrite); 
    sr.Close(); 
    StreamWriter sw = new StreamWriter("c:\\MyFile.txt"); 
    Console.WriteLine("CanRead:{0}", sw.BaseStream.CanRead); 
    Console.WriteLine("CanWrite:{0}", sw.BaseStream.CanWrite); 
    sw.Close(); 



    程序P17_5.cs的输出为: 
    CanRead:True 
    CanWrite:False 
    CanRead:False 
    CanWrite:True 
    由于使用的是不同的流对象,此时就不能同时使用StreamReader和StreamWriter对象来
    打开同一个文件。在程序P17_5.cs的代码中,如果不关闭StreamReader对象就创建
    StreamWriter对象,将引发一个 IOException异常。使用 File类的静态方法OpenText和
    AppendText时,情况也一样。 
    StreamReader中可以使用4种方法对流进行读操作: 
    ? Read,该方法有两种重载形式,在不接受任何输入参数时,它读取流的下一个字符;
    当在参数中指定了数组缓冲区、开始位置和偏移量时,它读入指定长度的字符数组。 
    ? ReadBlock,从当前流中读取最大数量的字符,并将数据输出到缓冲区。 
    ? ReadLine,从当前流中读取一行字符,即一个字符串。 
    ? ReadToEnd,从流的当前位置开始,一直读取到流的末尾,并把所有读入的内容都
    作为一个字符串返回;如果当前位置位于流的末尾,则返回空字符串。 
    StreamReader最常用的是ReadLine方法,该方法一次读取一行字符。这里“行”的定义
    是指一个字符序列,该序列要么以换行符(“\n”)结尾,要么以换行回车符(“\r\n”)
    结尾。 
    StreamWriter则提供了Write和WriteLine方法对流进行写操作。不过这两个方法可以接
    受的参数类型则丰富得多,包括char、int、string、float、double乃至object等,甚至可以对
    字符串进行格式化。看下面这段代码: 
    //创建一个文件流 
    FileStream fs = new FileStream("c:\\MyFile.txt", FileMode.Create, 
    FileAccess.Write); 
    StreamWriter sw = new StreamWriter(fs); 
    sw.WriteLine(25); //写入整数 
    sw.WriteLine(0.5f); //写入单精度浮点数 
    sw.WriteLine(3.1415926); //写入双精度浮点数 
    sw.WriteLine(’A’); //写入字符 
    sw.Write ("写入时间:"); //写入字符串 
    int hour = DateTime.Now.Hour; 
    int minute = DateTime.Now.Minute; 
    int second = DateTime.Now.Second; 
    //写入格式化字符串 
    sw.WriteLine("{0}时{1}分{2}秒", hour, minute, second); 
    //关闭文件 
    sw.Close(); 
    fs.Close(); 
    得到的文本文件内容是: 
    25 
    0.5 
    3.1415926 

    写入时间:10时11分9秒 
    Write和 WriteLine方法的使用读者应该很熟悉,因为它们所提供的重载形式和
    Console.Write以及Console.WriteLine方法完全一样。这些重载方法只是为了使用方便,实际
    368 C# 2.0 程序设计教程 
    上写入任何类型的对象时,都调用了对象的ToString方法,然后将字符串写入流中。不同的
    是,WriteLine方法在每个字符串后面加上了换行符,而Write方法则没有。
    StringReader和StringWriter同样是以文本方式对流进行IO操作,但它们以字符串为操作
    对象,功能相对简单,而且只支持默认的编码方式。


    17.3.4 流的二进制读写器 
    BinaryReader和BinaryWriter以二进制方式对流进行IO操作。它们的构造函数中需要指
    定一个Stream类型的参数,如有必要还可以指定字符的编码格式。和文本读写器不同的是,
    BinaryReader和BinaryWriter对象不支持从文件名直接进行构造。 
    类似的,可以通过BinaryReader和BinaryWriter对象的BaseStream属性来获得当前操作
    的流对象。 
    BinaryReader类提供了多个读操作方法,用于读入不同类型的数据对象,这些方法请参
    见表17.6。 
    表17.6 BinaryReader类的读操作方法 
    方法标识 返回类型 用途 
    Read(byte[],int, int) int 指定位置和偏移量,从流中读取一组字节到缓冲区 
    ReadBoolean() bool 从流中读取一个布尔值 
    ReadByte() byte 从流中读取一个字节 
    ReadBytes() byte[] 从流中读取一个字节数组 
    ReadChar() char 从流中读取一个字符 
    ReadChars() char[] 从流中读取一个字符数组 
    ReadDecimal() decimal 从流中读取一个十进制数值 
    ReadDouble() double 从流中读取一个双精度浮点型数值 
    ReadInt16() short 从流中读取一个短整型整数值 
    ReadInt32() int 从流中读取一个整数值 
    ReadInt64() long 从流中读取一个长整型整数值 
    ReadSByte() sbyte 从流中读取一个有符号字节 
    ReadSingle() float 从流中读取一个单精度浮点型数值 
    ReadString() string 从流中读取一个字符串 
    ReadUInt16() ushort 从流中读取一个无符号短整型整数值 
    ReadUInt32() uint 从流中读取一个无符号整数值 
    ReadUInt64() ulong 从流中读取一个无符号长整型整数值 
    使用这些方法时,注意,方法名称中指代的都是数据类型在System空间的原型。例如
    读取单精度浮点型数值,方法名称是ReadSingle而不是ReadFloat,另外读取short、int、long
    类型的整数值,方法名称也分别是ReadInt16、ReadInt32和ReadInt64。 
    而BinaryWriter则只提供了一个方法Write进行写操作,但提供了多种重载形式,用于写入不同类型的数据对象。各种重载形式中的参数类型和个数与StreamWriter中基本相同。 
    下面的代码演示了使用BinaryReader和BinaryWriter对象进行对应的读写操作: 
    //创建文件流和二进制读写器对象 
    FileStream fs = new FileStream("c:\\MyFile.bin", FileMode.OpenOrCreate); 
    BinaryWriter bw = new BinaryWriter(fs); 
    BinaryReader br = new BinaryReader(fs); 
    //依次写入各类型数据 
    bw.Write(25); 
    bw.Write(0.5f); 
    bw.Write(3.1415926); 
    bw.Write(’A’); 
    bw.Write("写入时间:"); 
    bw.Write(DateTime.Now.ToString()); 
    //定位到流的开始位置 
    fs.Seek(0, SeekOrigin.Begin); 
    //依次读出各类型数据 
    int i = br.ReadInt32(); 
    float f = br.ReadSingle(); 
    double d = br.ReadDouble(); 
    char c = br.ReadChar(); 
    string s = br.ReadString(); 
    DateTime dt = DateTime.Parse(br.ReadString()); 
    //关闭文件 
    bw.Close(); 
    br.Close(); 
    fs.Close();

     


    17.3.5 常用的其他流对象 
    除了FileStream类之外,代表具体流的、Stream类的常用派生类还有: 
    ? MemoryStream,表示内存流,支持内存文件的概念,不需要使用缓冲区; 
    ? UnmanagedMemoryStream,和MemoryStream类似,但支持从可控代码访问不可控
    的内存文件内容; 
    ? NetworkStream,表示网络流,通过网络套接字发送和接收数据,支持同步和异步
    访问,但不支持随机访问; 
    ? BufferStream,表示缓存流,为另一个流对象维护一个缓冲区; 
    ? GZipStream,表示压缩流,支持对数据流的压缩和解压缩; 
    ? CryptoStream,表示加密流,支持对数据流的加密和解密。 
    同样,可以由这些流对象构造出文本读写器或二进制读写器,并进行相应方式的读写
    操作。 
    程序P17_6.cs演示了利用文件流和缓存流来共同维护一个三角函数表: 
    //程序清单P17_6.cs: 
    using System; 
    using System.IO; 
    namespace P17_6 

    class BufferedStreamSample 

    static void Main() 

    TriangleTable table = new TriangleTable(); 
    Console.WriteLine("请输入度数(0~179之间):"); 
    try 

    int x = int.Parse(Console.ReadLine()); 
    Console.WriteLine("请选择函数类型:"); 
    Console.WriteLine("0.正弦函数 1.余弦函数 2.正切函数 3.余切函数 
    "); 
    int iType = int.Parse(Console.ReadLine()); 
    table.Open(); 
    double y = table.GetFunction(x, iType); 
    Console.WriteLine("函数值 = {0}", y); 

    catch (Exception) 

    File.Delete("C:\\Triangle.tbl"); 

    finally 

    table.Close(); 


    }

    public delegate double TwoIntFunction(int param1, int param2);

    /// 
    /// 类TriangleTable:三角函数表 
    /// 
    public class TriangleTable{ 
    private FileStream m_baseStream; 
    private BufferedStream m_stream; 
    private BinaryReader m_reader; 
    public TwoIntFunction GetFunction;

    public TriangleTable() 

    if (!File.Exists("C:\\Triangle.tbl")) 

    m_baseStream = new FileStream("C:\\Triangle.tbl", 
    FileMode.Create); 
    BinaryWriter writer = new BinaryWriter(m_baseStream); 
    byte[] buf = new byte[8]; 
    for (int i = 0; i < 180; i++) 

    double sin = Math.Sin(Math.PI * i / 180); 
    double cos = Math.Sqrt(1 - sin * sin); 
    double tan = sin / cos; 
    double ctan = cos / sin; 
    writer.Write(sin); 
    writer.Write(cos); 
    writer.Write(tan); 
    writer.Write(ctan); 

    writer.Close(); 
    m_baseStream.Close(); 

    }

    public void Open() 

    m_baseStream = new FileStream("C:\\Triangle.tbl", 
    FileMode.Open); 
    m_stream = new BufferedStream(m_baseStream); 
    m_reader = new BinaryReader(m_stream); 
    GetFunction = delegate(int angle, int iType) 

    if (iType < 0 || iType > 3) 
    throw new ArgumentOutOfRangeException("参数应为0~3之间的 
    整数"); 
    m_stream.Seek(sizeof(double) * (4 * angle + iType), 
    SeekOrigin.Begin); 
    return m_reader.ReadDouble(); 
    }; 
    }

    public void Close() 

    m_reader.Close(); 
    m_baseStream.Close(); 
    m_stream.Close(); 



    在三角函数表类TriangleTable中定义了 3个私有字段,类型分别为FileStream、
    BufferedStream和BinaryReader。首次使用该类时,计算出三角函数表所维护的全部数据,
    并存放在一个文件中。以后每次使用该类,都将数据读至缓存流,并通过缓存流直接获取
    函数值。读取函数值的功能由代表字段GetFunction实现,注意它在缓存流中的定位方式。
    由于缓存流中顺序存放了0~180之间每个角度的4个三角函数值,因此度数为angle的三角
    函数值的存放位置是从流的开始位置偏移(4 * angle)个double数据类型所占的字节数,并
    且从该位置起依次存放的是正弦、余弦、正切和余切函数值。

     

    展开全文
  • C#常用IO流与读写文件

    2017-04-01 11:17:07
    C# 常用 IO 与读写文件 1. 文件系统 .................................................................................... 2 (1) 文件系统类的介绍 .............................................

    C# 常用 IO 流与读写文件

    1. 文件系统 .................................................................................... 2

    (1) 文件系统类的介绍 ............................................................ 2

    (2) FileInfo 与File  ....................................................... 2

    (3) DirectoryInfo 与Directory  ................................. 2

    (4) Path  ............................................................................... 2

    (5) DriveInfo  .................................................................... 2

    2. 文件操作 .................................................................................... 3

    (1) 移动、复制、删除文件 ................................................... 3

    (2) 判断是文件还是文件夹 ................................................... 3

    3. 读写文件与数据流 .................................................................... 4

    (1) 读文件 ................................................................................. 4

    (2) 写文件 ................................................................................. 4

    (3) 数据流 ................................................................................. 4

    (4) 使用FileStream 读写二进制文件 ................................ 5

    (5) StreamWriter 与StreamReader .................................. 5

    4. 映射内存的文件 ........................................................................ 5

    (1) MemoryMappedFile 类(.NET4 新增) ............................ 5

    (2) 使用示例 ............................................................................. 6

    5. 文件安全 .................................................................................... 6

    (1) ACL 介绍 ............................................................................. 6

    (2) 读取文件的ACL ................................................................. 6

    (3) 读取文件夹的ACL ............................................................. 6

    (4) 修改ACL ............................................................................. 7

    6. 读写注册表 ................................................................................ 7

    (1) 注册表介绍 ........................................................................ 7

    (2) .NET 操作注册表的类 ...................................................... 7

    (3) 示例 ..................................................................................... 8

    7. 读 写独立的存储器 .................................................................... 8

    (1) IsolatedStorageFile  .............................................. 8

    (2) 示例 ..................................................................................... 8  

    1. 文件系统

    (1) 文件系统类的介绍

    文件操作类大都在 System.IO 命名空间里。 FileSystemInfo 类是任何文件系统类的基类; FileInfo 与 File 表示文件系统中的文件; DirectoryInfo 与 Directory 表示文件系统中的文件夹; Path 表示文件系统中的路径; DriveInfo 提供对有关驱动器的信息的访问。注意, XXXInfo 与 XXX 类的区别是: XXX 是静态类, XXXInfo 类可以实例化。

    还有个较为特殊的类 System.MarshalByRefObject 允许在支持远程处理的应用程序中跨应用程序域边界访问对象。

    (2) FileInfo 与 File 类

        class Program

        {

            static void Main( string [] args)

            {

                FileInfo file = new FileInfo ( @"E:\ 学习笔记 \C# 平台 \test.txt" ); // 创建文件

                Console .WriteLine( " 创建时间: " + file.CreationTime);

                Console .WriteLine( " 路径: " + file.DirectoryName);

                StreamWriter sw = file.AppendText(); // 打开追加流

                sw.Write( " 李志伟 " ); // 追加数据

                sw.Dispose(); // 释放资源 , 关闭文件

                File .Move(file.FullName, @"E:\ 学习笔记 \test.txt" ); // 移动

                Console .WriteLine( " 完成! " );

                Console .Read();

            }

        }

    (3) DirectoryInfo 与 Directory 类

        class Program

        {

            static void Main( string [] args)

            {

                // 创建文件夹

                DirectoryInfo directory = new DirectoryInfo ( @"E:\ 学习笔记 \C# 平台 \test" );

                directory.Create();

                Console .WriteLine( " 父文件夹: " + directory.Parent.FullName);

                // 输出父目录下的所有文件与文件夹

                FileSystemInfo [] files = directory.Parent.GetFileSystemInfos();

                foreach ( FileSystemInfo fs in files)

                {

                    Console .WriteLine(fs.Name);

                }

                Directory .Delete(directory.FullName); // 删除文件夹

                Console .WriteLine( " 完成! " );

                Console .Read();

            }

        }

    (4) Path 类

        class Program

        {

            static void Main( string [] args)

            {

                Console .WriteLine( Path .Combine( @"E:\ 学习笔记 \C# 平台 " , @"Test\Test.TXT" )); //连接

                Console .WriteLine( " 平台特定的字符: " + Path .DirectorySeparatorChar);

                Console .WriteLine( " 平台特定的替换字符: " + Path .AltDirectorySeparatorChar);

                Console .Read();

            }

        }

    (5) DriveInfo 类

        class Program

        {

            static void Main( string [] args)

            {

                DriveInfo [] drives = DriveInfo .GetDrives();

                foreach ( DriveInfo d in drives)

                {

                    if (d.IsReady)

                    {

                        Console .WriteLine( " 总容量: " + d.TotalFreeSpace);

                        Console .WriteLine( " 可用容量: " + d.AvailableFreeSpace);

                        Console .WriteLine( " 驱动器类型: " + d.DriveFormat);

                        Console .WriteLine( " 驱动器的名称: " + d.Name + "\n" );

                    }

                }

                Console .WriteLine( "OK!" );

                Console .Read();

            }

        }

    2. 文件操作

    (1) 移动、复制、删除文件

        class Program

        {

            static void Main( string [] args)

            {

                string path = @"E:\ 学习笔记 \C# 平台 \Test.txt" ;

                File .WriteAllText(path, " 测试数据 " );

                Console .WriteLine( " 文件已创建,请查看! " );

                Console .ReadLine();

                File .Move(path, @"E:\ 学习笔记 \Test.txt" );

                Console .WriteLine( " 移动完成,请查看! " );

                Console .ReadLine();

                File .Copy( @"E:\ 学习笔记 \Test.txt" , path);

                Console .WriteLine( " 文件已复制,请查看! " );

                Console .ReadLine();

                File .Delete(path);

                File .Delete( @"E:\ 学习笔记 \Test.txt" );

                Console .WriteLine( " 文件已删除,请查看! \nOK!" );

                Console .Read();

            }

        }

    (2) 判断是文件还是文件夹

        class Program

        {

            static void Main( string [] args)

            {

                IsFile( @"E:\ 学习笔记 \C# 平台 \Test.txt" );

                IsFile( @"E:\ 学习笔记 \" );

                IsFile( @"E:\ 学习笔记 \XXXXXXX" );

                Console .Read();

            }

            // 判断路径是否是文件或文件夹

            static void IsFile( string path)

            {

                if ( Directory .Exists(path))

                {

                    Console .WriteLine( " 是文件夹! " );

                }

                else if ( File .Exists(path))

                {

                    Console .WriteLine( " 是文件! " );

                }

                else

                {

                    Console .WriteLine( " 路径不存在! " );

                }

            }

        }

    3. 读写文件与数据流

    (1) 读文件

        class Program

        {

            static void Main( string [] args)

            {

                string path = @"E:\ 学习笔记 \C# 平台 \Test.txt" ;

                byte [] b = File .ReadAllBytes(path);

                Console .WriteLine( "ReadAllBytes 读二进制 :" );

                foreach ( byte temp in b)

                {

                    Console .Write(( char )temp+ " " );

                }

                string [] s = File .ReadAllLines(path, Encoding .UTF8);

                Console .WriteLine( "\nReadAllLines 读所有行 :" );

                foreach ( string temp in s)

                {

                    Console .WriteLine( " 行: " +temp);

                }

                string str = File .ReadAllText(path, Encoding .UTF8);

                Console .WriteLine( "ReadAllText 读所有行 :\n" + str);

                Console .Read();

            }

        }

    (2) 写文件

        class Program

        {

            static void Main( string [] args)

            {

                string path = @"E:\ 学习笔记 \C# 平台 \Test.txt" ;

                File .WriteAllBytes(path, new byte [] {0,1,2,3,4,5,6,7,8,9}); // 写入二进制

                Console .WriteLine( "WriteAllBytes 写入二进制成功 " );

                Console .ReadLine();

                string [] array = { "123" , "456" , "7890" };

                File .WriteAllLines(path, array, Encoding .UTF8); // 写入所有行

                Console .WriteLine( "WriteAllLines 写入所有行成功 " );

                Console .ReadLine();

                File .WriteAllText(path, "abcbefghijklmn" , Encoding .UTF8); // 写入字符串

                Console .WriteLine( "WriteAllText 写入字符串成功 \nOK!" );

                Console .Read();

            }

        }

    (3) 数据流

    最常用的流类如下:

    FileStream :文件流,可以读写二进制文件。

    StreamReader :流读取器,使其以一种特定的编码从字节流中读取字符。

    StreamWriter :流写入器,使其以一种特定的编码向流中写入字符。

    BufferedStream :缓冲流,给另一流上的读写操作添加一个缓冲层。

    数据流类的层次结构:

    图像 2

    (4) 使用 FileStream 读写二进制文件

        class Program

        {

            static void Main( string [] args)

            {

                string path = @"E:\ 学习笔记 \C# 平台 \Test.txt" ;

                // 以写文件的方式创建文件

                FileStream file = new FileStream (path, FileMode .CreateNew, FileAccess .Write);

                string str = " 测试文件 -- 李志伟 " ;

                byte [] bytes = Encoding .Unicode.GetBytes(str);

                file.Write(bytes, 0, bytes.Length); // 写入二进制

                file.Dispose();

                Console .WriteLine( " 写入数据成功!!! " );

                Console .ReadLine();

                // 以读文件的方式打开文件

                file = new FileStream (path, FileMode .Open, FileAccess .Read);

                byte [] temp = new byte [bytes.Length];

                file.Read(temp, 0, temp.Length); // 读取二进制

                Console .WriteLine( " 读取数据: " + Encoding .Unicode.GetString(temp));

                file.Dispose();

                Console .Read();

            }

        }

    (5) StreamWriter 与 StreamReader

    使用 StreamWriterStreamReader 就不用担心文本文件的编码方式,所以它们很适合读写文本文件。

        class Program

        {

            static void Main( string [] args)

            {

                string path = @"E:\ 学习笔记 \C# 平台 \Test.txt" ;

                // 以写文件的方式创建文件

                FileStream file = new FileStream (path, FileMode .Create, FileAccess .Write);

                StreamWriter sw = new StreamWriter (file);

                sw.WriteLine( " 测试文件 -- 李志伟 " );

                sw.Dispose();

                Console .WriteLine( " 写入数据成功!!! " );

                Console .ReadLine();

                // 以读文件的方式打开文件

                file = new FileStream (path, FileMode .Open, FileAccess .Read);

                StreamReader sr = new StreamReader (file);

                Console .WriteLine( " 读取数据 :" +sr.ReadToEnd());

                sr.Dispose();

                Console .Read();

            }

        }

    4. 映射内存的文件

    (1) MemoryMappedFile 类 (.NET4 新增 )

    应用程序需要频繁地或随机地访问文件时,最好使用 MemoryMappedFile 类 ( 映射内存的文件 )。使用这种方式允许把文件的一部分或者全部加载到一段虚拟内存上,这些文件内容会显示给应用程序,就好像这个文件包含在应用程序的主内存中一样。

    (2) 使用示例

        class Program

        {

            static void Main( string [] args)

            {

                MemoryMappedFile mmfile = MemoryMappedFile .CreateFromFile(

    @"E:\Test.txt" , FileMode .OpenOrCreate, "MapName" , 1024 * 1024);

                MemoryMappedViewAccessor view = mmfile.CreateViewAccessor(); // 内存映射文件的视图

                // 或使用数据流操作内存文件

                //MemoryMappedViewStream stream = mmfile.CreateViewStream();

                string str = " 测试数据:李志伟 !" ;

                int length = Encoding .UTF8.GetByteCount(str);

                view.WriteArray< byte >(0, Encoding .UTF8.GetBytes(str), 0, length); // 写入数据

                byte [] b = new byte [length];

                view.ReadArray< byte >(0, b, 0, b.Length);

                Console .WriteLine( Encoding .UTF8.GetString(b));

                mmfile.Dispose(); // 释放资源

                Console .Read();

            }

        }

    5. 文件安全

    (1) ACL 介绍

    ACL 是存在于计算机中的一张表 ( 访问控制表 ) ,它使操作系统明白每个用户对特定系统对象,例如文件目录或单个文件的存取权限。每个对象拥有一个在访问控制表中定义的安全属性。这张表对于每个系统用户有拥有一个访问权限。最一般的访问权限包括读文件(包括所有目录中的文件),写一个或多个文件和执行一个文件(如果它是一个可执行文件或者是程序的时候)。

    (2) 读取文件的 ACL

        class Program

        {

            static void Main( string [] args)

            {

                FileStream file = new FileStream ( @"E:\Test.txt" , FileMode .Open, FileAccess .Read);

                FileSecurity filesec = file.GetAccessControl(); // 得到文件访问控制属性

                // 输出文件的访问控制项

                foreach ( FileSystemAccessRule filerule in

    filesec.GetAccessRules( true , true , typeof ( NTAccount )))

                {

                    Console .WriteLine(filerule.AccessControlType

    + "--" + filerule.FileSystemRights + "--" + filerule.IdentityReference);

                }

                file.Dispose();

                Console .Read();

            }

        }

    (3) 读取文件夹的 ACL

        class Program

        {

            static void Main( string [] args)

            {

                DirectoryInfo dir= new DirectoryInfo ( @"E:\ 学习笔记 \C# 平台 " );

                DirectorySecurity filesec = dir.GetAccessControl(); // 得到文件访问控制属性

                // 输出文件的访问控制项

                foreach ( FileSystemAccessRule filerule in

    filesec.GetAccessRules( true , true , typeof ( NTAccount )))

                {

                    Console .WriteLine(filerule.AccessControlType

    + "--" + filerule.FileSystemRights + "--" + filerule.IdentityReference);

                }

                Console .Read();

            }

        }

    (4) 修改 ACL

        class Program

        {

            static void Main( string [] args)

            {

                FileStream file = new FileStream ( @"E:\Test.txt" , FileMode .Open, FileAccess .Read);

                FileSecurity filesec = file.GetAccessControl(); // 得到文件访问控制属性

                Print(filesec.GetAccessRules( true , true , typeof ( NTAccount ))); // 输出文件访问控制项

                FileSystemAccessRule rule = new FileSystemAccessRule (

    new NTAccount ( @"CENTER-YFB-512\LiZW" ), // 计算机账户名

    FileSystemRights .Delete, // 操作权限

    AccessControlType .Allow); // 能否访问受保护的对象

                filesec.AddAccessRule(rule); // 增加 ACL 项

                Print(filesec.GetAccessRules( true , true , typeof ( NTAccount ))); // 输出文件访问控制项

                filesec.RemoveAccessRule(rule); // 移除 ACL 项

                Print(filesec.GetAccessRules( true , true , typeof ( NTAccount ))); // 输出文件访问控制项

                file.Dispose();

                Console .Read();

            }

            // 输出文件访问控制项

            static void Print( AuthorizationRuleCollection rules)

            {

                foreach ( FileSystemAccessRule filerule in rules)

                {

                    Console .WriteLine(filerule.AccessControlType

    + "--" + filerule.FileSystemRights + "--" + filerule.IdentityReference);

                }

                Console .WriteLine( "================================================" );

            }

        }

    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) 示例

        class Program

        {

            static void Main( string [] args)

            {

                string path = @"SOFTWARE\Microsoft\Internet Explorer\Extensions" ;

                RegistryKey pregkey = Registry .LocalMachine.OpenSubKey(path, true ); // 以只读方式

                if (pregkey != null )

                {

                    Console .WriteLine(pregkey.Name + "--" + pregkey.SubKeyCount + "--"

    + pregkey.ValueCount);

                    string preName = System. Guid .NewGuid().ToString();

                    pregkey.CreateSubKey(preName); // 增加一个子键

                    RegistryKey new_pregkey = Registry .LocalMachine.OpenSubKey(

    path + @"\" + preName, true );

                    new_pregkey.SetValue( " 姓名 " , " 李志伟 " ); // 设置一个键的键值

                    new_pregkey.SetValue( " 键名 " , " 值内容 " ); // 设置一个键的键值

                    Console .WriteLine(pregkey.Name + "--" + pregkey.SubKeyCount + "--"

    + pregkey.ValueCount);

                    pregkey.Close();

                    new_pregkey.Close();

                }

                Console .Read();

            }

        }

    7. 读写独立的存储器

    (1) IsolatedStorageFile 类

    使用 IsolatedStorageFile 类可以读写独立的存储器,独立的存储器可以看成一个虚拟磁盘,在其中可以保存只由创建他们的应用程序或其应用程序程序实例共享的数据项。

    独立的存储器的访问类型有两种 ( 如下图 ) :第一种是一个应用程序的多个实例在同一个独立存储器中工作,第二种是一个应用程序的多个实例在各自不同的独立存储器中工作。

    图像 3

    (2) 示例

        class Program

        {

            static void Main( string [] args)

            {

                // 写文件

                IsolatedStorageFileStream storStream = new IsolatedStorageFileStream (

    @"Test.txt" , FileMode .Create, FileAccess .Write);

                string str = " 测试数据:李志伟! ABCD" ;

                byte [] bs = Encoding .UTF8.GetBytes(str);

                storStream.Write(bs, 0, bs.Length); // 写数据

                storStream.Dispose();

                // 读文件

                IsolatedStorageFile storFile = IsolatedStorageFile .GetUserStoreForDomain();

                string [] files=storFile.GetFileNames( @"Test.txt" );

                foreach ( string t in files)

                {

                    Console .WriteLine(t);

                    storStream = new IsolatedStorageFileStream (t, FileMode .Open, FileAccess .Read);

                    StreamReader sr= new StreamReader (storStream);

                    Console .WriteLine( " 读取文件: " +sr.ReadToEnd());

                    sr.Dispose();

                    storFile.DeleteFile(t); // 删除文件

                }

                storFile.Dispose();

                Console .WriteLine( "OK!" );

                Console .Read();

            }

        }

    展开全文
  • C#IO流的File和FileInfo操作实例 C#中操作文件的最基本类就是IO类,里面就定义了很多衍生类和方法给我们对文件进行处理、转换、执行等操作;其中流分为写入流(输入流)和读取流(输出流),输出流用于对文件进行...

    C#的IO流的File和FileInfo操作实例

    C#中操作文件的最基本类就是IO类,里面就定义了很多衍生类和方法给我们对文件进行处理、转换、执行等操作;其中流分为写入流(输入流)和读取流(输出流),输出流用于对文件进行读取流操作,输入流用于对文件进行写入数据;
    其中IO流中我们比较常用的类有BinaryReader(从二进制流读取原始数据), BinaryWriter(以二进制格式写入原始数据),BufferedStream(字节流的临时存储), Directory(有助于操作目录结构), DirectoryInfo(用于对目录执行操作),File(有助于处理文件),FileInfo(用于对文件执行操作), FileStream(用于文件中任何位置的读写)
    1、 File 和 FileInfo 这两个类主要是对文件进行处理和执行的操作,其中File类是静态类,不需要实例化就可以直接调用里面的方法,而FileInfo则需要实例化对象,其效率相对于File类比较低,当我们只需要对单个文件进行少量操作时可以用File类,如果对单个文件进行多个操作时就可以实例化FileInfo使用。下面是个简单的操作例子:

    namespace IO流
    {
        public partial class Form1 : Form
        {
          public Form1()
            {
               InitializeComponent();
           }
            private void button1_Click(object sender, EventArgs e)
            {
               string strDirectory = "E:\\IO流文件夹"; //声明一个文件夹
               string strFiles = "E:\\IO流文件夹\\mytext.txt"; //声明一个文件text
               string strFiles1 = "E:\\IO流文件夹\\mytext1.txt"; //声明一个文件text1
               if (!Directory.Exists(strDirectory)) //判断是否纯在该文件夹,不存在就创建
                {
                    Directory.CreateDirectory(strDirectory); //创建文件夹
                }
            //下面两个方法,执行其中一个就行了;
                //1、File新增文件并往txt文件里面写入文本内容,如果已经存在就覆盖;第一个参数是路径,第二个参数是文本内容
               File.WriteAllText(strFiles,textBox2.Text);
                 ////	2、FileInfo新增文件 
               //FileInfo fs = new FileInfo(strFiles); //实例化FileInfo类,对strFiles进行执行
                FileInfo cpfs = new FileInfo(strFiles1);//初始化实例化fs复制来的文件,
                if (cpfs.Exists)  //判断fs复制得到的文件是否纯在,不存在下面才可以fs复制得到strFiles1
                {
                    cpfs.Delete(); //存在就删除
                }
               // StreamWriter stw = fs.CreateText();//实现文本写入流
              // stw.WriteLine(textBox2.Text.ToString());//写入文本内容
              // stw.Close();//关闭StreamWriter 写入流
               // //复制文件
               // fs.CopyTo(strFiles1);
           }
        }
    }
    

    上面就是File和FileInfo对文集进行操作和执行的实例,不过这里是通过文本来展示,因为刚试着去理解IO流,只能从简单的文本出发,后期要处理图片,视频等文件时,就是通过二进制读取和写入文件流的了;从上面可以看到我们对单个文件进行单个操作时用File会比较方便,比如我要给一个文件写入内容时,通过File就可以直接写入了,如果打算多次重用某个对象就用FileInfo。上面的代码是Window From 的代码,通过页面输入内容添加到具体文件夹\文件中,并且复制该文件到新文件中,结果如下图;
    窗体截图
    在这里插入图片描述
    结果截图:
    在这里插入图片描述
    根据上面代码和两张截图可以看到我们可以通过使用File类的WriteAllText实现新增文本文件,亦可以通过实例化FileInfo 对象实现新增文本文件,复制文本文件等一系列操作;在这就不一一列举了!

    展开全文
  • C#文件IO流详解

    2017-04-25 19:24:18
     文件操作类大都在System.IO命名空间里。FileSystemInfo类是任何文件系统类的基类;FileInfo与File表示文件系统中的文件;DirectoryInfo与Directory表示文件系统中的文件夹;Path表示文件系统中的路径;DriveInfo...

    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. }
    展开全文
  • C#IO流总结

    2018-09-17 10:51:07
     文件操作类大都在System.IO命名空间里。FileSystemInfo类是任何文件系统类的基类;FileInfo与File表示文件系统中的文件;DirectoryInfo与Directory表示文件系统中的文件夹;Path表示文件系统中的路径;DriveInfo...
  • c#IO流读写操作

    2019-08-03 07:43:07
    1、使用FileStream读写文件文件头: using System;using System.Collections.Generic;...using System.IO; 读文件核心代码: byte[] byData = new byte[100];char[] charData = new char[1000];try{FileSt...
  • public static void main(String[] args) { File file = new File("tempfile1" + File.separator ... // 现在try外面定义好输出的引用 FileOutputStream fos = null; try { fos = new FileOutputStream(...
  • 可以理解为内存中字节序列,stream是所有的抽象基类,每个具体的存储实体都可以 通过stream派生类来实现。如FileStream就是这种储存实体
  • C# 文本文件操作 IO流

    2011-10-13 21:22:42
    一.读取文本文件  1/**//// 2/// 读取文本文件  3/// 4private void ReadFromTxtFile()  5{  6 if(filePath.PostedFile.FileName != "")
  • 继续之前的C# IO流,在前几篇小短片中我们大概看了下C# 的基础IO也对文件、目录和路径的操作有了一定的了解。这一篇开始,给大家演示一下流的各种操作。以文件流为例,一起来看看如何操作吧。 注:之前更新了一篇...
  • 通常来讲,用C#程序读取一个文件需要以下5个基本步骤 1:创建文件 2:创建阅读器或者写入器 3:执行读写操作 4:关闭阅读器或者写入器 5:关闭文件 (注意事项: 使用文件需要导入System.Io命名空间) //...
  • Android基础之IO流

    2016-03-25 22:10:28
    从斐青这篇文章中可以了解到:Java的IO使用装饰者模式将IO流分成了底层节点流和上层处理流。节点流直接和底层的物理存储节点关联,虽然不同的物理节点获取的节点流可能存在差异,但程序可以把不同的物理节点包装成统一...
  • 操作的单位不一样,一个是字节,一个是字符 操作中文的时候使用...如果不关闭流也会写入 字符输出 : 程序 ---> 缓冲[刷新(flush),关闭(close)] ---> 磁盘文件 ;如果不关闭流或者刷新缓冲区,不会写入文件 ...
  • (转)C#IO流文件操作

    2018-03-11 10:31:59
    我们知道,程序中的数据通常保存在内存中,当程序关闭时其对应的内存空间就会被释放掉,也就是说我们在程序中所作的操作或对数据的更改会在程序结束时自动删除,没办法永久的保存,如果你想永久的保存这些数据,则...
  • 一、读写文本文件 可以用fileStream来读写文本文件,但是FileStream是通过字节形式来读写数据的,要把字节数据转换为文本,要自己处理编码转换。 对于文本文件的读写,通常用 StreamReader类和 StreamWriter类更...
1 2 3 4 5 ... 20
收藏数 12,658
精华内容 5,063
热门标签