module 14 - working with files in c#

Module 14: Working with Files in C#

By

SRIRAM . B

Overview

Working with File System

Streams

Classes Used for I/O

File Stream

Stream Reader

Stream Writer

Random Access

Multi threading

Working with File System

Obtaining the Application’s Environment Information

– - System.Environment Class

– Properties :-

» - CurrentDirectory, MachineName, OSVersion, UserName, Version

– Methods :-

» GetFolderPath, GetLogicalDrives, Exit

Manipulating Files using System.IO.File and FileInfo classes

– File is a sealed class and contains only static methods

– FileInfo is a sealed class and contains only instance methods

File Class Members

– Copy, Create, Delete, Exists, Move

Working with File System..

GetAttributes (Returns an object of FileAttributes class)

SetAttributes (Takes a parameter of FileAttributes)

GetCreationTime, GetLastAccessTime, GetLastWriteTime (All returns an

object of DateTime Struct)

Open, OpenRead, OpenWrite (All returns an object of File Stream class)

Working with File System.. File Attribute Enumeration

– Directory, Hidden, Normal, System, Temporary, ReadOnly, Encrypted,

Compressed

File Info Members

– CreationTime, DirectoryName, Exists, LastAccessTime, LastWriteTime,

Length, CopyTo, MoveTo, Create, Delete, Open, OpenRead, OpenWrite,

OpenText

Working with File System..

Manipulating Directories

Two classes – Directory and DirectoryInfo Same like File and FileInfo classes

Directory Class members

CreateDirectory, Delete, Exists, GetDirectories, GetFiles, Move, GetParent

DirectoryInfo members

Create, Delete, GetDirectories, GetFiles

Streams In .Net Framework input and output is done through streams.

A stream is a continuous flow of bytes from a source to a destination.

It could be memory to hard disk or from network to loc sys

or one area of mem to another.

An output stream is used when data is written to some external destination.

Streams provide a way to write and read bytes to and from a storage medium.

Streams hide the implementation details of input/output operations.

A data channel having two ends, one is attached to the data source while the

other is attached to the reader or writer of the data.

Streams..

Streams..

Streams can be used for:

Sequential file accessRead from and write to the beginning of a file

Random file accessRead from and write to any locations within a file

Streams can be used to perform three fundamental operations:

Read from a stream into a data type

Write the contents of a data type to a stream

Seek particular positions within a stream

Streams..

Different types of Streams are :-

FileStreams – System.IO.FileStream

MemoryStreams – System.IO.MemoryStream

Networkstreams – System.Net.Sockets.NetworkStream

System.IO.Stream is the base class for all stream classes in IO.

– Stream is an abstract class.

Streams..

Different types of File Streams

FileStream – read/write bytes to a file

BinaryReader and BinaryWriter – To read/write primitive data types

StreamReader and StreamWriter – To read/write text files

Stream Class Properties & Methods

Length – returns long

Position – returns long

Flush(), Seek(long, SeekOrigin) (SeekOrigin.Begin, End, Current)

ReadByte(Byte []ar, int offset, int count)

WriteByte – same as readbyte

Streams File Modes

- Enumeration FileMode

AppendIf exists opens and seeks to the end of the file or creates a new file

CreateCreate a new file, if exists overwrites

CreateNewCreate a new file, if exists throws IOException

OpenOpens an existing file, else throws FileNotFoundException

OpenOrCreateIf exists open or create a new one

TruncateOpens an existing file and truncates to zero bytes

Streams

File Access

Enum FileAccess Read, ReadWrite, Write

File Sharing

Enum FileShare None – Declines sharing of the current file Read, ReadWrite, Write

FileMode, FileAccess and FileSharing to be specified in the FileStream

constructors

Streams

Binary Reader & Binary Writer

What is the Disadvantages of FileStream? Parent class is only Object Can be used for read and writing primitive data types to and from files.– Overloaded Read & Write methods to write all data types

Streams..

StreamReader and StreamWriter

Implements TextReader and TextWriter StreamReader

String ReadLine() ReadBlock(char[],int index, int count) String ReadToEnd()

StreamWriter

Flush, Write(data type) – Overloaded methods, WriteLine(String)

Classes used for I/0

File : A utility class that exposes many static methods for moving, copying and del files.

Directory : A utility class that exposes many static methods for moving,copy and del directories.

