• Creating Files Programmatically
• Reading Files
• Checking For File Existence
• Moving a File to Another Location

Source code used in this tutorial:

• readerwriter.cs
• streamreader.cs
• char_by_char.cs
• file_attributes.cs
• file_copy.cs

Creating Files Programmatically

The first thing you need to know about file operations in C#, such aswriting to a file, reading data from a file, etc., is that you mustplace a using reference to System.IO at the top of your source code (just beneath using System; is a good place):

As you can see in line #2, we include areference to the System.IO namespace, which contains classes forworking with input and output.

We can add a single line of code (line #8) inside our Main() method, to create a text file in our application's directory:

Run the program, then navigate to theapplication's executable directory under your projects folder, toconfirm that "myfile.txt" has indeed been created:

Notice that the file shows 0 Kb, which is what we would expect. We merely created a text file. We did not write any data to it. The file can have any extension you want, not just .txt,or no extension at all, but consider that here we created a text file(see line #8 in the source code) and therefore the file is writtenusing ASCII characters. A binary file is created the same way, justthat instead of using File.CreateText() you use File.Create().At first you won't notice any difference between the text file and thebinary file but it matters a lot because it is stored differently. Youuse the text file for storing text and the binary file for storingnon-text data.

Let's run the program again, but before we doso, let's update the source code so that it will actually cause thecreated text file to contain a line of text. We'll use something calleda StreamWriter object. This object is instantiated from a class in the System.IO namespace that is used for writing data to files.

Now, run the program, then navigate to theapplication directory and examine the "myfile.txt" file. You'll seethat it is no longer an empty file. It should now show 1 Kb:

If you double-click the file and examine its contents, you'll see something like the following:

It should be apparent what is going on here. With the help of a StreamWriterobject, we are writing a string to the text file. You could replace thestring I used, in line # 10, with any string of your choice, such as "Epluribus unum" or "Mi casa su casa". Use the program we just wrote towrite the following line of text to the file: The name is Bond… James Bond. Then exit the program and prepare to write a different program.

Reading a Text File

We can use C# to read either text or binary files. For the purpose ofthis introductory level tutorial, we'll only be focusing on text files.In a later tutorial, in another series altogether, I'll address writingand reading binary files.

What we're going to do now is write a programthat will open the "myfile.txt" text file and read the line of textthat it contains. Delete the current code in the project source codewindow, and paste this source code. Run this new program, and you should see the following output:

It is also possible to read text from a file one character at a time. Sometimes this can be useful, although in our previous example, the ReadLine() method of the StreamReaderclass was more appropriate. However, to see how to do it by reading itone character at a time, examine the following source code listing:

Note that we are using an integer variable to hold the value returned by each call to sr.Read();this is due to the fact that the method returns an integer value thatis the ASCII value of the character just read from the file. We thenhave to convert that ASCII value to a character (as you can see in line# 16). Probably the most complex line of code in the source codelisting shown above is line # 14. If the StreamReader object attemptsto read in a character from the file and is unsuccessful due to the endof the file having been reached, a value of negative one is returned.

lass="sm
allblack"> 

Checking For File Existence

If you attempt to open a file that isn't there, an exception will bethrown. Exceptions are ugly. They make users feel that your software isbuggy (not without some justification). You should check to ensure thata particular file exists on disk before attempting to open it. The System.IO namespace provides the FileExists() method, which will return true if the file path you pass into the method as a parameter is valid, or falseif it isn't. If your program creates a file and does not specify a pathfor it, it will, by default, be created in the directory in which theexecutable that is attempting to create the file is located. In C#projects, this will be the Debug or Release directory of the particularproject you're working on. I used this default directory in my examplesabove, where I demonstrated writing to a file, and then reading fromthat file.

You have to be careful about making assumptions when programming. You should not automatically assume that you're current directoryis the application executable's directory, because code can change theworking directory. To demonstrate this, I've added a single line ofcode (line #8 in the image below) to oneof the example programs we did earlier. The only thing line #8 does,below, is set the current directory to somewhere other than theapplication directory (which is where our file was created). You cansee the nasty error that is caused when you assume that you're in thecorrect directory when attempting to open a file.

You may not clearly understand the ratherunusual looking code in the example program for which I provide a linkabove. For example,

if ((fi.Attributes & FileAttributes.ReadOnly) != 0){
   // do this…
}

To break that down for you, simply know that whenever you see something in C# that looks like this:

if((BlahBlahThis & BlahBlahThat) != 0)

…what's being said is "if it's true that thestuff inside the nested parentheses is the case, then do thefollowing…" You can think of !=0 as "not not the case", in other words is the case.

There are other attributes that we didn't usein the code but you can easily figure them out thanks to IntelliSense,if you're using the Visual C# 2005 or the Visual C# 2005 Expressedition IDE.

Moving a File to Another Location

There is a method of the File object named Copy(). You can use it to copy a file from one location to another. Thissource code listing shows an example of copying a file from theapplication directory to your desktop directory. Copying a file doesn'teliminate the original file. If you want to move a file, i.e.,make it disappear from its current location and reappear in anotherdirectory, then you first copy it to the desired destination, thenfollow up by deleting it from the source directory. So, in the aboveexample, you could add the following line immediately after theinvocation of the File object's Copy() method, to change the program's function from copying to moving the file:

File.Delete("myfile.txt"); //deletes original file from the application's executable directory

In this tutorial, I've addressed only the most basic of input and output using the System.IOnamespace. With a reference to this namespace, we've been able to useinstances of the streamreader and streamwriter classes to either openan existing text file and read in its contents, or else write a newtext file to disk. You've also been shown how to read the data from atext file one character at a time, or, alternatively, one entire lineat a time. I've explained the importance of checking for fileexistence, and couching your read/write operations inside a try-catchblock. Although quite basic, you now have the skills to develop asimple computer roleplaying game. We'll be working on that throughoutthe next series, "C# for the Somewhat Initiated",a series that introduces WinForms programming, and some programmingtips and tricks that are bit more advanced than those covered in thisseries' nine tutorials.

Well, I hope that you've benefited, at least a little, from this tutorial and, indeed, all of the tutorials in the "C# for the Completely Uninitiated" series. As ever, I welcome any feedback you may wish to impart. 

HOW TO OPEN (READ) A FILE

Open your new project and name it "filestream",then create a button and in properties change its text to "open textfile to read" and its name to "btn1".
Then double click on option in the toolbar named "open file dialog",immediately the in the form design the "OpenFileDialog1" will appearbelow.

Also Create simple text box and in properties change its text to blank and its name to "text box1".

Also add label to text box where you can giveinstructions to the user that what to do with the text box.Now double click the button "open text file to read" and then add thelibrary "using System.IO" .After this make a following function in theclass as:

private string Read( string file )
{

StreamReader reader = new StreamReader( file );
string data = reader.ReadToEnd ();
reader.Close();

return data;
}

The explanation of this code is very simple.here we have just created a Read function and give it the parameter"file" of type string (so that whatever in the file is read as a stringof characters).in the braces we write the code of reading from the textfile .here StreamReader is associated with System.IO class ,we havecreated object of StreamReader and reserved space for the file with newkeyword ,then we read that file from start to end and stored it in thedata variable of type string, and return that data.After adding this code we will ad the following code in the buttonfunction..

textBox1.Text = "";
DialogResult result = openFileDialog1.ShowDialog();
if ( result == DialogResult.OK )
{
string data = Read( openFileDialog1.FileName );
textBox1.Text = data;
}
else
{

//do nothing
}

In the above code we have justcleared the textbox by "textBox1.Text = """.then in the next statementwe opened the dialog box "DialogResult result=openFileDialog1.ShowDialog()" .In the next statement we used if elsestatement to ensure if the user has selected the file then immediatelythe Read() function will be called(which we have created above) and itwill read from the file and store that contents of the file in thevariable of type "string", and display it in the text box and if userdoesn't select the text file then do nothing.

HOW TO SAVE FILE

Now I am going to tell you about how to saveyour file where ever you want in windows forms . Firstly go to the toolbar and double click on option named "SaveFileDialog"(same procedure asabove).Then Create a button and in properties set its text to "Saveyour file(write extension also)" and its name to "btn2".Double click onthis button and write following function in the class..

private void Save( string file, string data )
{
StreamWriter writer = new StreamWriter(file);
writer.Write(data);
writer.Close();
}

in the above code we have created the functionsave and passed two parameters in it of type string ,next in the braceswe simply write code for writing in the file .here Stream Writer(similar to StreamReader) is associated with the library System.IO.

After this add the following code in the button function..

DialogResult result = saveFileDialog1.ShowDialog();

string file=saveFileDialog1.FileName.ToString();
string data = textBox1.Text;
Save( file, data );

In the above code when user click on savebutton then the save dialog will appear where file name is enterednormally in the dialog box and stored in the variable "file" of typestring and contents of the text box which is entered by the user isstored in variable of type "data".
Then on clicking save button in dialog Box the file will be saved..

Author: BASEER AHMED
Student of: (Bachelor of science in telecommunication engineering)
National university of computer and emerging sciences (FAST)
Pakistan.
E-mail: baseerhmd@gmail.com

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Windows.Forms;
/// <remarks>
/// File Copier – WinForms demonstration program
/// (c) Copyright 2001 Liberty Associates, Inc.
/// </remarks>
namespace FileCopier
{
/// <summary>
/// Form demonstrating Windows Forms implementation
/// </summary>
// < declarations of Windows widgets cut here >
public class Form1 : System.Windows.Forms.Form
{
/// <summary>
/// internal class which knows how to compare
/// two files we want to sort large to small,
/// so reverse the normal return values.
/// </summary>
public class FileComparer : IComparer
{
public int Compare (object f1, object f2)
{
FileInfo file1 = (FileInfo) f1;
FileInfo file2 = (FileInfo) f2;
if (file1.Length > file2.Length)
{
return -1;
}
if (file1.Length < file2.Length)
{
return 1;
}
return 0;
}
}
public Form1( )
{
//
// Required for Windows Form Designer support
//
InitializeComponent( );
// fill the source and target directory trees
FillDirectoryTree(tvwSource, true);
FillDirectoryTree(tvwTargetDir, false);
}
/// <summary>
/// Fill the directory tree for either the Source or
/// Target TreeView.
/// </summary>
private void FillDirectoryTree(
TreeView tvw, bool isSource)
{
// Populate tvwSource, the Source TreeView,
// with the contents of
// the local hard drive.
// First clear all the nodes.
tvw.Nodes.Clear( );
// Get the logical drives and put them into the
// root nodes. Fill an array with all the
// logical drives on the machine.
string[] strDrives =
Environment.GetLogicalDrives( );
// Iterate through the drives, adding them to the tree.
// Use a try/catch block, so if a drive is not ready,
// e.g. an empty floppy or CD,
// it will not be added to the tree.
foreach (string rootDirectoryName in strDrives)
{
if (rootDirectoryName != @\"C:\\")
continue;
try
{
// Fill an array with all the first level
// subdirectories. If the drive is
// not ready, this will throw an exception.
DirectoryInfo dir =
new DirectoryInfo(rootDirectoryName);
dir.GetDirectories( );
TreeNode ndRoot = new TreeNode(rootDirectoryName);
// Add a node for each root directory.
tvw.Nodes.Add(ndRoot);
// Add subdirectory nodes.
// If TreeView is the source,
// then also get the filenames.
if (isSource)
{
GetSubDirectoryNodes(
ndRoot, ndRoot.Text, true);
}
else
{
GetSubDirectoryNodes(
ndRoot, ndRoot.Text, false);
}
}
catch (Exception e)
{
// Catch any errors such as
// Drive not ready.
MessageBox.Show(e.Message);
}
}
} // close for FillSourceDirectoryTree
/// <summary>
/// Gets all the subdirectories below the
/// passed in directory node.
/// Adds to the directory tree.
/// The parameters passed in at the parent node
/// for this subdirectory,
/// the full pathname of this subdirectory,
/// and a Boolean to indicate
/// whether or not to get the files in the subdirectory.
/// </summary>
private void GetSubDirectoryNodes(
TreeNode parentNode, string fullName, bool getFileNames)
{
DirectoryInfo dir = new DirectoryInfo(fullName);
DirectoryInfo[] dirSubs = dir.GetDirectories( );
// Add a child node for each subdirectory.
foreach (DirectoryInfo dirSub in dirSubs)
{
// do not show hidden folders
if ( (dirSub.Attributes & FileAttributes.Hidden)
!= 0 )
{
continue;
}
/// <summary>
/// Each directory contains the full path.
/// We need to split it on the backslashes,
/// and only use
/// the last node in the tree.
/// Need to double the backslash since it
/// is normally
/// an escape character
/// </summary>
TreeNode subNode = new TreeNode(dirSub.Name);
parentNode.Nodes.Add(subNode);
// Call GetSubDirectoryNodes recursively.
GetSubDirectoryNodes(
subNode,dirSub.FullName,getFileNames);
}
if (getFileNames)
{
// Get any files for this node.
FileInfo[] files = dir.GetFiles( );
// After placing the nodes,
// now place the files in that subdirectory.
foreach (FileInfo file in files)
{
TreeNode fileNode = new TreeNode(file.Name);
parentNode.Nodes.Add(fileNode);
}
}
}
// < boilerplate code cut here >
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main( )
{
Application.Run(new Form1( ));
}
/// <summary>
/// Create an ordered list of all
/// the selected files, copy to the
/// target directory
/// </summary>
private void btnCopy_Click(object sender,
System.EventArgs e)
{
// get the list
ArrayList fileList = GetFileList( );
// copy the files
foreach (FileInfo file in fileList)
{
try
{
// update the label to show progress
lblStatus.Text = \"Copying \" + txtTargetDir.Text +
\"\\\" + file.Name + \"…\";
Application.DoEvents( );
// copy the file to its destination location
file.CopyTo(txtTargetDir.Text + \"\\\" +
file.Name,chkOverwrite.Checked);
}
catch // (Exception ex)
{
// you may want to do more than just show the message
// MessageBox.Show(ex.Message);
}
}
lblStatus.Text = \"Done.\";
Application.DoEvents( );
}
/// <summary>
/// on cancel, exit
/// </summary>
private void btnCancel_Click(object sender, System.EventArgs e)
{
Application.Exit( );
}
/// <summary>
/// Tell the root of each tree to uncheck
/// all the nodes below
/// </summary>
private void btnClear_Click(object sender, System.EventArgs e)
{
// get the top most node for each drive
// and tell it to clear recursively
foreach (TreeNode node in tvwSource.Nodes)
{
SetCheck(node, false);
}
}
/// <summary>
/// check that the user does want to delete
/// Make a list and delete each in turn
/// </summary>
private void btnDelete_Click(object sender, System.EventArgs e)
{
// ask them if they are sure
System.Windows.Forms.DialogResult result =
MessageBox.Show(
\"Are you quite sure?\", // msg
\"Delete Files\", // caption
MessageBoxButtons.OKCancel, // buttons
MessageBoxIcon.Exclamation, // icons
MessageBoxDefaultButton.Button2); // default button
// if they are sure…
if (result == System.Windows.Forms.DialogResult.OK)
{
// iterate through the list and delete them.
// get the list of selected files
ArrayList fileNames = GetFileList( );
foreach (FileInfo file in fileNames)
{
try
{
// update the label to show progress
lblStatus.Text = \"Deleting \" +
txtTargetDir.Text + \"\\\" +
file.Name + \"…\";
Application.DoEvents( );
// Danger Will Robinson!
file.Delete( );
}
catch (Exception ex)
{
//
you may
want to do more than
// just show the message
MessageBox.Show(ex.Message);
}
}
lblStatus.Text = \"Done.\";
Application.DoEvents( );
}
}
/// <summary>
/// Get the full path of the chosen directory
/// copy it to txtTargetDir
/// </summary>
private void tvwTargetDir_AfterSelect(
object sender,
System.Windows.Forms.TreeViewEventArgs e)
{
// get the full path for the selected directory
string theFullPath = GetParentString(e.Node);
// if it is not a leaf, it will end with a backslash
// remove the backslash
if (theFullPath.EndsWith(\"\\\"))
{
theFullPath =
theFullPath.Substring(0,theFullPath.Length-1);
}
// insert the path in the text box
txtTargetDir.Text = theFullPath;
}
/// <summary>
/// Mark each node below the current
/// one with the current value of checked
/// </summary>
private void tvwSource_AfterCheck(object sender,
System.Windows.Forms.TreeViewEventArgs e)
{
// Call a recursible method.
// e.node is the node which was checked by the user.
// The state of the check mark is already
// changed by the time you get here.
// Therefore, we want to pass along
// the state of e.node.Checked.
SetCheck(e.Node,e.Node.Checked);
}
/// <summary>
/// recursively set or clear check marks
/// </summary>
private void SetCheck(TreeNode node, bool check)
{
// set this node's check mark
node.Checked = check;
// find all the child nodes from this node
foreach (TreeNode n in node.Nodes)
{
// if the child is a leaf
// just check it (or uncheck it)
if (node.Nodes.Count == 0)
{
node.Checked = check;
}
// if the child is a node in the tree, recurse
else
{
SetCheck(n,check);
}
}
}
/// <summary>
/// Given a node and an array list
/// fill the list with the names of
/// all the checked files
/// </summary>
// Fill the ArrayList with the full paths of
// all the feils checked
private void GetCheckedFiles(TreeNode node,
ArrayList fileNames)
{
// if this is a leaf…
if (node.Nodes.Count == 0)
{
// if the node was checked…
if (node.Checked)
{
// get the full path and add it to the arrayList
string fullPath = GetParentString(node);
fileNames.Add(fullPath);
}
}
else // if this node is not a leaf
{
// call this for all the subnodes
foreach (TreeNode n in node.Nodes)
{
GetCheckedFiles(n,fileNames);
}
}
}
/// <summary>
/// Given a node, return the
/// full pathname
/// </summary>
private string GetParentString(TreeNode node)
{
// if this is the root node (c:\) return the text
if(node.Parent == null)
{
return node.Text;
}
else
{
// recurse up and get the path then
// add this node and a slash
// if this node is the leaf, don't add the slash
return GetParentString(node.Parent) + node.Text +
(node.Nodes.Count == 0 ? \"\" : \"\\\");
}
}
/// <summary>
/// shared by delete and copy
/// creates an ordered list of all
/// the selected files
/// </summary>
private ArrayList GetFileList( )
{
// create an unsorted array list of the full filenames
ArrayList fileNames = new ArrayList( );
// fill the fileNames ArrayList with the
// full path of each file to copy
foreach (TreeNode theNode in tvwSource.Nodes)
{
GetCheckedFiles(theNode, fileNames);
}
// Create a list to hold the fileInfo objects
ArrayList fileList = new ArrayList( );
// for each of the filenames we have in our unsorted list
// if the name corresponds to a file (and not a directory)
// add it to the file list
foreach (string fileName in fileNames)
{
// create a file with the name
FileInfo file = new FileInfo(fileName);
// see if it exists on the disk
// this fails if it was a directory
if (file.Exists)
{
// both the key and the value are the file
// would it be easier to have an empty value?
fileList.Add(file);
}
}
// Create an instance of the IComparer interface
IComparer comparer = (IComparer) new FileComparer( );
// pass the comparer to the sort method so that the list
// is sorted by the compare method of comparer.
fileList.Sort(comparer);
return fileList;
}
}
}
/// <summary>
/// Mark each node below the current
/// one with the current value of checked
/// </summary>
protected void tvwSource_AfterCheck (
object sender, System.Windows.Forms.TreeViewEventArgs e)
{
}

C:\Documents and Settings\Nikola\MyDocuments\Visual Studio Projects\WindowsApplication1\Form1.cs(420): Anamespace does not directly contain members such as fields or methods

Introduction

This article is focused on understanding the Directory class of System.IO namespace. The Directory class exposes routines for manipulating directories & subdirectories. It contains all kinds of routines like creating, moving, and enumerating through directories and subdirectories. In most of the application developments we require some file accesses or directory accesses normally we use some low-level system API like Directory-Control Routines in C (ex:- _mkdir, _chdir, _rmdir) or Platform SDK function of Kernel32.lib (ex:- CreateDirectory(),SetCurrentDirectory(),RemoveDirectory()). In .net we have System.IO.Directory class to do all directory manipulation. For better understanding I will compare code with some C & SDK programs. You will see how easy it is in C# when compared to old programming languages.

Let take a small example to get all the available drive information (this includes both physical & logical drives).

Using C routines
—————–
#include <stdio.h>
#include <conio.h>
#include <direct.h>
#include <stdlib.h>
#include <ctype.h>
void main( void )
{
int drive, curdrive;
static char path[_MAX_PATH];

/* Save current drive. */
curdrive = _getdrive();

printf( "Using C routines, Available drives
are: \n" );

/* If we can switch to the drive, it exists. */
for( drive = 1; drive <= 26; drive++ )
if( !_chdrive( drive ) )
printf( "%c: \n", drive + 'A' – 1 );
}

Output:
Using C routines, Available drives are:
A:\
C:\
D:\
E:\
Z:\

Using Platform SDK File I/O routines
———————————–
#include <windows.h>
#include <stdio.h>
void main( void )
{
char *lpBuffer=new char[1000];
long retSize;

retSize=GetLogicalDriveStrings(1000,lpBuffer
);
printf("Using SDK routines, Available drives
are:\n");

for(int i=0;i<=retSize;i++)
{
if(lpBuffer[i]!='\0')
printf("%c",lpBuffer[i]);
else
printf("\n");
}
}

Output:
Using SDK routines, Available drives are:
A:\
C:\
D:\
E:\
Z:\

The same program we will do in C#

GetDr.cs
using System;
using System.IO;

class getDr
{
public static void Main()
{
try
{
string[] str=Directory.GetLogicalDrives();
Console.WriteLine( "Using C# Directory Class ,Available drives are:");
for(int i=0;i< str.Length;i++)
Console.WriteLine(str[i]);
}catch(IOException e) { Console.WriteLine(e.ToString()); }

} // end of Main
}//end of Class

Output:
Using C# Directory Class, Available drives are:
A:\
C:\
D:\
E:\
Z:\
</stdio.h></windows.h></ctype.h></stdlib.h></direct.h></conio.h></stdio.h>

So lets understand how this works System.IO.Directory class has method called GetLogicalDrives() this method returns all available drives in your system as array of strings. Before that some important thing to remember is all methods of the Directory class are static and can therefore be called without having an instance of a directory. The static methods of the Directory class do a security check on all methods. If you are going to reuse an object several times, consider using the corresponding instance method of DirectoryInfo instead, because the security check will not always be necessary.

Now that we know about Directory class so we will examine the IL code of C# sample (getDr.exe) and also System.IO library.

(IL code of sample code getDr.exe)
IL_0000:call string[] ['mscorlib']'System.IO'.'Directory'::'GetLogicalDrives'()
|
V
(IL code of System.IO library)
IL_000b: call int32 Microsoft.Win32.Win32Native::GetLogicalDrives()
|
V
(IL code of System.IO library)
.method assembly hidebysig static pinvokeimpl("kernel32.dll" lasterr winapi)
int32 GetLogicalDrives() cil managed preservesig
{ }

If you see the above IL code of System.IO library it internally calls the kernel32.dll GetLogicalDrives() which is nothing but File I/O function in Kernel32.dll library which retrieves a bitmask representing the currently available disk drives. When you call Directory Class methods of System.IO library it internally pinvokes the Microsoft Win32 native functions (see the above Platform SDK code).Similarly we will see a sample code to create and change directory. For this sample code we will be using Directory.CreateDirectory(), Directory.GetCurrentDirectory() ,Directory.Delete(), Directory.Exists() and Directory.SetCurrentDirectory().

chgDr.cs
using System;
using System.IO;
class chgDr
{
public static void Main()
{
try
{
Console.WriteLine("–>Your Current Directory");
String curDir=Directory.GetCurrentDirectory();
Console.WriteLine(curDir);
String newDir="TestDir";
Directory.CreateDirectory(newDir);
Console.WriteLine("–> '" + newDir + "' Directory created");
Directory.SetCurrentDirectory(newDir);
Console.WriteLine("–> Changing to '" + newDir + "' Directory ");
Console.WriteLine(Directory.GetCurrentDirectory());
Console.WriteLine("–> Changing to '" + curDir + "' Directory ");
Directory.SetCurrentDirectory(curDir);
Console.WriteLine(Directory.GetCurrentDirectory());
Console.WriteLine("–> Deleting '" + newDir + "' Directory ");
if(Directory.Exists(newDir))
Directory.Delete(newDir);
Console.WriteLine("–> Checking '" + newDir + "' Directory Exists or not");

if(!Directory.Exists(newDir))
Console.WriteLine("'" + newDir + "' Does not exists ");
}catch(IOException e){ Console.WriteLine(e.ToString()); }
}

}

Output:
D:\samples\vstudio>chgDr
–>Your Current Directory
D:\samples\vstudio
–> 'TestDir' Directory created
–> Changing to 'TestDir' Directory
D:\samples\vstudio\TestDir
–> Changing to 'D:\samples\vstudio' Directory
D:\samples\vstudio
–> Deleting 'TestDir' Directory
–> Checking 'TestDir' Directory Exists or not
'TestDir' Does not exists

Some points to remember:
a) Path names are limited to 248 characters

b) The specified path can also refer to a relative path or a Universal Naming Convention (UNC) path for a server and share name.

c) Ensure that your paths are well-formed when using methods that accept a path string .In C# path names should have \\ instead of single \

d) If you don't have permission it will generate FileIOPermission exception.

Further reading
1. .Net More information on .Net technologies

This is a simple program that shows a bit ofhow to manipulate files in Visual C#.Net.I developed this as a "C# Console Application" and this simple programacts like a "DOS" operating system. The only file needed for theapplication is the "MyClass.cs". Open the "ReadMe" file in the zippedfile to see it's usage.

Download FileManipulation.zip

INTRODUCTION:

This article covers the information of how toread or write (Unicode) character based data through TextReader andTextWriter. The TextReader and TextWriter are base classes. TheStreamReader and StringReader derives from the abstract typeTextReader. Similarly the StreamWriter and StringWriter derives fromthe abstract type TextWriter.

STREAMWRITERS & STREAMREADERS:

As I mentioned earlier StreamWriter typederives from a base class named TextWriter. This class defines membersthat allow derived types to write textual data to a given characterstream.

Let us see some of the main members of the abstract class TextWriter.

1.close() — Closes the Writer and frees any associated resources.
2.Write() — Writes a line to the text stream, with out a newline.
3.WriteLine() — Writes a line to the text stream, with a newline.
4.Flush() — Clears all buffers.

WRITING – TEXT FILE:

Let us see the Writing to a Text File with a example.

Before we move into writing to a text file wehave to know about “FileInfo” class. What is FileInfo? In the frameworkof .NET , the system.IO namespace is the region of the base classlibraries devoted to file-based input and output services.File Info isone of the core type of System.IO Namespace.The function of the FileInfo is to encapsulate a number of detailsregarding existing files on your hard drive (size,fileattributes,creating time,etc.)as well as aid in the creation anddestruction of new files. Let us move to example.

In this example in the Writetextfile class Icreate a file named “Arungg.txt” using the FileInfo class. Aftercreating the text file using the CreateText() method, I get aStreamWriter and write some textual data to the newly created textfile. We can also add numeric data into the text file.

public class Writetextfile

{
public static int Main(sting[] args)
{
FileInfo t = new FileInfo(“Arungg.txt”);
StreamWriter Tex =f.CreateText();
Tex.WriteLine(“Arungg has launced another article”);
Tex.WriteLine(“csharpheaven is the new url for c-sharpcorner”);
Tex.Write(Tex.NewLine);
Tex.close;
Console.WriteLine(” The Text file named Arungg is created “);
}
}

If you open the text file the data is entered there.

READING – TEXT FILE:

Now let us see how to read a text file using the StreamReader type.

Let us see some of the main members of the abstract class TextReader.

1.Read() — Reads data from an input stream.
2.ReadLine() — Reads a line of characters from the current stream and returns the data as a string.
3.ReadToEnd() — Reads all characters to the end of the TextReader and returns them as one string.

public class Readtextfile
{
public static int Main(string[] args)
{
StreamReader re = File.OpenText(“Arungg.txt”);
string input = null;
while ((input = re.ReadLine()) != null)
{
Console.WriteLine(input);
}
re.close;
return 0;
}
}

In the above class Readtextfile I open the text file Arungg.txt and read the contents using the ReadLine() method.In both StreamReader and StreamWriter are concerned with moving text data to and from a specified file.

STRINGWRITERS & STRINGREADERS:

Using the StringReaders and StringWriters cantreat textual information as a stream of in-memory characters. In thiswe can insert or remove string between a block of textual data.Let us see a program in which I add and delete some string between ablock of text.<pre. wr=”new”>Running the above program we get the textual data in the console.</pre.>

Continues…

1.Creating a Text File

For creating text file we use the CreateText Method of the FileClass. The CreateText methods takes in the path of the file to be created as an argument. It creates a file in the specified path and returns a StreamWriter object which can be used to write contents to the file.

Example


public class FileClass
{
public static void Main()
{
WriteToFile();
}
static void WriteToFile()
{
StreamWriter SW;
SW=File.CreateText("c:\\MyTextFile.txt");
SW.WriteLine("God is greatest of them all");
SW.WriteLine("This is second line");
SW.Close();
Console.WriteLine("File Created SucacessFully");
}
}


2.Reading Contents Of A Text File

For reading the contents of a text file we use the OpenText Method of the File Class.The OpenText methods takes in the path of the file to be opened as an argument. It opens the specified file and returns a StreamReader object which can be used to read the contents of the file.

Example


public class FileClass
{
public static void Main()
{
ReadFromFile("c:\\MyTextFile.txt");
}
static void ReadFromFile(string filename)
{
StreamReader SR;
string S;
SR=File.OpenText(filename);
S=SR.ReadLine();
while(S!=null)
{
Console.WriteLine(S);
S=SR.ReadLine();
}
SR.Close();
}
}


3.Appending Content To A Text File

For appending content to a text file we use the AppendText Method of the File Class. The AppendText methods takes in the path of the file to which the contents to be appended as an argument. It opens the file in the specified path and returns a StreamWriter object which can be used to append contents to the file.
Continues…