.NET教程 - 文件 & 流 & 压缩（File & Stream & Compress）

更新记录
转载请注明出处：
2022年10月4日发布。
2022年10月1日从笔记迁移到博客。

文件I/O基础（File I/O）

文件概念

存储在磁盘上按特定顺序字节的数据组成的命名集合

A file is a collection of data stored in a disk with a specific name and a directory path. When a file is opened for reading or writing, it becomes a stream

The stream is basically the sequence of bytes passing through the communication path. There are two main streams: the input stream and the output stream. The input stream is used for reading data from file (read operation) and the output stream is used for writing into the file (write operation).

Windows系统平台文件权限说明

.NET中主要的命名空间

System
System.IO

.NET中文件处理主要的类

.NET中的类型	说明
File	处理文件的静态类
Dictionary	处理文件夹的静态类
FileSystemInfo	是FileInfo和DictionaryInfo的基类
FileInfo	代表一个文件，用于处理文件
DictionaryInfo	代表一个目录，用于处理目录
Path	路径类，用于处理目录
DriveInfo	驱动器类，提供有关驱动器信息的访问
FileMode	文件操作模式枚举
FileAccess	文件存储权限枚举
FileAttributes	文件属性枚举
FileShare	文件共享枚举
SearchOption	搜索选项枚举
SeekOrigin	枚举
DriveType	驱动选项枚举
Stream	流的基类
BufferedStream	缓存流
FileStream	文件流
MemorySteam	内存流
UnmanagedMemoryStream	无控制的内存流
StreamReader	字符串流读取器
StreamWriter	字符串流写入器
TextReader	文本流读取器的基类
TextWriter	文本流写入器的基类
StringReader	字符串读取器
StringWriter	字符串写入器
BinaryReader	二进制流读取器
BinaryWriter	二进制流写入器
IOException	IO异常
FileLoadException	文件加载异常
DriveNotFoundExceptin	驱动器没有找到异常
FileNotFoundException	文件没有找到异常
DirectoryNotFoundException	目录没有找到异常
PathTooLongException	路径过长异常
EndOfStreamException	流到尾异常
DeflateStream	压缩解压缩gzip
GZipStream	压缩解压缩gzip
ZipArchive	压缩解压缩zip
SslStream
AuthenticatedStream	This sends credentials across the stream

文件流

概念

流是用于对数据进行读写的对象

流是一个抽象概念，表示字节序列

使用流可以很好的抽象底层的细节，专注业务逻辑

典型的数据流和某个外部数据源相关

流中的数据可以来自内存、文件、外部设备、TCP/IP套接字

当通过网络传输数据，或者对文件数据进行操作时，首先需要将数据转化为数据流

根据数据源的不同，.NET提供了多个从Stream类派生的子类

每个类都代表了一种具体的数据流类型

使用FileStream类表示文件流，用于对文件进行读写操作

使用MemeryStream类表示内存流，用于内存读写

使用DeflateStream类实现数据压缩，命名空间System.IO.Compression

使用CryptoStream类实现数据加密解密，命名空间System.Security.Cryptography

使用NetworkStream类表示网络流，命名空间System.Net.Sockets

使用BinaryReader类和BinaryWriter类对二进制流进行读取和写入操作

使用StreamReader和StreamWriter类对文本进行读取和写入操作

类结构图：

文件流操作

流提供以下3种基本操作

写入：将数据从内存缓冲区传输到外部源

读取：将数据从外部源传输到内存缓冲区

查找：重新设置流的当前位置，以便随机读写

需要注意的是，并不是所有的流类型都能够支持查找

如网络流没有当前位置的概念,因此不支持杳找功能

Stream类及其派生类都提供了 Read和 Write方法，可支持在字节级别上对数据进行读写，Read方法从当前流读取字节序列，Write方法向当前流中写入字节序列，但是仅支持字节级别的数据处理会给开发人员带来不便，假定应用程序需要将字符数据写入到流中，则需要首先将字符数据转化为字节数组，之后才能调用Write方法写入流，因此，除了Stream及其派生类的读写方法之外，.NET框架同样提供了其他多种支持流读写的类

常见的支持流读写的类

BinaryReader 从 Streams读取编码的字符串和基元数据类型

BinaryWriter 向 Streams写入编码的字符串和基元数据类型

StreamWriter 通过使用Encoding将字符转换为字节，向 Streams写人字符

StreamReader 通过使用Encoding进行字符和字节转换，可直接从Streams中读取字符

System.Environment

说明

获得应用程序的运行环境信息

获得程序当前文件夹

使用CurrmentDirectory属性

Console.WriteLine(Environment.CurrentDirectory);
//C: \Users\pxdwo\source\repos\ConsoleApp1\ConsoleApp1\bin\Debug

获得当前运行的计算机名称

使用MachineName属性

Console.WriteLine(Environment.MachineName);
//DESKTOP - 9GR4MGU

获得当前操作系统的版本信息

使用OSVersion属性

Console.WriteLine(Environment.OSVersion); 
//Microsoft Windows NT 6.2.9200.0

获得当前操作程序的用户的用户名称

使用UserName属性

Console.WriteLine(Environment.UserName);
//pxdwo

获得当前主机的域名

Console.WriteLine(Environment.UserDomainName);
//DESKTOP - 9GR4MGU

获得当前的CLR版本信息

使用Version()方法
注意：返回一个System.Version对象

Console.WriteLine(Environment.Version);

通用换行

Console.WriteLine(Environment.NewLine);

设置和获取退出代码

//设置退出代码
Environment.ExitCode = 666;
//获取退出代码
Console.WriteLine(Environment.ExitCode);

终止当前程序

使用Exit()方法

Environment.Exit(0);

获得所有命令行的参数

注意：第一个参数是程序名称（完全路径）

//输出命令行的参数
foreach (string item in Environment.GetCommandLineArgs())
{
    Console.WriteLine(item);
}

获得指定的命令行参数

string someArgs = Environment.GetEnvironmentVariable("Panda");
Console.WriteLine(someArgs);

获得各驱动器的名称

string[] allDrives = Environment.GetLogicalDrives()
foreach (string item in allDrives)
{
    Console.WriteLine(item);
}

获得Windows系统各种预设文件夹完整路径

获得[我的文档]、[开始菜单]等标准文件夹路径
使用GetFolderPath()方法
该方法参数为System.Environment.SoecialFolder的枚举值

实例：

Console.WriteLine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles));
Console.WriteLine(Environment.GetFolderPath(Environment.SpecialFolder.Windows));
Console.WriteLine(Environment.GetFolderPath(Environment.SpecialFolder.CommonMusic));

获得当前系统驱动器列表

使用GetLogicalDrives()方法
注意：返回一个字符串序列

string[] localDrives = Environment.GetLogicalDrives();
foreach (string drive in localDrives)
{
    Console.WriteLine(drive);
}

检测当前是否为64位系统

//检测当前是否为64位系统
bool result1 = Environment.Is64BitOperatingSystem;
Console.WriteLine(result1);

检测当前进程是否为64位进程

//检测当前进程是否为64位进程
bool result2 = Environment.Is64BitProcess;
Console.WriteLine(result2);

设置/创建/修改环境变量的值

//设置/创建/修改环境变量的值
Environment.SetEnvironmentVariable("Panda", "6666");
Console.WriteLine(Environment.GetEnvironmentVariable("Panda"));

获得当前硬件上的处理器数量

//获得当前硬件上的处理器数量
int procssorCount = Environment.ProcessorCount;
Console.WriteLine("ProcssorCount {0}",procssorCount);

获得操作系统的内存页字节数量

//获得操作系统的内存页字节数量
int pageSize = Environment.SystemPageSize;
Console.WriteLine("pageSize {0}", pageSize);

获得系统启动后经过的毫秒数

//获得系统启动后经过的毫秒数
int tickCount = Environment.TickCount;
Console.WriteLine("tickCount {0}",tickCount);

获得CLR的版本

//获得CLR的版本
Version v = Environment.Version;
Console.WriteLine(v.ToString());

获得用户关联的主机网络域名

//获得用户关联的主机网络域名
string userDomainName = Environment.UserDomainName;
Console.WriteLine("userDomainName {0}", userDomainName);

获得用户是否在交互环境中

//获得用户是否在交互环境中
bool userIsInteractive = Environment.UserInteractive;
Console.WriteLine("userIsInteractive {0}", userIsInteractive);

获得当前登录到系统的用户的用户名

//获得当前登录到系统的用户的用户名
string userName = Environment.UserName;
Console.WriteLine("UserName {0}", userName);

FileMode类

说明

FileMode用于指定文件打开方式

FileMode是一个枚举类型

主要成员说明

打开文件

文件存在则打开文件
不存在则新建文件

Console.WriteLine(FileMode.Open);

打开文件或者创建

文件不存在则报异常

Console.WriteLine(FileMode.OpenOrCreate);

创建新文件

如果文件存在则删除，然后再创建

Console.WriteLine(FileMode.Create);

追加文件

打开文件，并移动指针到文件末尾
文件不存在会新建文件
只能和FileAccess.Write一起使用

Console.WriteLine(FileMode.Append);

创建文件

文件不存在则报异常

Console.WriteLine(FileMode.CreateNew);

创建文件

