Group
File Handling in C#
Objective
1. The program requires two parameters: the file name and the size (in bytes) for each split part.
2. The program reads the input file and splits it into smaller files.
3. It will generate files with the original file name followed by a sequence number (e.g., file.exe.001, file.exe.002, etc.).
4. If the file size is not evenly divisible by the specified chunk size, the last file will contain the remaining data.
5. Use the following format to run the program:
split myFile.exe 2000
Create a program to split a file (of any kind) into pieces of a certain size. It must receive the name of the file and the size as parameters. For example, it can be used by typing:
split myFile.exe 2000
If the file "myFile.exe" is 4500 bytes long, that command would produce a file named "myFile.exe.001" that is 2000 bytes long, another file named "myFile.exe.002" that is also 2000 bytes long, and a third file named "myFile.exe.003" that is 500 bytes long.
Example C# Exercise
Show C# Code
using System;
using System.IO;
class FileSplitter
{
// Main method where the program starts execution
static void Main(string[] args)
{
// Check if the user provided the correct number of arguments
if (args.Length != 2)
{
Console.WriteLine("Usage: split ");
return;
}
// Get the input file name and chunk size from the arguments
string inputFileName = args[0];
int chunkSize;
// Try to parse the chunk size to an integer
if (!int.TryParse(args[1], out chunkSize) || chunkSize <= 0)
{
Console.WriteLine("Please enter a valid chunk size (positive integer).");
return;
}
// Check if the input file exists
if (!File.Exists(inputFileName))
{
Console.WriteLine("The specified file does not exist.");
return;
}
try
{
// Open the input file using FileStream
using (FileStream inputFile = new FileStream(inputFileName, FileMode.Open, FileAccess.Read))
{
// Get the total size of the input file
long fileSize = inputFile.Length;
// Calculate the number of chunks needed
int chunkCount = (int)Math.Ceiling((double)fileSize / chunkSize);
// Loop through and create the chunks
for (int i = 0; i < chunkCount; i++)
{
// Generate the name for the new chunked file (e.g., file.exe.001)
string outputFileName = $"{inputFileName}.{i + 1:D3}";
// Open the output file with FileStream to write the chunk
using (FileStream outputFile = new FileStream(outputFileName, FileMode.Create, FileAccess.Write))
{
// Calculate how many bytes to read in this chunk
int bytesToRead = (i < chunkCount - 1) ? chunkSize : (int)(fileSize - i * chunkSize);
// Buffer to hold the chunk data
byte[] buffer = new byte[bytesToRead];
// Read the data into the buffer
inputFile.Read(buffer, 0, bytesToRead);
// Write the buffer to the output file
outputFile.Write(buffer, 0, bytesToRead);
}
// Output progress message
Console.WriteLine($"Created: {outputFileName}");
}
// Indicate completion of the process
Console.WriteLine("File split completed successfully.");
}
}
catch (Exception ex)
{
// Handle any exceptions that may occur during file processing
Console.WriteLine("An error occurred: " + ex.Message);
}
}
}
Output
//For example, if you run the program on a file named myFile.exe of size 4500 bytes with a chunk size of 2000 bytes, the output files will be:
Created: myFile.exe.001
Created: myFile.exe.002
Created: myFile.exe.003
File split completed successfully.