DriveInfo[] drivers = DriveInfo.GetDrives();
foreach(DriveInfo driver in drivers)
{
    if(driver.DriveType == DriveType.Fixed && driver.DriveFormat == "NTFS")
    {
        Console.WriteLine("在{0}驱动器上还有{1}字节的剩余空间。", driver.Name, driver.AvailableFreeSpace);
    }
}
Console.ReadLine();

Directory.CreateDirectory(@"d:\C#程序设计");
if(Directory.Exists(@"d:\C#程序设计"))
{
    Console.WriteLine("创建成功");
}
Directory.Delete(@"d:\C#程序设计");
if (!Directory.Exists(@"d:\C#程序设计"))
{
    Console.WriteLine("删除成功");
}

DirectoryInfo dir = new DirectoryInfo(@"d:\C#程序设计");
if (!dir.Exists)
{
    dir.Create();
}
else
{
    Console.WriteLine("该目录已经存在");
}

 //设置所要创建文件的绝对路径
string path = @"d:\test.txt";
//以路径为参数创建文件
File.Create(path);

string path = @"c:\windows\System32\notepad.exe";
Console.WriteLine(Path.GetDirectoryName(path));
Console.WriteLine(Path.GetFileName(path));

//要写入文件的字符数组
char[] m_cDataWrite = new char[100];
//包含要写入该流的数据的缓冲区
byte[] m_bDataWrite = new byte[100];           
           
try
{
    //创建d:\file.txt的FileStream对象
    FileStream m_FileStream = new FileStream(@"d:\file.txt", FileMode.OpenOrCreate);
    //将要写入的字符串转换成字符数组
    m_cDataWrite = "test filestream".ToCharArray();
 
    //通过UTF-8编码方法将字符数组转成字节数组
    Encoder m_Enc = Encoding.UTF8.GetEncoder();
    m_Enc.GetBytes(m_cDataWrite, 0, m_cDataWrite.Length, m_bDataWrite, 0, true);
 
    //设置流当前位置为文件开始位置
    m_FileStream.Seek(0, SeekOrigin.Begin);
    //将字节数组中的内容写入文件
    m_FileStream.Write(m_bDataWrite, 0, m_bDataWrite.Length);
    if (m_FileStream != null)
    {
        //清除此流的缓冲区，使得所有缓冲的数据都写入到文件中
        m_FileStream.Flush();
        m_FileStream.Close();
    }
}
catch (Exception ex)
{
    Console.WriteLine("There is an IOException");
    Console.WriteLine(ex.Message);
}
Console.WriteLine("Write to File Succeed!");

//要写入文件的字符数组
char[] m_cDataWrite = new char[100];
//包含要写入该流的数据的缓冲区
byte[] m_bDataWrite = new byte[100];
 
try
{
    //创建d:\file.txt的FileStream对象
    FileStream m_FileStream = new FileStream(@"d:\file.txt", FileMode.Open);
 
    //设置流当前位置为文件开始位置
    m_FileStream.Seek(0, SeekOrigin.Begin);
    //将文件的内容存到字节数组中（缓存）
    m_FileStream.Read(m_bDataWrite, 0, 100);               
}
catch (Exception ex)
{
    Console.WriteLine("There is an IOException");
    Console.WriteLine(ex.Message);
}
 
//通过UTF-8编码方法将字符数组转换成字符数组
Decoder m_Dec = Encoding.UTF8.GetDecoder();
m_Dec.GetChars(m_bDataWrite, 0, m_bDataWrite.Length, m_cDataWrite, 0);
Console.WriteLine("Read from file Succeed!");
Console.WriteLine(m_cDataWrite);

try
{
    //保留文件现有数据，以追加写入的方式打开d:\file.txt文件
    StreamWriter m_SW = new StreamWriter(@"d:\file.txt", true);
    //向文件写入新字符串，并关闭StreamWriter
    m_SW.WriteLine("Another File Operation Method");
    m_SW.Close();               
}
catch (Exception ex)
{
    Console.WriteLine("There is an IOException");
    Console.WriteLine(ex.Message);
         }
  StreamWriter类提供了另一种从文件中读取数据的方法，下面演示其用法：
try
{
    //以绝对路径方式构造新的StreamReader对象
    StreamReader m_SR = new StreamReader(@"d:\file.txt");
 
    //用ReadToEnd方法将d:\file.txt中的数据全部读入到字符串m_Data中，并关闭StreamReader
    string m_Data = m_SR.ReadToEnd();
    m_SR.Close();
    Console.WriteLine(m_Data);
}
catch (Exception ex)
{
    Console.WriteLine("There is an IOException");
    Console.WriteLine(ex.Message);
}

FileStream m_FS = new FileStream(@"d:\data.dat", FileMode.Create);
//通过文件流创建相应的BinaryWriter
BinaryWriter m_BW = new BinaryWriter(m_FS);
for(int i = 0; i < 11; i++)
{
    //向d:\data.dat中写入数据
    m_BW.Write((int)i);
}
 
m_BW.Close();
m_FS.Close();

FileStream m_FS = new FileStream(@"d:\data.dat", FileMode.Open, FileAccess.Read);
//通过文件流创建相应的BinaryReader
BinaryReader m_BR = new BinaryReader(m_FS);
//从d:\data.dat中读取数据
for(int i = 0; i < 11; i++)
{
    Console.WriteLine(m_BR.ReadInt32());
}
 