清除内容，然后指向文件开头

Console.WriteLine(FileMode.Truncate);

FileAccess类

说明

FileAccess类用于设置文件的读写方式
FileAccess值是枚举的一个成员，它控制对文件的访问权限
Read 打开文件，用于只读
Write 打开文件,用于只写
ReadWrite 打开文件，用于读写

只读打开文件

System.Console.WriteLine(FileAccess.Read);

只写打开文件

System.Console.WriteLine(FileAccess.Write);

读写打开文件

默认选项

System.Console.WriteLine(FileAccess.ReadWrite);

FileAttributes类

说明

FileShare类

说明

官方文档

SearchOption类

说明

官方文档

SeekOrigin类

说明

官方文档

DriveInfo类

说明

DriveInfo表示驱动器信息

主要成员

Name

DriveType

TotalFreeSpace

DriveFormat

VolumeLabel

实例

获得系统中所有驱动器1

using System;
using System.IO;

namespace Test
{
    class TestClass
    {
        public static void Main()
        {
            //使用DriveInfo的静态方法获得所有驱动器信息
            DriveInfo[] driveInfos = DriveInfo.GetDrives();
            //遍历输出驱动器信息
            foreach (DriveInfo drive in driveInfos)
            {
                //驱动器已经准备好
                if(drive.IsReady)
                {
                    //驱动器名称
                    Console.WriteLine(drive.Name);
                    //驱动器的卷标
                    Console.WriteLine(drive.VolumeLabel);
                    //驱动器的格式
                    Console.WriteLine(drive.DriveFormat);
                    //驱动器的类型
                    Console.WriteLine(drive.DriveType);
                    //驱动器的根目录
                    Console.WriteLine(drive.RootDirectory);
                    //驱动器的大小
                    Console.WriteLine(drive.TotalSize);
                    //驱动器的可用空闲大小
                    Console.WriteLine(drive.TotalFreeSpace);
                    Console.WriteLine(drive.AvailableFreeSpace);
                }
            }

            Console.ReadKey();
        }
    }
}

获得系统中所有驱动器2

using System;
using System.IO;

namespace ConsoleApp6
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("{0,-30} | {1,-10} | {2,-7} | {3,18} | {4,18}",
                "NAME", "TYPE", "FORMAT", "SIZE (BYTES)", "FREE SPACE");
            foreach (DriveInfo drive in DriveInfo.GetDrives())
            {
                if (drive.IsReady)
                {
                    Console.WriteLine(
                    "{0,-30} | {1,-10} | {2,-7} | {3,18:N0} | {4,18:N0}",
                    drive.Name, drive.DriveType, drive.DriveFormat,
                    drive.TotalSize, drive.AvailableFreeSpace);
                }
                else
                {
                    Console.WriteLine("{0,-30} | {1,-10}", drive.Name, drive.DriveType);
                }
            }
            
            //wait
            Console.ReadKey();
        }
    }
}

File类

说明

处理文件的静态类

与FileInfo如何选择

简单的单次操作使用File类，简单并且高效，File每次都会对执行的方法进行安全检查
复杂的多次操作使用FileInfo类，所以如果多次操作文件，考虑使用FileInfo类

主要成员

创建文件

using System;
using System.IO;
namespace PandaNamespace
{
    class PandaClass
    {
        static void Main(string[] args)
        {
            using(FileStream F = File.Create("D:/pandaTest.txt"))
            {

            }

            Console.ReadKey();
        }
    }
}

复制文件

string sourcePath = "D:/test.txt";
string destPath = "D:/test2.txt";
//复制（不覆盖同名文件）
File.Copy(sourcePath, destPath);
//复制（覆盖同名文件）
File.Copy(sourcePath, destPath, true);

移动文件

string sourcePath = "D:/test.txt";
string destPath = "D:/test2.txt";
//移动
File.Move(sourcePath, destPath);

删除文件

string path = "D:/test2.txt";
//删除
File.Delete(path);
检测文件存在
string path = "D:/test.txt";
//检测存在
if (File.Exists(path))
{
    Console.WriteLine("File Exist");
}
else
{
    Console.WriteLine("File Not Exist");
}

获得文件属性信息

string path = "D:/test.txt";
//获得文件信息
FileAttributes fileAttributes = File.GetAttributes(path);
//使用文件信息1（检测是否只读）
if (fileAttributes.HasFlag(FileAttributes.ReadOnly))
{
    Console.WriteLine("File is ReadOnly");
}
//使用文件信息2（检测是否隐藏）
if (fileAttributes.HasFlag(FileAttributes.Hidden))
{
    Console.WriteLine("File is Hidden");
}

设置文件属性信息

string path = "D:/test.txt";
//设置文件只读和隐藏
File.SetAttributes(path, FileAttributes.ReadOnly | FileAttributes.Hidden);

获得文件创建时间

string path = "D:/test.txt";
//获得文件创建日期
DateTime creationTime = File.GetCreationTime(path);
//输出文件创建日期
Console.WriteLine(creationTime);

设置文件创建时间

string path = "D:/test.txt";
File.SetCreationTime(path, DateTime.Now);

获得文件最后一次访问时间

string path = "D:/test.txt";
DateTime lastAccessTime = File.GetLastAccessTime(path);
Console.WriteLine(lastAccessTime);

设置文件最后一次访问时间

string path = "D:/test.txt";
File.SetLastAccessTime(path, DateTime.Now);
Console.ReadKey();

获得文件最后一次修改时间

string path = "D:/test.txt";
DateTime lastWriteTime = File.GetLastWriteTime(path);
Console.WriteLine(lastWriteTime);

设置文件最后一次修改时间

string path = "D:/test.txt";
File.SetLastWriteTime(path, DateTime.Now);

打开指定文件

string path = "D:/test.txt";
FileStream fileStream = File.Open(path, FileMode.OpenOrCreate);
fileStream.Close();

或者使用using语句

string path = "D:/test.txt";
using (FileStream fileStream = File.Open(path, FileMode.OpenOrCreate))
{
    //code
}
打开指定文件（只读方式）
string path = "D:/test.txt";
FileStream fileStream = File.OpenRead(path);
fileStream.Close();

或者使用using语句

string path = "D:/test.txt";
using(FileStream fileStream = File.OpenRead(path))
{
    //code
}

打开指定文件（读写方式）

string path = "D:/test.txt";
FileStream fileStream = File.OpenWrite(path);
fileStream.Close();

或者使用using语句

string path = "D:/test.txt";
using(FileStream fileStream = File.OpenWrite(path))
{
    //code
}

创建一个文本文件

string path = "D:/test.txt";
StreamWriter streamWriter = File.CreateText(path);
streamWriter.WriteLine("First Line");
streamWriter.WriteLine("Second Line");
streamWriter.WriteLine("Third Line");
streamWriter.WriteLine(Environment.NewLine);
streamWriter.WriteLine("Fiftd Line");
streamWriter.Close();

或者使用using语句

string path = "D:/test.txt";
using(StreamWriter streamWriter = File.CreateText(path))
{
    streamWriter.WriteLine("First Line");
    streamWriter.WriteLine("Second Line");
    streamWriter.WriteLine("Third Line");
    streamWriter.WriteLine(Environment.NewLine);
    streamWriter.WriteLine("Fiftd Line");
}

追加文本

string path = "D:/test.txt";
using (StreamWriter streamWriter = File.AppendText(path))
{
    streamWriter.WriteLine("New Line1");
    streamWriter.WriteLine("New Line2");
    streamWriter.WriteLine("New Line3");
    streamWriter.WriteLine(Environment.NewLine);
}

追加所有行

string path = "D:/test.txt";
string[] content = new string[] { "New Line11", "New Line22" };
//追加所有行
File.AppendAllLines(path, content);

追加所有文本

string path = "D:/test.txt";
string content = "New Line3";
//追加所有文本
File.AppendAllText(path, content);

打开一个文本文件

string path = "D:/test.txt";
using (StreamReader streamReader = File.OpenText(path))
{
    while (!streamReader.EndOfStream)
    {
        Console.WriteLine(streamReader.ReadLine());
    }
}

读取所有行

string path = "D:/test.txt";
string allText = File.ReadAllText(path, System.Text.Encoding.UTF8);
Console.WriteLine(allText);

写入所有行

string path = "D:/test.txt";
string content = "New Line4";
File.WriteAllText(path, content);

FileInfo类

说明

该类代表一个文件

处理文件的实例类

主要成员

Name

FullName

Extension

Length

Create

Delete

Exists

CopyTo

MoveTo

实例化文件对象

string path = "D:/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);

复制文件

string path = "D:/new/test.txt";
string dest = "D:/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
fileInfo.CopyTo(dest);

移动文件

string path = "D:/test.txt";
string dest = "D:/new/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
fileInfo.MoveTo(dest);

删除文件

string path = "D:/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
fileInfo.Delete();

刷新文件状态

string path = "D:/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
//刷新状态
fileInfo.Refresh();

检测文件是否存在

string path = "D:/new/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
//检测文件是否存在
if(fileInfo.Exists)
{
    Console.WriteLine("Exists");
}
else
{
    Console.WriteLine("Not Exists");
}

检测文件是否只读

