超级IO操作类

using System;
using System.IO;
using System.IO.Compression;
using System.Text;
using System.Diagnostics;
using System.Threading;
using System.Runtime.InteropServices;
using System.Collections.Generic;


namespace CSharpRecipes
{
    public class FileSystemIO
    {
        #region 12.1 Creating, Copying, Moving, And Deleting A File
        public static void CreateCopyMoveDeleteFile()
        {
            FileStream fileStream = null;
            Directory.CreateDirectory(@"c:\delete\test");
            if (!File.Exists(@"c:\delete\test\test.txt"))
            {
                fileStream = File.Create(@"c:\delete\test\test.txt");

                fileStream.Close();
            }
            
            FileInfo fileInfo = null;
            fileStream = null;
            if (!File.Exists (@"c:\delete\test\test.txt"))
            {
                fileInfo = new FileInfo(@"c:\delete\test\test.txt");
                fileStream = fileInfo.Create();

                fileStream.Close();
            }
            
            if (File.Exists(@"c:\delete\test\test.txt"))
            {
                File.Copy(@"c:\delete\test\test.txt ", 
                    Directory.GetCurrentDirectory() + @"\test.txt", true);
                Thread.Sleep(2000);
            }

            fileInfo = new FileInfo(@"c:\delete\test\test.txt");
            fileInfo.CopyTo(@"c:\test.txt", true);

            if (!File.Exists(Directory.GetCurrentDirectory() + @"\test.txt"))
            {
                File.Move(@"c:\delete\test\test.txt ", 
                    Directory.GetCurrentDirectory() + @"\test.txt");
            }

            fileInfo = new FileInfo(@"c:\delete\test\test.txt");
            if (!File.Exists(@"c:\test.txt "))
            {
                fileInfo.MoveTo(@"c:\test.txt ");
            }

            if (File.Exists(Directory.GetCurrentDirectory() + @"\test.txt"))
            {
                File.Delete(Directory.GetCurrentDirectory() + @"\test.txt");
            }


            if(File.Exists(@"c:\delete\test\test.txt"))
            {
                fileInfo = new FileInfo(@"c:\delete\test\test.txt");
                fileInfo.Delete();
            }
            Directory.Delete(@"c:\delete",true);
        }
        #endregion

