Part V: Beyond Basic Classes in C#.NET

Maker Code 128 Code Set A in C#.NET Part V: Beyond Basic Classes

{ public static void Main(string[] strings) { SubClass sc1 = new SubClass(10); SubClass sc2 = new SubClass(20); MyFunc(sc1, sc2); // wait for user to acknowledge the results ConsoleWriteLine( Press Enter to terminate ); ConsoleRead(); } // MyFunc - use the methods provided by the ICompare interface // to display the value of two objects and then an indication // of which is greater (according to the object itself) public static void MyFunc(ICompare ic1, ICompare ic2) { ConsoleWriteLine( The value of ic1 is {0} and ic2 is {1} , ic1GetValue(), ic2GetValue()); string s; switch (ic1CompareTo(ic2)) { case 0: s = is equal to ; break; case -1: s = is less than ; break; case 1: s = is greater than ; break; default: s = something messed up ; break; } ConsoleWriteLine( The objects themselves think that ic1 {0} ic2 , s); } } }

programs The ICompare interface describes a class that can compare two objects and fetch their value ICompare inherits the CompareTo() requirement from the IComparable interface To that, ICompare adds GetValue(), which returns the value of the objects as an int

Even though it may return the value of the object as an int, GetValue() says nothing about the internals of the class Generating an int value may involve a complex calculation, for all I know The class BaseClass implements the ICompare interface the concrete GetValue() method returns the data member nValue However, the CompareTo() method, which is also required by the ICompare interface, is declared abstract Declaring a class abstract means that it is an incomplete concept lacking an implementation of one or more properties in this case, the method CompareTo() The implementation is thus postponed for subclasses to complete

concrete Notice that SubClass automatically implements the ICompare interface, even though it doesn t explicitly say so BaseClass promised to implement the methods of ICompare, and SubClass IS_A BaseClass By inheriting these methods, SubClass automatically inherits the requirement to implement ICompare

Main() creates two objects of class SubClass with different values It then passes those objects to MyFunc() The MyFunc() method expects to receive two objects of interface ICompare MyFunc() uses the CompareTo() method to decide which object is greater and then uses GetValue() to display the

value of the two objects The output from this program is short and sweet:

The value of ic1 is 10 and ic2 is 20 The objects themselves think that ic1 is less than ic2 Press Enter to terminate

15 deepens the already remarkable capability of interfaces by showing you how to write generic interfaces

C# appears to have a dichotomy in the way you declare variables You declare and initialize value type variables such as int and double in the following way:

However, you declare and initialize references to objects in a completely different way:

public class MyClass { public int n; } MyClass mc; mc = new MyClass();

The class variable mc is known as a reference type because the variable mc refers to potentially distant memory Intrinsic variables like int or double are known as value type variables If you examine n and mc more closely, however, you see that the only real difference is that C# allocates the memory for the value type variable automatically while you have to allocate the memory for the class object explicitly int is from Venus; MyClass is from Mars Is there nothing that can tie the two together into a Unified Class Theory

C# defines a third variable type called a structure that bridges the gap between the reference types and the value types The syntax of a structure declaration looks like that of a class:

public struct MyStruct { public int n; public double d; } public class MyClass { public int n; public double d; }

A structure object is accessed like a class object but allocated like a value type, as demonstrated in the following code:

// declaring and accessing a simple value type int n; n = 1; // declaring a struct is much like declaring a simple int MyStruct ms; // automatically allocates memory msn = 3; // access the members the same as a class object msd = 30; // a class object must be allocated out of a separate // memory area with new