string path = "D:/new/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
//检测文件是否只读
if (fileInfo.IsReadOnly)
{
    Console.WriteLine("Is ReadOnly");
}
else
{
    Console.WriteLine("Not ReadOnly");
}

获得/设置文件属性对象

string path = "D:/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
//获得文件属性对象
Console.WriteLine(fileInfo.Attributes);
//设置文件属性
fileInfo.Attributes = FileAttributes.ReadOnly | FileAttributes.Hidden | FileAttributes.;
//使用文件属性（检测是否只读）
if(fileInfo.Attributes.HasFlag(FileAttributes.ReadOnly))
{
    Console.WriteLine("ReadOnly");
}
//使用文件属性（检测是否隐藏）
if (fileInfo.Attributes.HasFlag(FileAttributes.Hidden))
{
    Console.WriteLine("Hidden");
}

获得/设置文件创建时间

string path = "D:/new/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
//设置文件的创建时间
fileInfo.CreationTime = DateTime.Now;
//获得文件创建时间
Console.WriteLine(fileInfo.CreationTime);

获得/设置文件最后一次访问时间

string path = "D:/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
//设置文件最后一次访问时间
fileInfo.LastAccessTime = DateTime.Now;
//获得文件最后一次访问时间
Console.WriteLine(fileInfo.LastAccessTime);

获得/设置文件最后一次修改时间

string path = "D:/new/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
//设置文件最后一次修改时间
fileInfo.LastWriteTime = DateTime.Now;
//获得文件最后一次修改时间
Console.WriteLine(fileInfo.LastWriteTime);

获得文件名（全路径）

string path = "D:/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
//全路径文件名
Console.WriteLine(fileInfo.FullName);

获得文件名

string path = "D:/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
//文件名
Console.WriteLine(fileInfo.Name);

获得文件扩展名

string path = "D:/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
//文件扩展名
Console.WriteLine(fileInfo.Extension);

获得文件大小

注意：单位字节

string path = "D:/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
//文件大小（单位：字节）
Console.WriteLine(fileInfo.Length);

获得文件所在目录名

string path = "D:/new/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
//文件所在的目录名
Console.WriteLine(fileInfo.DirectoryName);

获得文件所在目录名（详细）

返回一个DirectoryInfo对象

string path = "D:/new/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
//获得文件目录详细信息
DirectoryInfo directoryInfo = fileInfo.Directory;
Console.WriteLine(directoryInfo.FullName);
Console.WriteLine(directoryInfo.Name);
Console.WriteLine(directoryInfo.Exists);

打开文件（可读写）

string path = "D:/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
using (FileStream fileStream = fileInfo.Open(FileMode.OpenOrCreate))
{
    fileStream.Write(new byte[] { 1, 2 }, 0, 2);
}

打开文件（只读）

string path = "D:/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
using (FileStream fileStream = fileInfo.OpenRead())
{
    byte[] buffer = new byte[2];
    fileStream.Read(buffer, 0, 2);
    foreach (byte item in buffer)
    {
        Console.WriteLine(item);
    }
}

打开文件（只写）

string path = "D:/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
//开启读写
using (FileStream fileStream = fileInfo.OpenWrite())
{
    byte[] writeDate = new byte[] { 3, 4 };
    fileStream.Write(writeDate, 2, 2);
}

打开文本

string path = "D:/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
//打开文本
using (StreamReader streamReader = fileInfo.OpenText())
{
    while (!streamReader.EndOfStream)
    {
        Console.WriteLine(streamReader.ReadLine());
    }
}

追加文本

string path = "D:/new/test.txt";
//实例化
FileInfo fileInfo = new FileInfo(path);
//添加文本
using (StreamWriter streamWriter = fileInfo.AppendText())
{
    streamWriter.WriteLine("First Line");
    streamWriter.WriteLine("Second Line");
    streamWriter.WriteLine("Last Line");
}

Dictionary类

说明

处理文件夹的静态类

主要成员

Delete

Exists

Move

CreateDirectory

GetCreationTime

GetLastAccessTime

GetLastWriteTime

SetCreationTime

SetLastAccessTime

SetLastWriteTime

GetDirectories

GetFiles

GetDirectoryRoot

GetFileSystemEntries

GetParent

GetLogicalDrives

创建文件夹

string path = "D:/test";
//创建文件夹
DirectoryInfo directoryInfo = Directory.CreateDirectory(path);

删除文件夹

string path = "D:/test/test2";
//删除文件夹(空文件夹)
Directory.Delete(path);
//删除文件夹（非空，递归删除）
Directory.Delete(path, true);

移动/修改文件夹

string path = "D:/test";
string dest = "D:/test2";
//移动文件夹（重命名也可以用这个）
Directory.Move(path, dest);

检测文件夹是否存在

string dest = "D:/test2";
//检测文件夹是否存在
if (Directory.Exists(dest))
{
    Console.WriteLine("Exists");
}
else
{
    Console.WriteLine("Not Exists");
}

获得文件夹下的所有文件列表

string path = "D:/test";
//获得文件夹下的文件列表
string[] subFiles = Directory.GetFiles(path);
foreach (string file in subFiles)
{
    Console.WriteLine(file);
}

获得文件夹下的指定类型文件列表（筛选）

string path = @"C:\Users\pxdwo\Downloads";
//获得文件夹下的文件列表
string[] subFiles = Directory.GetFiles(path,"*.exe");
foreach (string file in subFiles)
{
    Console.WriteLine(file);
}

获得文件夹下的所有目录列表

string path = "D:/test";
//获得文件夹下的目录列表
string[] subDirectory = Directory.GetDirectories(path);
foreach (string dictionary in subDirectory)
{
    Console.WriteLine(dictionary);
}

string path = "D:/";
//获得目录下所有文件和目录
string[] subEntries = Directory.GetFileSystemEntries(path);
foreach (string item in subEntries)
{
    Console.WriteLine(item);
}

获得/设置文件夹创建时间

string path = "D:/test";
//设置文件夹创建时间
Directory.SetCreationTime(path, DateTime.Now);
//获得文件夹创建时间
Console.WriteLine(Directory.GetCreationTime(path));

获得/设置文件夹最后一次访问时间

string path = "D:/test";
//设置文件夹最后一次访问时间
Directory.SetLastAccessTime(path, DateTime.Now);
//获得文件夹最后一次访问时间
Console.WriteLine(Directory.GetLastAccessTime(path));

获得/设置文件夹最后一次写入时间

string path = "D:/test";
//设置文件夹最后一次写入时间
Directory.SetLastWriteTime(path, DateTime.Now);
//获得文件夹最后一次写入时间
Console.WriteLine(Directory.GetLastWriteTime(path));

获得父目录

string path = "D:/test";
//获得父目录
DirectoryInfo directoryInfo = Directory.GetParent(path);
Console.WriteLine(directoryInfo.Name);
Console.WriteLine(directoryInfo.FullName);

获得应用程序当前目录

Console.WriteLine(Directory.GetCurrentDirectory());

获得所有驱动器名称

string path = "D:/test";
//获得所有驱动器名称
string[] allLogicalDrives = Directory.GetLogicalDrives();
foreach (string drive in allLogicalDrives)
{
    Console.WriteLine(drive);
}

获得可枚举的目录信息

string path = "D:/";
IEnumerable<string> Directories = Directory.EnumerateDirectories(path);
foreach (var item in Directories)
{
    Console.WriteLine(item);
}

获得可枚举的文件信息

string path = "D:/test";
IEnumerable<string> files = Directory.EnumerateFiles(path);
foreach (var item in files)
{
    Console.WriteLine(item);
}
Console.ReadKey();

获得可枚举的文件和目录信息

string path = "D:/";
IEnumerable<string> all = Directory.EnumerateFileSystemEntries(path);
foreach (string item in all)
{
    Console.WriteLine(item);
}

DictionaryInfo类

说明

DictionaryInfo类代表一个文件夹

DictionaryInfo用于处理文件夹

主要成员

Create

CreateSubdicrectory

Name

FullName

Extension

Exists

MoveTo

CreationTime

LastAccessTime

LastWriteTime

GetFiles

GetDirectories

GetFileSystemInfos

Attributes

Parent

Root

打开文件夹

string path = @"D:/test.cs";
//打开文件夹
DirectoryInfo directoryInfo = new DirectoryInfo(path);

获得文件夹的完整路径

string path = "D:/";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//获得文件夹的完整路径
Console.WriteLine(directoryInfo.FullName);

获得文件夹名称

string path = "D:/test";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//获得文件夹名称
Console.WriteLine(directoryInfo.Name);

获得文件夹的父目录

string path = "D:/test";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//获得文件夹的父目录
DirectoryInfo parent = directoryInfo.Parent;
Console.WriteLine(parent.FullName);

获得/设置文件夹的属性

string path = "D:/test";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//设置文件夹的属性
directoryInfo.Attributes = FileAttributes.ReadOnly | FileAttributes.Hidden;
//获得文件夹的属性
FileAttributes attribute = directoryInfo.Attributes;
//检测是否只读
if (attribute.HasFlag(FileAttributes.ReadOnly))
{
    Console.WriteLine("文件夹是只读的");
}
//检测是否隐藏
if (attribute.HasFlag(FileAttributes.Hidden))
{
    Console.WriteLine("文件是隐藏的");
}

删除文件夹

