//假如目标目录不存在，创建它
     if(!destination.exists)
     {
          destination.create();
     }

     //复制所有文件
     fileinfo[] files = source.getfiles();
     foreach(fileinfo file in files)
     {
          //将文件复制到目标目录
          file.copyto(path.combine(destination.fullname,file.name), true);
     }

     //处理子目录
     directoryinfo[]dirs=source.getdirectories();
     foreach(directoryinfo dir in dirs)
     {
          string destination dir=path.combine(destination.fullname,dir.name);

          //递归处理子目录
          copydirectory(dir,newdirectoryinfo(destinationdir));
     }
}

 
问题10：如何获得计算机的所有逻辑驱动器；
解决方案：使用driveinfo类（需要.net2.0）
driveinfo.getdrives()：获得计算机的所有逻辑驱动器，返回类型为driveinfo[]；

问题11：如何获取指定驱动器的信息；
解决方案：
driveinfo.name：获取驱动器的名称（如c:）；
driveinfo.drivetype：获取驱动器的类型（如fixed，cdrom，removable，network等）；
driveinfo.driveformat：获取驱动器的格式（如ntfs，fat32，cdfs，udf等）；
driveinfo.isready：获取驱动器是否已预备好，比如cd是否已放入cd驱动器，假如驱动器没有预备好，访问其信息会引发ioexception类型异常；
driveinfo.availablefreespace：获取驱动器的可用空间；
driveinfo.totalfreespace：获取驱动器总的可用空间，它与availablefreespace的不同在于availablefreespace会磁盘配额的设置；
driveinfo.totalsize：获取驱动器总的空间；
driveinfo.rootdirectory：获得驱动器的根目录（directoryinfo类型）；

至此，我们已经了解了文件和目录相关的一些基本操作。

文件读写相关类介绍:
文件读写操作涉及的类主要是：
marshalbyrefobject类：答应在支持远程处理的应用程序中跨应用程序域边界访问对象；
binaryreader类：用特定的编码将基元数据类型读作二进制值。
binarywriter类：以二进制形式将基元类型写入流，并支持用特定的编码写入字符串。
stream类：提供字节序列的一般视图。
filestream类：公开以文件为主的stream，既支持同步读写操作，也支持异步读写操作。
memorystream类：创建其支持存储区为内存的流。
bufferedstream类：给另一流上的读写操作添加一个缓冲层。
textreader类：表示可读取连续字符系列的阅读器。
textwriter类：表示可以编写一个有序字符系列的编写器。
streamreader类：实现一个textreader，使其以一种特定的编码从字节流中读取字符。
streamwriter类：实现一个textwriter，使其以一种特定的编码向流中写入字符。
stringreader类：实现从字符串进行读取的textreader。
stringwriter类：实现一个用于将信息写入字符串的textwriter。该信息存储在基础stringbuilder中。
在使用它们之前最好能了解它们的继续关系，有助于作出最合适的选择：

另外还要注重一下fileinfo和file类的一些方法，如create，createtext，open等，有时也会带来方便。
这些类的内容比较繁多，更多内容还请参考msdn。

下面是一些常见的问题及其解决方案：
问题1：如何读写文本文件（并考虑不同的编码类型）；
解决方案：
创建一个filestream对象用以引用该文件。要写入文件，将filestream对象封装在streamwriter对象中，使用其重载了的write方法；要读取文件，将filestream对象封装在streamreader对象中，使用其read或readline方法；
.netframework答应通过streamwriter和streamreader类操作任何流来读写文本文件。当使用streamwriter类写入数据时，调用它的write方法，该方法在重载后可以支持所有常见的c#数据类型，包括字符串、字符、整数、浮点数以及十进制数等。但write方法总会将的得到的数据转换为文本，假如希望将这些文本转换回原来的数据类型，应使用writeline方法，以确保每个值都处于单独的一行上。
字符串的表现形式取决于你使用的编码，最常见的编码类型包括下面几种：ascii，utf-16，utf-7，utf-8。
.netframework在system.text命名空间中为每种编码类型提供了一个类。在使用streamwriter和streamreader类时，可以指定需要的编码类型，或者使用默认的utf-8。
而在读取文本文件时，则要使用streamreader类的read或readline方法。read方法读取单个字符或者指定个数的字符，返回类型为字符或字符数组；readline方法则返回包含整行内容的字符串；readtoend方法从当前位置读取至流的结尾。
（更多内容还请参考msdn）
写入文本文件的示例：  

using(filestream fs=new filestream(filename,filemode.create))
{
     //创建一个streamwriter对象，使用utf-8编码格式
     using(streamwriter writer=new streamwriter(fs,encoding.utf8))
     {
          //分别写入十进制数，字符串和字符类型的数据
          writer.writeline(123.45m);
          writer.writeline("stringdata");
          writer.writeline("a");
     }
}
 

