Given a text file, how would I go about reading an arbitrary line and nothing else in the file?
Say, I have a file test.txt. How would I go about reading line number 15 in the file?
All I've seen is stuff involving storing the entire text file as a String array and then using the value of the line number as the number of the String to use from the array... but there are some complications: The text file is enormously huge and the machine that the application I'm coding isn't exactly a top-notch system. Speed isn't the top priority, but it is definitely a major issue.
Are there any ways to ONLY read a specific line of a text file and store the result as a string?
Thanks for your responses: The file is KINDA structured. It's got 25 lines of info and then X lines of numbers but line 17 of the first 25 has the value of X.
But then, there's 1 blank line and it repeats itself all over as a second record in the file and X can have a different value for each record.
What I want to do is read and store the first 25 lines as independent values and then store the next X (usually around 250) lines as an array. Then I'm going to store it in an SQL database and repeat with the NEXT record until I reach the Yth record (the number of records in the file is in line 3)
EDIT 2: Alright, I think I've gotten to a solution based on a combination of your alls' responses.
I'm going to read the first 25 lines and store it as an array. I'll copy the pertinent contents of the array to local variables then I'll delete the first 25 lines. Then, I can use the info to store the next X lines (the value of item 13 in the array) as an array, serialize it, store it in a database then delete the lines that I just read.
I could then repeat the process for each subsequent record.
Of course, this relies on one assumption I'm making, which to be honest, I'm not sure is true. Is it possible to delete the first n lines from a text file from within C# without having to read the entire thing and re-write it without the first n lines?
As Mehrdad said, you cannot just seek to the n-th line without reading the file. However, you don't need to store the entire file in memory - just discard the data you don't need.
string line;
using (StreamReader sr = new StreamReader(path))
for (int i = 0; i<15; i++)
{
line = sr.ReadLine();
if (line==null) break; // there are less than 15 lines in the file
}
Unless you have fixed sized lines, you need to read every line until you reach the line you want. Although, you don't need to store each line, just discard it if it's not the line you desire.
Edit:
As mentioned, it would also be possible to seek in the file if the line lengths were predictable -- that is to say you could apply some deterministic function to transform a line number into a file position.
Read five lines each time, just put your statement in if statement , thats it
String str1 = @"C:\Users\TEMP\Desktop\StaN.txt";
System.IO.StreamReader file = new System.IO.StreamReader(str1);
line = file.ReadLine();
Int32 ctn=0;
try
{
while ((line = file.ReadLine()) != null)
{
if (Counter == ctn)
{
MessageBox.Show("I am here");
ctn=ctn+5;
continue;
}
else
{
Counter++;
//MessageBox.Show(Counter.ToString());
MessageBox.Show(line.ToString());
}
}
file.Close();
}
catch (Exception er)
{
}
If the lines are all of a fixed length you can use the Seek method of a stream to move to the correct starting positiion.
If the lines are of a variable length your options are more limited.
If this is a file you will be only using once and then discarding, then you are best off reading it in and working with it in memeory.
If this is a file you will keeping and will be reading from more than writing to, you can create a custom index file that contains the starting positions of each line. Then use that index to get your Seek position. The process of creating the index file is resource intensive. Everytime you add a new line to the file you will need to update the index, so maintenance becomes a non-trivial issue.
If each line is a fixed length then you can open a Stream around it, seek (bytes per line) * n into the file and read your line from there.
using( Stream stream = File.Open(fileName, FileMode.Open) )
{
stream.Seek(bytesPerLine * (myLine - 1), SeekOrigin.Begin);
using( StreamReader reader = new StreamReader(stream) )
{
string line = reader.ReadLine();
}
}
Alternatively you could just use the StreamReader to read lines until you found the one you wanted. That way's slower but still an improvement over reading every single line.
using( Stream stream = File.Open(fileName, FileMode.Open) )
{
using( StreamReader reader = new StreamReader(fileStream) )
{
string line = null;
for( int i = 0; i < myLineNumber; ++i )
{
line = reader.ReadLine();
}
}
}
if (File.Exists(fpath))
{
var data = File.ReadLines(fpath);
Console.WriteLine(data.ToArray()[14]);
}
While you can't seek an N'th line directly in a non-symmetrical file without reading data in the file (because you need to count how many lines you have progressed into the file) you can count line breaks until you get to the line you want which takes the least amount of memory and probably has the best performance.
This is going to be more memory efficient than reading everything to an array, since it will only read into the file until it hits the end of the file or the line number (whichever comes first). It is far from perfect, but will probably suit your needs:
string line15 = ReadLine(@"C:\File.csv", 15);
public string ReadLine(string FilePath, int LineNumber){
string result = "";
try{
if( File.Exists(FilePath) ){
using (StreamReader _StreamReader = new StreamReader(FilePath)){
for (int a = 0; a < LineNumber; a++) {
result = _StreamReader.ReadLine();
}
}
}
}catch{}
return result;
}
You could read line by line so you don't have to read the entire all at once (probably at all)
int i=0
while(!stream.eof() && i!=lineNum)
stream.readLine()
i++
line = stream.readLine()
No unfortunately there is not. At the raw level files do not work on a line number basis. Instead they work at a position / offset basis. The root filesystem has no concept of lines. It's a concept added by higher level components.
So there is no way to tell the operating system, please open file at line blah. Instead you have to open the file and skip around counting new lines until you've passed the specified number. Then store the next set of bytes into an array until you hit the next new line.
A variation. Produces an error if line number is greater than number of lines.
string GetLine(string fileName, int lineNum)
{
using (StreamReader sr = new StreamReader(fileName))
{
string line;
int count = 1;
while ((line = sr.ReadLine()) != null)
{
if(count == lineNum)
{
return line;
}
count++;
}
}
return "line number is bigger than number of lines";
}
Late Answer but worth it .
You need to load the lines in array or list object where each line will be assign to an index ,then simply call any range of lines by their index in for loop .
Solution is pretty Good ,but there is a memory consumption in between .
give it try ...Its worth it
If your file contains lines with different lengths and you need to read lines often and you need to read it quickly you can make an index of the file by reading it once, saving position of each new line and then when you need to read a line, you just lookup the position of the line in your index, seek there and then you read the line.
If you add new lines to the file you can just add index of new lines and you don't need to reindex it all. Though if your file changes somewhere in a line you have already indexed then you have to reindex.
Tried and tested. It's as simple as follows:
string line = File.ReadLines(filePath).ElementAt(actualLineNumber - 1);
As long as you have a text file, this should work. Later, depending upon what data you expect to read, you can cast the string accordingly and use it.
Source: Stackoverflow.com