C# 4 and .NET 4

eading and Writing to files ❘ 787
Grease
Close Encounters of the Third Kind
The Day After Tomorrow
The WriteAllLines() method writes out the string array with each array item taking its own line
in the file.
Because data may be written not only to disk but to other places as well (such as to named pipes or to
memory), it is also important to understand how to deal with file I/O in .NET using streams as a means of
moving file contents around. This is shown in the following section.
streams
The idea of a stream has been around for a very long time. A stream is an object used to transfer data. The
data can be transferred in one of two directions:
➤
➤
If the data is being transferred from some outside source into your program, it is called reading from
the stream.
If the data is being transferred from your program to some outside source, it is called writing to
the stream.
Very often, the outside source will be a file, but that is not always the case. Other possibilities include:
➤
➤
➤
Reading or writing data on the network using some network protocol, where the intention is for this
data to be picked up by or sent from another computer
Reading or writing to a named pipe
Reading or writing to an area of memory
Of these examples, Microsoft has supplied a .NET base class for writing to or reading from memory, the
System.IO.MemoryStream object. The System.Net.Sockets.NetworkStream object handles network
data. There are no base stream classes for writing to or reading from pipes, but there is a generic stream
class, System.IO.Stream, from which you would inherit if you wanted to write such a class. Stream does
not make any assumptions about the nature of the external data source.
The outside source might even be a variable within your own code. This might sound paradoxical, but the
technique of using streams to transmit data between variables can be a useful trick for converting data
between data types. The C language used something similar — the sprintf function — to convert between
integer data types and strings or to format strings.
The advantage of having a separate object for the transfer of data, rather than using the FileInfo or
DirectoryInfo classes to do this, is that separating the concept of transferring data from the particular
data source makes it easier to swap data sources. Stream objects themselves contain a lot of generic code
that concerns the movement of data between outside sources and variables in your code. By keeping this
code separate from any concept of a particular data source, you make it easier for this code to be reused
(through inheritance) in different circumstances. For example, the StringReader and StringWriter
classes are part of the same inheritance tree as two classes that you will be using later on to read and write
text files. The classes will almost certainly share a substantial amount of code behind the scenes.
Figure 29-8 illustrates the actual hierarchy of stream-related classes in the System.IO namespace.
As far as reading and writing files, the classes that concern us most are:
➤
➤
FileStream — This class is intended for reading and writing binary data in a binary file. However,
you can also use it to read from or write to any file.
StreamReader and StreamWriter — These classes are designed specifically for reading from and
writing to text files.
www.it-ebooks.info