string path = "D:/test";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//删除文件夹(空文件夹)
directoryInfo.Delete();
//删除文件夹(递归删除)
directoryInfo.Delete(true);

获得可枚举的子目录信息

string path = "D:/";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//获得可枚举的子目录信息
IEnumerable<DirectoryInfo> subDir = directoryInfo.EnumerateDirectories();
foreach (DirectoryInfo item in subDir)
{
    Console.WriteLine(item.FullName);
}

获得可枚举的子文件信息

string path = "D:/";
DirectoryInfo directoryInfo = new DirectoryInfo(path);

//获得可枚举的子文件信息
IEnumerable<FileInfo> subFiles = directoryInfo.EnumerateFiles();
foreach (FileInfo item in subFiles)
{
    Console.WriteLine(item.FullName);
}

得可枚举的子目录和子文件信息

string path = "D:/test";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//获得可枚举的子目录和子文件信息
IEnumerable<FileSystemInfo> subAll = directoryInfo.EnumerateFileSystemInfos();
foreach (FileSystemInfo item in subAll)
{
    Console.WriteLine(item.FullName);
}

检测文件夹是否存在

string path = "D:/test";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//检测文件夹是否存在
if (directoryInfo.Exists)
{
    Console.WriteLine("Exists");
}

获得所有子文件夹

string path = "D:/";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//获得子文件夹
DirectoryInfo[] directoryInfos = directoryInfo.GetDirectories();
foreach (DirectoryInfo item in directoryInfos)
{
    Console.WriteLine(item.FullName);
}

获得所有子文件

string path = "D:/";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//获得子文件
FileInfo[] fileInfos = directoryInfo.GetFiles();
foreach (FileInfo item in fileInfos)
{
    Console.WriteLine(item.FullName);
}

获得指定类型子文件（筛选）

string path = @"C:\Users\pxdwo\Downloads";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//获得子文件
FileInfo[] fileInfos = directoryInfo.GetFiles("*.exe");
foreach (FileInfo item in fileInfos)
{
    Console.WriteLine(item.FullName);
}

获得所有子文件和子目录

string path = "D:/test";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//获得子文件和子目录
FileSystemInfo[] filesysteminfo = directoryInfo.GetFileSystemInfos();
foreach (FileSystemInfo item in filesysteminfo)
{
    Console.WriteLine(item.FullName);
}

获得文件夹扩展名

string path = "D:/test.tst";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//获得文件夹扩展名
Console.WriteLine(directoryInfo.Extension);

获得/设置文件夹的创建时间

string path = "D:/test";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//设置文件夹的创建时间
directoryInfo.CreationTime = DateTime.Now;
//获得文件夹的创建时间
Console.WriteLine(directoryInfo.CreationTime);

获得/设置文件夹最后一次获取时间

string path = "D:/test";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//设置文件夹最后一次获取时间
directoryInfo.LastAccessTime = DateTime.Now;
//获得文件夹最后一次获取时间
Console.WriteLine(directoryInfo.LastAccessTime);

获得/设置文件夹最后一次写入时间

string path = "D:/test";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//获得文件夹最后一次写入时间
directoryInfo.LastWriteTime = DateTime.Now;
//设置文件夹最后一次写入时间
Console.WriteLine(directoryInfo.LastWriteTime);

将文件夹移动到指定目录

string path = "D:/test";
string dest = "D:/test2";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//将文件夹移动到指定目录
directoryInfo.MoveTo(dest);

刷新文件夹对象状态

string path = "D:/test";
string dest = "D:/test2";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
//刷新文件夹对象状态
directoryInfo.Refresh();

FileSystemInfo类

说明

是FileInfo和DictionaryInfo的基类

主要成员

Path类

说明

Path表示路径类

注意：Path是一个静态类型

实例

合并路径

string somePath = Path.Combine(@"C:/Panda", "test.txt");
Console.WriteLine(somePath);

Combine是一个重载方法，可以提供任意个参数

预定义分隔符

//分隔二级以及以下目录、文件的符号，Windows下是/
Console.WriteLine(Path.AltDirectorySeparatorChar);
//目录分隔符，Windows下是\
Console.WriteLine(Path.DirectorySeparatorChar);
//磁盘卷分隔符，Windows下是：
Console.WriteLine(Path.VolumeSeparatorChar);
//环境变量中的路径分隔符，Windows下是；
Console.WriteLine(Path.PathSeparator);

获得系统的临时文件夹路径

//C:\Users\用户名\AppData\Local\Temp\
//C:\Users\Administrator\AppData\Local\Temp\
Console.WriteLine(Path.GetTempPath());

创建临时文件

string tempPath = Path.GetTempFileName();

创建随机文件名

string randomFileName = Path.GetRandomFileName();

获得全路径

string filePath = @"C:/test/test.txt";
Console.WriteLine(Path.GetFullPath(filePath));

获取指定路径的根目录信息

string filePath = @"C:/test/test.txt";
string roots = Path.GetPathRoot(filePath);
//C:\

获得文件名（带扩展名）

string filePath = @"C:/test/test.txt";
Console.WriteLine(Path.GetFileName(filePath));

获得文件名（不带扩展名）

string filePath = @"C:/test/test.txt";
Console.WriteLine(Path.GetFileNameWithoutExtension(filePath));

获得文件扩展名

string filePath = @"C:/test/test.txt";
Console.WriteLine(Path.GetExtension(filePath));

修改扩展名

string filePath = @"C:/test/test.txt";
//修改扩展名
string newPath = Path.ChangeExtension(filePath,".doc");
//输出路径
Console.WriteLine(newPath);

获取不允许在文件名中使用的字符的数组

char[] invalidFileNameChars = Path.GetInvalidFileNameChars();

获取不允许在路径名中使用的字符的数组

char[] invalidPathChars = Path.GetInvalidPathChars();

检测路径是否包含有文件扩展名

string filePath = @"C:/test/test.txt";
bool hasExtension = Path.HasExtension(filePath);
Console.WriteLine(hasExtension);//true

检测路径字符串是否包含根路径

string filePath = @"C:/test/test.txt";
bool hasPathRooted = Path.IsPathRooted(filePath);
Console.WriteLine(hasPathRooted);//true

FileSystemWatcher类

说明

侦听文件系统的变化触发事件

新建监听对象

//新建对象
FileSystemWatcher watcher = new FileSystemWatcher();

设置监听的路径

//设置监控路径
watcher.Path = @"D:/";

事件监听

//创建文件和目录时发生
public event FileSystemEventHandler Created;
//删除文件或目录时发生
public event FileSystemEventHandler Deleted;
//当更改文件和目录时发生
public event FileSystemEventHandler Changed;
//重命名文件或目录时发生
public event RenamedEventHandler Renamed;
//当无法继续监视更改或内部缓冲区溢出时发生
public event ErrorEventHandler Error;

筛选监听的文件类型

//设置监控的文件类型
watcher.Filter = "*.txt";

设置监听文件的哪个部分

//设置监控类型
watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.CreationTime | NotifyFilters.Size;

支持的类型：

public enum NotifyFilters
{
    FileName = 1,
    DirectoryName = 2,
    Attributes = 4,
    Size = 8,
    LastWrite = 16,
    LastAccess = 32,
    CreationTime = 64,
    Security = 256
}

开启监听

//开启监控
watcher.EnableRaisingEvents = true;

实例

//新建对象
FileSystemWatcher watcher = new FileSystemWatcher();
try
{
    //设置监控路径
    watcher.Path = @"D:/";
    //设置监控类型
    watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.CreationTime | NotifyFilters.Size;
    //设置监控的文件类型
    watcher.Filter = "*.txt";
    //事件绑定
    watcher.Renamed += (object sender, RenamedEventArgs e) => { Console.WriteLine("改名了，旧名：{0}，新名{1}", e.OldName, e.Name); };
    watcher.Changed += (object sender, FileSystemEventArgs e) => { Console.WriteLine("改动了,{0}", e.Name); };
    watcher.Deleted += (object sender, FileSystemEventArgs e) => { Console.WriteLine("删除了,{0}", e.Name); };
    watcher.Created += (object sender, FileSystemEventArgs e) => { Console.WriteLine("新增了,{0}", e.Name); };
    //开启监控
    watcher.EnableRaisingEvents = true;
}
catch (ArgumentException e)
{
    Console.WriteLine(e.Message);
}

Stream类

说明

流的抽象基类

常见成员

FileStream类

说明

FileStream类表示一个文件流，基于字节流，支持随机访问

使用FileStream类可以对文件系统上的文件进行读取、写入、打开和关闭操作

主要成员

Name
Length
Position
CanRead
CanWrite
CanSeek
CanTimeout //是否可以操作超时
ReadTimeout
WriteTimeout
IsAsync
Read
Write
BeginRead
EndRead
BeginWrite
EndWrite
Seek
SetLength
Close
Lock
Unlock
ReadByte
WriteByte

读文件

获取FileStream实例之后，即可以利用FileStream对象的Read方法读取文件中的数据
该方法用于从流中读取字节块并将数据写入给定的字节数组中
Read方法返问从FileStream 中读取的字节数

public override int Read(
    byte[] array,   //存储从文件流中读取的数据
    int offset      //array字节数组中开始写入数据的下标值，一般为0
    int count       //要从文件流中读出字节的大小
)

