File Operations in C#
Hemant Singh
Read and print a file's content
This program uses a StreamReader object to read the file specified by the path variable. The ReadToEnd method of the StreamReader object reads the entire contents of the file into a string variable, which is then displayed on the console.
Note that you should replace the value of the path variable with the path to the file you want to read. If the file is not in the same directory as your program, you will need to specify the full path to the file.
using System;
using System.IO;
class Program
{
static void Main()
{
string path = "MyFile.txt"; // replace with the path to your file
try
{
// Open the file and create a StreamReader object for reading
using (StreamReader reader = new StreamReader(path))
{
// Read the entire file and store it in a string variable
string fileContent = reader.ReadToEnd();
// Display the file content on the console
Console.WriteLine(fileContent);
}
}
catch (IOException e)
{
Console.WriteLine("An error occurred while reading the file:");
Console.WriteLine(e.Message);
}
}
}
Read a huge text file one line at a time
using System;
using System.IO;
class Program
{
static void Main()
{
string path = "hugefile.txt"; // replace with the path to your file
try
{
using (StreamReader reader = new StreamReader(path))
{
string line;
while ((line = reader.ReadLine()) != null)
{
// Process each line of the file here
Console.WriteLine(line);
}
}
}
catch (IOException e)
{
Console.WriteLine("An error occurred while reading the file:");
Console.WriteLine(e.Message);
}
}
}
In this example, the StreamReader object is created with the path to the file as an argument. The ReadLine() method of the StreamReader class is used to read each line of the file, one by one. The program then processes each line of the file as needed.
Note that this approach reads the file line by line, which is suitable for text files. If your file is not a text file and you need to read it in chunks, you can use FileStream , MemoryMappedFile or BufferedStream.
Read a huge file one chunk at a time using FileStream
When working with large files, it's important to consider memory usage and performance. Here's an example C# program that reads a huge file in chunks, to avoid loading the entire file into memory at once:
using System;
using System.IO;
class Program
{
static void Main()
{
string path = "hugefile.txt"; // replace with the path to your file
int chunkSize = 1024 * 1024; // read 1 MB at a time
try
{
using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read))
{
byte[] buffer = new byte[chunkSize];
int bytesRead;
do
{
bytesRead = fileStream.Read(buffer, 0, buffer.Length);
// Process the chunk of data here
Console.Write(Encoding.UTF8.GetString(buffer, 0, bytesRead));
} while (bytesRead == buffer.Length);
}
}
catch (IOException e)
{
Console.WriteLine("An error occurred while reading the file:");
Console.WriteLine(e.Message);
}
}
}
This program uses a FileStream object to open the file in read mode. It then reads the file in chunks of 1 MB (adjust chunkSize as needed for your specific use case) using a byte array buffer.
The program reads one chunk at a time in a loop, until the Read method returns less bytes than the buffer size, indicating that the end of the file has been reached.
Inside the loop, you can process each chunk of data as needed. In this example, the program simply outputs the chunk to the console using the Encoding.UTF8.GetString method to convert the byte array to a string. You can modify this part to suit your specific needs.
Note that reading a huge file in chunks like this can still be a slow process, especially on mechanical hard drives. If performance is a concern, you may want to consider using multi-threading or asynchronous programming to read the file in parallel.
Read a huge file one chunk at a time using MemoryMappedFile
Memory-mapped file allows you to access file data as if it were in memory, without reading the entire file into memory. This means you can read and write to the file using memory operations, which can be faster than using traditional file I/O methods. Here's an example of reading a huge file using a memory-mapped file:
using System;
using System.IO;
using System.IO.MemoryMappedFiles;
using System.Text;
class Program
{
static void Main()
{
string path = "hugefile.txt"; // replace with the path to your file
int chunkSize = 1024 * 1024; // read 1 MB at a time
try
{
using (var mmf = MemoryMappedFile.CreateFromFile(path, FileMode.Open))
{
using (var accessor = mmf.CreateViewAccessor())
{
long length = new FileInfo(path).Length;
for (long i = 0; i < length; i += chunkSize)
{
long size = Math.Min(chunkSize, length - i);
byte[] buffer = new byte[size];
accessor.ReadArray(i, buffer, 0, buffer.Length);
// Process the chunk of data here
Console.Write(Encoding.UTF8.GetString(buffer));
}
}
}
}
catch (IOException e)
{
Console.WriteLine("An error occurred while reading the file:");
Console.WriteLine(e.Message);
}
}
}
This program uses a MemoryMappedFile object to map the file to memory. It then creates a MemoryMappedViewAccessor object to access the file contents. The program reads the file in chunks using the ReadArray method of the MemoryMappedViewAccessor object, which reads a byte array from the specified position in the memory-mapped file.
Read a huge file one chunk at a time using BufferedStream
The BufferedStream class provides a way to read a file in chunks using a buffer. It can improve performance by reducing the number of I/O operations needed to read the file. Here's an example of reading a huge file using a BufferedStream:
using System;
using System.IO;
using System.Text;
class Program
{
static void Main()
{
string path = "hugefile.txt"; // replace with the path to your file
int chunkSize = 1024 * 1024; // read 1 MB at a time
try
{
using (FileStream stream = new FileStream(path, FileMode.Open))
using (BufferedStream bufferedStream = new BufferedStream(stream))
{
byte[] buffer = new byte[chunkSize];
int bytesRead;
do
{
bytesRead = bufferedStream.Read(buffer, 0, buffer.Length);
// Process the chunk of data here
Console.Write(Encoding.UTF8.GetString(buffer, 0, bytesRead));
} while (bytesRead == buffer.Length);
}
}
catch (IOException e)
{
Console.WriteLine("An error occurred while reading the file:");
Console.WriteLine(e.Message);
}
}
}
This program uses a BufferedStream object to wrap a FileStream object. It reads the file in chunks using the Read method of the BufferedStream object, which reads a byte array from the file and stores it in a buffer. The program then processes each chunk of data as needed.
Note that the BufferedStream class is already optimized for reading large files in chunks, so you may not see a significant performance improvement over the first example using a FileStream.
Basically, if you need to read or write binary data or need fine-grained control over I/O operations, FileStream is the better choice. If you need to read or write text files or other types of files that can be read or written in chunks, BufferedStream is the better choice.
Stream a video file to a web page
To stream a video file on a web page using C#, you can use HTML5 video player and the FileContentResult class in ASP.NET. Here's an example code snippet that demonstrates how to stream a video file on a web page:
using System.IO;
using System.Web.Mvc;
public class VideoController : Controller
{
public ActionResult Stream(string filename)
{
string videoPath = Path.Combine(Server.MapPath("~/Videos"), filename);
if (System.IO.File.Exists(videoPath))
{
FileStream videoStream = new FileStream(videoPath, FileMode.Open, FileAccess.Read);
return new FileStreamResult(videoStream, "video/mp4");
}
else
{
return HttpNotFound();
}
}
}
In this example, the Stream action method of the VideoController class is used to stream a video file. The video file is specified in the filename parameter of the action method. The Server.MapPath method is used to get the physical path of the video file on the server.
If the video file exists, a FileStream object is created to read the file, and a FileStreamResult object is returned to stream the video to the client. The FileStreamResult object specifies the video/mp4 content type for the video file.
On the client side, you can use an HTML5 video player to play the video. Here's an example HTML code snippet that shows how to embed the video player on a web page:
htmlCopy code<video width="640" height="360" controls>
<source src="/Video/Stream?filename=myvideo.mp4" type="video/mp4">
</video>
In this example, the src attribute of the source element specifies the URL of the Stream action method of the VideoController, with the filename parameter set to the name of the video file to be streamed. The type attribute specifies the MIME type of the video file. The controls attribute is used to display the video player controls.
Subscribe to my newsletter
Read articles from Hemant Singh directly inside your inbox. Subscribe to the newsletter, and don't miss out.
Written by