using System;

using System.IO;

class DirectoryCopyExample

{

    static void Main()

    {

        DirectoryCopy(".", @".\temp", true);

    }

    private static void DirectoryCopy(

        string sourceDirName, string destDirName, bool copySubDirs)

    {

      DirectoryInfo dir = new DirectoryInfo(sourceDirName);

      DirectoryInfo[] dirs = dir.GetDirectories();

      // If the source directory does not exist, throw an exception.

        if (!dir.Exists)

        {

            throw new DirectoryNotFoundException(

                "Source directory does not exist or could not be found: "

                + sourceDirName);

        }

        // If the destination directory does not exist, create it.

        if (!Directory.Exists(destDirName))

        {

            Directory.CreateDirectory(destDirName);

        }

        // Get the file contents of the directory to copy.

        FileInfo[] files = dir.GetFiles();

        foreach (FileInfo file in files)

        {

            // Create the path to the new copy of the file.

            string temppath = Path.Combine(destDirName, file.Name);

            // Copy the file.

            file.CopyTo(temppath, false);

        }

        // If copySubDirs is true, copy the subdirectories.

        if (copySubDirs)

        {

            foreach (DirectoryInfo subdir in dirs)

            {

                // Create the subdirectory.

                string temppath = Path.Combine(destDirName, subdir.Name);

                // Copy the subdirectories.

                DirectoryCopy(subdir.FullName, temppath, copySubDirs);

            }

        }

    }

}

using System;

using System.IO;

public class DirectoryLister

{

    public static void Main(String[] args)

    {

        string path = Environment.CurrentDirectory;

        if (args.Length > 0)

        {

            if (Directory.Exists(args[0]))

            {

                path = args[0];

            }

            else

            {

                Console.WriteLine("{0} not found; using current directory:",

                    args[0]);

            }

        }

        DirectoryInfo dir = new DirectoryInfo(path);

        foreach (FileInfo f in dir.GetFiles("*.exe"))

        {

            string name = f.Name;

            long size = f.Length;

            DateTime creationTime = f.CreationTime;

            Console.WriteLine("{0,-12:N0} {1,-20:g} {2}", size,

                creationTime, name);

        }

    }

}

using System;

using System.IO;

class MyStream

{

    private const string FILE_NAME = "Test.data";

    public static void Main()

    {

        // Create the new, empty data file.

        if (File.Exists(FILE_NAME))

        {

            Console.WriteLine("{0} already exists!", FILE_NAME);

            return;

        }

        using (FileStream fs = new FileStream(FILE_NAME, FileMode.CreateNew))

        {

            // Create the writer for data.

            using (BinaryWriter w = new BinaryWriter(fs))

            {

                // Write data to Test.data.

                for (int i = 0; i < 11; i++)

                {

                    w.Write(i);

                }

            }

        }

        // Create the reader for data.

        using (FileStream fs = new FileStream(FILE_NAME, FileMode.Open, FileAccess.Read))

        {

            using (BinaryReader r = new BinaryReader(fs))

            {

                // Read data from Test.data.

                for (int i = 0; i < 11; i++)

                {

                    Console.WriteLine(r.ReadInt32());

                }

            }

        }

    }

}

using System;

using System.IO;

class DirAppend

{

    public static void Main()

    {

        using (StreamWriter w = File.AppendText("log.txt"))

        {

            Log("Test1", w);

            Log("Test2", w);

            // Close the writer and underlying file.

            w.Close();

        }

        // Open and read the file.

        using (StreamReader r = File.OpenText("log.txt"))

        {

            DumpLog(r);

        }

    }

    public static void Log(string logMessage, TextWriter w)

    {

        w.Write("\r\nLog Entry : ");

        w.WriteLine("{0} {1}", DateTime.Now.ToLongTimeString(),

            DateTime.Now.ToLongDateString());

        w.WriteLine("  :");

        w.WriteLine("  :{0}", logMessage);

        w.WriteLine ("-------------------------------");

        // Update the underlying file.

        w.Flush();

    }

    public static void DumpLog(StreamReader r)

    {

        // While not at the end of the file, read and write lines.

        string line;

        while ((line = r.ReadLine()) != null)

        {

            Console.WriteLine(line);

        }

        r.Close();

    }

}

