Post
Ask Question

Introduction to New Methods in System.IO.File in .Net 4.0

One of the core .NET namespace for file handling is System.IO. This namespace contains the class "File" which has a lot of static methods to handle the file systems. These all are already available since the initial stage of the .NET. But here we are looking at some improvements made as part of .NET 4.0 which made the file handling more flexible and fast using the File class.
 
1. ReadLines method - Since .NET 2.0, if you needed to read the lines of a text file, you could call the File.ReadAllLines method, which returns a string array of all the lines in the file. ReadAllLines returns an array. Before ReadAllLines can return, it must read all lines and allocate an array to return. It can be problematic for large text files that have millions of lines as before any process to continue, this reading and allocating process needs to be completed.
 
In .NET 4, we've added a new method to File named ReadLines (as opposed to ReadAllLines) that returns IEnumerable<string> instead of string[]. This new method is much more efficient because it does not load all of the lines into memory at once; instead, it reads the lines one at a time. Here is a sample code attached to this article which you can download. 
  1. IEnumerable<string> lineContents = File.ReadLines(@"C:\Test.txt");  
  2. foreach (string currentLine in lineContents)  
  3. {  
  4.     Console.WriteLine("Length={0}, Line={1}", currentLine.Length, currentLine);  
  5. } 
File. ReadLines() will just initiate an IEnumerable type. But the actual file reading is happening once executing a for each loop against IEnumerable. So line by line reading is happening rather than the whole lines reading at once and storing it to an array-like below, which is old standard using ReadAllLines.
  1. //Below reading all lines as a whole and then storing it to an array, which is not  
  2. //acceptable for file with huge number of lines.  
  3. string[] lineContents = File.ReadAllLines(@"C:\Test.txt");  
  4. foreach (string currentLine in lineContents)  
  5. {  
  6.     Console.WriteLine("Length={0}, Line={1}", currentLine.Length, currentLine);  
  7. } 
Note that the call to .NET 4.0 File.ReadLines returns immediately. You no longer have to wait until all of the lines are read into memory before you can iterate through the lines. The iteration of the foreach loop actually drives the reading of the file. Not only does this significantly improve the perceived performance of the code, because you can start processing the lines as they're being read, it's also much more efficient because the lines are being read one at a time. Using File. ReadLines has an added benefit in that it allows you to break out of the loop early if necessary, without wasting time reading additional lines you don't care about.
 
2. WriteAllLines method override - Before .NET 4.0 WriteAllLines method was accepting a string array as the second parameter. So you need to store any collection of string 1st to an array, then only was possible to pass to WriteAllLines. With .NET 4.0 WriteAllLines accepting IEnumerable<string> as a second parameter. This means if you have a collection of strings, you can pass it directly to these methods without having to first convert it into a string array. How practically this will be benefited. I have a sample code attached like below. There I used different collection types to write to the same file using the same method WriteAllLines. So we can use multiple types as source pf string collection
  1. List<string> list = new List<string>();  
  2. list.Add("List One Added");  
  3. list.Add("List Two Added");  
  4. list.Add("List Three Added");  
  5. File.WriteAllLines(@"C:\Test.txt", list); 
Above I used List<string> as a source for writing using WriteAllLines
  1. LinkedList<string> llist = new System.Collections.Generic.LinkedList<string>();  
  2. llist.AddLast("Linked List One Added");  
  3. llist.AddLast("Linked List Two Added");  
  4. llist.AddLast("Linked List Three Added");  
  5. File.WriteAllLines(@"C:\Test.txt", llist); 
Above I used LinkedList <string> as a source for writing using WriteAllLines
 
So now in .NET 4.0, you are seeing WriteAllLines can directly support different types rather than Array, which was the only type supporting before .NET 4.0. This means if you have a collection of strings, you can pass it directly to these methods without having to first convert it into a string array.
 
3. AppendAllLines method override - Same scenarios like below but this will append the string to the file rather than fresh new writing. 
  1. List<string> list = new List<string>();  
  2. list.Add("List One Appended");  
  3. list.Add("List Two Appended");  
  4. list.Add("List Three Appended");  
  5. File.AppendAllLines(@"C:\Test.txt", list); 
Above I used List<string> as a source for appending using AppendAllLines
  1. LinkedList<string> llist = new LinkedList<string>();  
  2. llist.AddLast("Linked List One Appended");  
  3. llist.AddLast("Linked List Two Appended");  
  4. llist.AddLast("Linked List Three Appended");  
  5. File.AppendAllLines(@"C:\Test.txt", llist); 
Above I used LinkedList <string> as a source for appending using AppendAllLines.
 
Download the code and run the application for getting the feel of each scenario.


Similar Articles