How to use C # to read files effectively

How do you usually read the files? Use stream read. Yes, C # provides us with a very powerful class library (once again touted.) NET, which encapsulates almost everything we can think of and we do not think of class, stream is the general means of reading files, then you will really use it to read the data in the file? Can you really read the whole thing?

Usually we read a file using the following steps:

1. Declare and instantiate a file stream object using the OpenRead of file, as follows

FileStream fs = file.openread (filename);

Or

FileStream fs = FileStream (filename, FileMode.Open, FileAccess.Read, FileShare.Read);

2. Prepare a byte array containing the contents of the file, FS. Length will get the actual size of the file, just like the following

byte[] data = new BYTE[FS. Length];

3, Wow! Start reading, a method that invokes a file stream reads the data into an array

Fs. Read (data, 0, data.) Length);

Oh! We have only written 3 words can be the contents of the document is read out, it is too concise! Can this code really work as you expected? The answer is: almost! In most cases the above code works very well, but we should note that the Read method has a return value, and since there is a return value, there must be a reason, if you follow the above can be a function of no return value. The purpose of the return value is to give us an opportunity to determine the size of the actual read file, and to determine whether the file has been fully read. So the code above does not guarantee that we must have read all the bytes in the file (although in many cases it has been read). The following method provides a more secure method than the previous method to ensure that the file is read out completely

public static void Saferead (Stream stream, byte[] data) {

int offset=0;

int remaining = data. Length;

Read the rest of the bytes as long as they are available.

while (Remaining > 0) {

int read = stream. Read (data, offset, remaining);

if (read <= 0)

throw new EndOfStreamException ("file read to" +read.) ToString () + "Failed!" ");

Reduce the number of bytes remaining

remaining = read;

Increase offset

Offset + = read;

}

}



In some cases you do not know the actual length of the stream, such as network flow. A similar method can be used to read the stream until the data inside the stream is fully read. We can initialize a cache, and then write the stream that is read to the memory stream, as follows:

public static byte[] Readfully (Stream stream) {

Initializes a 32k cache

byte[] buffer = new byte[32768];

using (MemoryStream ms = new MemoryStream ()) {//return result automatically reclaims the Dispose method that calls the object to free memory

Keep reading.

while (true) {

int read = stream. Read (buffer, 0, buffer.) Length);

You can return the results until you've read the last 3M data.

if (read <= 0)

Return Ms. ToArray ();

Ms. Write (buffer, 0, read);

}

}

}



Although the above examples are relatively simple, the effect is not very obvious (most of them are right), maybe you would have, it's okay this article is originally written to beginners.

The following method provides a way to read a stream using the specified cache length, although in many cases you can get the length of the stream directly using Stream.length, but not all streams can be obtained.

public static byte[] Read2buffer (Stream stream, int bufferlen) {

Specifies a default length as the cache size, if a buffer of the specified length is invalid

if (Bufferlen < 1) {

Bufferlen = 0x8000;

}

Initialize a buffer

byte[] buffer = new Byte[bufferlen];

int read=0;

int block;

Every time you read the cached data from the stream, you know that all the streams are read

while (block = stream. Read (buffer, read, buffer.) length-read)) > 0) {

Reset Read Location

Read + = block;



Check to see if the cached bounds are reached, and check for information that can be read

if (read = = buffer. Length) {

Attempt to read a byte

int nextbyte = stream. ReadByte ();



Read failure indicates that read completion can return the result

if (nextbyte==-1) {

return buffer;

}



Adjust array size to continue reading

byte[] Newbuf = new Byte[buffer. LENGTH*2];

Array.copy (buffer, newbuf, buffer. Length);

Newbuf[read]= (byte) nextbyte;

Buffer = newbuf;//buffer is a reference (pointer), which is intended to reset the buffer pointer to a larger memory

read++;

}

}

If the cache is too large, use RET to shrink the buffer read in front of it and return directly to

byte[] ret = new Byte[read];

Array.copy (buffer, ret, read);

return ret;

}