读取文本文件的示例：
//以只读模式打开一个文本文件
using(filestream fs=new filestream(filename,filemode.open))
{
     using(streamreader reader = new streamreader(fs,encoding.utf8))
     {
          string text = string.empty;

          while(!reader.endofstream)
          {
               text=reader.readline();
               txtmessage.text =text environment.newline;
          }
     }
}
 

问题2：如何读写二进制文件（使用强数据类型）；
解决方案：
创建一个filestream对象用以引用该文件。要写入文件，将filestream对象封装在binarywriter对象中，使用其重载了的write方法；要读取文件，将filestream对象封装在binaryreader对象中，使用相应数据类型的read方法。
.netframework答应通过binarywriter和binaryreader类操作任何流来读写二进制数据。当使用binarywriter类写入数据时，调用它的write方法，该方法在重载后可以支持所有常见的c#数据类型，包括字符串、字符、整数、浮点数以及十进制数等，然后数据会被编码为一系列字节写入文件，也可以配置该过程中的编码类型。
在使用二进制文件时，一定要非凡注重其中的数据类型。当你读取数据时，一定要使用binaryreader类的某种强类型的read方法。例如，要读取字符串，要使用readstring方法。（binarywriter在写入二进制文件时总会记录字符串的长度以避免任何可能的错误）
写入文件的示例：
using(filestream fs = new filestream(filename,filemode.create))
{
     using(binarywriter writer = new binarywriter(fs))
     {
          //写入十进制数，字符串和字符
          writer.write(234.56m);
          writer.write("string");
          writer.write("!");
     }
}
 

 
读取文件的示例：
//以只读模式打开一个二进制文件
using(filestream fs=new filestream(filename,filemode.open))
{
     using(streamreader sr=new streamreader(fs))
     {
          messagebox.show("全部数据：" sr.readtoend());

          fs.position=0;
          using(binaryreader reader=new binaryreader(fs))
          {
               //选用合适的数据类型读取数据
               string message = reader.readdecimal().tostring() environment.newline;
               message =reader.readstring() environment.newline;
               message =reader.readchar().tostring();
               messagebox.show(message);
          }
     }
}
 

问题3：如何异步读取文件；
解决方案：
有时你需要读取一个文件但又不希望影响程序的执行。常见的情况是读取一个存储在网络驱动器上的文件。
filestream提供了对异步操作的基本支持，即它的beginread和endread方法。使用这些方法，可以在.netframework线程池提供的线程中读取一个数据块，而无须直接与system.threading命名空间中的线程类打交道。
采用异步方式读取文件时，可以选择每次读取数据的大小。根据情况的不同，你可能会每次读取很小的数据（比如，你要将数据逐块拷贝至另一个文件），也可能是一个相对较大的数据（比如，在程序逻辑开始之前需要一定数量的数据）。在调用beginread时指定要读取数据块的大小，同时传入一个缓冲区（buffer）以存放数据。因为beginread和endread需要访问很多相同的信息，如filestream，buffer，数据块大小等，因此将这些内容封装一个单独的类当中是一个好主意。
下面这个类就是一个简单的示例。asyncprocessor类提供了startprocess方法，调用它开始读取，每次读取操作结束，oncompletedread回调函数会被触发，此时可以处理数据，假如还有剩余数据，则开始一个新的读取操作。默认情况下，asyncprocessor类每次读取2kb数据。

classasyncprocessor
{
     private stream inputstream;

     //每次读取块的大小
     private int buffersize=2048;

     public int buffersize
     {
          get{returnbuffersize;}
          set{buffersize=value;}
     }

     //容纳接收数据的缓存
     privatebyte[]buffer;

     public asyncprocessor(string filename)
     {
          buffer=newbyte[buffersize];

          //打开文件，指定参数为true以提供对异步操作的支持
          inputstream=newfilestream(filename,filemode.open,fileaccess.read,fileshare.read,buffersize,true);
     }

     publicvoidstartprocess()
     {
          //开始异步读取文件，填充缓存区
          inputstream.beginread(buffer,0,buffer.length,oncompletedread,null);
     }

     privatevoidoncompletedread(iasyncresultasyncresult)
     {
          //已经异步读取一个块，接收数据
          intbytesread=inputstream.endread(asyncresult);

          //假如没有读取任何字节，则流已达文件结尾
          if(bytesread>0)
          {
               //暂停以模拟对数据块的处理
               debug.writeline("异步线程：已读取一块");
               thread.sleep(timespan.frommilliseconds(20));

               //开始读取下一块
               inputstream.beginread(buffer,0,buffer.length,oncompletedread,null);
          }
          else
          {
               //结束操作
               debug.writeline("异步线程：读取文件结束");
               inputstream.close();
          }
     }
}
 

 
使用该类时可以这么写：
//开始在另一线程中异步读取文件
asyncprocessor asyncio = new asyncprocessor("test.txt");
asyncio.startprocess();

