Summary

This chapter has given you a glimpse at the incredible power that a developer can wield using generics. Generics are a tool that allow developers to maximize performance and code reuse as well as create a robust object-oriented programming environment by not having to resort to repetitive typecasting and the overuse of parameters of type System.Object . Using generics, developers can defer the specification of data types until such time as their class is instantiated , but still reap the benefits of strong data types. After reading this chapter, you should be able to continue learning all that C# 2.0 has to offer and feel comfortable when you see generics being used by the .NET Framework and in your own sample code.

Part II: .NET Framework 2.0 Fundamentals

In This Part

Chapter 7. I/O and Persistence

In this day and age of enterprise applications and smart clients that get their data from large relational databases like SQL Server and Oracle, it is often easy to overlook the fact that we still use the underlying file system for something other than storing shortcuts and documents.

We use files for numerous tasks , including storing configuration settings, images, icons, textual data (such as comma-delimited files from other sources like mainframes), file-based databases such as Microsoft Access, Excel spreadsheets, and even XML data.

This chapter shows you the basics of working with files using the .NET Framework, including how to work with streams, the basic unit of input/output (I/O) used throughout the entire framework. Finally, you'll see some more advanced file I/O techniques such as asynchronous I/O and the use of isolated storage to provide a secure, isolated location for your application's data.

Introduction to Streams

A stream is an object that essentially connects data between two endpoints with a narrow access window. Streams allow you to write and read small portions of data at a time, providing for an extremely efficient means of access. For example, using a stream, you can read data in small portions from a file that is several hundred megabytes in size without actually consuming several hundred megabytes of memory. The same is true of writing to streams. You can place small amounts of data on a stream without having to have all of the data in memory at any given time.

In addition to the performance benefit, streams also provide a unified model for reading and writing data, regardless of the format or location of the underlying data. For example, you can access data from a disk file using a stream and you can access data from a relational database or from a web service in a stream as well.

Streams can also be connected through a process referred to as composition . By composing streams, you can attach various types of reader and writer classes to the end of the stream to make data access easier. As you will see in Chapter 15 "Cryptography and Data Protection," you can even attach specially encrypted streams so that data is encrypted as soon as it is placed on the stream. Streams can also be used for network communication in addition to file I/O.

Using Memory Streams

Streams are the basic unit of I/O in the .NET Framework and you will find them used everywhere. Before getting into working with physical files on disk, this section will illustrate the basics of opening streams and reading and writing from streams using the MemoryStream class as an example. When you know how to manipulate a MemoryStream , you will find that you will be able to use all of the other types of streams exposed by .NET Framework classes with little difficulty.

As mentioned earlier, streams provide a narrow window of access. This often causes developers trouble. For example, when you write to a stream, the Position of the pointer in the stream advances. When you read from a stream, the read always starts from the current pointer position within the stream . A common source of problems when reading from streams is not setting the pointer position properly with the Seek method.

Before taking a look at the MemoryStream sample code, take a look at Tables 7.1 and 7.2, which list the methods and properties that belong to all Stream classes, regardless of the underlying data store.

Table 7.1. Stream Properties

using System;
using System.IO;
using System.Collections.Generic;
using System.Text;

namespace MemStream
{
    class Program
    {
        static void Main(string[] args)
        {
            string sourceString = "Mary had a little lamb.";
            MemoryStream ms = new MemoryStream(100) ;

            // put some data on the stream
            ms.Write(ASCIIEncoding.ASCII.GetBytes(sourceString),
              0, sourceString.Length);

            Console.WriteLine("After initial write:");
            Console.WriteLine(string.Format(
                "Capacity: {0}\nLength: {1}\nPosition: {2}",
                ms.Capacity, ms.Length, ms.Position));

            ms.Seek(0, SeekOrigin.Begin);
            // read the first 4 bytes of the stream
            byte[] tempBytes = new byte[sourceString.Length];
            ms.Read(tempBytes, 0, 4);

            Console.WriteLine(ASCIIEncoding.ASCII.GetString(tempBytes));

            // get the word 'lamb'
            ms.Seek(-5, SeekOrigin.End);
            ms.Read(tempBytes, 0, 4) ;
            Console.WriteLine(ASCIIEncoding.ASCII.GetString(tempBytes));

            // write some bytes
            ms.Seek(11, SeekOrigin.Begin);
            ms.Write(ASCIIEncoding.ASCII.GetBytes("really"),0, 6);

            // now get the whole stream
            ms.Seek(0, SeekOrigin.Begin);
            ms.Read(tempBytes, 0, (int)ms.Length);
            Console.WriteLine(ASCIIEncoding.ASCII.GetString(tempBytes));

            ms.Close();

            Console.ReadLine();
        }
    }
}