写文件

Stream类及其所有子类都提供了Write方法，FileStream类也不例外
该方法可将字节数组写入流。语法形式为：

public override void Write(
    byte[] buffer,  //包含要写人流的数据
    int offset,     //buffer中开始写入数据的位置
    int size        //要写入流的字节数
)

新建文件流

string path = "D:/test.txt";
//直接实例化
using (FileStream fileStream = new FileStream(path, FileMode.OpenOrCreate))
{

}

//使用File静态类
using (FileStream fileStream = File.Open(path, FileMode.OpenOrCreate))
{

}

//使用File静态类（只读）
using (FileStream fileStream = File.OpenRead(path))
{

}

//使用File静态类（只写）
using (FileStream fileStream = File.OpenWrite(path))
{

}

读取文件字节

string path = "D:/test.txt";
//读取文件中的字节
using (FileStream fileStream = File.OpenRead(path))
{
    byte[] data = new byte[3];
    fileStream.Read(data, 0, 3);
    foreach (byte item in data)
    {
        Console.WriteLine(item);
    }
}

写入文件字节

string path = "D:/test.txt";
//写入字节到文件中
using (FileStream fileStream = File.OpenWrite(path))
{
    byte[] data = new byte[] { 1, 2, 3 };
    fileStream.Write(data, 0, 3);
}

移动文件指针

using (FileStream fileStream = new FileStream(@"D:/test.txt", FileMode.Create))
{
    //移动文件内部指针（从文件头开始）
    fileStream.Seek(8, SeekOrigin.Begin);
    //设置数据
    byte[] data = new byte[2] { 1, 2 };
    fileStream.Write(data, 0, 2);
}

预定义内部文件指针位置SeekOrigin支持的值：

public enum SeekOrigin
{
    //流的开始位置
    Begin = 0,
    //流中的当前位置
    Current = 1,
    //流的末尾
    End = 2
}

获得文件流的名称

string filePath = @"D:\test.txt";
//打开文件
using (FileStream fs = File.OpenRead(filePath))
{
    //获得文件流的名称
    Console.WriteLine(fs.Name);
}

获得文件流的长度

string filePath = @"D:\test.txt";
//打开文件
using (FileStream fs = File.OpenRead(filePath))
{
    //获得文件流的长度
    Console.WriteLine(fs.Length);
}

获得文件流当前指针位置

string filePath = @"D:\test.txt";
//打开文件
using (FileStream fs = File.OpenRead(filePath))
{
    //获得文件流的当前指针的位置
    Console.WriteLine(fs.Position);
}

检测文件流是否可读

string filePath = @"D:\test.txt";
//打开文件
using (FileStream fs = File.OpenRead(filePath))
{
    //检测文件流是否可读
    Console.WriteLine("CanRead {0}", fs.CanRead);
}

检测文件流是否可写

string filePath = @"D:\test.txt";
//打开文件
using (FileStream fs = File.OpenRead(filePath))
{
    //检测文件流是否可写
    Console.WriteLine("CanWrite {0}", fs.CanWrite);
}

检测文件流是否可查找

string filePath = @"D:\test.txt";
//打开文件
using (FileStream fs = File.OpenRead(filePath))
{
    //检测文件流是否可查找
    Console.WriteLine("CanSeek {0}", fs.CanSeek);
}

检测文件流操作是否可以超时

string filePath = @"D:\test.txt";
//打开文件
using (FileStream fs = File.OpenRead(filePath))
{
    //检测文件流操作是否可以超时
    Console.WriteLine("CanTimeout {0}", fs.CanTimeout);
}

检测文件流是否异步流

string filePath = @"D:\test.txt";
//打开文件
using (FileStream fs = File.OpenRead(filePath))
{
    //检测文件流是否异步流
    Console.WriteLine("IsAsync {0}", fs.IsAsync);
}

刷新缓冲

string filePath = @"D:\test.txt";
//打开文件
using (FileStream fs = File.OpenRead(filePath))
{
    //刷新缓冲
    fs.Flush();
}

锁定文件流

string filePath = @"D:\test.txt";
//打开文件
using (FileStream fs = File.OpenRead(filePath))
{
    //锁定文件流
    fs.Lock(0, 10);
}

解锁文件流

string filePath = @"D:\test.txt";
//打开文件
using (FileStream fs = File.OpenRead(filePath))
{
    //解锁文件流
    fs.Unlock(0, 10);
}

获得/设置写入超时时间

string filePath = @"D:\test.txt";
//打开文件
using (FileStream fs = File.OpenRead(filePath))
{
    if (fs.CanTimeout)
    {
        //设置写入超时时间
        fs.WriteTimeout = 10000;
        //获得写入超时时间
        Console.WriteLine(fs.WriteTimeout);
    }
}

获得/设置读取超时时间

string filePath = @"D:\test.txt";
//打开文件
using (FileStream fs = File.OpenRead(filePath))
{
    if (fs.CanTimeout)
    {
        //设置读取超时时间
        fs.ReadTimeout = 10000;
        //获得读取超时时间
        Console.WriteLine(fs.ReadTimeout);
    }
}

BufferedStream类

说明

临时流

其他流的缓冲器流

主要成员

MemorySteam类

说明

内存流

支持随机访问

和文件流不同，MemoryStream类表示的是保存在内存中的数据流

由内存流封装的数据可以在内存中直接访问

内存流一般用于暂时缓存数据以降低应用程序中对临时缓冲区和临时文件的需要

既然字节数组也在内存中存储，为什么还要引入内存流的概念

这是因为内存流和字节数组虽然都位于程序缓冲区，但是具有不同的特性

内存流相对于字节数组而言，具有流特有的特性，并且容量可自动增长

在数据加密以及对长度不定的数据进行缓存等场合，使用内存流比较方便

Memorystream支持对数据流的查找和随机访问，该对象的CanSeek属性值为true

程序中可通过访问Position属性获取内存流的当前位置

构造函数

MemoryStream类的构造函数有多种重载形式，常用的有以下3种

MemoryStream()

该构造函数初始分配的容量大小为,随着数据的不断写入，其容量可以不断地自动扩展。

一般在数据内容及大小都不确定的场合下使用这种形式。

MemoryStream(Byte[])

MemoryStream的无参数构造函数不同，通过该构造函数获取

的MemoryStream实例根据Byte类型的字节数组进行初始化

并且实例的容量大小固定为字节数组的长度。

由于实例的容量不能扩展，该构造函数般用于数据不发生变化的场合。例如：

string testdata = "测试数据";
Byte[] bytes = new Byte[Encoding.UTF8.GetByteCount(testdata)];
MemoryStream mem =new MemoryStream(bytes);

MemoryStream(int capacity)

通过该构造函数创建初始容量大小为capacity的实例，并且实例容量大小可扩展

读写数据

MemoryStream的Wirte及Read方法和FileStream的用法基本相同

MemoryStream类的常用属性

CanRcad 获取一个值，该值指示当前流是否支持读取

CanWrite 获取一个值，该值指示当前流是否支持写人

CanSeek 获取一个值，该值指示当前流是否支持查找

Capacity 获取或设置分配给该流的字节数

Length 获取用字节表示的流长度

Position 获取或设置流中的当前位置

RcadTimcout 获取或设置一个值(以毫秒为单位)

该值确定流在超时前尝试读取多长时间

WriteTimeout 获取或设置一个值(以毫秒为单位)

该值确定流在超时前尝试写入多长时间

CanTimeout 获取一个值，该值确定当前流是否可以超时

Networkstream类

说明

在网络上传输数据时，使用的是网络流(Networkstream)

网络流的意思是数据在网络的各个位置之间是以连续的字节形式传输的

为了处理这种流，C#在System.Net.Sockets命名空间中提供了一个Networkstream类用于发送和接收网络数据

可以将Networkstream看作在数据来源端和接收端之间架设了一个数据通道

这样一来，读取和写入数据就可以针对这个通道来进行

需要注意的是.Networkstream类仅支持面向连接的套接字

对于Networkstream流，写入操作是指从来源端内存缓冲区到网络上的数据传输；

读取操作是从网络上到接收端内存缓冲区(如字节数组)的数据传

构建NetworkStream

一旦构造了一个Networkstream对象，就可以使用它发送和接收网络数据

获取 Networkstream 对象

利用TcpClient获取网络流对象

TcpClient tcpClient=new TcpClient();
tcpClient.Connect("Panda666.com",51888);
Networkstream  networkStream = client.GetStream();

利用Socket获取网络流对象

NetworkStream myNetworkstream = new Networkstream (mySocket);

利用Networkstream对象发送数据

Networkstream类的Write、Read方法的语法格式和文件流相同

Networkstream类的Write()方法

byte[] myWriteBuffer = Encoding.ASCII.GetByties("Areyoureceivingthismessage?");
myNetworkStream.Write(myWriteBuffer,0,myWriteBuffer.Length);

Networkstream类的Read()方法

byte[] myReadBuffer = new byte(1024);
StringBuilder myCompleteMessage = new StringBuilder( );
int numberOfBytesRead = 0;
//准备接收的信息有可能会大于1024,所以要用循环
do{
    numberOfBytesRead = myNetworkStream.Read(myReadBuffer, 0, myReadBuffer.Length);
    myCompleteMessage.AppendFormat("{0}", Encoding.ASCII.GetString(myReadBuffer, 0, numberOfBytesRead));
}while(myNetworkStream.DataAvailable);