Path : A utility class that is used to manipulate path names.

FileInfo: Represents phy file on disk, for read and writ a stream obj must be created.

Classes used for I/0

DirectoryInfo : Represents a phy directory on disk.

FileStream : File that can be written or read or both.

SteamReader : Read char from a stream.

StreamWriter : Writes char data to a stream

File & Directory Classes

File Class

Copy() - Copies the file to specified location

Create() - Creates a file in a specified path

Delete() - Deletes a file

Open() - Returns a FileStream object at the specified path

Move() - Moves a specified file to specific location

Directory Class

CreateDirectory() - Creates a directory with the specified path

Delete() - Deletes the specified directory and all files within it

GetDirectories() - Returns the array of Directory objects that represent the directories below the current directory

Move() - Moves a specified directory to the new location

GetFiles - Returns an array of file objects in the current directory

FileInfo & DirectoryInfo Classes Attributes - Gets or Sets the attributes of current file

CreationTime - Gets the creation date & time for current life

DirectoryName- Returns the path to the file directory

Exists - Determine whether file exists

Fullname - Retrieves the full path of the current life

Length - Gets the size of file

File Stream Class

It represents a stream pointing to a file on a disk or network path.

FileStream class operates on bytes and byte arrays.

Objects of FileStream class provide random access to files using the Seek()

method.

Seek() method allows read/write positions to be moved within a file.

General structure of Seek() method is:

Seek(byte_position, reference_ point)

Example: Seek(10, SeekOrigin.Begin);

Properties of Seek Origin

SeekOrigin.Begin – Refers to the beginning of the file position

SeekOrigin.Current – Refers to the current file position

SeekOrigin.End – Refers to the end of the file position

File Stream Class Constructor

Initializes a new instance of the FileStream object for the specified file

The general structure of the constructor can be given as:

public FileStream(path, FileMode, FileAccess);

In this code,

path – Represents the file name or file path

FileMode – Determines how the file is opened or created

FileAccess – Determines how the file may be accessed by the FileStream object

File Stream

File Mode Property Values

Append

Create

CreateNew

Open

OpenOrCreate

File Access Property Values

Read

Write

ReadWrite

Creating File Stream Object

FileStream fs= new FileStream(“Myfile.txt”, FileMode.Append, FileAccess. Write);

This opens the file, Myfile.txt , in the append mode for the write operation.

Example – File Stream

using System;

using System.IO;

namespace Files{ class Class1 { static void Main(string[] args) {

string str;

try

{

FileStream fs = new FileStream(@"c:\newfile.xls",

FileMode.OpenOrCreate);


StreamWriter sw = new StreamWriter(fs);

sw.WriteLine("hi");

sw.WriteLine("Welcome to filehandling classes");

sw.Close();

} catch (IOException e)

{

Console.WriteLine("An IO exception Occurred " + e);

}


StreamReader sr = new StreamReader(@"c:\newfile.txt");

str = sr.ReadToEnd();

while (str != null)

{

Console.WriteLine(str);

str = sr.ReadLine();

}

sr.Close();

}

}

}

Stream Writer

The objects of StreamWriter class are used to perform write operations to a stream.

Example: StreamWriter sw=new StreamWriter(fs);

In this code, fs is an object of the stream class.

Example – Stream Writerusing System;

using System.IO;

namespace day8{ class Class1 { static void Main(string[] args) {

try { FileStream fs = new FileStream(@"d:\log.txt", FileMode.OpenOrCreate);

Example – Stream Writer..

StreamWriter sw = new StreamWriter(fs);

sw.WriteLine("hi, how are you");

sw.WriteLine("This is string");

sw.Close();

}

catch (IOException e) {

Console.WriteLine("An IO exception Occurred " + e); }

}

}

}

Stream Reader

Objects of the StreamReader class is used to perform read operations from a stream.

Example: StreamReader sr=new StreamReader(fs);

In the above code, fs is an object of the stream class.

Example – Stream Reader

using System;

using System.IO;

