Code
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工具类
4220
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