NetworkStream类的常用属性和方法

CanRead属性指示Networkstream是否支持读操作

CanWrite属性指示Network Stream是否支持写操作

CanSeek属性指示Networkstream流是否支持杳找，该属性总是返I可false

DataAvaiiable属性指示Networkstream上是否有可用的数据，有则为真

Position属性获取或设置流中的当前位置,此属性始终引发NotSupportedException

Readable属性指示Networkstream流是否可读，为 true时可读

Writeable属性指示Networkstream流是否可写，

为 true时可写 Read方法从 Networkstream流中读取数据

Write方法向Networkstream流中写入数据

Close方法关闭 Networkstream 对象

BeginRead方法从 Networkstream流开始异步读取

BeginWrite 方法开始向Networkstream流异步写入

EndRead方法结束对一个NetworkStream流的异步读取

EndWrite 方法结束向一个NetworkStream流的异步写入

Dispose方法释放NetworkStream占用的资源

Seek方法查找NetworkStream流的当前位置

此方法将引发NotSupportedException

使用NetworkStream对象时注意

(1)通过DataAvailable属性，可以迅速查看在缓冲区中是否有数据等待读出。

(2)网络流没有当前位置的概念，因此它不支持对数据流的查找和随机访问，Networkstream对象的CanSeek属性始终返回 false, 读取Position属性和调用Seek方法时,都会引发NotSupportedException异常。

(3)网络数据传输完成后，不要忘记用Close方法关闭Networkstream对象

TextReader类

说明

文本读取器的抽象基类

主要成员

TextWriter类

说明

文本写入器的抽象基类

主要成员

StreamReader类

说明

文本读取器，基于物理文件，不支持随机访问

Networkstream类、MemoryStream类和FileStream类都提供了

以字节为基本单位的读写方法，但是这种方法需要首先将待写入的数据转化为字节序列后才能进行一读写，

当操作的是使用字符编码的文本数据时，使用很不方便。

因此，在操作文本数据时，一般使用Streamwriter、StreamReader执行这些功能。

这是因为Stream类操作的是字节和字节数组，而StreamWriter类与StreamReader类自身对底层的转换进行了封装，

使开发人员直接操作的就是字符数据，更易于使用。

StreamReader类主要完成以一种特定的编码从流中读取字符的功能

一般用于对文本数据的读操作

Streamwriter类则主要以特定的编码向流中写入字符

一般用于对文本数据的写操作

主要成员

Read

ReadLine

ReadBlock

ReadToEnd

常用的构造函数

StreamWriter(Stream stream)

StreamWriter不仅能对FileStream对象进行封装
而且能够对NetWorkStream、MemeryStream等继承于Stream类的流对象进行封装
如果已经有了Stream对象,可以直接使用流对象创建StreamWriter对象
由于FileStream类是Stream类的扩充类，因此，利用FileStream对象，
就可以直接使用流对象创建StreamWriter对象。例如：

FileStream fs = new FileStream(filePath,FileMode.Open,FileAccess.ReadWrite);
Streamwriter sw = new Streamwriter(fs);

同样道理，如果已经有了网络流对象，也可以直接使用它创建Streamwriter对象

例如：

Networkstream networkstream = client.Getstream();
Streamwriter sw = new Streamwriter(networkstream);

StreamWriter(String path)

如果需要处理的是文件流，则可直接利用文件路径创建一个以UTF8编码的StreamWriter对象

例如：

StreamWriter sw = new StreamWriter(@"C:/abc.txt");

与该方法等价的有File及Fileinfo类提供的CreateText方法。

例如：

StreamWriter sw = File.CreateText(@"C:/abc.txt");

常用方法

设置读取编码

string path = @"C:\Users\pxdwo\Downloads\text.txt";
using (FileStream fileStream = new FileStream(path,FileMode.OpenOrCreate))
{
    //设置编码
    using(StreamReader streamReader = new StreamReader(fileStream,Encoding.UTF8))
    {

    }
}

读取文本文件的内容（行读取）

string path = @"C:\Users\pxdwo\Downloads\text.txt";
//读取文本文件内容
using (StreamReader streamReader = new StreamReader(path))
{
    while (!streamReader.EndOfStream)
    {
        Console.WriteLine(streamReader.ReadLine());
    }
}

读取文本文件的内容（字符读取）

string path = @"C:\Users\pxdwo\Downloads\text.txt";
//读取文本文件内容
using (StreamReader streamReader = new StreamReader(path))
{
    while(!streamReader.EndOfStream)
    {
        Console.WriteLine(Char.ConvertFromUtf32(streamReader.Read()));
    }
}

读取文本文件的内容（字符读取）（指定个数）

string path = @"C:\Users\pxdwo\Downloads\text.txt";
//读取文本文件内容
using (StreamReader streamReader = new StreamReader(path))
{
    char[] result = new char[10];
    streamReader.Read(result, 0, 10);
    foreach (char item in result)
    {
        Console.Write(item);
    }
}

一次性读取所有内容

string path = @"C:\Users\pxdwo\Downloads\text.txt";
//读取文本文件内容
using (StreamReader streamReader = new StreamReader(path))
{
    //一次性读取所有字符
    string result = streamReader.ReadToEnd();
    Console.WriteLine(result);
}

StreamWriter类

说明

写入器文本
基于物理文件
不支持随机访问
StreamWriter默认使用UTF8编码

主要成员

Write
WriteLine
NewLine
Encoding
Flush
Close
Formatprovider

常用属性

常用方法

写入数据

Write()

向数据流写入数据

Write()方法只是把传送给它的字符串写入流，但不追加换行符

因此可以使用Write语句写入完整的句子或段落

WriteLine()

向数据流写入指定数据和一个换行符

关闭流

StreamWriter对象使用完毕后，需要调用Close方法关闭

Close()

写入数据

下面的代码首先利用StreamWriter对网络流进行封装，

然后利用StramWriter实例的WriteLine向网络写入一条消息，

可以看出相对于利用NetwrokStream的 Write方法操作Byte类型的数组来说，

StreamWriter用起来更方便

StreamWriter sw = new StreamWriter(myNetworkStream);
if(myNetworkStream.CanWrite)
{
    sw.WriteLine("Are you receiving this message?");
}
else
{
    Console.WriteLine("Sorry. You cannot write to this Networkstream"); 
}

设置为追加内容

string path = @"C:\Users\pxdwo\Downloads\text.txt";
//写入(追加)内容到文本文件
using (StreamWriter streamWriter = new StreamWriter(path,true))
{

}

设置文件的编码

string path = @"C:\Users\pxdwo\Downloads\text.txt";
using (FileStream fileStream = new FileStream(path,FileMode.OpenOrCreate))
{
    //设置编码
    using(StreamWriter streamWriter = new StreamWriter(fileStream, Encoding.UTF8))
    {

    }
}

写入内容到文本文件（写入行）

string path = @"C:\Users\pxdwo\Downloads\text.txt";
//写入内容到文本文件
using (StreamWriter streamWriter = new StreamWriter(path))
{
    streamWriter.WriteLine("Panda666.com");
    streamWriter.WriteLine("Panda666.com");
    streamWriter.WriteLine("Panda666.com");
    streamWriter.WriteLine("Panda666.com");
}

写入内容到文本文件（写入字符）

string path = @"C:\Users\pxdwo\Downloads\text.txt";
//写入内容到文本文件
using (StreamWriter streamWriter = new StreamWriter(path))
{
    //写入整形
    streamWriter.Write(1666);
    //写入浮点型
    streamWriter.Write(166.66);
    //写入字符串
    streamWriter.Write("Abc");
    //写入字符
    streamWriter.Write('d');
    //写入换行
    streamWriter.Write(streamWriter.NewLine);
    streamWriter.Write("EEE");
}

一次性写入所有字符串

BinaryReader类

说明

读取器二进制

为了操作图像、压缩文件等二进制流文件

System.IO还提供了BinaryReader类和BinaryWriter类，用于以二进制模式读写流

对于每个读方法，都有一个与之对应的写方法，比如针对不同的数据结构，

BinaryReader 类提供了 ReadByte、ReadBoolean s Readlnt、Readlntl6、ReadDouble、ReadString等方法与之对应BinaryWriter类则提供了多个重载的Write方法，分别对应上面的读方法。例如，当 Write方法传递的参数为Int32类型时，利用BinaryWriter类的Write方法可以将int32类型数据转化为长度为4的字节数组，并将字节流传递给一个Stream对象意味这写入什么类型的数据，读取就用什么类型去读取

主要成员

Read
ReadByte
ReadBytes
ReadChar
ReadChars
ReadInt32
ReadString
ReadBoolean
PeekChar
Close

常用方法

读取文件中的二进制内容

using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
namespace PandaNamespace
{
    class PandaClass
    {
        static void Main(string[] args)
        {
            string path = "D:/test.txt";

            using(FileStream fileStream = new FileStream(path, FileMode.OpenOrCreate))
            {
                using (BinaryReader binaryReader = new BinaryReader(fileStream))
                {
                    binaryReader.ReadString();
                }
            }
            Console.ReadKey();
        }
    }
}

