CSharp Bits is a tutorial-based digest that explains the C# programming language. It evolves, covering prerequisite topics and is currently broad in coverage rather than getting deep into a specific topic. That will come after a basis has been established.  I issue the topics daily (:p), and mainly cover one topic in each issue, so readers can fit it in their daily routine.  I email these topics internally at Microsoft and have been asked to blog the digests externally to reach out to the user community.

All code examples are meant to demonstrate the topic only. It is neither shippable nor secure code by any stretch of the imagination.  An archive of the topics I submitted internally within Microsoft before I started blogging these out is not currently available externally.

==

Base/Derived Conversions

You can convert a reference to an object of a derived class to an object of its base class, and vice versa, under certain conditions.

Conversion to Base Class Reference

References to objects of one class type can be converted into references to another type if one class inherits from the other, either directly or indirectly.

A reference to an object can always be converted to a reference to a base class object. This conversion can be performed implicitly (by assignment or as part of an expression) or explicitly (by using the cast operator).

The following examples will use two classes: Animal and Bird. Animal is the base class of Bird, or, to put it another way, Bird inherits from Animal.

The following example declares a variable of type Animal and a variable of type Bird:

Animal a;
Bird b = new Bird(...);

Now consider the following assignment, in which the reference in b is copied to a:

a = b;

The Bird class inherits from the Animal class. Therefore, a method that is found in Animal is also found in Bird. (The Bird class might have overridden some of the methods of Animal to create its own version of them, but an implementation of the method will exist nonetheless.) Therefore, it is possible for references to Bird objects to be assigned to variables containing references to objects of type Animal.

In this case, C# performs a type conversion from Bird to Animal. You can explicitly convert Bird to Animal by using a cast operator, as shown:

a = (Animal) b;

The preceding code will produce exactly the same result.

Conversion to Derived Class Reference

You can convert a reference to a derived type, but you must explicitly specify the conversion by using a cast. An explicit conversion is subject to run-time checking to ensure that the types are compatible, as shown in the following example:

Bird b = (Bird) a; // Okay

This code will compile successfully. At run time, the cast operator performs a check to determine whether the object referred to is really of type Bird. If it is not, the run-time InvalidCastException is raised.

If you attempt to assign to a derived type without a conversion operator, as in the following code, the compiler will display an error message stating, "Cannot implicitly convert type 'Animal' to 'Bird.'"

b = a; // Will not compile

You can trap a type conversion error by using try and catch, just like any other exception, as shown in the following code:

try {
   b = (Bird) a;
}
catch (InvalidCastException) {
   Console.WriteLine("Not a bird");
}

Namespaces in the .NET Framework

The .NET Framework provides common language services to a variety of application development tools. The classes in the framework provide an interface to the common language runtime, the operating system, and the network.

System.IO Namespace

The System.IO namespace is important because it contains many classes that allow an application to perform input and output (I/O) operations in various ways through the file system.

The System.IO namespace also provides classes that allow an application to perform input and output operations on files and directories.

The System.IO namespace is large and cannot be explained in detail here. However, the following list gives an indication of the facilities available:

·           The File and Directory classes allow an application to create, delete, and manipulate directories and files.

·           The StreamReader and StreamWriter classes enable a program to access file contents as a stream of bytes or characters.

·           The FileStream class can be used to provide random access to files.

·           The BinaryReader and BinaryWriter classes provide a way to read and write primitive data types as binary values.

System.IO Example

The following example shows how a file can be opened and read as a stream. The example is not meant to illustrate all of the possible ways in which the System.IO namespace can be used, but does show how you can perform a simple file copy operation.

using System;
using System.IO; // Use IO namespace
// ...
StreamReader reader = new StreamReader("infile.txt");
// Text in from file
StreamWriter writer = new StreamWriter("outfile.txt");
// Text out to file
string line;
while ((line = reader.ReadLine( )) != null)
{
   writer.WriteLine(line);
}

reader.Close( );
writer.Close( );

To open a file for reading, the code in the example creates a new StreamReader object and passes the name of the file that needs to be opened in the constructor. Similarly, to open a file for writing, the example creates a new StreamWriter object and passes the output file name in its constructor. In the example, the file names are hard-coded, but they could also be string variables.

The example program copies a file by reading one line at a time from the input stream and writing that line to the output stream.

ReadLine and WriteLine might look familiar. The Console class has two static methods of that name. In the example, the methods are instance methods of the StreamReader and StreamWriter classes, respectively.

For more information about the System.IO namespace, search for "System.IO namespace" in the .NET Framework SDK Help documents.