m_BR.Close();
m_FS.Close();
 
Console.ReadLine();

const string _FILENAME = @"..\..\logfile.txt";
static void Main()
{
    //从指定的目录以打开或者创建的形式读取日志文件
    using (FileStream fs = new FileStream(_FILENAME, FileMode.OpenOrCreate, FileAccess.Write))
    {
        //创建日志文件的写入流
        StreamWriter sw = new StreamWriter(fs);
        //向日志文件写入日志信息
        Log("日志文件创建成功", sw);
        //关闭日志文件写入流
        sw.Close();
        Console.WriteLine("日志文件已创建");
    }
 
    //读取并显示日志文件
    using (StreamReader sr = new StreamReader(_FILENAME, Encoding.UTF8))
    {
        string strContent = sr.ReadToEnd();
        sr.Close();
        Console.WriteLine(strContent);
    }
 
    Console.ReadLine();
}
 
static void Log(String message, TextWriter tw)
{
    tw.Write("Log Entry:");
    tw.WriteLine("{0} {1}", DateTime.Now.ToLongTimeString(), DateTime.Now.ToLongDateString());
    tw.WriteLine(" :");
    tw.WriteLine(" :{0}", message);
            tw.WriteLine("----------------------------------");
            //将缓冲区中的内容更新到日志文件中
   tw.Flush();
}

//表示日志文件路径及文件名称的字符串
const string FILENAME = @"..\..\logfile.txt";
static void Main(string[] args)
{
    //写入日志信息
    WriteLogFile(FILENAME, "日志信息一");
    //读取日志文件
    Console.WriteLine(ReadLogFile(FILENAME));
    Console.ReadLine();
}
 
static string ReadLogFile(string FileNameWithPath)
{
    //从指定的目录以打开或创建的形式读取日志文件
    FileStream fs = new FileStream(FileNameWithPath, FileMode.OpenOrCreate, FileAccess.Read);
    //定义输出字符串
    StringBuilder output = new StringBuilder();
    //初始化该字符串的长度为0
    output.Length = 0;
    //为上面创建的文件流创建读取数据流
    StreamReader read = new StreamReader(fs);
    //设置当前流的起始位置为文件流的起始点
    read.BaseStream.Seek(0, SeekOrigin.Begin);
    //读取文件
    while(read.Peek() > -1)
    {
        //取文件的一行内容并换行
        output.Append(read.ReadLine() + "\n");
    }
    //关闭释放读数据流
    read.Close();
    //返回读到的日志文件内容
    return output.ToString();
}
 
static void WriteLogFile(string FileNameWithPath, string Message)
{
    //定义文件信息对象
    FileInfo finfo = new FileInfo(FileNameWithPath);
    //判断文件是否存在以及是否大于2K
    if(finfo.Exists && finfo.Length > 2048)
    {
        //删除该文件
        finfo.Delete();
    }
    //创建只写文件流
    using(FileStream fs = finfo.OpenWrite())
    {
        //根据上面创建的文件流创建写数据流
        StreamWriter w = new StreamWriter(fs);
        //设置写数据流的起始位置为文件流的末尾
        w.BaseStream.Seek(0, SeekOrigin.End);
        //写入"Log Entry:"
        w.Write("Log Entry:");
        //写入系统的当前时间并换行
        w.Write("{0} {1} \r\n", DateTime.Now.ToLongTimeString(), DateTime.Now.ToLongDateString());
        //写入日志内容并换行
        w.Write(Message + "\r\n");
        //写入-------------------------并换行
        w.Write("----------------------\r\n");
        //清空缓冲区内容，并把缓冲区内容写入基础流
        w.Flush();
        w.Close();
    }

//源文件路径及文件名
const string SOURCEFILENAME = @"..\..\myfile.txt";
//目标文件路径及文件名
const string DESTINATIONFILENAME = @"..\..\result.txt";
static void Main(string[] args)
{
    try
    {
        //判断源文件是否存在
        if(!File.Exists(SOURCEFILENAME))
        {
            Console.WriteLine("找不到源文件");
        }
        else if (File.Exists(DESTINATIONFILENAME))
        {
            Console.Write("目标文件已经存在，是否覆盖？(Y/N)");
            if(Console.ReadKey(false).Key == ConsoleKey.Y)
            {
                //覆盖文件
                File.Copy(SOURCEFILENAME, DESTINATIONFILENAME, true);
                Console.WriteLine("复制文件完成");
            }
            else
            {
                Console.WriteLine("取消复制文件");
            }
        }
        else
        {
            //直接复制
            File.Copy(SOURCEFILENAME, DESTINATIONFILENAME);
            Console.WriteLine("复制文件完成");
        }
    }
    catch (Exception)
    {
        Console.WriteLine("复制文件失败");
    }
    Console.ReadLine();
}

        static MemoryStream GetFileStream(string fileName)
        {
            FileStream sr = File.OpenRead(fileName);
            int byteLen = (int)sr.Length;
            byte[] fileBytes = new byte[byteLen];
            int bytesRead = sr.Read(fileBytes, 0, byteLen);
            MemoryStream stream = new MemoryStream(fileBytes);
            sr.Dispose();
            return stream;
        }