BinaryWriter类

说明

写入器二进制

主要成员

Write
Seek
Flush
Close

常用方法

写入二进制内容到文件中

using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
namespace PandaNamespace
{
    class PandaClass
    {
        static void Main(string[] args)
        {
            string path = "D:/test.txt";

            using(FileStream fileStream = new FileStream(path, FileMode.OpenOrCreate))
            {
                using(BinaryWriter binaryWriter = new BinaryWriter(fileStream))
                {
                    binaryWriter.Write("Hello Panda666 ");
                    binaryWriter.Write("Hello Panda666 ");
                    binaryWriter.Flush();
                }
            }
            Console.ReadKey();
        }
    }
}

StringReader类

说明

读取器文本

基于字符串缓冲区

不支持随机访问

主要成员

Read

ReadLine

ReadBlock

ReadToEnd

StringWriter类

说明

写入器文本

基于字符串缓冲区

不支持随机访问

主要成员

Write

WriteLine

NewLine

Encoding

Flush

Formatprovider

实例

DeflateStream类

说明

压缩解压缩gzip

命名空间：System.IO.Compression

解压文件

压缩文件

GZipStream类

说明

压缩解压缩gzip

命名空间：System.IO.Compression

解压文件

压缩文件

ZipArchive类

说明

压缩解压缩zip

程序集：System.IO.Compression

命名空间：System.IO.Compression

解压文件

压缩文件

实例

递归遍历所有文件夹

递归遍历所有文件

递归遍历所有文件夹和文件

压缩&解压缩

基础

介绍

.NET中预定义了一些用于压缩和解压缩文件的类型

所在命名空间

using System.IO.Compression;

DeflateStream类型

说明

DeflateStream类型使用Deflate压缩算法进行文件压缩和解压缩操作

在.NET框架内部使用zlib实现DeflateStream类型

所在命名空间

using System.IO.Compression;

实例：压缩文件

using System;
using System.IO;
using System.IO.Compression;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //被压缩文件的路径
            string inputFilePath = @"E:\sss.docx";
            //压缩完成的文件存放路径
            string outputFilePath = @"E:\compressed.def";

            //打开输出流
            using(FileStream inputFileStream = new FileStream(inputFilePath,FileMode.Open))
            {
                //打开输出流
                using(FileStream outputFileStream = new FileStream(outputFilePath,FileMode.Create))
                {
                    //建立deflate压缩流对象
                    using (DeflateStream deflateStream = new DeflateStream(outputFileStream,CompressionLevel.Optimal))
                    {
                        //将数据从输入流读入
                        inputFileStream.CopyTo(deflateStream);
                    }
                }
            }

            //wait
            Console.WriteLine("Success");
            Console.ReadKey();
        }
    }
}

实例：解压文件

using System;
using System.IO;
using System.IO.Compression;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //需要解压缩文件的路径
            string inputFilePath = @"E:\compressed.def";
            //解缩完成的文件存放路径
            string outputFilePath = @"E:\sss.docx";

            //打开输出流
            using(FileStream inputFileStream = new FileStream(inputFilePath,FileMode.Open))
            {
                //打开输出流
                using(FileStream outputFileStream = new FileStream(outputFilePath,FileMode.Create))
                {
                    //建立deflate压缩流对象
                    using (DeflateStream deflateStream = new DeflateStream(inputFileStream,CompressionMode.Decompress))
                    {
                        //数据写入到输出流
                        deflateStream.CopyTo(outputFileStream);
                    }
                }
            }

            //wait
            Console.WriteLine("Success");
            Console.ReadKey();
        }
    }
}

ZipArchive类型

说明

ZipArchive类型支持对zip压缩文件的管理

压缩文件内的每个文件使用ZipArchiveEntity类型表示

实例：压缩文件

using System;
using System.IO;
using System.IO.Compression;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //压缩完成后文件存放位置
            string outputFilePath = @"E:\cc.zip";
            //需要被压缩的文件1路径
            string needBeCompressFile1Path = @"E:\1.docx";
            //需要被压缩的文件2路径
            string needBeCompressFile2Path = @"E:\2.docx";

            //创建输出流
            using (FileStream outputFileStream = new FileStream(outputFilePath,FileMode.Create))
            {
                //创建压缩文件流
                using(ZipArchive zipArchive = new ZipArchive(outputFileStream,ZipArchiveMode.Create))
                {
                    //添加文件到压缩包中
                    zipArchive.CreateEntryFromFile(needBeCompressFile1Path, "文件1.docx");
                    //添加文件到压缩包中（自定义层次文件夹）
                    zipArchive.CreateEntryFromFile(needBeCompressFile2Path, "文件夹1/文件2.docx");
                    //添加流到压缩包中
                    ZipArchiveEntry zipArchiveEntry = zipArchive.CreateEntry("文件夹2/文件3.txt");
                    //建立流
                    using(Stream stream = zipArchiveEntry.Open())
                    {
                        //建立写入流
                        using(StreamWriter streamWriter = new StreamWriter(stream))
                        {
                            streamWriter.WriteLine("Panda666.com");
                        }
                    }
                }
            }

            //wait
            Console.WriteLine("Success");
            Console.ReadKey();
        }
    }
}

实例：解压文件

using System;
using System.IO;
using System.IO.Compression;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //压缩包文件存放位置
            string inputFilePath = @"E:\cc.zip";
            //解压完成文件存储的文件夹
            string fileSaveDirectoryPath = @"E:\";
            //创建输入流
            using (FileStream inputFileStream = new FileStream(inputFilePath,FileMode.Open))
            {
                //创建压缩文件流(读取)
                using(ZipArchive zipArchive = new ZipArchive(inputFileStream, ZipArchiveMode.Read))
                {
                    //依次读取所有文件
                    foreach (ZipArchiveEntry item in zipArchive.Entries)
                    {
                        //将文件打开成流
                        using (Stream stream = item.Open())
                        {
                            //写入文件到输出流
                            using(FileStream saveFileStream = File.Create(Path.Combine(fileSaveDirectoryPath, item.Name)))
                            {
                                stream.CopyTo(saveFileStream);
                            }
                        }
                    }
                }
            }

            //wait
            Console.WriteLine("Success");
            Console.ReadKey();
        }
    }
}

GZipStream类型

说明

用于处理GZip压缩文件

实例：压缩文件

using System;
using System.IO;
using System.IO.Compression;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //被压缩文件存放位置
            string inputFilePath = @"E:\input.docx";
            //压缩完成文件存储位置
            string fileSavePath = @"E:\cc.gz";

            //建立输出流
            using (FileStream outputFileStream = new FileStream(fileSavePath, FileMode.Create))
            {
                //建立压缩流
                using(GZipStream gZipStream = new GZipStream(outputFileStream,CompressionMode.Compress))
                {
                    
                    //建立输入流
                    using (FileStream inputFileStream = new FileStream(inputFilePath,FileMode.Open))
                    {
                        inputFileStream.CopyTo(gZipStream);
                    }
                }
            }

            //wait
            Console.WriteLine("Success");
            Console.ReadKey();
        }
    }
}

实例：解压文件

using System;
using System.IO;
using System.IO.Compression;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //压缩包文件存放位置
            string inputFilePath = @"E:\cc.gz"; 
            //解压缩完成文件存储位置
            string fileSavePath = @"E:\output.docx";

            //建立输入流
            using (FileStream inputFileStream = new FileStream(inputFilePath, FileMode.Open))
            {
                //建立压缩流
                using(GZipStream gZipStream = new GZipStream(inputFileStream, CompressionMode.Decompress))
                {
                    //建立输出流
                    using (FileStream outputFileStream = new FileStream(fileSavePath, FileMode.Create))
                    {
                        gZipStream.CopyTo(outputFileStream);
                    }
                }
            }

            //wait
            Console.WriteLine("Success");
            Console.ReadKey();
        }
    }
}

命名管道

基础

说明

命名管道是一种简单易用的通信方式

支持在同一台计算机或不同计算机上进程与进程间通信

所在命名空间

using System.IO.Pipes;

NamedPipeServerStream类型表示通信中的服务器

实例化该类型后需要调用WaitForConnection/WaitForConnectionAsync方法

来侦听客户端连接

NamedPipeClientStream类型表示通信中的客户端

实例化该类型后需要调用Connect方法来向服务器发起连接

以上2个类型都继承自Stream类型

实例：客户端与服务器通信使用命名管道（本地）

说明

项目1：服务器端项目，用于侦听客户的连接

项目2：客户端项目，用于向服务器发起连接

注意：2个项目都需要启动才能正常工作

项目1代码：服务器端

using System;
using System.IO;
using System.IO.Pipes;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("===========服务器端===========");

            //新建命名管道服务器端
            using (NamedPipeServerStream namedPipeServerStream = new NamedPipeServerStream("Panda"))
            {
                //等待客户连接
                namedPipeServerStream.WaitForConnection();

                //读取客户端发来的消息
                try
                {
                    using (StreamReader streamReader = new StreamReader(namedPipeServerStream))
                    {
                        //存储消息的变量
                        string message = string.Empty;
                        //读取数据
                        while ((message = streamReader.ReadLine()) != null)
                        {
                            Console.WriteLine($"客户端发来数据:{message}");
                        }
                    }
                }
                catch
                {
                    Console.WriteLine("发生错误");
                }
                Console.WriteLine("按任意键退出服务器");
                Console.ReadKey();
            }

            //wait
            Console.WriteLine("Success");
            Console.ReadKey();
        }
    }
}

