C# File tutorial
last modified July 5, 2020
C# File tutorial shows how to work with files in C#. We create files, read
files, delete files, write to files, and append to files.
To work with files in C#, we use the System.IO
and System.Text
namespaces. C# tutorial
is a comprehensive tutorial on C# language.
The File
class of the System.IO
provides static
methods for the creation, copying, deletion, moving, and opening of a single
file. It also helps in the creation of FileStream
objects.
The words.txt file
This is a text file that we work with in some examples.
sky blue cloud raisin tree falcon owl eagle rock water lake
C# File.Create
The File.create
creates or overwrites a file in the specified path.
It returns a FileStream
, which provides read/write access to the
file specified in path.
using System; using System.IO; using System.Text; namespace CreateFile { class Program { static void Main(string[] args) { var path = "words.txt"; using FileStream fs = File.Create(path); byte[] data = Encoding.UTF8.GetBytes("falcon\nribbon\ncloud"); fs.Write(data, 0, data.Length); Console.WriteLine("data written to file"); } } }
The example creates a file and writes three words into it.
using FileStream fs = File.Create(path);
We create a file and retrieve a file stream to the file.
byte[] data = Encoding.UTF8.GetBytes("falcon\nribbon\ncloud");
We get the bytes of the three words we are going to write with
Encoding.UTF8.GetBytes
.
fs.Write(data, 0, data.Length);
The bytes are written to the file with Write
.
C# File.CreateText
The File.CreateText
creates or opens a file for writing UTF-8
encoded text. If the file already exists, its contents are overwritten. It
returns a StreamWriter
that writes to the specified file using
UTF-8 encoding.
using System; using System.IO; namespace CreateFile2 { class Program { static void Main(string[] args) { var path = "words.txt"; using StreamWriter sw = File.CreateText(path); sw.WriteLine("falcon"); sw.WriteLine("sky"); sw.WriteLine("cloud"); Console.WriteLine("data written to file"); } } }
The example creates a new file with File.CreateText
. It writes three
words with WriteLine
.
C# File.Copy
The File.copy
copies an existing file to a new file.
It takes the source file and the destination file as parameters.
using System; using System.IO; namespace CopyFile { class Program { static void Main(string[] args) { var sourcePath = "words.txt"; var destPath = "words_bck.txt"; File.Copy(sourcePath, destPath); Console.WriteLine("file copied"); } } }
The example copies a text file.
C# File.Move
The File.Move
moves a specified file to a new location.
With this method, we can move a file to a new location or to rename a file.
using System; using System.IO; namespace MoveFile { class Program { static void Main(string[] args) { var sourcePath = "words.txt"; var destPath = "data.txt"; File.Move(sourcePath, destPath); Console.WriteLine("file moved"); } } }
The example renames words.txt
to data.txt
.
C# File.Exists
The File.Exists
determines whether the specified file exists.
using System; using System.IO; namespace FileExists { class Program { static void Main(string[] args) { var path = "words2.txt"; if (File.Exists(path)) { Console.WriteLine("the file exists"); } else { Console.WriteLine("the file does not exist"); } } } }
In the code example we check if the words2.txt
file exists.
C# File.Delete
The File.Delete
deletes the specified file.
using System; using System.IO; namespace DeleteFile { class Program { static void Main(string[] args) { var path = "words.txt"; File.Delete(path); Console.WriteLine("file deleted"); } } }
The example deletes a text file.
C# File.GetCreationTime
The File.GetCreationTime
returns the creation date and time of the
specified file or directory.
using System; using System.IO; namespace CreationTime { class Program { static void Main(string[] args) { var path = "words.txt"; DateTime dt = File.GetCreationTime(path); Console.WriteLine($"Creation time: {dt}"); } } }
The example prints the creation time of the words.txt
file.
$ dotnet run Creation time: 6/21/2020 10:41:16 AM
This is a sample output.
C# File.GetLastWriteTime
The File.GetLastWriteTime
returns the date and time of the
specified file or directory was last written to.
using System; using System.IO; namespace LastWriteTime { class Program { static void Main(string[] args) { var path = "words.txt"; DateTime dt = File.GetLastWriteTime(path); Console.WriteLine($"Last write time: {dt}"); } } }
The example prints the last write time of the text file.
C# File.Open
The File.Open
opens a FileStream
on the specified path.
The overloaded methods of File.Open
allow to specify the file mode
(Open, Create, CreateNew, Truncate, Append, or OpenOrCreate), the file access
(Read, Write, ReadWrite).
The file share value specifies the type of access other threads have to the file, such as Delete, None, Read, ReadWrite, Write, or Inheritable.
using System; using System.IO; using System.Text; namespace OpenFile { class Program { static void Main(string[] args) { var path = "words.txt"; using FileStream fs = File.Open(path, FileMode.Open, FileAccess.Read); byte[] buf = new byte[1024]; int c; while ((c = fs.Read(buf, 0, buf.Length)) > 0) { Console.WriteLine(Encoding.UTF8.GetString(buf, 0, c)); } } } }
The example reads the contents of the words.txt
file.
using FileStream fs = File.Open(path, FileMode.Open, FileAccess.Read);
We open the file for reading.
byte[] buf = new byte[1024]; int c;
We create a buffer of bytes and an auxiliary variable.
while ((c = fs.Read(buf, 0, buf.Length)) > 0) { Console.WriteLine(Encoding.UTF8.GetString(buf, 0, c)); }
The Read
method reads a block of bytes from the stream and writes
the data to the given buffer. The Encoding.UTF8.GetString
decodes a
sequence of bytes into a string.
$ dotnet run sky blue cloud raisin tree falcon owl eagle rock water lake
This is the output.
C# File.OpenRead
The File.OpenRead
opens an existing file for reading. It returns a
read-only FileStream
on the specified path. It is a convenience
method to the File.Open
.
using System; using System.IO; using System.Text; namespace OpenFileRead { class Program { static void Main(string[] args) { var path = "words.txt"; using FileStream fs = File.OpenRead(path); byte[] buf = new byte[1024]; int c; while ((c = fs.Read(buf, 0, buf.Length)) > 0) { Console.WriteLine(Encoding.UTF8.GetString(buf, 0, c)); } } } }
The example reads a file with File.OpenRead
.
C# File.OpenText
The File.OpenText
opens an existing UTF-8 encoded text file for
reading. It returns a StreamReader
on the specified path.
using System; using System.IO; namespace OpenFileText { class Program { static void Main(string[] args) { var path = "words.txt"; using StreamReader sr = File.OpenText(path); string s = String.Empty; while ((s = sr.ReadLine()) != null) { Console.WriteLine(s); } } } }
The example opens a text file and reads its contents.
while ((s = sr.ReadLine()) != null) { Console.WriteLine(s); }
We read the text file line by line. We do not have to decode the bytes into the string ourselves.
C# File.OpenWrite
The File.OpenWrite
opens an existing file or creates a new file for
writing. It returns a FileStream
object on the specified path with
write access.
using System; using System.IO; namespace OpenFileWrite { class Program { static void Main(string[] args) { var path = "langs.txt"; using FileStream fs = File.OpenWrite(path); using StreamWriter sr = new StreamWriter(fs); sr.WriteLine("PHP\nDart\nJava\nC#\n"); Console.WriteLine("data written"); } } }
The example opens a file in write mode and writes a line to the file.
using FileStream fs = File.OpenWrite(path); using StreamWriter sr = new StreamWriter(fs);
We open a filestream to the specified path. The stream is passed to the
StreamWriter
, which is used to write characters in a particular
encoding (UTF8 by default).
sr.WriteLine("PHP\nDart\nJava\nC#\n");
A line of text is written to the file with WriteLine
.
C# File.ReadLines
The File.ReadLines
opens a text file, reads all lines of the file
into a string array, and then closes the file.
using System; using System.IO; namespace ReadLines { class Program { static void Main(string[] args) { var path = "words.txt"; var lines = File.ReadLines(path); foreach (var line in lines) { Console.WriteLine(line); } } } }
The example reads all lines of a text file. The returned array of strings
is traversed with a foreach
loop.
C# File.ReadAllText
The File.ReadAllText
opens a text file, reads all the text in the
file into a string, and then closes the file. Note that this method should
not be used for very large files.
using System; using System.IO; namespace ReadAllText { class Program { static void Main(string[] args) { var path = "words.txt"; string readText = File.ReadAllText(path); Console.WriteLine(readText); } } }
The example reads the whole text into a string in one go.
C# File.ReadAllBytes
The File.ReadAllBytes
opens a binary file, reads the contents of
the file into a byte array, and then closes the file.
using System; using System.IO; namespace ReadAllBytesEx { class Program { static void Main(string[] args) { var path = "favicon.ico"; byte[] data = File.ReadAllBytes(path); int i = 0; foreach (byte c in data) { Console.Write("{0:X2} ", c); i++; if (i % 10 == 0) { Console.WriteLine(); } } } } }
The example reads a favicon.ico
binary file. The data is printed
to the console in hex format.
$ dotnet run 00 00 01 00 01 00 10 10 00 00 00 00 00 00 68 05 00 00 16 00 00 00 28 00 00 00 10 00 00 00 20 00 00 00 01 00 08 00 00 00 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 00 00 00 FF FF FF 00 4D 45 3D 00 00 00 00 00 00 00 ...
This is a sample, partial output.
C# File.WriteAllText
The File.WriteAllText
creates a new file, writes the contents to
the file, and then closes the file. If the target file already exists, it is
overwritten.
using System; using System.IO; namespace WriteAllText { class Program { static void Main(string[] args) { var path = "words.txt"; string data = "sky\ncloud\nfalcon\nowl\ncrane"; File.WriteAllText(path, data); Console.WriteLine("data written"); } } }
In the example, we write four words to a file with File.WriteAllText
.
C# File.WriteAllLines
The File.WriteAllLines
creates a new file, writes one or more
strings to the file, and then closes the file.
using System; using System.IO; using System.Text; namespace WriteAllLines { class Program { static void Main(string[] args) { var path = "words.txt"; string[] data = { "sky", "cloud", "falcon", "hawk" }; File.WriteAllLines(path, data, Encoding.UTF8); Console.WriteLine("data written"); } } }
In the example, we have an array of strings. We write these strings to a file
in one go with File.WriteAllLines
.
C# File.WriteAllBytes
The File.WriteAllBytes
creates a new file, writes the specified
byte array to the file, and then closes the file.
using System; using System.IO; using System.Text; namespace WriteAllBytesEx { class Program { static void Main(string[] args) { var path = "words.txt"; var text = "falcon\nhawk\nforest\ncloud\nsky"; byte[] data = Encoding.UTF8.GetBytes(text); File.WriteAllBytes(path, data); Console.WriteLine("data written"); } } }
The example writes data to a file with File.WriteAllBytes
.
var text = "falcon\nhawk\nforest\ncloud\nsky"; byte[] data = Encoding.UTF8.GetBytes(text);
First, we transform the text data into a array of bytes with Encoding.UTF8.GetBytes
.
File.WriteAllBytes(path, data);
Then we write the array to the file with File.WriteAllBytes
.
C# File.AppendText
The File.AppendText
creates a StreamWriter
that
appends UTF-8 encoded text to an existing file, or to a new file if the
specified file does not exist.
using System; using System.IO; namespace AppendTextEx { class Program { static void Main(string[] args) { var path = "words.txt"; using StreamWriter sw = File.AppendText(path); sw.WriteLine("sky"); sw.WriteLine("lake"); } } }
The example appends two words to the words.txt
file.
C# File.AppendAllText
The File.AppendAllText
appends the specified string to the file.
It creates the file if it does not exist.
using System; using System.IO; namespace AppendAllTextEx { class Program { static void Main(string[] args) { var path = "words.txt"; var contents = "armour\nsword\narrow\n"; File.AppendAllText(path, contents); Console.WriteLine("text appended to file"); } } }
The example appends three words to the specified text file.
C# File.AppendAllLines
The File.AppendAllLines
appends lines to a file, and then closes
the file.
using System; using System.IO; using System.Collections.Generic; namespace AppendAllLinesEx { class Program { static void Main(string[] args) { var path = "words.txt"; var data = new List<string> {"brown", "blue", "khaki"}; File.AppendAllLines(path, data); Console.WriteLine("data written to file"); } } }
The example appends a list of strings to the file with File.AppendAllLines
.
In this tutorial, we have worked with files in C#. We have utilized the
File
class of the System.IO
.
Read C# tutorial or list all C# tutorials.