namespace day8{ class Class1 { static void Main(string[] args) { string str;

try {

FileStream fs = new FileStream(@"d:\log.txt", FileMode.Open);

StreamReader sr = new StreamReader(fs);

str = sr.ReadLine();

Example – Stream Reader

while (str != null) { Console.WriteLine(str);

str = sr.ReadLine(); }

sr.Close();

} catch (IOException e) {

Console.WriteLine("Sorry!.Exception

Occurred " + e.ToString());

} } }}

Random Access

Reading data using File Stream class is not as easy the StreamReader class because it deals exclusively with Raw bytes.

Read from and write to any locations within a file is called Random Access.

This class is used to read files such as images and sounds. For reading

strings with FileStream class we have to use conversion classes to convert

byte data into character form.

Example – Random Access

using System;

using System.IO;

using System.Text;

namespace Files{ public class Randomaccess { static byte[] bdata = new byte[1000];

static char[] cdata = new char[1000];

static void writing() { try { FileStream fs = new FileStream(@"c:\rndfile1.txt", FileMode.OpenOrCreate);

cdata = "hello how are you??".ToCharArray();


Encoder e = Encoding.UTF8.GetEncoder();

e.GetBytes(cdata, 0, cdata.Length, bdata, 0, true);

fs.Seek(0, SeekOrigin.Begin);

fs.Write(bdata, 0, bdata.Length);

fs.Flush();

}

catch (IOException e)

{

Console.WriteLine("An IO exception occurred" + e);

}

}


static void reading() { try { FileStream fs = new FileStream(@"c:\rndfile1.txt", FileMode.Open);

//cdata = "hello ".ToCharArray ();

//e.GetBytes (cdata,0,cdata.Length ,bdata,0,true);

fs.Seek(0, SeekOrigin.Begin);

fs.Read(bdata, 0, 10); } catch (IOException e) { Console.WriteLine("An IO exception occurred" + e); return;

}


static void Main() {

//writing();

//Console.WriteLine("writing completed");

Console.WriteLine("data written in the file:");

reading();

} }}

Asynchronous File Access

Flow of application did not continue until the read or write operation is completed is called Synchronous operation.

Suppose when you need to write large chunk of data but we don't need the

application to wait for it to complete before continuing or we need to read

from a file on a network location with slow connection, our application can

continue to do other processing is called Asynchronous operation.

Example – Asynchronous File Access

using System;

using System.IO;

using System.Text;

namespace Files{ public class Asynchronousaccess { static byte[] bdata = new byte[1000];

static char[] cdata = new char[1000];

static void writing() { try { FileStream fs = new FileStream(@"c:\C#\asyfile1.cs", FileMode.Open);


fs.Seek(0, SeekOrigin.Begin); System.IAsyncResult synchResult = fs.BeginRead(bytedata, 0,100,null,null);

//Do other processing while data is being read while(!synchResult.IsCompleted) {

Console.WriteLine(“Reading from file”);

} fs.EndRead(synchResult);

Decoder d = Encoding.ASCII.GetDecoder();

d.GetChars(bytedata,0,bytedata.Length,chardata,0);

Console.Write(chardata); }


catch(IOException e)

{ Console.WriteLine(“Exception Occurred”+e.ToString());

} } }

}

Multi Tasking & MultiThreading

MultiTasking

Different applications execute at the same time MultiThreading

One application has more than one application path at the same time Namespace to be included Using System.Threading

MultiThreading

Creating a Thread

A Thread in .Net is represented by a System.Threading.Thread class

Multiple threads are nothing but multiple instances of this object

The method to be called when a thread starts is to be specified by passing a

delegate of the ThreadStart type to the Thread’s constructor.

The method should return void and not take any parameters.

MultiThreading.. A thread to be started using the Start method of the Thread class.

Methods of Thread class

Thread.Sleep(int time in milliseconds) Name (Property to get/set a thread’s name) IsAlive(Property to find whether a thread is alive or not) ThreadState (Property – Aborted, Stopped, Running, Suspended, Unstarted etc) Priority – (Property to set/get the priority of a thread) Start Abort Suspend Resume Join

MultiThreading..

Thread Priorities

– Normal, AboveNormal, BelowNormal, Highest and Lowest

– Default priority is Normal

– To change the priority» secondThread.Priority = ThreadPriority.AboveNormal;

When a thread is aborted a ThreadAbortException is thrown.

Calling Suspend(), Resume() or Abort() methods on a non-running thread a

ThreadStateException is thrown

Thread Synchronization

– .Net provides a locking mechanism to avoid simultaneous access by multiple threads to the same shared object.

Session Ends

Exercise

module 14 - working with files in c#

Documents