        #region 12.2 Manipulating File Attributes
        public static void ManipulateFileAttribs()
        {
            string path = Path.GetTempFileName();
            if (!File.Exists(path))
                File.Create(path);
                
            try
            {
                // Use the File class static methods to play with the timestamps and attributes
                DisplayFileAttr1(path);
                ModifyFileAttr1(path);


                // Use the FileInfo class instance methods to play with the timestamps and attributes
                DisplayFileAttr2(path);
                ModifyFileAttr2(path);
                ViewModifyFileAttr(path);
            }
            catch(Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }

        public static void DisplayFileAttr1(string path)
        {
            Console.WriteLine(File.GetCreationTime(path).ToString());
            Console.WriteLine(File.GetLastAccessTime(path).ToString());
            Console.WriteLine(File.GetLastWriteTime(path).ToString());
        }

        public static void DisplayFileAttr2(string path)
        {
            FileInfo fileInfo = new FileInfo(path);

            Console.WriteLine(fileInfo.CreationTime.ToString());
            Console.WriteLine(fileInfo.LastAccessTime.ToString());
            Console.WriteLine(fileInfo.LastWriteTime.ToString());
        }

        public static void ModifyFileAttr1(string path)
        {
            File.SetCreationTime(path, DateTime.Parse(@"May 10, 2003"));
            File.SetLastAccessTime(path, DateTime.Parse(@"May 10, 2003"));
            File.SetLastWriteTime(path, DateTime.Parse(@"May 10, 2003"));
        }

        public static void ModifyFileAttr2(string path)
        {
            FileInfo fileInfo  = new FileInfo(path);

            DateTime dt = new DateTime(2001,2,8);
            fileInfo.CreationTime = dt;
            fileInfo.LastAccessTime = dt;
            fileInfo.LastWriteTime = dt; 
        }

        public static void ViewModifyFileAttr(string path)
        {
            if(File.Exists(path))
            {
                FileInfo fileInfo = new FileInfo(path);

                // Display this file抯 attributes
                Console.WriteLine(fileInfo.Attributes.ToString());

                // Display whether this file is hidden
                Console.WriteLine("Is file hidden? = " + 
                    ((fileInfo.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden));

                // Modify this file抯 attributes
                fileInfo.Attributes |= FileAttributes.Hidden;

                // Display whether this file is hidden
                Console.WriteLine("Is file hidden? = " + 
                    ((fileInfo.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden));

            }
        }

        #endregion

        #region 12.3 Rename a File
        public static void RenameFile()
        {
            //File.Delete(@"C:\temp\foo.txt");
            if(!Directory.Exists(@"c:\temp"))
                Directory.CreateDirectory(@"c:\temp");
            File.Delete(@"C:\temp\bar.dat");

            if (!File.Exists(@"c:\temp\foo.txt"))
                File.Create(@"c:\temp\foo.txt");

            RenameFile1(@"c:\temp\foo.txt",@"c:\temp\bar.dat");

            RenameFile1(@"c:\temp\bar.dat",@"c:\temp\foo.txt");

            FileInfo originalFile = new FileInfo(@"c:\temp\foo.txt");
            RenameFile2(originalFile,@"c:\temp\bar.dat");
        }

        public static void RenameFile1(string originalName, string newName)
        {
            File.Move(originalName, newName);
        }

        public static void RenameFile2(FileInfo originalFile, string newName)
        {
            originalFile.MoveTo(newName);
        }


        #endregion

        #region 12.4 Determining if a File Exists
        public static void DetermineFileExists()
        {
            File.Create(@"c:\temp\test.txt");
            if (File.Exists(@"c:\temp\test.txt"))
            {
                // Operate on that file here
                Console.WriteLine("Found");
            }
        }
        #endregion

        #region 12.5 Choosing A Method Of Opening A File Or Stream For Reading And/Or Writing
        public static void ChooseMethodOpenFileOrStream()
        {
            // create a temp file to work with
            string tempFile = Path.GetTempFileName();

            // FileStream
            FileStream fileStream = null;
            try
            {
                // open the file
                fileStream = File.Open(tempFile,FileMode.Append);
    
                string text = "Hello World ";
                byte [] bytes = Encoding.ASCII.GetBytes(text.ToCharArray());
    
                // write to the file
                fileStream.Write(bytes,0,bytes.Length);
            }
            finally
            {
                //make sure the file is closed if it was opened
                if(fileStream != null)
                    fileStream.Close();
            }

            // StreamReader
            StreamReader streamReader = null;
            try
            {
                streamReader = new StreamReader(tempFile);
                char[] chars = new char[64];
                // read a block of characters
                streamReader.Read(chars,0,64);
                string charsFound = new string(chars);
                Console.WriteLine("Chars in stream {0}",charsFound);
            }
            finally
            {
                if(streamReader != null)
                    streamReader.Close();
            }

            // StreamWriter
            StreamWriter streamWriter = null;
            // open for append
            streamWriter = new StreamWriter(tempFile,true);
            // append some text
            streamWriter.WriteLine(", It's the StreamWriter!");

            // BinaryWriter
            BinaryWriter binaryWriter = null;
            long pos = 0;
            int twentyFive = 25;
            try
            {
                // start up the binary writer with the base stream from the streamwriter 
                // since it is open
                binaryWriter = new BinaryWriter(streamWriter.BaseStream);
                // move to end
                pos = binaryWriter.Seek(0, SeekOrigin.End);
                // write out 25
                binaryWriter.Write(twentyFive);
            }
            finally
            {
                // close writer
                if (streamWriter != null)
                    streamWriter.Close();
                // close up
                if(binaryWriter != null)
                    binaryWriter.Close();
            }

            // BinaryReader 
            StreamReader streamReader2 = null;
            BinaryReader binaryReader = null;
            try
            {
                // open a new reader
                streamReader2 = new StreamReader(tempFile);
                binaryReader = new BinaryReader(streamReader2.BaseStream);

                // advance the stream to the number we stored
                for(long i=0;i<pos;i++)
                    binaryReader.ReadByte();
                // read our number (should be 25)
                int num = binaryReader.ReadInt32();
                // is this the same number?
                if(num == twentyFive)
                    Console.WriteLine("Successfully read 25 back from stream");
                else
                    Console.WriteLine("Failed to successfully read 25 back from stream");
            }
            finally
            {
                // close up
                if(binaryReader != null)
                    binaryReader.Close();
                // close stream
                if(streamReader2 != null)
                    streamReader2.Close();
            }
        }
        #endregion

        #region 12.6 Randomly Accessing Part of a File 
        public static void RandomAccessPartOfFile()
        {
            string theFirstLine = "This is the first line.";
            CreateFile(theFirstLine, 1020304050);
            ModifyFile(1020304050);
            ReadFile(theFirstLine);


            long offsetValue = -20;
            FileStream fileStream = File.Open("data.txt",FileMode.Open,FileAccess.ReadWrite,FileShare.None);
    
            StreamWriter streamWriter = new StreamWriter(fileStream);

            if ((offsetValue + streamWriter.BaseStream.Position) >= 0)
            {
                streamWriter.BaseStream.Seek(offsetValue, SeekOrigin.Current);
            }
            else
            {
                Console.WriteLine("Cannot seek before the beginning of the file.");
            }

            if ((offsetValue + streamWriter.BaseStream.Length) >= 0)
            {
                streamWriter.BaseStream.Seek(offsetValue, SeekOrigin.End);
            }
            else
            {
                Console.WriteLine("Cannot seek before the beginning of the file.");
            }

            if (offsetValue >= 0)
            {
                streamWriter.BaseStream.Seek(offsetValue, SeekOrigin.Begin);
            }
            else
            {
                Console.WriteLine("Cannot seek before the beginning of the file.");
            }

        }

        public static void CreateFile(string theFirstLine, int theSecondLine)
        {
            FileStream fileStream = new FileStream("data.txt", 
                FileMode.Create, 
                FileAccess.ReadWrite, 
                FileShare.None);
            StreamWriter streamWriter = new StreamWriter(fileStream);

            streamWriter.WriteLine(theFirstLine);
            streamWriter.WriteLine(theSecondLine);
            streamWriter.Flush();
            streamWriter.Close();
            fileStream.Close();
        }

        public static void ModifyFile(int theSecondLine)
        {
            // open the file for read/write
            FileStream fileStream = File.Open("data.txt",FileMode.Open,FileAccess.ReadWrite,FileShare.None);
    
            StreamWriter streamWriter = new StreamWriter(fileStream);

            // backup over the newline
            int offset = streamWriter.NewLine.Length;
            // backup over the second line
            offset += (theSecondLine.ToString().Length);
            // make negative
            offset = offset - (2 * offset);
            // move file pointer to just after first line
            streamWriter.BaseStream.Seek(offset, SeekOrigin.End);
            
            StringBuilder sb = new StringBuilder("This line added by seeking ");
            sb.AppendFormat("{0} chars from the end of this file.",offset);

            streamWriter.WriteLine(sb.ToString());
            streamWriter.Flush();

            streamWriter.BaseStream.Seek(0, SeekOrigin.End);
            streamWriter.WriteLine("This is the last line, added by seeking to the end of the file.");

            streamWriter.Close();
        }

        public static void ReadFile(string theFirstLine)
        {
            StreamReader streamReader = new StreamReader("data.txt");

            streamReader.BaseStream.Seek(
                theFirstLine.Length + Environment.NewLine.Length, SeekOrigin.Begin);

            Console.WriteLine(streamReader.ReadToEnd());
            streamReader.Close();
        }

        public void MoveInFile(int offsetValue)
        {
            FileStream fileStream = File.Open("data.txt",FileMode.Open,FileAccess.ReadWrite,FileShare.None);
    
            StreamWriter streamWriter = new StreamWriter(fileStream);

            // move from the beginning of the file
            streamWriter.BaseStream.Seek(offsetValue, SeekOrigin.Begin);

            // move from the end of the file
            streamWriter.BaseStream.Seek(offsetValue, SeekOrigin.End);

            // move from the current file pointer location in the file
            streamWriter.BaseStream.Seek(offsetValue, SeekOrigin.Current);

            streamWriter.Close();
        }
        #endregion

        #region 12.7 A Platform Independent EOL Character
        public static void PlatformIndependentEOL()
        {
            // 1) Remember to use Environment.NewLine on every block of text 
            // we format that we want platform correct newlines inside of
            string line;
            line = String.Format("FirstLine {0} SecondLine {0} ThirdLine {0}",Environment.NewLine);

            // get a temp file to work with
            string file = Path.GetTempFileName();
            FileStream stream = File.Create(file);
            byte[] bytes = Encoding.Unicode.GetBytes(line);
            stream.Write(bytes,0,bytes.Length);
            // close the file
            stream.Close();

            // remove the file (good line to set a breakpoint to check out the file
            // we created)
            File.Delete(file);


            // 2) Set up a text writer and tell it to use the certain newline
            // string
            // get a new temp file
            file = Path.GetTempFileName();
            line = "Double spaced line";
            StreamWriter streamWriter = new StreamWriter(file);
            // make this always write out double lines
            streamWriter.NewLine = Environment.NewLine + Environment.NewLine;
            // WriteLine on this stream will automatically use the newly specified
            // newline sequence (double newline in our case)
            streamWriter.WriteLine(line);
            streamWriter.WriteLine(line);
            streamWriter.WriteLine(line);
            // close the file
            streamWriter.Close();
            // remove the file (good line to set a breakpoint to check out the file
            // we created)
            File.Delete(file);

            // 3) Just use any of the normal WriteLine methods as they use the 
            // Environment.NewLine by default
            line = "Default line";
            Console.WriteLine(line);

        }
        #endregion

        #region 12.8 Create, Write to, and Read from a File
        public static void CreateWriteReadFile()
        {
            string tempFile = Path.GetTempFileName();
            FileStream fileStream = null;
            try
            {
                fileStream = CreateLogFile(tempFile);
                WriteToLog(fileStream,"First log event!");
                WriteToLog(fileStream,"Second log event!");
                WriteToLog(fileStream,"Third log event!");
                string logContents = ReadAllLog(fileStream);
                Console.WriteLine("Read whole log at once and found this:\r\n{0}",logContents);
                ReadLogPeeking(fileStream);
                ReadLogByLines(fileStream);
                ReadAllLogAsBytes(fileStream);
                ReadAllBufferedLog(fileStream);
                fileStream.Close();
            }
            catch(Exception e)
            {
                Console.WriteLine(e.ToString());
            }


            StreamReader streamReader = new StreamReader(tempFile);
            while (streamReader.Peek() != -1)
            {
                Console.WriteLine(streamReader.ReadLine());
            }
            streamReader.Close();


            streamReader = new StreamReader(tempFile);
            char [] chars = new char[5];
            while ((streamReader.Read(chars, 0, chars.Length)) != 0)
            {
                Console.WriteLine(chars);
            }
            streamReader.Close();


            streamReader = new StreamReader(tempFile);
            string text = "";
            while ((text = streamReader.ReadLine()) != null)
            {
                Console.WriteLine(text);
            }
            streamReader.Close();

            fileStream = new FileStream(tempFile, FileMode.Open);
            byte retVal = (byte) fileStream.ReadByte();

            fileStream = new FileStream(tempFile, FileMode.Open);
            int retByte = 0;
            while ((retByte = fileStream.ReadByte()) != -1)
            {
                Console.WriteLine((byte)retByte);
            }
            fileStream.Close();

            fileStream = new FileStream(tempFile, FileMode.Open);
            long currPosition = 0;
            while (currPosition < fileStream.Length)
            {
                Console.WriteLine((byte) fileStream.ReadByte());
                currPosition++;
            }
            fileStream.Close();

            fileStream = new FileStream(tempFile, FileMode.Open);
            BinaryReader binaryReader = new BinaryReader(fileStream);
            while (binaryReader.PeekChar() != -1)
            {
                Console.WriteLine(binaryReader.ReadChar());
            }
            binaryReader.Close();

        }

        public static FileStream CreateLogFile(string logFileName)
        {
            FileStream fileStream = new FileStream(logFileName, 
                FileMode.Create, 
                FileAccess.ReadWrite, 
                FileShare.None);
            return (fileStream);
        }

        public static void WriteToLog(FileStream fileStream, string data)
        {
            // make sure we can write to this stream
            if(!fileStream.CanWrite)
            {
                // close it and reopen for append
                string fileName = fileStream.Name;
                fileStream.Close();
                fileStream = new FileStream(fileName,FileMode.Append);
            }
            StreamWriter streamWriter = new StreamWriter(fileStream);
            streamWriter.WriteLine(data);
            streamWriter.Close(); 
        }

        public static string ReadAllLog(FileStream fileStream)
        {
            if(!fileStream.CanRead)
            {
                // close it and reopen for read
                string fileName = fileStream.Name;
                fileStream.Close();
                fileStream = new FileStream(fileName,FileMode.Open,FileAccess.Read);
            }
            StreamReader streamReader = new StreamReader(fileStream);
            string contents = streamReader.ReadToEnd();
            streamReader.Close();
            return contents; 
        }

        public static void ReadLogPeeking(FileStream fileStream)
        {
            if(!fileStream.CanRead)
            {
                // close it and reopen for read
                string fileName = fileStream.Name;
                fileStream.Close();
                fileStream = new FileStream(fileName,FileMode.Open,FileAccess.Read);
            }
            Console.WriteLine("Reading file stream peeking at next line:");
            StreamReader streamReader = new StreamReader(fileStream);
            while (streamReader.Peek() != -1)
            {
                Console.WriteLine(streamReader.ReadLine());
            }    
            streamReader.Close();
        }

        public static void ReadLogByLines(FileStream fileStream)
        {
            if(!fileStream.CanRead)
            {
                // close it and reopen for read
                string fileName = fileStream.Name;
                fileStream.Close();
                fileStream = new FileStream(fileName,FileMode.Open,FileAccess.Read);
            }
            Console.WriteLine("Reading file stream as lines:");
            StreamReader streamReader = new StreamReader(fileStream);
            string text = "";
            while ((text = streamReader.ReadLine()) != null)
            {
                Console.WriteLine(text);
            }
            streamReader.Close();
        }

        public static void ReadAllLogAsBytes(FileStream fileStream)
        {
            if(!fileStream.CanRead)
            {
                // close it and reopen for read
                string fileName = fileStream.Name;
                fileStream.Close();
                fileStream = new FileStream(fileName,FileMode.Open,FileAccess.Read);
            }
            Console.WriteLine("Reading file stream as bytes:");
            StreamReader streamReader = new StreamReader(fileStream);
            while (streamReader.Peek() != -1)
            {
                Console.Write(streamReader.Read());
            }
            streamReader.Close();
        }

        public static void ReadAllBufferedLog (FileStream fileStream)
        {
            if(!fileStream.CanRead)
            {
                // close it and reopen for read
                string fileName = fileStream.Name;
                fileStream.Close();
                fileStream = new FileStream(fileName,FileMode.Open,FileAccess.Read);
            }
            Console.WriteLine("Reading file stream as buffers of bytes:");
            StreamReader streamReader = new StreamReader(fileStream);
            while (streamReader.Peek() != -1)
            {
                char[] buffer = new char[10];
                int bufferFillSize = streamReader.Read(buffer, 0, 10);
                foreach (char c in buffer)
                {
                    Console.Write(c);
                }
                Console.WriteLine(bufferFillSize);
            }
            streamReader.Close();
        }

        public static void ReadAllBufferedLogBlock(FileStream fileStream)
        {
            if(!fileStream.CanRead)
            {
                // close it and reopen for read
                string fileName = fileStream.Name;
                fileStream.Close();
                fileStream = new FileStream(fileName,FileMode.Open,FileAccess.Read);
            }
            Console.WriteLine("Reading file stream as buffers of bytes using ReadBlock:");
            StreamReader streamReader = new StreamReader(fileStream);
            while (streamReader.Peek() != -1)
            {
                char[] buffer = new char[10];
                int bufferFillSize = streamReader.ReadBlock(buffer, 0, 10);
                foreach (char c in buffer)
                {
                    Console.Write(c);
                }
                Console.WriteLine(bufferFillSize);
            }
            streamReader.Close();
        }


        #endregion

        #region 12.9 Determining if a Directory Exists
        public static void DetermineDirectoryExists()
        {
            if (Directory.Exists(@"c:\temp"))
            {
                // Operate on that directory here
                Console.WriteLine(@"Found C:\temp");
            }
        }
        #endregion

        #region 12.10 Creating, Moving, and Deleting a Directory
        public static void CreateMoveDeleteDirectory()
        {
            DirectoryInfo dirInfo = null;
            if (!Directory.Exists(@"c:\delete\test"))
            {
                dirInfo = Directory.CreateDirectory(@"c:\delete\test");
            }

            dirInfo = null;
            if (!Directory.Exists(@"c:\delete\test"))
            {
                dirInfo = new DirectoryInfo(@"c:\delete\test");
                dirInfo.Create();
            }

            if (!Directory.Exists(@"c:\MovedDir"))
            {
                Directory.Move(@"c:\delete", @"c:\MovedDir");
            }

            dirInfo = null;
            if (!Directory.Exists(@"c:\MovedDir"))
            {
                dirInfo = new DirectoryInfo(@"c:\delete\test");
                dirInfo.MoveTo(@"c:\MovedDir");
            }

            if (Directory.Exists(@"c:\MovedDir"))
            {
                Directory.Delete(@"c:\MovedDir", true);
            }

            dirInfo = null;
            if (Directory.Exists(@"c:\MovedDir"))
            {
                dirInfo = new DirectoryInfo(@"c:\delete\test");
                dirInfo.Delete(true);
            }

        }
        #endregion

        #region 12.11 Manipulating Directory Attributes
        public static void ManipulateDirectoryAttribs()
        {
            string path = Path.GetTempPath() + @"\MyTemp";
            Directory.CreateDirectory(path);
            try
            {
                // Display, manipulate the directory timestamps using the static methods of the 
                // Directory class.
                DisplayDirAttr1(path);
                ModifyDirAttr1(path);


                // Use the DirectoryInfo class instance methods to play with the timestamps and attributes
                DisplayDirAttr2(path);
                ModifyDirAttr2(path);
                ViewModifyDirAttr(path,FileAttributes.Hidden);
            }
            catch(Exception e)
            {
                Console.WriteLine("{0}",e.ToString());
            }
            Directory.Delete(path,true);
        }

        public static void DisplayDirAttr1(string path)
        {
            Console.WriteLine(Directory.GetCreationTime(path).ToString());
            Console.WriteLine(Directory.GetLastAccessTime(path).ToString());
            Console.WriteLine(Directory.GetLastWriteTime(path).ToString());
        }

        public static void DisplayDirAttr2(string path)
        {
            DirectoryInfo dirInfo = Directory.CreateDirectory(path);

            Console.WriteLine(dirInfo.CreationTime.ToString());
            Console.WriteLine(dirInfo.LastAccessTime.ToString());
            Console.WriteLine(dirInfo.LastWriteTime.ToString());
        }

        public static void ModifyDirAttr1(string path)
        {
            DateTime dt = new DateTime(2003,5,10);
            Directory.SetCreationTime(path, dt);
            Directory.SetLastAccessTime(path, dt);
            Directory.SetLastWriteTime(path, dt);
        }

        public static void ModifyDirAttr2(string path)
        {
            DirectoryInfo dirInfo = Directory.CreateDirectory(path);

            DateTime dt = new DateTime(2001,2,8);
            dirInfo.CreationTime = dt;
            dirInfo.LastAccessTime = dt;
            dirInfo.LastWriteTime = dt; 
        }

        public static void ViewModifyDirAttr(string path, FileAttributes fileAttributes)
        {
            DirectoryInfo dirInfo = new DirectoryInfo(@"C:\Windows\System32"); 
            // Display this directory抯 attributes
            Console.WriteLine(dirInfo.Attributes);

            // Display whether this directory is hidden
            Console.WriteLine("Is directory hidden? = " + 
                ((dirInfo.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden));

            // Modify this directory抯 attributes
            dirInfo.Attributes |= fileAttributes;

            // Display whether this directory is hidden
            Console.WriteLine("Is directory hidden? = " + 
                ((dirInfo.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden));
        }
        #endregion

        #region 12.12 Renaming a Directory
        public static void RenameDirectory()
        {
            string path = Path.GetTempPath() + "MyTemp";
            string newpath = path + "1";
            Directory.CreateDirectory(path);

            DemonstrateRenameDir1(path,newpath);
            DemonstrateRenameDir2(newpath,path);
        }

        public static void DemonstrateRenameDir1(string originalName, string newName)
        {
            try
            {
                Directory.CreateDirectory(originalName);
                // "rename" it
                Directory.Move(originalName, newName);
            }
            catch(IOException ioe) 
            {
                // most likely given the directory exists or isn't empty
                Console.WriteLine(ioe.ToString());
            }
            catch(Exception e) 
            {
                // catch any other exceptions
                Console.WriteLine(e.ToString());
            } 
        }

        public static void DemonstrateRenameDir2 (string originalName, string newName)
        {
            try
            {
                DirectoryInfo dirInfo = new DirectoryInfo(originalName);
                // create the dir
                dirInfo.Create();
                // "rename" it
                dirInfo.MoveTo(newName);
            }
            catch(IOException ioe) 
            {
                // most likely given the directory exists or isn't empty
                Console.WriteLine(ioe.ToString());
            }
            catch(Exception e) 
            {
                // catch any other exceptions
                Console.WriteLine(e.ToString());
            } 
        }

        #endregion

        #region 12.13 Searching for Directories or Files Using Wildcards
        public static void SearchDirFileWildcards()
        {
            try
            {
                // set up initial paths
                string tempPath = Path.GetTempPath();        
                string tempDir = tempPath + @"\MyTempDir";
                string tempDir2 = tempDir + @"\MyNestedTempDir";
                string tempDir3 = tempDir + @"\MyNestedTempDirPattern";
                string tempFile = tempDir + @"\MyTempFile.PDB";
                string tempFile2 = tempDir2 + @"\MyNestedTempFile.PDB";
                string tempFile3 = tempDir + @"\MyTempFile.TXT";

                // create temp dirs and files
                Directory.CreateDirectory(tempDir);
                Directory.CreateDirectory(tempDir2);
                Directory.CreateDirectory(tempDir3);
                FileStream stream = File.Create(tempFile);
                FileStream stream2 = File.Create(tempFile2);
                FileStream stream3 = File.Create(tempFile3);
                // close files before using
                stream.Close();
                stream2.Close();
                stream3.Close();

                // print out all of the items in the temp dir
                DisplayFilesDirs1(tempDir);

                // print out the items matching a pattern
                string pattern = "*.PDB";
                DisplayFilesDirs3(tempDir,pattern);

                // print out the directories in the path
                DisplayDirs1(tempDir);

                // print out directories matching a pattern
                pattern = "*Pattern*";
                DisplayDirs3(tempDir,pattern);
                
                // print out all files
                DisplayFiles1(tempDir);

                // print out all files matching a pattern
                pattern = "*.PDB";
                DisplayFiles3(tempDir,pattern);

                // Now use methods that return actual objects instead of just the string path
                
                // get the items
                DisplayFilesDirs2(tempDir);

                // get the items that match the pattern
                pattern = "*.PDB";
                DisplayFilesDirs4(tempDir,pattern);

                // get the directory infos
                DisplayDirs2(tempDir);

                // get the directory infos that match a pattern
                pattern = "*Pattern*";
                DisplayDirs4(tempDir,pattern);

                // get the file infos
                DisplayFiles2(tempDir);

                // get the file infos that match a pattern
                pattern = "*.PDB";
                DisplayFiles4(tempDir,pattern);

                // clean up temp stuff we looked at
                File.Delete(tempFile3);
                File.Delete(tempFile2);
                File.Delete(tempFile);
                Directory.Delete(tempDir3);
                Directory.Delete(tempDir2);
                Directory.Delete(tempDir);
            }
            catch(Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }

        public static void DisplayFilesDirs1(string path)
        {
            string[] items = Directory.GetFileSystemEntries(path);
            foreach (string item in items)
            {
                Console.WriteLine(item);
            }
        }
        
        public static void DisplayDirs1(string path)
        {
            string[] items = Directory.GetDirectories(path);
            foreach (string item in items)
            {
                Console.WriteLine(item);
            }
        }

        public static void DisplayFiles1(string path)
        {
            string[] items = Directory.GetFiles(path);
            foreach (string item in items)
            {
                Console.WriteLine(item);
            }
        }

        public static void DisplayFilesDirs2(string path)
        {
            DirectoryInfo mainDir = new DirectoryInfo(path);
            FileSystemInfo[] items = mainDir.GetFileSystemInfos();
            foreach (FileSystemInfo item in items)
            {
                if (item is DirectoryInfo)
                {
                    Console.WriteLine("DIRECTORY: " + ((DirectoryInfo)item).Name);
                }
                else if (item is FileInfo)
                {
                    Console.WriteLine("FILE: " + item.Name);
                }
                else
                {
                    Console.WriteLine("Unknown");
                }
            }
        }

        public static void DisplayDirs2(string path)
        {
            DirectoryInfo mainDir = new DirectoryInfo(path);
            DirectoryInfo[] items = mainDir.GetDirectories();
            foreach (DirectoryInfo item in items)
            {
                Console.WriteLine("DIRECTORY: " + ((DirectoryInfo)item).Name);
            }
        }

        public static void DisplayFiles2(string path)
        {
            DirectoryInfo mainDir = new DirectoryInfo(path);
            FileInfo[] items = mainDir.GetFiles();
            foreach (FileInfo item in items)
            {
                Console.WriteLine("FILE: " + item.Name);
            }
        }

        // The pattern passed in is a string equal to "*.PDB"
        public static void DisplayFilesDirs3(string path, string pattern)
        {
            string[] items = Directory.GetFileSystemEntries(path, pattern);
            foreach (string item in items)
            {
                Console.WriteLine(item);
            }
        }

        // The pattern passed in is a string equal to "*.PDB"
        public static void DisplayDirs3(string path, string pattern)
        {
            string [] items = Directory.GetDirectories(path, pattern);
            foreach (string item in items)
            {
                Console.WriteLine(item);
            }
        }

        // The pattern passed in is a string equal to "*.PDB"
        public static void DisplayFiles3(string path, string pattern)
        {
            string [] items = Directory.GetFiles(path, pattern);
            foreach (string item in items)
            {
                Console.WriteLine(item);
            }
        }

        // The pattern passed in is a string equal to "*.PDB"
        public static void DisplayFilesDirs4(string path, string pattern)
        {
            DirectoryInfo mainDir = new DirectoryInfo(path);
            FileSystemInfo[] items = mainDir.GetFileSystemInfos(pattern);
            foreach (FileSystemInfo item in items)
            {
                if (item is DirectoryInfo)
                {
                    Console.WriteLine("DIRECTORY: " + ((DirectoryInfo)item).Name);
                }
                else if (item is FileInfo)
                {
                    Console.WriteLine("FILE: " + item.Name);
                }
                else
                {
                    Console.WriteLine("Unknown");
                }
            }
        }

        // The pattern passed in is a string equal to "*.PDB"
        public static void DisplayDirs4(string path, string pattern)
        {
            DirectoryInfo mainDir = new DirectoryInfo(@"C:\TEMP ");
            DirectoryInfo[] items = mainDir.GetDirectories("*.PDB");
            foreach (DirectoryInfo item in items)
            {
                Console.WriteLine("DIRECTORY: " + ((DirectoryInfo)item).Name);
            }
        }

        // The pattern passed in is a string equal to "*.PDB"
        public static void DisplayFiles4(string path, string pattern)
        {
            DirectoryInfo mainDir = new DirectoryInfo(@"C:\TEMP ");
            FileInfo[] items = mainDir.GetFiles("*.PDB");
            foreach (FileInfo item in items)
            {
                Console.WriteLine("FILE: " + item.Name);
            }
        }

        #endregion

        #region 12.14 Obtaining the Directory Tree, Including Files, From Any Point In The Directory Hierarchy
        public static void ObtainDirTree()
        {
            try
            {
                // set up items to find
                string tempPath = Path.GetTempPath();        
                string tempDir = tempPath + @"\MyTempDir";
                string tempDir2 = tempDir + @"\Chapter 1 - The Beginning";
                string tempDir3 = tempDir2 + @"\Chapter 1a - The Rest Of The Beginning";
                string tempDir4 = tempDir2 + @"\IHaveAPDBFile";
                string tempFile = tempDir + @"\MyTempFile.PDB";
                string tempFile2 = tempDir2 + @"\MyNestedTempFile.PDB";
                string tempFile3 = tempDir3 + @"\Chapter 1 - MyDeepNestedTempFile.PDB";
                string tempFile4 = tempDir4 + @"\PDBFile.PDB";
                // Tree looks like this
                // TEMP\
                //        MyTempDir\
                //                Chapter 1 - The Beginning\
                //                                Chapter 1a - The Rest Of The Beginning\
                //                                IHaveAPDBFile
                //

                // create temp dirs and files
                Directory.CreateDirectory(tempDir);
                Directory.CreateDirectory(tempDir2);
                Directory.CreateDirectory(tempDir3);
                Directory.CreateDirectory(tempDir4);
                FileStream stream = File.Create(tempFile);
                FileStream stream2 = File.Create(tempFile2);
                FileStream stream3 = File.Create(tempFile3);
                FileStream stream4 = File.Create(tempFile4);
                // close files before using
                stream.Close();
                stream2.Close();
                stream3.Close();
                stream4.Close();

                // list all of the directories
                GetAllDirFilesRecurse(tempDir);

                // obtain a listing of all files with the extension of PDB that 
                // exist in directories that begin with 慍hapter 1?
                GetAllFilesInPatternRecurse(tempDir);

                // clean up temp stuff we looked at
                File.Delete(tempFile4);
                File.Delete(tempFile3);
                File.Delete(tempFile2);
                File.Delete(tempFile);
                Directory.Delete(tempDir4);
                Directory.Delete(tempDir3);
                Directory.Delete(tempDir2);
                Directory.Delete(tempDir);
            }
            catch(Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }

        public static void GetAllDirFilesRecurse(string dir)
        {
            DirectoryInfo mainDir = new DirectoryInfo(dir);
            FileSystemInfo[] items = mainDir.GetFileSystemInfos();
            foreach (FileSystemInfo item in items)
            {
                if (item is DirectoryInfo)
                {
                    Console.WriteLine("DIRECTORY: " + ((DirectoryInfo)item).FullName);
                    GetAllDirFilesRecurse(((DirectoryInfo)item).FullName);
                }
                if (item is FileInfo)
                {
                    Console.WriteLine("FILE: " + ((FileInfo)item).FullName);
                }
                else
                {
                    Console.WriteLine("Unknown");
                }
            } 
        }

        public static void GetAllFilesInPatternRecurse(string dir)
        {
            DirectoryInfo mainDir = new DirectoryInfo(dir);
            FileSystemInfo[] items = mainDir.GetFileSystemInfos("Chapter 1*");
            foreach (FileSystemInfo item in items)
            {
                if (item is DirectoryInfo)
                {
                    GetAllFilesInPatternRecurse(((DirectoryInfo)item).FullName);
                }
                if (item is FileInfo)
                {
                    FileInfo fileInfo = item as FileInfo;
                    if(fileInfo.Extension.ToUpper().CompareTo(".PDB")==0)
                        Console.WriteLine("FILE: " + (fileInfo.FullName));
                }
            }
        }
        #endregion

        #region 12.15 Parsing a Path
        public static void ParsePath()
        {
            ParsePath(@"c:\test\tempfile.txt");
        }

        public static void ParsePath(string path)
        {
            string root = Path.GetPathRoot(path);
            string dirName = Path.GetDirectoryName(path);
            string fullFileName = Path.GetFileName(path);
            string fileExt = Path.GetExtension(path);
            string fileNameWithoutExt = Path.GetFileNameWithoutExtension(path);
            StringBuilder format = new StringBuilder();
            format.Append("ParsePath of {0} breaks up into the following pieces:\r\n\tRoot: {1}\r\n\t");
            format.Append("Directory Name: {2}\r\n\tFull File Name: {3}\r\n\t");
            format.Append("File Extension: {4}\r\n\tFile Name Without Extension: {5}\r\n");
            Console.WriteLine(format.ToString(),path,root,dirName,fullFileName,fileExt,fileNameWithoutExt);
        }

        #endregion

        #region 12.16 Parsing Paths in Environment Variables
        public static void ParsePathsEnvVars()
        {
            ParsePathEnvironmentVariable();
        }

        public static void ParsePathEnvironmentVariable()
        {
            string originalPathEnv = Environment.GetEnvironmentVariable("PATH");
            string[] paths = originalPathEnv.Split(new char[1] {Path.PathSeparator});
            foreach (string s in paths)
            {
                string pathEnv = Environment.ExpandEnvironmentVariables(s);            
                if(pathEnv.Length > 0)
                {
                    Console.WriteLine("Individual Path = " + pathEnv);
                }
                else
                {
                    Console.WriteLine("Skipping blank environment path details " +
                        " as it causes exceptions");
                                                    }
                Console.WriteLine();
            }
        }

        #endregion

        #region 12.17 Verifying a Path
        public static void VerifyPath()
        {
            CheckUserEnteredPath(@"Q:\MyNonExistentPath\MyNonExistentFile.txt", true);
            CheckUserEnteredPath(@"Q:\MyNonExistentPath\MyNonExistentFile.txt", false);
            CheckUserEnteredPath(@"Q:\MyNonExistentPath\", true);
            CheckUserEnteredPath(@"Q:\MyNonExistentPath\", false);
            CheckUserEnteredPath(@"Q:\MyNonExistentPath\MyNonExistentFile", true);
            CheckUserEnteredPath(@"Q:\MyNonExistentPath\MyNonExistentFile", false);
            CheckUserEnteredPath(@"Q:\<MyNonExistentPath>\MyNonExistentFile.txt", true);
            CheckUserEnteredPath(@"Q:\<MyNonExistentPath>\MyNonExistentFile.txt", false);
            CheckUserEnteredPath(@"Q:\MyNonExistentPath\MyNonExist:entFil*e.txt", true);
            CheckUserEnteredPath(@"Q:\MyNonExistentPath\MyNonExist:entFil*e.txt", false);
            CheckUserEnteredPath(null, true);
        }

        public static bool CheckUserEnteredPath(string path, bool any)
        {
            try
            {
                Console.WriteLine("Checking path {0}",path);

                // Verify that the path parameter is not null
                if (path == null)
                {
                    throw (new ArgumentNullException("path", "The path passed in cannot be null"));
                }
                
                bool illegal = false;

                // Two ways to do the search, one more expensive than the other
                if(any == true)
                    illegal = FindAnyIllegalChars(path);    // Cheap
                else
                    illegal = FindAllIllegalChars(path);    // Expensive

                if (!illegal)
                {
                    // Now make sure the path is not an empty string
                    //    and its file name has an extension
                    if (Path.GetFileName(path).Length == 0)
                    {
                        Console.WriteLine("A file name must be entered");
                    }    
                    else if (!Path.HasExtension(path))
                    {
                        Console.WriteLine("The file name must have an extension");
                    }
                    else
                    {
                        Console.WriteLine("Path is correct");
                        return (true);
                    }
                }
            }
            catch(Exception e)
            {    
                Console.WriteLine(e.ToString());
            }
            
            return (false);
        }

        private static bool FindAllIllegalChars(string path)
        {
            // Get directory portion of the path
            string dirName = path;
            string fullFileName = "";
            int pos = path.LastIndexOf('\\');
            if (pos >= 0)
            {
                dirName = path.Substring(0, pos);

                // Get file name portion of the path
                if (pos >= 0 && (pos + 1) < path.Length)
                    fullFileName = path.Substring(pos + 1);
            }
            
            int  invalidCharPos = 0;
            bool endOfPath = false;
            bool foundIllegalChars = false;

            // Find any characters in the directory that are illegal
            while (!endOfPath)
            {
                invalidCharPos = dirName.IndexOfAny(Path.GetInvalidPathChars(), 
                    invalidCharPos++);
                if (invalidCharPos == -1)
                {
                    endOfPath = true;
                }
                else
                {
                    foundIllegalChars = true;
                    Console.WriteLine("Invalid char {0} found at position {1} in directory path.", dirName[invalidCharPos], invalidCharPos);
                    if (invalidCharPos >= dirName.Length - 1)
                    {
                        endOfPath = true;
                    }
                    else
                    {
                        invalidCharPos++;
                    }
                }
            }

            bool endOfFileName = false;
            invalidCharPos = 0;

            // Find any characters in the file name that are illegal
            while (!endOfFileName)
            {
                invalidCharPos = fullFileName.IndexOfAny(Path.GetInvalidFileNameChars(),
                    invalidCharPos++);
                if (invalidCharPos == -1)
                {
                    endOfFileName = true;
                }
                else
                {
                    foundIllegalChars = true;
                    Console.WriteLine("Invalid char {0} found at position {1} in file name.", fullFileName[invalidCharPos], invalidCharPos);
                    if (invalidCharPos >= fullFileName.Length - 1)
                    {
                        endOfFileName = true;
                    }
                    else
                    {
                        invalidCharPos++;
                    }
                }
            }

            return (foundIllegalChars);
         }

        private static bool FindAnyIllegalChars(string path)
        {
            // Get directory portion of the path
            string dirName = path;
            string fullFileName = "";
            int pos = path.LastIndexOf('\\');
            if (pos >= 0)
            {
                dirName = path.Substring(0, pos);

                // Get file name portion of the path
                if (pos >= 0 && (pos + 1) < path.Length)
                    fullFileName = path.Substring(pos + 1);
            }

            // Find any characters in the directory that are illegal
            int invalidCharPos = dirName.IndexOfAny(Path.GetInvalidPathChars());
            if (invalidCharPos == -1)
            {
                // Find any characters in the file name that are illegal
                invalidCharPos = fullFileName.IndexOfAny(Path.GetInvalidFileNameChars());
                if (invalidCharPos == -1)
                {
                    return (false);
                }
                else
                {
                    Console.WriteLine("Invalid char {0} found at position {1} in file name.", fullFileName[invalidCharPos], invalidCharPos);
                    return (true);
                }
            }
            else
            {
                Console.WriteLine("Invalid char {0} found at position {1} in directory path.", dirName[invalidCharPos], invalidCharPos);
                return (true);
            }
        }

        #endregion

        #region 12.18 Using a Temporary File in Your Application
        public static void UseTempFile()
        {
            try
            {
                // display the temp dir
                string tempDir = Path.GetTempPath();
                Console.WriteLine("TEMP Directory is at {0}",tempDir);
                // create an empty temp file in the temp dir
                string tempFile = Path.GetTempFileName();
                Console.WriteLine("Temporary file created at {0}",tempFile);
                // remove the temp file
                File.Delete(tempFile);
            }
            catch(Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }
        #endregion

        #region 12.19 Opening a File Stream with Only a File Handle
        public static void OpenFileStreamWithFileHandle()
        {
            UsingAnUnmanagedFileHandle();
        }

        public static void UsingAnUnmanagedFileHandle()
        {
            IntPtr hFile = IntPtr.Zero;
            // create a file using unmanaged code
            hFile = (IntPtr)FileInteropFunctions.CreateFile("data.txt",
                FileInteropFunctions.GENERIC_WRITE,
                0,
                IntPtr.Zero,
                FileInteropFunctions.CREATE_ALWAYS,
                0,
                0);

            if(hFile.ToInt64() > 0)
            {
                // write to the file using managed code
                WriteToFileHandle(hFile);
                // close the file
                FileInteropFunctions.CloseHandle(hFile);
                // remove the file
                File.Delete("data.txt");
            }
        }

        public static void WriteToFileHandle(IntPtr hFile)
        {
            // Wrap our file handle in a safe handle wrapper object
            Microsoft.Win32.SafeHandles.SafeFileHandle safeHFile = 
                new Microsoft.Win32.SafeHandles.SafeFileHandle(hFile, true);
            
            // Open a FileStream object using the passed in safe file handle
            FileStream fileStream = new FileStream(safeHFile, FileAccess.ReadWrite);
            // flush before we start to clear any pending unmanaged actions
            fileStream.Flush();    
            // Operate on file here?
            string line = "Managed code wrote this line!";
            // write to the file
            byte[] bytes = Encoding.ASCII.GetBytes(line);
            fileStream.Write(bytes,0,bytes.Length);
            // just close the file stream
            fileStream.Close();
        }

        class FileInteropFunctions
        {
            public const uint GENERIC_READ = (0x80000000);
            public const uint GENERIC_WRITE = (0x40000000);
            public const uint GENERIC_EXECUTE = (0x20000000);
            public const uint GENERIC_ALL = (0x10000000);

            public const uint CREATE_NEW        = 1;
            public const uint CREATE_ALWAYS     = 2;
            public const uint OPEN_EXISTING     = 3;
            public const uint OPEN_ALWAYS       = 4;
            public const uint TRUNCATE_EXISTING = 5;

            [DllImport("kernel32.dll", SetLastError=true)]
            public static extern bool CloseHandle(IntPtr hObject);        

            [DllImport("kernel32.dll", SetLastError=true)]
            public static extern IntPtr CreateFile(
                String lpFileName,              // file name
                uint dwDesiredAccess,              // access mode
                uint dwShareMode,              // share mode
                IntPtr attr,                  // Security Descriptor
                uint dwCreationDisposition,          // how to create
                uint dwFlagsAndAttributes,          // file attributes
                uint hTemplateFile);              // handle to template file

            [DllImport("kernel32.dll", SetLastError=true)]
            public static extern bool FlushFileBuffers(IntPtr hFile);
        }

        #endregion

        #region 12.20 Write to Multiple Output Files at One Time
        public static void WriteMultipleOutputFiles()
        {
            // Create a list of three file names
            string[] names = new string[3];
            for (int i=0;i<3;i++)
            {
                names[i] = Path.GetTempFileName();
            }
            MultiWriter multi = new MultiWriter(names);
            multi.WriteLine("First Line");
            multi.WriteLine("Second Line");
            multi.WriteLine("Third Line");
            multi.Close();
        }

        class MultiWriter : IDisposable
        {
            FileStream[] _streams;
            string [] _names;
            int _streamCount = 0;
            bool _disposed = false;

            public MultiWriter(string[] fileNames)
            {
                try
                {
                    // copy the names
                    _names = (string[])fileNames.Clone();
                    // set the number of streams
                    _streamCount = fileNames.Length;
                    // make the stream array
                    _streams = new FileStream[_streamCount];
                    for(int i = 0; i < _streams.Length; i++)
                    {
                        // create this filestream
                        _streams[i] = new FileStream(_names[i], 
                            FileMode.Create, 
                            FileAccess.ReadWrite, 
                            FileShare.None);
                    }
                }
                catch(IOException ioe)
                {
                    Console.WriteLine(ioe.ToString());
                }
            }

            public void WriteLine(string text)
            {
                // add a newline
                text += Environment.NewLine;
                // get the bytes in unicode format
                byte[] bytes = Encoding.ASCII.GetBytes(text);
                // roll over the streams
                for(int i = 0; i < _streams.Length; i++)
                {
                    // write the text
                    _streams[i].Write(bytes,0,bytes.Length);
                }
            }

            public void Close()
            {
                Dispose();
            }

            public void Dispose()
            {
                try
                {
                    // only close out once
                    if(_disposed == false)
                    {
                        // close each stream
                        for(int i=0;i<_streams.Length;i++)
                        {
                            _streams[i].Close();
                        }
                        // prevent refinalizing
                        GC.SuppressFinalize(this);
                        // indicate we have done this already
                        _disposed = true;
                    }
                }
                catch(IOException ioe)
                {
                    Console.WriteLine(ioe.ToString());
                }
            }
        }
        #endregion

        #region 12.21 Launching and Interacting with Console Utilities 
        public static void LaunchInteractConsoleUtils()
        {
            RunProcessToReadStdIn();
        }

        public static void RunProcessToReadStdIn()
        {
            Process application = new Process();
            // run the command shell
            application.StartInfo.FileName = @"cmd.exe";

            // turn on standard extensions
            application.StartInfo.Arguments = "/E:ON";

            application.StartInfo.RedirectStandardInput = true;

            application.StartInfo.UseShellExecute = false;

            // start it up
            application.Start();

            // get stdin
            StreamWriter input = application.StandardInput;

            // run the command to display the time
            input.WriteLine("TIME /T");

            // stop the application we launched
            input.WriteLine("exit");
        }

        #endregion

        #region 12.22 Locking Subsections of a File 
        public static void LockSubsectionsOfAFile()
        {
            string path = Path.GetTempFileName();
            CreateLockedFile(path);
            File.Delete(path);
        }

        public static void CreateLockedFile(string fileName)
        {
            FileStream fileStream = new FileStream(fileName, 
                FileMode.Create, 
                FileAccess.ReadWrite, 
                FileShare.ReadWrite);
            StreamWriter streamWriter = new StreamWriter(fileStream);

            streamWriter.WriteLine("The First Line");
            streamWriter.WriteLine("The Second Line");
            streamWriter.Flush();

            // Lock all of the file
            fileStream.Lock(0, fileStream.Length);
 
            // Do some lengthy processing here?
            Thread.Sleep(1000);

            // Make sure we unlock the file.            
            // If a process terminates with part of a file locked or closes a file 
            // that has outstanding locks, the behavior is undefined which is MS 
            // speak for bad things.
            fileStream.Unlock(0, fileStream.Length);

            streamWriter.WriteLine("The Third Line");
            streamWriter.Close();
            fileStream.Close();
        }

        #endregion

        #region 12.23 Watching the File System for Specific Changes To One or More Files or Directories
        public static void WatchFileSystemChanges()
        {
            TestWatcher();
        }

        public static void TestWatcher()
        {
            FileSystemWatcher fsw = new FileSystemWatcher();
            fsw.Path = @"c:\";
            fsw.Filter = @"*.txt";
            fsw.IncludeSubdirectories = true;

            fsw.NotifyFilter = NotifyFilters.FileName    | 
                NotifyFilters.Attributes  | 
                NotifyFilters.LastAccess  | 
                NotifyFilters.LastWrite   | 
                NotifyFilters.Security    | 
                NotifyFilters.Size        |
                NotifyFilters.CreationTime|
                NotifyFilters.DirectoryName;

            fsw.Changed += new FileSystemEventHandler(OnChanged);
            fsw.Created += new FileSystemEventHandler(OnCreated);
            fsw.Deleted += new FileSystemEventHandler(OnDeleted);
            fsw.Renamed += new RenamedEventHandler(OnRenamed);
            fsw.Error += new ErrorEventHandler(OnError);

            fsw.EnableRaisingEvents = true;

            string file = @"c:\myfile.txt";
            string newfile = @"c:\mynewfile.txt";
            FileStream stream = File.Create(file);
            stream.Close();
            File.Move(file,newfile);
            File.Delete(newfile);

            fsw.Dispose();
        }

        public static void OnChanged(object source, FileSystemEventArgs e) 
        {
            Console.WriteLine("File " + e.FullPath + " --> " + e.ChangeType.ToString());
        }

        public static void OnDeleted(object source, FileSystemEventArgs e) 
        {
            Console.WriteLine("File " + e.FullPath + " --> " + e.ChangeType.ToString());
        }

        public static void OnCreated(object source, FileSystemEventArgs e) 
        {
            Console.WriteLine("File " + e.FullPath + " --> " + e.ChangeType.ToString());
        }

        public static void OnRenamed(object source, RenamedEventArgs e) 
        {
            Console.WriteLine("File " + e.OldFullPath + " (renamed to)--> " + e.FullPath);
        }


        public static void OnError(object source, ErrorEventArgs e) 
        {
            Console.WriteLine("Error " + e.ToString());
        }

        #endregion

        #region 12.24 Waiting for an Action to Occur in the File System
        public static void WaitFileSystemAction()
        {
            string tempPath = Path.GetTempPath();
            string fileName = "temp.zip";
            File.Delete(tempPath + fileName);
            
            WaitForZipCreation(tempPath,fileName);
        }

        public static void WaitForZipCreation(string path, string fileName)
        {
            FileSystemWatcher fsw = null;
            try
            {
                fsw = new FileSystemWatcher();
                string [] data = new string[] {path,fileName};
                fsw.Path = path;
                fsw.Filter = fileName;
                fsw.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite
                    | NotifyFilters.FileName | NotifyFilters.DirectoryName;

                // Run the code to generate the file we are looking for
                // Normally you wouldn抰 do this as another source is creating
                // this file
                if(ThreadPool.QueueUserWorkItem(new WaitCallback(PauseAndCreateFile),
                    data))
                {
                    Thread.Sleep(2000);
                    // block waiting for change
                    WaitForChangedResult result =
                        fsw.WaitForChanged(WatcherChangeTypes.Created);
                    Console.WriteLine("{0} created at {1}.", result.Name, path);
                }
            }
            catch(Exception e)
            {
                Console.WriteLine(e.ToString());
            }
            
            // clean it up
            File.Delete(fileName);
    
            if(fsw != null)
                fsw.Dispose();
        }

        static void PauseAndCreateFile(Object stateInfo) 
        {
            try
            {
                string[] data = (string[])stateInfo;
                // wait a sec
                Thread.Sleep(1000);
                // create a file in the temp directory
                string path = data[0];
                string file = path + data[1];
                Console.WriteLine("Creating {0} in PauseAndCreateFile",file);
                FileStream fileStream = File.Create(file);
                fileStream.Close();
            }
            catch(Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }
        #endregion

        #region 12.25 Comparing Version Information of Two Executable Modules
        public static void CompareVersionInfo()
        {
            // Version comparison
            string file1 = Path.GetTempFileName();
            string file2 = Path.GetTempFileName();
            FileSystemIO.FileComparison result = 
                FileSystemIO.CompareFileVersions(file1,file2);
            // cleanup
            File.Delete(file1);
            File.Delete(file2);
        }

        public enum FileComparison
        {
            Error = 0,
            File1IsNewer = 1,
            File2IsNewer = 2,
            FilesAreSame = 3
        }

        public static FileComparison CompareFileVersions(string file1, string file2)
        {
            FileComparison retValue = FileComparison.Error;
            // do both files exist?
            if (!File.Exists(file1))
            {
                Console.WriteLine(file1 + " does not exist");
            }
            else if (!File.Exists(file2))
            {
                Console.WriteLine(file2 + " does not exist");
            }
            else
            {
                // get the version information
                FileVersionInfo file1Version = FileVersionInfo.GetVersionInfo(file1);
                FileVersionInfo file2Version = FileVersionInfo.GetVersionInfo(file2);

                // check major
                if (file1Version.FileMajorPart > file2Version.FileMajorPart)
                {
                    Console.WriteLine(file1 + " is a newer version");
                    retValue = FileComparison.File1IsNewer;
                }
                else if (file1Version.FileMajorPart < file2Version.FileMajorPart)
                {
                    Console.WriteLine(file2 + " is a newer version");
                    retValue = FileComparison.File2IsNewer;
                }
                else // major version is equal, check next
                {
                    // check minor
                    if (file1Version.FileMinorPart > file2Version.FileMinorPart)
                    {
                        Console.WriteLine(file1 + " is a newer version");
                        retValue = FileComparison.File1IsNewer;
                    }
                    else if (file1Version.FileMinorPart < file2Version.FileMinorPart)
                    {
                        Console.WriteLine(file2 + " is a newer version");
                        retValue = FileComparison.File2IsNewer;
                    }
                    else // minor version is equal, check next
                    {
                        // check build
                        if (file1Version.FileBuildPart > file2Version.FileBuildPart)
                        {
                            Console.WriteLine(file1 + " is a newer version");
                            retValue = FileComparison.File1IsNewer;
                        }
                        else if (file1Version.FileBuildPart < file2Version.FileBuildPart)
                        {
                            Console.WriteLine(file2 + " is a newer version");
                            retValue = FileComparison.File2IsNewer;
                        }
                        else // build version is equal, check next
                        {
                            // check private
                            if (file1Version.FilePrivatePart > file2Version.FilePrivatePart)
                            {
                                Console.WriteLine(file1 + " is a newer version");
                                retValue = FileComparison.File1IsNewer;
                            }
                            else if (file1Version.FilePrivatePart < 
                                file2Version.FilePrivatePart)
                            {
                                Console.WriteLine(file2 + " is a newer version");
                                retValue = FileComparison.File2IsNewer;
                            }
                            else
                            {
                                // identical versions.
                                Console.WriteLine("The files have the same version");
                                retValue = FileComparison.FilesAreSame;
                            }
                        }
                    }
                }
            }
            return retValue;
        }

        #endregion

        #region "12.26 Querying Information for All Drives on a System"
        public static void TestAllDriveInfo()
        {
            DisplayOneDrivesInfo();
            DisplayAllDriveInfo();
        }
        
        public static void DisplayOneDrivesInfo()
        {
            DriveInfo drive = new DriveInfo("D");
            if (drive.IsReady)
                Console.WriteLine("The space available on the D:\\ drive: " + drive.AvailableFreeSpace);
            else
                Console.WriteLine("Drive D:\\ is not ready.");
    
            // If the drive is not ready you will get a:
            //   System.IO.IOException: The device is not ready.    
            Console.WriteLine();
        }
                
        public static void DisplayAllDriveInfo()
        {
            foreach (DriveInfo drive in DriveInfo.GetDrives())
            {
                if (drive.IsReady)
                {
                    Console.WriteLine("Drive " + drive.Name + " is ready.");
                    Console.WriteLine("AvailableFreeSpace: " + drive.AvailableFreeSpace);
                    Console.WriteLine("DriveFormat: " + drive.DriveFormat);
                    Console.WriteLine("DriveType: " + drive.DriveType);
                    Console.WriteLine("Name: " + drive.Name);
                    Console.WriteLine("RootDirectory.FullName: " + drive.RootDirectory.FullName);
                    Console.WriteLine("TotalFreeSpace: " + drive.TotalFreeSpace);
                    Console.WriteLine("TotalSize: " + drive.TotalSize);
                    Console.WriteLine("VolumeLabel: " + drive.VolumeLabel);
                }
                else
                {
                    Console.WriteLine("Drive " + drive.Name + " is not ready.");
                }
                
                Console.WriteLine();
            }
        }
        #endregion

        #region "12.27 Encrypting/Decrypting an Existing File"
        public static void TestEncryptExistingFile()
        {
            EncryptFile(@"C:\Encrypted.txt");
            DecryptFile(@"C:\Encrypted.txt");
        }

        public static void EncryptFile(string fileName)
        {
            File.Encrypt(fileName);
            // System.IO.IOException: The request is not supported.
            //at System.IO.__Error.WinIOError(Int32 errorCode, String str)
            //at System.IO.File.Encrypt(String path)
            //at CSharpRecipes.FileSystemIO.EncryptFile(String fileName) in c:\documents and settings\operator\desktop\csharp recipes 2nd edition\code\csharprecipes\12_filesystemio.cs:line 1987
            //at CSharpRecipes.FileSystemIO.TestEncryptExistingFile() in c:\documents and settings\operator\desktop\csharp recipes 2nd edition\code\csharprecipes\12_filesystemio.cs:line 1981
            //at CSharpRecipes.MainTester.TestFileSystemIO() in c:\documents and settings\operator\desktop\csharp recipes 2nd edition\code\csharprecipes\00_maintester.cs:line 786
            //at CSharpRecipes.MainTester.Main(String[] args) in c:\documents and settings\operator\desktop\csharp recipes 2nd edition\code\csharprecipes\00_maintester.cs:line 927

            // bool Microsoft.Win32.Win32Native::EncryptFile(string)
        }

        public static void DecryptFile(string fileName)
        {
            File.Decrypt(fileName);
        }
        #endregion

        #region "12.28 Compress and Decompress Your Files"
        public static void TestCompressNewFile()
        {
            byte[] data = new byte[10000000];
            for (int i = 0; i < 10000000; i++)
                data[i] = (byte)i;
                
            FileStream fs = new FileStream(@"C:\NewNormalFile.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
            NormalFile(fs, data);

            fs = new FileStream(@"C:\NewCompressedFile.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
            CompressFile(fs, data, CompressionType.Deflate);

            fs = new FileStream(@"C:\NewCompressedFile.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
            List<byte> retData = DeCompressFile(fs, CompressionType.Deflate);
            Console.WriteLine("Deflated file bytes count == " + retData.Count);
            
            fs = new FileStream(@"C:\NewGZCompressedFile.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
            CompressFile(fs, data, CompressionType.GZip);

            fs = new FileStream(@"C:\NewGzCompressedFile.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
            retData = DeCompressFile(fs, CompressionType.GZip);
            Console.WriteLine("GZipped file bytes count == " + retData.Count);

            //Normal file size == 10,000,000 bytes
            //GZipped file size == 85,113
            //Deflated file size == 85,095
            // 18 bytes is related to the GZip CRC
            
            fs.Close();
        }

        public static void NormalFile(Stream strm, byte[] data)
        {
            BinaryWriter normal = new BinaryWriter(strm);
            normal.Write(data);
            normal.Close();
        }

        public static void CompressFile(Stream strm, byte[] data, CompressionType compressionType)
        {
            // Determine how to compress the file
            Stream deflate = null;
            if (compressionType == CompressionType.Deflate)
                deflate = new DeflateStream(strm, CompressionMode.Compress);
            else
                deflate = new GZipStream(strm, CompressionMode.Compress);

            // Write compressed data to the file
            deflate.Write(data, 0, data.Length);
            
            // Clean up
            deflate.Close();
        }

        public static List<byte> DeCompressFile(Stream strm, CompressionType compressionType)
        {
            // Determine how to decompress the file
            Stream reInflate = null;
            if (compressionType == CompressionType.Deflate)
                reInflate = new DeflateStream(strm, CompressionMode.Decompress);
            else
                reInflate = new GZipStream(strm, CompressionMode.Decompress);
            
            List<byte> data = new List<byte>();
            int retVal = 0;

            // Read all data in and uncompress it
            while (retVal >= 0)
            {
                retVal = reInflate.ReadByte();
                if (retVal != -1)
                    data.Add((byte)retVal);
            }
            
            // Clean up
            reInflate.Close();
            
            return (data);
        }
        
        public enum CompressionType
        {
            Deflate,
            GZip
        }
        #endregion

    }
}

IO 文件的绝大多的操作方法，都在这里，各位可以拿去把他当成一个IO工具类