//在主程序中，做其它事情，这里简单地循环10秒
datetime starttime = datetime.now;
while(datetime.now.subtract(starttime).totalseconds<10)
{
     debug.writeline("主程序：正在进行");
     //暂停线程以模拟耗时的操作
     thread.sleep(timespan.frommilliseconds(100));
}

debug.writeline("主程序：已完成");
 

问题4：如何创建临时文件；
解决方案：
有时需要在特定用户的临时目录下创建一个临时文件，这要求该文件具有唯一的名称，避免与其它程序生成的临时文件相冲突。我们会有多种选择。最简单的是，在程序所在目录内使用guid或时间戳加上随机值作为文件名称。但path类提供的方法还是可以为你节省工作量，这就是它的静态gettempfilename方法，它在当前用户的临时目录下创建一个临时文件（文件名称一定是唯一的），临时目录通常类似于这样：c:documentsandsettings[username]localsettingstemp。
string tempfile = path.gettempfilename();

using(filestream fs = new filestream(tempfile,filemode.open))
{
     using(binarywriter writer = new binarywriter(fs))
     {
          //写入数据
          writer.write("临时文件信息");
     }
}

//dosomething

//最后删除临时文件
file.delete(tempfile);
 

问题5：如何获得随机文件名；
解决方案：
使用path.getrandomfilename方法，它与gettempfilename方法的不同之处在于它仅仅返回一个字符串但不会创建文件。

问题6：监视文件系统的变化；
解决方案：
假如指定路径内的文件发生改变（比如文件被修改或创建），你希望能对此作出反应。
假如程序与其它多个程序或业务处理相关，经常需要创建一个程序，并且只有文件系统发生变化时它才处于活动状态。你可以创建一个这样的程序，让它定期区检测指定目录，此时会发现有件事情让你苦恼：检测得越频繁，就会浪费越多的系统资源；而检测得越少，那么检测到变化的时间就会越长。
这时可以使用filesystemwatcher组件，指定要进行监视的目录或文件，并处理其created，deleted，renamed，changed事件。
要使用filesystemwatcher组件，首先要创建它的一个实例，然后设置下列属性：
path：指定要监视的目录；
filter：指定要监视的文件类型，如”*.txt”；
notifyfilter：指定要监视的变化类型；
filesystemwatcher会引发四个要害的事件：created，deleted，renamed，changed。这些事件都在其filesystemeventargs参数中提供了相关文件的信息：如文件名，路径，改变类型，renamed事件中还可以了解到改变前的文件名和路径。假如要禁用这些事件，则将它的enableraisingevents属性设置为false。created，deleted，renamed三个事件比较轻易处理，但changed事件就得当心了，你需要设置它的notifyfilter属性以指示监视那些类型的变化。否则，程序会在文件被修改时沉没在不断发生的事件中（缓存区溢出）。
//设置相关属性
watcher.path=apppath;
watcher.filter="*.txt";
watcher.includesubdirectories=true;  

//添加事件处理函数
watcher.created = new filesystemeventhandler(onchanged);
watcher.deleted = new filesystemeventhandler(onchanged);
watcher.changed =new filesystemeventhandler(onchanged);
watcher.renamed =new renamedeventhandler(onrenamed);

void onrenamed(object sender,renamedeventargs e)
{
     string renamedformat="file:{0}被重命名为:{1}";
     txtchangedinfo.text=string.format(renamedformat,e.oldfullpath,e.fullpath);
}

void onchanged(object sender,filesystemeventargs e)
{
     //显示通知信息
     txtchangedinfo.text="文件:" e.fullpath "发生改变" environment.newline;
     txtchangedinfo.text ="改变类型:" e.changetype.tostring();
}
 

问题7：如何使用独立存储文件；
解决方案：
有时你需要将数据存储在文件中，但对本地硬盘驱动器却没有必要的权限（fileiopermission）。这时要用到system.io.isolatedstorage命名空间中的类，这些类答应你的程序在特定用户的目录下将数据写入文件而不需要直接访问硬盘驱动器的权限：

//创建当前用户的独立存储
using(isolatedstoragefile store = isolatedstoragefile.getuserstoreforassembly())
{
     //创建一个文件夹
     store.createdirectory("myfolder");

     //创建一个独立存储文件
     using(streamfs=newisolatedstoragefilestream("myfile.txt",filemode.create,store))
     {
          streamwriterwriter=newstreamwriter(fs);
          writer.writeline("testline!");
          writer.flush();
     }

     debug.writeline("当前大小：" store.currentsize.tostring() environment.newline);
     debug.writeline("范围：" store.scope.tostring() environment.newline);
     string[]files=store.getfilenames("*.*");
     if(files.length>0)
     {
          debug.writeline("当前文件：" environment.newline);
          foreach(stringfileinfiles)
          {
               debug.writeline(file environment.newline);
          }
     }
}

本文来源：http://www.gdgbn.com/jiaocheng/28820/