The following console application takes a file path from a command-line argument, and then displays information about the file, the containing directory, and the drive.

using System;
using System.IO;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_01
    {
        static void Main(string[] args)
        {
            if (args.Length == 0)
            {
                Console.WriteLine("Please supply a filename.");
                return;
            }

            // Display file information.
            FileInfo file = new FileInfo(args[0]);

            Console.WriteLine("Checking file: " + file.Name);
            Console.WriteLine("File exists: " + file.Exists.ToString());

            if (file.Exists)
            {
                Console.Write("File created: ");
                Console.WriteLine(file.CreationTime.ToString());
                Console.Write("File last updated: ");
                Console.WriteLine(file.LastWriteTime.ToString());
                Console.Write("File last accessed: ");
                Console.WriteLine(file.LastAccessTime.ToString());
                Console.Write("File size (bytes): ");
                Console.WriteLine(file.Length.ToString());

Console.Write("File attribute list: ");
                Console.WriteLine(file.Attributes.ToString());
            }
            Console.WriteLine();

            // Display directory information.
            DirectoryInfo dir = file.Directory;

            Console.WriteLine("Checking directory: " + dir.Name);
            Console.WriteLine("In directory: " + dir.Parent.Name);
            Console.Write("Directory exists: ");
            Console.WriteLine(dir.Exists.ToString());

            if (dir.Exists)
            {
                Console.Write("Directory created: ");
                Console.WriteLine(dir.CreationTime.ToString());
                Console.Write("Directory last updated: ");
                Console.WriteLine(dir.LastWriteTime.ToString());
                Console.Write("Directory last accessed: ");
                Console.WriteLine(dir.LastAccessTime.ToString());
                Console.Write("Directory attribute list: ");
                Console.WriteLine(dir.Attributes.ToString());
                Console.WriteLine("Directory contains: " +
                  dir.GetFiles().Length.ToString() + " files");
            }
            Console.WriteLine();

            // Display drive information.
            DriveInfo drv = new DriveInfo(file.FullName);

            Console.Write("Drive: ");
            Console.WriteLine(drv.Name);

            if (drv.IsReady)
            {
                Console.Write("Drive type: ");
                Console.WriteLine(drv.DriveType.ToString());
                Console.Write("Drive format: ");
                Console.WriteLine(drv.DriveFormat.ToString());
                Console.Write("Drive free space: ");
                Console.WriteLine(drv.AvailableFreeSpace.ToString());
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

If you execute the command Recipe05-01.exe c:windowswin.ini, you might expect the following output:

Checking file: win.ini

File exists: True

File created: 31.Mar.2003 5:30:00 PM

File last updated: 24.Sep.2005 11:11:13 PM

File last accessed: 10.Nov.2005 9:41:05 PM

File size (bytes): 658

File attribute list: Archive

Checking directory: windows

In directory: c:

Directory exists: True

Directory created: 04.Jun.2005 4:47:56 PM

Directory last updated: 01.Nov.2005 10:09:45 AM

Directory last accessed: 11.Nov.2005 6:24:59 AM

Directory attribute list: Directory

Directory contains: 134 files

Drive: c:

Drive type: Fixed

Drive format: NTFS

Drive free space: 14045097984

The following example takes a read-only test file and checks for the read-only attribute:

using System;
using System.IO;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_02
    {
        static void Main()
        {
            // This file has the archive and read-only attributes.
            FileInfo file = new FileInfo(@"C:Windowswin.ini");

            // This displays the attributes.
            Console.WriteLine(file.Attributes.ToString());

            // This test fails because other attributes are set.
            if (file.Attributes == FileAttributes.ReadOnly)
            {
                Console.WriteLine("File is read-only (faulty test).");
            }

            // This test succeeds because it filters out just the
            // read-only attribute.
            if ((file.Attributes & FileAttributes.ReadOnly) ==
              FileAttributes.ReadOnly)
            {
                Console.WriteLine("File is read-only (correct test).");
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

When setting an attribute, you must also use bitwise arithmetic, as demonstrated in the following example. In this case, it's needed to ensure that you don't inadvertently clear the other attributes.

// This adds just the read-only attribute.
file.Attributes = file.Attributes | FileAttributes.ReadOnly;

// This removes just the read-only attribute.
file.Attributes = file.Attributes & ~FileAttributes.ReadOnly;

One useful feature that is missing from the DirectoryInfo class is a copy method. Fortunately, you can write this logic easily enough by relying on recursive logic and the FileInfo object.

The following example contains a helper function that can copy any directory, and its contents.

using System;
using System.IO;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_03
    {
        static void Main(string[] args)
        {
            if (args.Length != 2)
            {

Console.WriteLine("USAGE:  " +
                  "Recipe05_03 [sourcePath] [destinationPath]");
                  Console.ReadLine();
                  return;
            }

            DirectoryInfo sourceDir = new DirectoryInfo(args[0]);
            DirectoryInfo destinationDir = new DirectoryInfo(args[1]);

            CopyDirectory(sourceDir, destinationDir);

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }

        static void CopyDirectory(DirectoryInfo source,
            DirectoryInfo destination)
        {
            if (!destination.Exists)
            {
                destination.Create();
            }

            // Copy all files.
            foreach (FileInfo file in source.EnumerateFiles())
            {
                file.CopyTo(Path.Combine(destination.FullName,
                    file.Name));
            }

            // Process subdirectories.
            foreach (DirectoryInfo dir in source.EnumerateDirectories())
            {
                // Get destination directory.
                string destinationDir = Path.Combine(destination.FullName,
                    dir.Name);

                // Call CopyDirectory() recursively.
                CopyDirectory(dir, new DirectoryInfo(destinationDir));
            }
        }
    }
}

The following example calculates the size of a directory and optionally examines contained directories recursively.

using System;
using System.IO;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_04
    {
        static void Main(string[] args)
        {
            if (args.Length == 0)
            {
                Console.WriteLine("Please supply a directory path.");
                return;
            }

            DirectoryInfo dir = new DirectoryInfo(args[0]);
            Console.WriteLine("Total size: " +
              CalculateDirectorySize(dir, true).ToString() +
              " bytes.");

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }

static long CalculateDirectorySize(DirectoryInfo directory,
      bool includeSubdirectories)
        {
            long totalSize = 0;

            // Examine all contained files.
            foreach (FileInfo file in directory.EnumerateFiles())
            {
                totalSize += file.Length;
            }

            // Examine all contained directories.
            if (includeSubdirectories)
            {
                foreach (DirectoryInfo dir in directory.EnumerateDirectories())
                {
                    totalSize += CalculateDirectorySize(dir, true);
                }
            }

            return totalSize;
        }
    }
}

The FileVersionInfo properties are too numerous to list here, but the following code snippet shows an example of what you might retrieve:

using System;
using System.Diagnostics;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_05
    {
        static void Main(string[] args)
        {
            if (args.Length == 0)
            {
                Console.WriteLine("Please supply a filename.");
                return;
            }

            FileVersionInfo info = FileVersionInfo.GetVersionInfo(args[0]);

            // Display version information.
            Console.WriteLine("Checking File: " + info.FileName);
            Console.WriteLine("Product Name: " + info.ProductName);
            Console.WriteLine("Product Version: " + info.ProductVersion);
            Console.WriteLine("Company Name: " + info.CompanyName);
            Console.WriteLine("File Version: " + info.FileVersion);
            Console.WriteLine("File Description: " + info.FileDescription);
            Console.WriteLine("Original Filename: " + info.OriginalFilename);
            Console.WriteLine("Legal Copyright: " + info.LegalCopyright);
            Console.WriteLine("InternalName: " + info.InternalName);
            Console.WriteLine("IsDebug: " + info.IsDebug);
            Console.WriteLine("IsPatched: " + info.IsPatched);
            Console.WriteLine("IsPreRelease: " + info.IsPreRelease);
            Console.WriteLine("IsPrivateBuild: " + info.IsPrivateBuild);
            Console.WriteLine("IsSpecialBuild: " + info.IsSpecialBuild);

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

If you run the command Recipe05_05 c:windowsexplorer.exe, the example produces the following output:

Checking File: c:windowsexplorer.exe

Product Name: Microsoftr Windowsr Operating System

Product Version: 6.00.2900.2180

Company Name: Microsoft Corporation

File Version: 6.00.2900.2180 (xpsp_sp2_rtm.040803-2158)

File Description: Windows Explorer

Original Filename: EXPLORER.EXE

Legal Copyright: c Microsoft Corporation. All rights reserved.

InternalName: explorer

IsDebug: False

IsPatched: False

IsPreRelease: False

IsPrivateBuild: False

IsSpecialBuild: False

The following shows the code element of a Windows Forms application that demonstrates this recipe. Download the source code that accompanies this book for the full Visual Studio project.

using System;
using System.Windows.Forms;
using System.IO;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    public partial class DirectoryTree : Form
    {
        public DirectoryTree()
        {
            InitializeComponent();
        }

        private void DirectoryTree_Load(object sender, EventArgs e)
        {
            // Set the first node.
            TreeNode rootNode = new TreeNode(@"C:");
            treeDirectory.Nodes.Add(rootNode);

// Fill the first level and expand it.
            Fill(rootNode);
            treeDirectory.Nodes[0].Expand();
        }

        private void treeDirectory_BeforeExpand(object sender,
            TreeViewCancelEventArgs e)
        {
            // If a dummy node is found, remove it and read the
            // real directory list.
            if (e.Node.Nodes[0].Text == "*")
            {
                e.Node.Nodes.Clear();
                Fill(e.Node);
            }
        }

        private void Fill(TreeNode dirNode)
        {
            DirectoryInfo dir = new DirectoryInfo(dirNode.FullPath);

            // An exception could be thrown in this code if you don't
            // have sufficient security permissions for a file or directory.
            // You can catch and then ignore this exception.
            foreach (DirectoryInfo dirItem in dir.GetDirectories())
            {
                // Add node for the directory.
                TreeNode newNode = new TreeNode(dirItem.Name);
                dirNode.Nodes.Add(newNode);
                newNode.Nodes.Add("*");
            }
        }
    }
}

Figure 5-1 shows the directory tree in action.

Figure 5.1. A directory tree with the TreeView

The following console application writes and then reads a text file:

using System;
using System.IO;
using System.Text;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_07
    {
        static void Main()
        {
            // Create a new file.
            using (FileStream fs = new FileStream("test.txt", FileMode.Create))
            {
                // Create a writer and specify the encoding.
                // The default (UTF-8) supports special Unicode characters,
                // but encodes all standard characters in the same way as
                // ASCII encoding.

using (StreamWriter w = new StreamWriter(fs, Encoding.UTF8))
                {
                    // Write a decimal, string, and char.
                    w.WriteLine(124.23M);
                    w.WriteLine("Test string");
                    w.WriteLine('!'),
                }
            }
            Console.WriteLine("Press Enter to read the information.");
            Console.ReadLine();

            // Open the file in read-only mode.
            using (FileStream fs = new FileStream("test.txt", FileMode.Open))
            {
                using (StreamReader r = new StreamReader(fs, Encoding.UTF8))
                {
                    // Read the data and convert it to the appropriate data type.
                    Console.WriteLine(Decimal.Parse(r.ReadLine()));
                    Console.WriteLine(r.ReadLine());
                    Console.WriteLine(Char.Parse(r.ReadLine()));
                }
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

Running the program creates a file that contains the following content:

124.23

Test string

!

The following console application writes and then reads a binary file:

using System;
using System.IO;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_08
    {
        static void Main()
        {
            // Create a new file and writer.
            using (FileStream fs = new FileStream("test.bin", FileMode.Create))
            {
                using (BinaryWriter w = new BinaryWriter(fs))
                {
                    // Write a decimal, two strings, and a char.
                    w.Write(124.23M);
                    w.Write("Test string");
                    w.Write("Test string 2");
                    w.Write('!'),
                }
            }
            Console.WriteLine("Press Enter to read the information.");
            Console.ReadLine();

// Open the file in read-only mode.
            using (FileStream fs = new FileStream("test.bin", FileMode.Open))
            {
                // Display the raw information in the file.
                using (StreamReader sr = new StreamReader(fs))
                {
                    Console.WriteLine(sr.ReadToEnd());
                    Console.WriteLine();

                    // Read the data and convert it to the appropriate data type.
                    fs.Position = 0;
                    using (BinaryReader br = new BinaryReader(fs))
                    {
                        Console.WriteLine(br.ReadDecimal());
                        Console.WriteLine(br.ReadString());
                        Console.WriteLine(br.ReadString());
                        Console.WriteLine(br.ReadChar());
                    }
                }
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example demonstrates reading a file asynchronously. The AsyncProcessor class provides a public StartProcess method, which starts an asynchronous read. Every time the read operation finishes, the OnCompletedRead callback is triggered and the block of data is processed. If there is more data in the file, a new asynchronous read operation is started. AsyncProcessor reads 2 kilobytes (2048 bytes) at a time.

using System;
using System.IO;
using System.Threading;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    public class AsyncProcessor
    {
        private Stream inputStream;

        // The amount that will be read in one block (2KB).
        private int bufferSize = 2048;

        public int BufferSize
        {
            get { return bufferSize; }
            set { bufferSize = value; }
        }

        // The buffer that will hold the retrieved data.
        private byte[] buffer;

        public AsyncProcessor(string fileName)
        {
            buffer = new byte[bufferSize];

// Open the file, specifying true for asynchronous support.
            inputStream = new FileStream(fileName, FileMode.Open,
              FileAccess.Read, FileShare.Read, bufferSize, true);
        }

        public void StartProcess()
        {

            // Start the asynchronous read, which will fill the buffer.
            inputStream.BeginRead(buffer, 0, buffer.Length,
              OnCompletedRead, null);
        }

        private void OnCompletedRead(IAsyncResult asyncResult)
        {
            // One block has been read asynchronously.
            // Retrieve the data.
            int bytesRead = inputStream.EndRead(asyncResult);

            // If no bytes are read, the stream is at the end of the file.
            if (bytesRead > 0)
            {
                // Pause to simulate processing this block of data.
                Console.WriteLine("	[ASYNC READER]: Read one block.");
                Thread.Sleep(TimeSpan.FromMilliseconds(20));

                // Begin to read the next block asynchronously.
                inputStream.BeginRead(
                buffer, 0, buffer.Length, OnCompletedRead,
                  null);
            }
            else
            {
                // End the operation.
                Console.WriteLine("	[ASYNC READER]: Complete.");
                inputStream.Close();
            }
        }
    }
}

The following example shows a console application that uses AsyncProcessor to read a 2MB file:

using System;
using System.IO;
using System.Threading;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_09
    {
        static void Main(string[] args)
        {
            // Create a test file.
            using (FileStream fs = new FileStream("test.txt", FileMode.Create))
            {
                fs.SetLength(100000);
            }

            // Start the asynchronous file processor on another thread.
            AsyncProcessor asyncIO = new AsyncProcessor("test.txt");
            asyncIO.StartProcess();

            // At the same time, do some other work.
            // In this example, we simply loop for 10 seconds.
            DateTime startTime = DateTime.Now;
            while (DateTime.Now.Subtract(startTime).TotalSeconds < 2)
            {
                Console.WriteLine("[MAIN THREAD]: Doing some work.");

                // Pause to simulate a time-consuming operation.
                Thread.Sleep(TimeSpan.FromMilliseconds(100));
            }

            Console.WriteLine("[MAIN THREAD]: Complete.");
            Console.ReadLine();

            // Remove the test file.
            File.Delete("test.txt");
        }
    }
}

The following is an example of the output you will see when you run this test:

[MAIN THREAD]: Doing some work.

        [ASYNC READER]: Read one block.

        [ASYNC READER]: Read one block.

[MAIN THREAD]: Doing some work.

        [ASYNC READER]: Read one block.

        [ASYNC READER]: Read one block.

[ASYNC READER]: Read one block.

        [ASYNC READER]: Read one block.

[MAIN THREAD]: Doing some work.

        [ASYNC READER]: Read one block.

        [ASYNC READER]: Read one block.

        [ASYNC READER]: Read one block.

        . . .

The following example retrieves the names of all the files in a specified directory that match a specified filter string. The directory and filter expression are submitted as command-line arguments. The code then iterates through the retrieved FileInfo collection of matching files and displays the name and size of each one:

using System;
using System.IO;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_10
    {
        static void Main(string[] args)
        {
            if (args.Length != 2)
            {
                Console.WriteLine(
                  "USAGE:  Recipe05_10 [directory] [filterExpression]");
                return;
            }

            DirectoryInfo dir = new DirectoryInfo(args[0]);
            FileInfo[] files = dir.GetFiles(args[1]);

            // Display the name of all the files.
            foreach (FileInfo file in files)
            {
                Console.Write("Name: " + file.Name + "  ");
                Console.WriteLine("Size: " + file.Length.ToString());
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example demonstrates a simple console application that reads two file names that are supplied as arguments and uses hash codes to test the files for equality. The hashes are compared by converting them into strings. Alternatively, you could compare them by iterating over the byte array and comparing each value. This approach would be slightly faster, but because the overhead of converting 20 bytes into a string is minimal, it's not required.

using System;
using System.IO;
using System.Security.Cryptography;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_11
    {
        static void Main(string[] args)
        {
            if (args.Length != 2)
            {
                Console.WriteLine("USAGE:  Recipe05_11 [fileName] [fileName]");
                return;
            }

            Console.WriteLine("Comparing " + args[0] + " and " + args[1]);

            // Create the hashing object.
            using (HashAlgorithm hashAlg = HashAlgorithm.Create())
            {
                using (FileStream fsA = new FileStream(args[0], FileMode.Open),
                    fsB = new FileStream(args[1], FileMode.Open))
                {
                    // Calculate the hash for the files.
                    byte[] hashBytesA = hashAlg.ComputeHash(fsA);
                    byte[] hashBytesB = hashAlg.ComputeHash(fsB);

// Compare the hashes.
                    if (BitConverter.ToString(hashBytesA) ==
                        BitConverter.ToString(hashBytesB))
                    {
                        Console.WriteLine("Files match.");
                    }
                    else
                    {
                        Console.WriteLine("No match.");
                    }
                }
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example demonstrates how you can quickly determine if a path corresponds to a file or directory:

using System;
using System.IO;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_13
    {
        static void Main(string[] args)
        {
            foreach (string arg in args)
            {
                Console.Write(arg);

                if (Directory.Exists(arg))
                {
                    Console.WriteLine(" is a directory");
                }
                else if (File.Exists(arg))
                {
                    Console.WriteLine(" is a file");
                }

else
                {
                    Console.WriteLine(" does not exist");
                }
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following is a simple example that demonstrates working with relative paths:

using System;
using System.IO;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_14
    {
        static void Main()
        {

Console.WriteLine("Using: " + Directory.GetCurrentDirectory());
            Console.WriteLine("The relative path 'file.txt' " +
              "will automatically become: '" +
              Path.GetFullPath("file.txt") + "'");

            Console.WriteLine();

            Console.WriteLine("Changing current directory to c:\");
            Directory.SetCurrentDirectory(@"c:");

            Console.WriteLine("Now the relative path 'file.txt' " +
              "will automatically become '" +
              Path.GetFullPath("file.txt") + "'");

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The output for this example might be the following (if you run the application in the directory C: emp):

Using: c:	emp

The relative path 'file.txt' will automatically become 'c:	empfile.txt'



Changing current directory to c:

The relative path 'file.txt' will automatically become 'c:file.txt'

The following example demonstrates creating a temporary file:

using System;
using System.IO;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_15
    {
        static void Main()
        {
            string tempFile = Path.GetTempFileName();

            Console.WriteLine("Using " + tempFile);

            using (FileStream fs = new FileStream(tempFile, FileMode.Open))
            {
                // (Write some data.)
            }

            // Now delete the file.
            File.Delete(tempFile);

// Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following console application shows the available free space using the DriveInfo class for the given drive or for all logical drives if no argument is passed to the application:

using System;
using System.IO;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_16
    {
        static void Main(string[] args)
        {
            if (args.Length == 1)
            {
                DriveInfo drive = new DriveInfo(args[0]);

                Console.Write("Free space in {0}-drive (in kilobytes): ", args[0]);
                Console.WriteLine(drive.AvailableFreeSpace / 1024);
                Console.ReadLine();
                return;
            }

            foreach (DriveInfo drive in DriveInfo.GetDrives())
            {
                try
                {
                    Console.WriteLine(
                        "{0} - {1} KB",
                        drive.RootDirectory,
                        drive.AvailableFreeSpace / 1024
                        );
                }
                catch (IOException) // network drives may not be available
                {
                    Console.WriteLine(drive);
                }
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following code shows the code part of a Windows Forms application that allows the user to load documents into a RichTextBox, edit the content, and then save the modified document. When opening and saving a document, the OpenFileDialog and SaveFileDialog classes are used. Download the source code that accompanies this book from www.apress.com/book/sourcecode to see the full Visual Studio project.

using System;
using System.Windows.Forms;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    public partial class MainForm : Form
    {
        public MainForm()
        {
            InitializeComponent();
        }

private void mnuOpen_Click(object sender, EventArgs e)
        {
            OpenFileDialog dlg = new OpenFileDialog();
            dlg.Filter = "Rich Text Files (*.rtf)|*.RTF|" +
              "All files (*.*)|*.*";
            dlg.CheckFileExists = true;
            dlg.InitialDirectory = Application.StartupPath;

            if (dlg.ShowDialog() == DialogResult.OK)
            {
                rtDoc.LoadFile(dlg.FileName);
                rtDoc.Enabled = true;
            }
        }

        private void mnuSave_Click(object sender, EventArgs e)
        {
            SaveFileDialog dlg = new SaveFileDialog();
            dlg.Filter = "RichText Files (*.rtf)|*.RTF|Text Files (*.txt)|*.TXT" +
              "|All files (*.*)|*.*";
            dlg.CheckFileExists = true;
            dlg.InitialDirectory = Application.StartupPath;

            if (dlg.ShowDialog() == DialogResult.OK)
            {
                rtDoc.SaveFile(dlg.FileName);
            }
        }

        private void mnuExit_Click(object sender, EventArgs e)
        {
            this.Close();
        }
    }
}

The following example shows how you can access isolated storage:

using System;
using System.IO;
using System.IO.IsolatedStorage;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_18
    {
        static void Main(string[] args)
        {
            // Create the store for the current user.
            using (IsolatedStorageFile store =

IsolatedStorageFile.GetUserStoreForAssembly())
            {
                // Create a folder in the root of the isolated store.
                store.CreateDirectory("MyFolder");

                // Create a file in the isolated store.
                using (Stream fs = new IsolatedStorageFileStream(
                  "MyFile.txt", FileMode.Create, store))
                {
                    StreamWriter w = new StreamWriter(fs);

                    // You can now write to the file as normal.
                    w.WriteLine("Test");
                    w.Flush();
                }

                Console.WriteLine("Current size: " +
                    store.UsedSize.ToString());
                Console.WriteLine("Scope: " + store.Scope.ToString());

                Console.WriteLine("Contained files include:");
                string[] files = store.GetFileNames("*.*");
                foreach (string file in files)
                {
                    Console.WriteLine(file);
                }
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following demonstrates using multiple AppDomain instances running in the same application to receive different isolated stores:

// Access isolated storage for the current user and assembly
// (which is equivalent to the first example).
store = IsolatedStorageFile.GetStore(IsolatedStorageScope.User |
  IsolatedStorageScope.Assembly, null, null);

// Access isolated storage for the current user, assembly,
// and application domain. In other words, this data is
// accessible only by the current AppDomain instance.
store = IsolatedStorageFile.GetStore(IsolatedStorageScope.User |
  IsolatedStorageScope.Assembly | IsolatedStorageScope.Domain,
  null, null);

The following example shows a console application that handles Created and Deleted events, and tests these events by creating a test file:

using System;
using System.IO;
using System.Windows.Forms;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_19
    {
        static void Main()
        {
            // Configure the FileSystemWatcher.
            using (FileSystemWatcher watch = new FileSystemWatcher())
            {
                watch.Path = Application.StartupPath;
                watch.Filter = "*.*";
                watch.IncludeSubdirectories = true;

                // Attach the event handler.
                watch.Created += new FileSystemEventHandler(OnCreatedOrDeleted);
                watch.Deleted += new FileSystemEventHandler(OnCreatedOrDeleted);
                watch.EnableRaisingEvents = true;

                Console.WriteLine("Press Enter to create a file.");
                Console.ReadLine();

                if (File.Exists("test.bin"))
                {
                    File.Delete("test.bin");
                }

                // Create test.bin.
                using (FileStream fs = new FileStream("test.bin", FileMode.Create))
                {
                    // Do something.
                }

                Console.WriteLine("Press Enter to terminate the application.");
                Console.ReadLine();
            }

// Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }

        // Fires when a new file is created in the directory being monitored.
        private static void OnCreatedOrDeleted(object sender,
          FileSystemEventArgs e)
        {
            // Display the notification information.
            Console.WriteLine("	NOTIFICATION: " + e.FullPath +
              "' was " + e.ChangeType.ToString());
            Console.WriteLine();
        }
    }
}

The following example demonstrates a simple console application that writes a string into the COM1 port:

using System;
using System.IO.Ports;

namespace Apress.VisualCSharpRecipes.Chapter05
{

static class Recipe05_20
    {
        static void Main(string[] args)
        {
            using (SerialPort port = new SerialPort("COM1"))
            {
                // Set the properties.
                port.BaudRate = 9600;
                port.Parity = Parity.None;
                port.ReadTimeout = 10;
                port.StopBits = StopBits.One;

                // Write a message into the port.
                port.Open();
                port.Write("Hello world!");

                Console.WriteLine("Wrote to the port.");
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example demonstrates using a random file name. Note that this example differs from that in recipe 5-15 in that we have to ensure that the file exists before opening it—we do this be using the FileMode.OpenOrCreate enumeration value as an argument to the constructor of FileStream.

using System;
using System.IO;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_21
    {
        static void Main()
        {
            string tempFile = Path.GetRandomFileName();

            Console.WriteLine("Using " + tempFile);

            using (FileStream fs = new FileStream(tempFile, FileMode.OpenOrCreate))
            {
                // (Write some data.)
            }

            // Now delete the file.
            File.Delete(tempFile);

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example demonstrates the effect of denying Everyone Read access to a temporary file, using a console application. An attempt to read the file after a change in the ACL triggers a security exception.

using System;
using System.IO;
using System.Security.AccessControl;

namespace Apress.VisualCSharpRecipes.Chapter05
{
    static class Recipe05_22
    {
        static void Main(string[] args)
        {
            FileStream stream;
            string fileName;

            // Create a new file and assign full control to 'Everyone'.
            Console.WriteLine("Press any key to write a new file...");
            Console.ReadKey(true);

            fileName = Path.GetRandomFileName();
            using (stream = new FileStream(fileName, FileMode.Create))
            {
                // Do something.
            }
            Console.WriteLine("Created a new file " + fileName + ".");
            Console.WriteLine();


            // Deny 'Everyone' access to the file
            Console.WriteLine("Press any key to deny 'Everyone' " +
                "access to the file...");
            Console.ReadKey(true);
            SetRule(fileName, "Everyone",
                FileSystemRights.Read, AccessControlType.Deny);

Console.WriteLine("Removed access rights of 'Everyone'.");
            Console.WriteLine();


            // Attempt to access file.
            Console.WriteLine("Press any key to attempt " +
                "access to the file...");
            Console.ReadKey(true);

            try
            {
                stream = new FileStream(fileName, FileMode.Create);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Exception thrown: ");
                Console.WriteLine(ex.ToString());
            }
            finally
            {
                stream.Close();
                stream.Dispose();
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }

        static void AddRule(string filePath, string account,
            FileSystemRights rights, AccessControlType controlType)
        {
            // Get a FileSecurity object that represents the
            // current security settings.
            FileSecurity fSecurity = File.GetAccessControl(filePath);

            // Add the FileSystemAccessRule to the security settings.
            fSecurity.AddAccessRule(new FileSystemAccessRule(account,
                rights, controlType));

            // Set the new access settings.
            File.SetAccessControl(filePath, fSecurity);
        }

        static void SetRule(string filePath, string account,
            FileSystemRights rights, AccessControlType controlType)
        {
            // Get a FileSecurity object that represents the
            // current security settings.
            FileSecurity fSecurity = File.GetAccessControl(filePath);

// Add the FileSystemAccessRule to the security settings.
            fSecurity.ResetAccessRule(new FileSystemAccessRule(account,
                rights, controlType));

            // Set the new access settings.
            File.SetAccessControl(filePath, fSecurity);
        }

    }
}

The following sample creates a new file and uses the GZipStream class to write compressed data to it from a StreamWriter instance. The file is closed and then opened in read mode so that the compressed data can be decompressed and written to the console:

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

namespace Recipe05_23
{
    class Recipe05_23
    {
        static void Main(string[] args)
        {
            // Create the compression stream.
            GZipStream zipout = new GZipStream(
                File.OpenWrite("compressed_data.gzip"),
                CompressionMode.Compress);
            // wrap the gzip stream in a stream writer
            StreamWriter writer = new StreamWriter(zipout);

            // Write the data to the file.
            writer.WriteLine("the quick brown fox");
            // Close the streams.
            writer.Close();

            // Open the same file so we can read the
            // data and decompress it.
            GZipStream zipin = new GZipStream(
                File.OpenRead("compressed_data.gzip"),
                CompressionMode.Decompress);
            // Wrap the gzip stream in a stream reader.
            StreamReader reader = new StreamReader(zipin);

            // Read a line from the stream and print it out.
            Console.WriteLine(reader.ReadLine());

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example creates a List that contains a number of strings, representing two kinds of logging data. All of the entries are written to one file, and LINQ is used to query the collection so that only certain entries are written to a second file. See Chapter 2 for recipes that use LINQ to query collections.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace Recipe05_24
{
    class Recipe05_24
    {
        static void Main(string[] args)
        {
            // Create a list and populate it.
            List<string> myList = new List<string>();
            myList.Add("Log entry 1");
            myList.Add("Log entry 2");
            myList.Add("Log entry 3");
            myList.Add("Error entry 1");
            myList.Add("Error entry 2");
            myList.Add("Error entry 3");

            // Write all of the entries to a file.
            File.WriteAllLines("all_entries.log", myList);

            // Only write out the errors.
            File.WriteAllLines("only_errors.log",
                myList.Where(e => e.StartsWith("Error")));
        }
    }
}

The following example reads lines from one of the files created in the previous recipe. In order to demonstrate how to read entries and be selective with LINQ, the program reads all of the entries, just the entries that begin with "Error" and the first character of entries that do not begin with "Error."

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace Recipe05_25
{
    class Program
    {
        static void Main(string[] args)
        {
            // Read all of the entries from the file.
            IEnumerable<string> alldata = File.ReadAllLines("all_entries.log");
            foreach (string entry in alldata)
            {
                Console.WriteLine("Entry: {0}", entry);
            }

            // Read the entries and select only some of them.
            IEnumerable<string> somedata
               = File.ReadLines("all_entries.log").Where(e => e.StartsWith("Error"));

foreach (string entry in somedata)
            {
                Console.WriteLine("Error entry: {0}", entry);
            }

            // Read selected lines and write only the first character.
            IEnumerable<char> chardata = File.ReadLines("all_entries.log").Where(e
               => !e.StartsWith("Error")).Select(e => e[0]);
            foreach (char entry in chardata)
            {
                Console.WriteLine("Character entry: {0}", entry);
            }
        }
    }
}

The following example contains both a pipe server and a pipe client in one class—if the executable is started with the command-line argument client, then the pipe client will operate; otherwise, the pipe server will run. The server creates a named pipe and waits for a client to connect. When the client connects, the server writes ten messages to the client, and then reads ten responses.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.IO.Pipes;

namespace Recipe05_26
{
    class Recipe05_26
    {
        static void Main(string[] args)
        {
            if (args.Length > 0 && args[0] == "client")
            {
                pipeClient();
            }
            else
            {
                pipeServer();
            }
        }

        static void pipeServer()
        {
            // Create the server pipe.
            NamedPipeServerStream pipestream = new
 NamedPipeServerStream("recipe_05_26_pipe");
            // Wait for a client to connect.
            Console.WriteLine("Waiting for a client connection");
            pipestream.WaitForConnection();

            Console.WriteLine("Received a client connection");
            // Wrap a stream writer and stream reader around the pipe.
            StreamReader reader = new StreamReader(pipestream);
            StreamWriter writer = new StreamWriter(pipestream);

            // Write some data to the pipe.
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("Writing message ", i);
                writer.WriteLine("Message {0}", i);
                writer.Flush();
            }

// Read data from the pipe.
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("Received: {0}", reader.ReadLine()); ;
            }
            // Close the pipe.
            pipestream.Close();
        }

        static void pipeClient()
        {
            // Create the client pipe.
            NamedPipeClientStream pipestream =
 new NamedPipeClientStream("recipe_05_26_pipe");
            // connect to the pipe server
            pipestream.Connect();

            // Wrap a reader around the stream.
            StreamReader reader = new StreamReader(pipestream);
            StreamWriter writer = new StreamWriter(pipestream);

            // Read the data.
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("Received: {0}", reader.ReadLine());
            }

            // Write data to the pipe.
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("Writing response ", i);
                writer.WriteLine("Response {0}", i);
                writer.Flush();
            }
            // Close the pipe.
            pipestream.Close();
        }
    }
}