using System;

using System.IO;

using System.Text;

using System.Collections.Generic;

class Program

{

    static void Main(string[] args)

    {

        string mydocpath =

        	Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

        StringBuilder sb = new StringBuilder();

        foreach (string txtName in Directory.EnumerateFiles(mydocpath,"*.txt"))

        {

            using (StreamReader sr = new StreamReader(txtName))

            {

                sb.AppendLine(txtName.ToString());

                sb.AppendLine("= = = = = =");

                sb.Append(sr.ReadToEnd());

                sb.AppendLine();

                sb.AppendLine();

            }

        }

        using (StreamWriter outfile =

        	new StreamWriter(mydocpath + @"\AllTxtFiles.txt"))

        {

            outfile.Write(sb.ToString());

        }

    }

}

using System;

using System.IO;

class Test

{

    public static void Main()

    {

        try

        {

            // Create an instance of StreamReader to read from a file.

            // The using statement also closes the StreamReader.

            using (StreamReader sr = new StreamReader("TestFile.txt"))

            {

                String line;

                // Read and display lines from the file until the end of

                // the file is reached.

                while ((line = sr.ReadLine()) != null)

                {

                    Console.WriteLine(line);

                }

            }

        }

        catch (Exception e)

        {

            // Let the user know what went wrong.

            Console.WriteLine("The file could not be read:");

            Console.WriteLine(e.Message);

        }

    }

}

using System;

using System.IO;

public class TextFromFile

{

    private const string FILE_NAME = "MyFile.txt";

    public static void Main()

    {

        if (!File.Exists(FILE_NAME))

        {

            Console.WriteLine("{0} does not exist.", FILE_NAME);

            return;

        }

        using (StreamReader sr = File.OpenText(FILE_NAME))

        {

            String input;

            while ((input = sr.ReadLine()) != null)

            {

                Console.WriteLine(input);

            }

            Console.WriteLine ("The end of the stream has been reached.");

        }

    }

}

using System;

using System.IO;

public class CharsFromStr

{

    public static void Main()

    {

        // Create a string to read characters from.

        string str = "Some number of characters";

        // Make a char array the size of the source string

        char[] b = new char[str.Length];

        // Create an instance of StringReader and attach it to the string.

        StringReader sr = new StringReader(str);

        // Read 13 characters into the array that holds the string,

        // starting at the third array member.

        sr.Read(b, 0, 13);

        // Display the output.

        Console.WriteLine(b);

        // Read the rest of the string from the current position in the

        // source string into the array, starting at the 6th array member.

        sr.Read(b, 5, str.Length - 13);

        // Display the output.

        Console.WriteLine(b);

        // Close the StringReader.

        sr.Close();

    }

}

// The example has the following output:

//

// Some number o

// Some f characters

using System;

using System.IO;

using System.Text;

public class CharsToStr

{

    public static void Main()

    {

        // Create an instance of StringBuilder that can then be modified.

        StringBuilder sb = new StringBuilder("Some number of characters");

        // Define and create an instance of a character array from which

        // characters will be read into the StringBuilder.

        char[] b = {' ','t','o',' ','w','r','i','t','e',' ','t','o','.'};

        // Create an instance of StringWriter

        // and attach it to the StringBuilder.

        StringWriter sw = new StringWriter(sb);

        // Write three characters from the array into the StringBuilder.

        sw.Write(b, 0, 3);

        // Display the output.

        Console.WriteLine(sb);

        // Close the StringWriter.

        sw.Close();

    }

}

using System;

using System.Text;

public class Example

{

   public static void Main()

   {

      StringBuilder sb = new StringBuilder();

      bool flag = true;

      string[] spellings = { "recieve", "receeve", "receive" };

      sb.AppendFormat("Which of the following spellings is {0}:", flag);

      sb.AppendLine();

      for (int ctr = 0; ctr <= spellings.GetUpperBound(0); ctr++) {

         sb.AppendFormat("   {0}. {1}", ctr, spellings[ctr]);

         sb.AppendLine();

      }

      sb.AppendLine();

      Console.WriteLine(sb.ToString());

   }

}

// The example displays the following output:

//       Which of the following spellings is True:

//          0. recieve

//          1. receeve