项目2代码：客户端

using System;
using System.IO;
using System.IO.Pipes;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("===========客户端===========");
            //新建命名管道客户端端
            using (NamedPipeClientStream namedPipeClientStream = new NamedPipeClientStream("Panda"))
            {
                //连接到服务器端
                namedPipeClientStream.Connect();

                //写入要发送的消息
                using(StreamWriter streamWriter = new StreamWriter(namedPipeClientStream))
                {
                    //每次写入后就进行更新发送
                    streamWriter.AutoFlush = true;
                    while (true)
                    {
                        string message = Console.ReadLine();
                        if(!string.IsNullOrEmpty(message))
                        {
                            streamWriter.WriteLine(message);
                        }
                    }
                }
            }

            //wait
            Console.WriteLine("Success");
            Console.ReadKey();
        }
    }
}

实例：客户端与服务器通信使用命名管道（远程）

说明

项目1：服务器端项目，用于侦听客户的连接

项目2：客户端项目，用于向服务器发起连接

注意：2个项目都需要启动才能正常工作

项目1代码：服务器端

using System;
using System.IO;
using System.IO.Pipes;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("===========服务器端===========");

            //新建命名管道服务器端
            using (NamedPipeServerStream namedPipeServerStream = new NamedPipeServerStream("Panda",PipeDirection.In))
            {
                //等待客户连接
                namedPipeServerStream.WaitForConnection();

                //读取客户端发来的消息
                try
                {
                    using (StreamReader streamReader = new StreamReader(namedPipeServerStream))
                    {
                        //存储消息的变量
                        string message = string.Empty;
                        //读取数据
                        while ((message = streamReader.ReadLine()) != null)
                        {
                            Console.WriteLine($"客户端发来数据:{message}");
                        }
                    }
                }
                catch
                {
                    Console.WriteLine("发生错误");
                }
                Console.WriteLine("按任意键退出服务器");
                Console.ReadKey();
            }

            //wait
            Console.WriteLine("Success");
            Console.ReadKey();
        }
    }
}

项目2代码：客户端

using System;
using System.IO;
using System.IO.Pipes;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("===========客户端===========");
            //新建命名管道客户端端
            //指定了服务器端的IP地址
            using (NamedPipeClientStream namedPipeClientStream = new NamedPipeClientStream("localhost","Panda",PipeDirection.Out))
            {
                //连接到服务器端
                namedPipeClientStream.Connect();

                //写入要发送的消息
                using (StreamWriter streamWriter = new StreamWriter(namedPipeClientStream))
                {
                    //每次写入后就进行更新发送
                    streamWriter.AutoFlush = true;
                    while (true)
                    {
                        string message = Console.ReadLine();
                        if (!string.IsNullOrEmpty(message))
                        {
                            streamWriter.WriteLine(message);
                        }
                    }
                }
            }

            //wait
            Console.WriteLine("Success");
            Console.ReadKey();
        }
    }
}

读写内存映射文件

说明

内存映射文件是在应用程序内存空间内划分一块特殊的内存区域

然后可以像操作文件一样在内存中新建和读写文件

内存映射文件也可以用于在多个进程之间共享数据

所在命名空间

using System.IO.MemoryMappedFiles;

新建内存文件

//定义内存文件（新建文件）
MemoryMappedFile memoryMappedFile1 = MemoryMappedFile.CreateNew("PandaMFile", 3000L);

//定义内存文件（从已有的文件读取）
string filePath = @"‪E:\PandaText.txt";‬
MemoryMappedFile memoryMappedFile2 = MemoryMappedFile.CreateFromFile(filePath);

写入内容到内存文件

using System;
using System.IO;
using System.IO.MemoryMappedFiles;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //定义内存文件（新建文件）
            MemoryMappedFile memoryMappedFile1 = MemoryMappedFile.CreateNew("PandaMFile", 3000L);

            //写入内容到内存文件
            using(var mStream1 = memoryMappedFile1.CreateViewStream())
            {
                //新建写入流
                using(StreamWriter streamWriter = new StreamWriter(mStream1))
                {
                    //写入内容
                    streamWriter.WriteLine("Panda666.com");
                }
            }

            //wait
            Console.WriteLine("Success");
            Console.ReadKey();
        }
    }
}

读取内存文件的内容

using System;
using System.IO;
using System.IO.MemoryMappedFiles;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //定义内存文件（新建文件）
            MemoryMappedFile memoryMappedFile1 = MemoryMappedFile.CreateNew("PandaMFile", 3000L);

            //写入内容到内存文件
            using(var mStream1 = memoryMappedFile1.CreateViewStream())
            {
                //新建写入流
                using(StreamWriter streamWriter = new StreamWriter(mStream1))
                {
                    //写入内容
                    streamWriter.WriteLine("Panda666.com");
                }
            }

            //读取内存文件的内容
            using(MemoryMappedFile needOpenMFile = MemoryMappedFile.OpenExisting("PandaMFile"))
            {
                //新建内存文件流
                using(var mFileStream = needOpenMFile.CreateViewStream())
                {
                    //新建文件读取器
                    using(StreamReader streamReader = new StreamReader(mFileStream))
                    {
                        //读取文件
                        string data = streamReader.ReadLine();
                        Console.WriteLine(data);
                    }
                }
            }

            //wait
            Console.WriteLine("Success");
            Console.ReadKey();
        }
    }
}

从已存在文件读入到内存中进行读写

using System;
using System.IO;
using System.IO.MemoryMappedFiles;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {

            //定义内存文件（从已有的文件读取）
            string filePath = @"E:\PandaText.txt";
            MemoryMappedFile memoryMappedFile2 = MemoryMappedFile.CreateFromFile(filePath,FileMode.Open,"PandaFile");

            //读取内存文件的内容
            using(MemoryMappedFile needOpenMFile = MemoryMappedFile.OpenExisting("PandaFile"))
            {
                //新建内存文件流
                using(var mFileStream = needOpenMFile.CreateViewStream())
                {
                    //新建文件读取器
                    using(StreamReader streamReader = new StreamReader(mFileStream))
                    {
                        //读取文件
                        string data = streamReader.ReadToEnd();
                        Console.WriteLine(data);
                    }
                }
            }

            //wait
            Console.WriteLine("Success");
            Console.ReadKey();
        }
    }
}

将内存映射文件写入到磁盘中

内存中的数据断电后就会消失，为了持久化数据，需要将数据写入到磁盘中

using System;
using System.IO;
using System.IO.MemoryMappedFiles;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {

            //定义内存文件（从已有的文件读取）
            string filePath = @"E:\PandaText.txt";
            MemoryMappedFile memoryMappedFile2 = MemoryMappedFile.CreateFromFile(filePath,FileMode.Open,"PandaFile");

            //写入内容到内存文件
            using (var mStream1 = memoryMappedFile2.CreateViewStream())
            {
                //新建写入流
                using (StreamWriter streamWriter = new StreamWriter(mStream1))
                {
                    //写入内容
                    streamWriter.WriteLine("panda666.com");
                }
            }

            //wait
            Console.WriteLine("Success");
            Console.ReadKey();
        }
    }
}

posted @ 2022-10-04 08:33 重庆熊猫阅读(470) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

重庆熊猫 Loading

重庆熊猫

wx：wdfysoft

.NET教程 - 文件 & 流 & 压缩（File & Stream & Compress）

文件I/O基础（File I/O）

文件概念

Windows系统平台文件权限说明

.NET中主要的命名空间

.NET中文件处理主要的类

文件流

概念

文件流操作

常见的支持流读写的类

System.Environment

说明

获得程序当前文件夹

获得当前运行的计算机名称

获得当前操作系统的版本信息

获得当前操作程序的用户的用户名称

获得当前主机的域名

获得当前的CLR版本信息

通用换行

设置和获取退出代码

终止当前程序

获得所有命令行的参数

获得指定的命令行参数

获得各驱动器的名称

获得Windows系统各种预设文件夹完整路径

获得当前系统驱动器列表

检测当前是否为64位系统

检测当前进程是否为64位进程

设置/创建/修改环境变量的值

获得当前硬件上的处理器数量

获得操作系统的内存页字节数量

获得系统启动后经过的毫秒数

获得CLR的版本

获得用户关联的主机网络域名

获得用户是否在交互环境中

获得当前登录到系统的用户的用户名

FileMode类

说明

主要成员说明

打开文件

打开文件或者创建

创建新文件

追加文件

创建文件

创建文件

FileAccess类

说明

只读打开文件

只写打开文件

读写打开文件

FileAttributes类

说明

FileShare类

说明

官方文档

SearchOption类

说明

官方文档

SeekOrigin类

说明

官方文档

DriveInfo类

说明

主要成员

实例

获得系统中所有驱动器1

获得系统中所有驱动器2

File类

说明

与FileInfo如何选择

主要成员

创建文件

复制文件

移动文件

删除文件

获得文件属性信息

设置文件属性信息