//          2. receive

using System;

using System.IO;

using System.Security.AccessControl;

namespace FileSystemExample

{

    class FileExample

    {

        public static void Main()

        {

            try

            {

                string fileName = "test.xml";

                Console.WriteLine("Adding access control entry for "

                    + fileName);

                // Add the access control entry to the file.

                AddFileSecurity(fileName, @"DomainName\AccountName",

                    FileSystemRights.ReadData, AccessControlType.Allow);

                Console.WriteLine("Removing access control entry from "

                    + fileName);

                // Remove the access control entry from the file.

                RemoveFileSecurity(fileName, @"DomainName\AccountName",

                    FileSystemRights.ReadData, AccessControlType.Allow);

                Console.WriteLine("Done.");

            }

            catch (Exception e)

            {

                Console.WriteLine(e);

            }

        }

        // Adds an ACL entry on the specified file for the specified account.

        public static void AddFileSecurity(string fileName, string account,

            FileSystemRights rights, AccessControlType controlType)

        {

            // Get a FileSecurity object that represents the

            // current security settings.

            FileSecurity fSecurity = File.GetAccessControl(fileName);

            // Add the FileSystemAccessRule to the security settings.

            fSecurity.AddAccessRule(new FileSystemAccessRule(account,

                rights, controlType));

            // Set the new access settings.

            File.SetAccessControl(fileName, fSecurity);

        }

        // Removes an ACL entry on the specified file for the specified account.

        public static void RemoveFileSecurity(string fileName, string account,

            FileSystemRights rights, AccessControlType controlType)

        {

            // Get a FileSecurity object that represents the

            // current security settings.

            FileSecurity fSecurity = File.GetAccessControl(fileName);

            // Remove the FileSystemAccessRule from the security settings.

            fSecurity.RemoveAccessRule(new FileSystemAccessRule(account,

                rights, controlType));

            // Set the new access settings.

            File.SetAccessControl(fileName, fSecurity);

        }

    }

}

using System;

using System.IO;

using System.IO.Compression;

namespace zip

{

    public class Program

    {

        public static void Main()

        {

            // Path to directory of files to compress and decompress.

            string dirpath = @"c:\users\public\reports";

            DirectoryInfo di = new DirectoryInfo(dirpath);

            // Compress the directory's files.

            foreach (FileInfo fi in di.GetFiles())

            {

                Compress(fi);

            }

            // Decompress all *.gz files in the directory.

            foreach (FileInfo fi in di.GetFiles("*.gz"))

            {

                Decompress(fi);

            }

        }

        public static void Compress(FileInfo fi)

        {

            // Get the stream of the source file.

            using (FileStream inFile = fi.OpenRead())

            {

                // Prevent compressing hidden and

                // already compressed files.

                if ((File.GetAttributes(fi.FullName)

                	& FileAttributes.Hidden)

                	!= FileAttributes.Hidden & fi.Extension != ".gz")

                {

                    // Create the compressed file.

                    using (FileStream outFile =

                    			File.Create(fi.FullName + ".gz"))

                    {

                        using (GZipStream Compress =

                        	new GZipStream(outFile,

                        	CompressionMode.Compress))

                        {

                            // Copy the source file into

                            // the compression stream.

                        inFile.CopyTo(Compress);

                            Console.WriteLine("Compressed {0} from {1} to {2} bytes.",

                                fi.Name, fi.Length.ToString(), outFile.Length.ToString());

                        }

                    }

                }

            }

        }

        public static void Decompress(FileInfo fi)

        {

            // Get the stream of the source file.

            using (FileStream inFile = fi.OpenRead())

            {

                // Get original file extension, for example

                // "doc" from report.doc.gz.

                string curFile = fi.FullName;

                string origName = curFile.Remove(curFile.Length -

                		fi.Extension.Length);

                //Create the decompressed file.

                using (FileStream outFile = File.Create(origName))

                {

                    using (GZipStream Decompress = new GZipStream(inFile,

                            CompressionMode.Decompress))

                    {

                        // Copy the decompression stream

                        // into the output file.

            		    Decompress.CopyTo(outFile);

                        Console.WriteLine("Decompressed: {0}", fi.Name);

                    }

                }

            }

        }

    }

}