Apress © 2003 (1200 pages)

The thrust of this chapter is to introduce you to the core aspects of the C# language, including intrinsic data

This comprehensive text starts with a brief overview of the

types (both value-based and reference-based); decision and iteration constructs; boxing and unboxing

C# language and then quickly moves to key technical and

mechanisms; the role of System.Object and basic class construction techniques. Along the way, you also learn how to manipulate CLR strings, arrays, enumerations, and structures using the syntax of C#.

To illustrate these language fundamentals, you will take a programmatic look at the .NET base class

Table of Contents

libraries, and build a number of sample applications making use of various .NET namespaces. The chapter

C# and the .NET Platform, Second Edition

closes by showing you how to organize your custom types into discrete user-defined namespaces (and

Introduction

explains why you might want to do so).

Part One - Introducing C# and the .NET Platform

Chapter 1 - The Philosophy of .NET

The Anatomy of a Basic C# Class

Chapter 2 - Building C# Applications

Part Two - The C# Programming Language

Like the Java language, C# demands that all program logic is contained within a type definition (recall that a

Chapter 3 - C# Language Fundamentals

type is a generic term referring to a member of the set {class, interface, structure, enumeration, delegate}).

Chapter 4 - Object-Oriented Programming with C#

Unlike C(++), it is not possible to create global functions or global points of data. In its simplest form, a C#

Chapter 5 - Exceptions and Object Lifetime

class can be defined as follows (also recall that the "using" keyword simplifies type declarations):

Chapter 6 - Interfaces and Collections

Chapter 7 - Callback Interfaces, Delegates, and Events

// By convention, C# files end with a *.cs file extension.

Chapter 8 - Advanced C# Type Construction Techniques using System;

Part Three - Programming with .NET Assemblies

class HelloClass

Chapter 9 - Understanding .NET Assemblies

{

Chapter 10 - Processes, AppDomains, Contexts, and'private'Thre ds

/* Main() can be declared as

Chapter if11 -youTypedesireR flection,...Late*/Binding, and Attribute-Based Programming

Part Fourpublic- Leveragingstatiche .NETintLibrMain(string[]ries args)

Chapter {12 - Object Serialization and the .NET Remoting Layer

Chapter 13 - BuildingConsolea Better.WriteLine("HelloWindow (IntroducingWorld!");Windows Forms)

returner 0;

Chapter 14 - A B Painting Framework (GDI+)

}

Chapter 15 - Programming with Windows Forms Controls

}

Chapter 16 - The System.IO Namespace Chapter 17 - Data Access with ADO.NET

Part Five - Web Applications and XML Web Services

Here, you have created a definition for an appropriately named type (HelloClass) that supports a single

Chapter 18 - ASP.NET Web Pages and Web Controls

method named Main(). Every executable C# application must contain a class defining a Main() method,

Chapter 19 - ASP.NET Web Applications

which is used to signify the entry point of the application.

Chapter 20 - XML Web Services

IndexNote Although it is technically possible (albeit unlikely) for a single C# project to contain multiple

List of Figuresclasses defining a Main() method, you must specify which type contains the Main() method to be

used as the application's entry point (via the csc.exe /main flag or, for VS .NET applications, via

List of Tables

the "Startup Object" setting of the Project Properties window). If you fail to do so, you encounter a compile-time error.

As you can see, the signature of Main() is adorned with the public and static keywords (also note the capital "M" in Main(), which is obligatory as C# is case-sensitive). Later in this chapter you are supplied with a formal definition of the "public" and "static" keywords. Until then, understand that public methods are accessible from other types, while static methods are scoped at the class level (not at an object level) and can thus be invoked without the need to first create a new object variable.

In addition to the public and static keywords, our Main() method has a single parameter, which happens to be an array of strings (string[] args). Although you are not currently bothering to manipulate this array, it is possible that this parameter can contain any number of command line arguments (you see how to access them momentarily).

The program logic of the HelloClass is within Main() itself. Here, you make use of the Console class, which is defined within the System namespace. Among its set of members is the static WriteLine(), which as you

might assume, pumps a text string to the standard console (more details on System.Console a bit later in

C# and the .NET Platform, Second Edition

this chapter):

by Andrew Troelsen ISBN:1590590554

Apress © 2003 (1200 pages)

// Pump some text to the console.

This comprehensive text starts with a brief overview of the

Console.WriteLine("Hello World!");

C# language and then quickly moves to key technical and

architectural issues for .NET developers.

Because our Main() method has been defined as returning an integer data type, you return zero (success)

before exiting. Finally, as you can see from the HelloClass type definition, C and C++ styles comments have

Table of Contents

carried over into the C# language.

C# and the .NET Platform, Second Edition

Introduction

PartVariationsOne - Introduciong C#theandMain()the .NET PlatformMethod

Chapter 1 - The Philosophy of .NET

The previous iteration of Main() was defined to take a single parameter (an array of strings) and return an

Chapter 2 - Building C# Applications

integer data type. This is not the only possible form of Main(), however. It is permissible to construct your

Part Two - The C# Programming Language

application's Main() method using any of the following signatures (assuming it is contained within a C# class

Chapter 3 - C# Language Fundamentals

definition):

Chapter 4 - Object-Oriented Programming with C#

Chapter 5 - Exceptions and Object Lifetime

// No return type, array of strings as argument.

Chapter 6 - Interfaces and Collections

public static void Main(string[] args)

Chapter 7 - Callback Interfaces, Delegates, and Events

{

Chapter 8 - Advanced C# Type Construction Techniques

// Process command line arguments.

Part Three - Programming with .NET Assemblies

// Make some objects.

Chapter 9 - Understanding .NET Assemblies

}

Chapter 10 - Processes, AppDomains, Contexts, and Threads

// No return type, no arguments.

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming public static void Main()

Part Four - Leveraging the .NET Libraries

{

Chapter 12 - Object Serialization and the .NET Remoting Layer

// Make some objects.

Chapter 13 - Building a Better Window (Introducing Windows Forms)

}

Chapter 14 - A Better Painting Framework (GDI+)

Chapter 15 - Programming with Windows Forms Controls

// Integer return type, no arguments.

Chapter 16 - The System.IO Namespace

public static int Main()

Chapter{ 17 - Data Access with ADO.NET

Part Five//- WebMakeApplicationssome objectsand XML. Web Services

Chapter//18Return- ASP.NETaWebvaluePagestoandtheW bsystemCon rols.

Chapter} 19 - ASP.NET Web Applications

Chapter 20 - XML Web Services

Index

Obviously, your choice of how to construct Main() will be based on two questions: First, do you need to process any command line parameters? If so, they will be stored in the array of strings. Next, do you want to return a value to the system when Main() has completed? If so, you need to return an integer data type rather than void.

Processing Command Line Parameters

Assume that you now wish to update HelloClass to process any possible command line parameters (I examine the details behind the {0} notation in just a bit):

// This time, check if we have been sent any command line arguments.

using System;

class HelloClass

{

public static int Main(string[] args)

{

Console.WriteLine("***** Command line args *****");

Arguments" textbox found under the Configuration | Debugging node (Figure 3-2).

C# and the .NET Platform, Second Edition

of the

and

Table

C# and

Part

Chapter

Chapter

Part

Chapter

Chapter

Figure 3-2: Setting command arguments via VS .NET

Chapter 5 - Exceptions and Object Lifetime

Chapter 6 - Interfaces and Collections

Chapter 7 - Callback Interfaces, Delegates, and Events

Needless to say, regardless of the technique you use to specify application arguments, you are the one in Chaptercharge8of determining- Advanced C#whichTypecommandConstructionlineTechniquesparameters your application will respond to, and what to do with

PartthemThreeonce- Programmingthe end user haswithsupplied.NET Assembliesthem.

Chapter 9 - Understanding .NET Assemblies

Chapter 10 - Processes, AppDomains, Contexts, and Threads

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

Part Four - Leveraging the .NET Libraries

Chapter 12 - Object Serialization and the .NET Remoting Layer

Chapter 13 - Building a Better Window (Introducing Windows Forms)

Chapter 14 - A Better Painting Framework (GDI+)

Chapter 15 - Programming with Windows Forms Controls

Chapter 16 - The System.IO Namespace

Chapter 17 - Data Access with ADO.NET

Part Five - Web Applications and XML Web Services

Chapter 18 - ASP.NET Web Pages and Web Controls

Chapter 19 - ASP.NET Web Applications

Chapter 20 - XML Web Services

Index

List of Figures

List of Tables

Creating Objects:C# and theConstructor.NET Platform, SecondBasicsEdition

Now that you have the role of Main() under your belt, let's move on to the topic of object construction. All

Apress © 2003 (1200 pages)

object-oriented languages make a clear distinction between classes and objects. A class is a definition of a

This comprehensive text starts with a brief overview of the

user-defined typeC#(UDT)languagethat isandoftenthenregardedquickly movesas a blueprintto key technicalfor variablesand of this type. An object is simply a term describing aarchitecturgiven instancel issuesof aforparticular.NET developersclass. In. C#, the "new" keyword is the de facto way to create an object instance. Unlike other OO languages (such as C++), it is not possible to allocate a class type on the stack, and therefore if you attempt to use a class variable that has not been "new-ed" you are

Table of Contents

issued a compile time error. Thus the following illustrative C# logic is illegal:

C# and the .NET Platform, Second Edition

Introduction

// This is no good...

Part One - Introducing C# and the .NET Platform

Using System;

Chapter 1 - The Philosophy of .NET

class HelloClass

Chapter 2 - Building C# Applications

{

Part Two - The C# Programming Language

public static int Main(string[] args)

Chapter 3 - C# Language Fundamentals

{

Chapter 4 - Object-Oriented Programming with C#

// Error! Use of unassigned local variable! Must use 'new'.

Chapter 5 - ExcHelloClassptions and Objectc1; Lifetime

Chapter 6 - Interfacesc1.SayHi();and Collections

Chapter 7 - CallbackreturnInterfaces,0; Delegates, and Events

}

Chapter 8 - Advanced C# Type Construction Techniques

}

Part Three - Programming with .NET Assemblies

Chapter 9 - Understanding .NET Assemblies

Chapter 10 - Processes, AppDomains, Contexts, and Threads

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

To illustrate the proper procedure for class instantiation, observe the following update:

Part Four - Leveraging the .NET Libraries

Chapter 12 - Object Serialization and the .NET Remoting Layer

// Make HelloClass typescorrectlyusing the C# 'new' keyword.

Chapter 13 - Building a Better Window (Introducing Windows Forms)

Using System;

Chapter 14 - A Better Painting Framework (GDI+) class HelloClass

Chapter 15 - Programming with Windows Forms Controls

{

Chapter 16 - The System.IO Namespace

public static int Main(string[] args)

Chapter{17 - Data Access with ADO.NET

Part Five - Web Applications and XML Web Services

// You can declare and create a new object in a single line...

Chapter 18 - ASP.NET Web Pages and Web Controls

HelloClass c1 = new HelloClass();

Chapter 19 - ASP.NET Web Applications

// ...or break declaration and creation into two lines.

Chapter 20 - XML Web Services

HelloClass c2;

List of Figuresreturn 0;

List of Tables}

}

The "new" keyword is in charge of allocating the correct number of bytes for the specified class and acquiring sufficient memory from the managed heap. Here, you have allocated two objects (c1 and c2) each of which points to a unique instance of the HelloClass type. Understand that C# object variables are actually a reference to the object in memory, not the actual object itself. Thus, in this light, c1 and c2 each reference a distinct HelloClass object allocated on the managed heap (Chapter 4 offers additional details regarding the .NET garbage collector and the managed heap).

As you may be aware, the previous code is making calls to the default constructor of the class. Every C# class is automatically endowed with a default constructor, which you are free to redefine if need be. Like C++ (and Java), default constructors never take arguments. Beyond allocating a new class instance, the default constructor ensures that all member data is set to an appropriate default value (this behavior is true for all constructors). Contrast this to C++, where uninitialized state data points to garbage (sometimes the little things mean a lot).

Typically, your customC# andclassesthe .NETprovidePlatform,additionalSecondconstructorsEdition beyond the default. In doing so, you provide the object user withby Andrewa simpleTroelsenway to initialize the state of an objectISBN:1590590554at the time of creation. Here is the HelloClass type onceApr ssagain,© 2003with(1200apages)custom constructor, a redefined default constructor, and some simple state data:

// HelloClass, with constructors.

using System;

class HelloClass

Table of Contents

{

C# and the .NET Platform, Second Edition

// Constructors always assign state data to default values.

Introduction

public HelloClass()

Part One - Introducing C# and the .NET Platform

{ Console.WriteLine("Default ctor called!"); }

Chapter 1 - The Philosophy of .NET

// This custom constructor assigns state data to a known value.

Chapter 2 - Building C# Applications

public HelloClass (int x, int y)

Part Two{- The C# Programming Language

Chapter 3 - C# Language Fundamentals

Console.WriteLine("Custom ctor called!");

Chapter 4 - Object-Oriented Programming with C# intX = x;

Chapter 5 - Exceptions and Object Lifetime

intY = y;

Chapter }6 - Interfaces and Collections

Chapter //7 -SomeCallbackpublicInterfaces,stateDelegates,data.and Events

Chapter public8 - Advancedint C#intX,Type intY;Construction Techniques

Part Three - Programming with .NET Assemblies

// Program entry point.

Chapter 9 - Unde standing .NET Assemblies

public static int Main(string[] args)

Chapter 10 - Processes, AppDomains, Contexts, and Threads

{

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

// Trigger default constructor.

Part Four - Leveraging the .NET Libraries

HelloClass c1 = new HelloClass();

Chapter 12 - Object Serialization and the .NET Remoting Layer

Console.WriteLine("c1.intX = {0}\nc1.intY = {1}\n",

Chapter 13 - Building a Better Window (Introducing Windows Forms)

c1.intX, c1.intY);

Chapter 14 - A Better Painting Framework (GDI+)

Chapter 15 - Programming with Windows Forms Controls

// Trigger parameterized constructor.

Chapter 16 - The System.IO Namespace

HelloClass c2;

Chapter 17 - Data Access with ADO.NET

c2 = new HelloClass(100, 200);

Part Five - Web Applications and XML Web Services

Console.WriteLine("c2.intX = {0}\nc2.intY = {1}\n",

Chapter 18 - ASP.NET Web Pages and Web Controls

c2.intX, c2.intY);

Chapter 19 - ASP.NET Web Applications

return 0;

Chapter 20 - XML Web Services

}

Index

}

List of Figures

List of Tables

As you can see, C# constructors are named identical to the class they are constructing, and do not take a return value (not even void). On examining the program's output you can see that the default constructor has indeed assigned the internal state data to the default values (zero), while the custom constructor has assigned the member data to values specified by the object user (see Figure 3-3).

Second Edition

ISBN:1590590554

with a brief overview of the

moves to key technical and

developers.

Table

C# and

Part One - Introducing C# and the .NET Platform

Figure 3-3: Simple constructor logic

Chapter 1 - The Philosophy of .NET

Chapter 2 - Building C# Applications

Part Two - The C# Programming Language

Is That a Memory Leak?

Chapter 3 - C# Language Fundamentals

Chapter 4 - Object-Oriented Programming with C#

If you have a background in C++, you may be alarmed by the previous code samples. Specifically, notice

Chapter 5 - Exceptions and Object Lifetime

how the Main() method of the previous HelloClass type has no logic that explicitly destroys the c1 and c2

Chapter 6 - Interfaces and Collections variables:

Chapter 7 - Callback Interfaces, Delegates, and Events

Chapter 8 - Advanced C# Type Construction Techniques

// Leaky method?

Part Three - Programming with .NET Assemblies

public static int Main(string[] args)

Chapter 9 - Understanding .NET Assemblies

{

Chapter 10 - Processes, AppDomains, Contexts, and Threads

HelloClass c1 = new HelloClass();

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

Console.WriteLine("c1.intX = {0}\nc1.intY = {1}\n", c1.intX, c1.intY);

Part Four - Leveraging the .NET Libraries

HelloClass c2;

Chapter 12 - Object Serialization and the .NET Remoting Layer c2 = new HelloClass(100, 200);

Chapter 13 - Building a Better WindowintX(In roducing Windows Forms)

Console.WriteLine("c2. = {0}\nc2.intY = {1}\n", c2.intX, c2.intY);

Chapter//14Hey!- A BetterDidPaintingsomeoneFrameworkforget(GDI+)to delete these objects?

Chapterreturn15 - Programming0; with Windows Forms Controls

Chapter} 16 - The System.IO Namespace

Chapter 17 - Data Access with ADO.NET

Part Five - Web Applications and XML Web Services

This is not a horrible omission, but the way of .NET. Like Visual Basic and Java developers, C#

Chapter 18 - ASP.NET Web Pages and Web Controls

programmers never explicitly destroy an object. The .NET garbage collector frees the allocated memory automatically, and therefore C# does not support a "delete" keyword. Again, Chapter 4 examines the

garbage collection process in more detail. Until then, just remember that the .NET runtime environment

Index

automatically destroys the objects you allocate.

List of Figures

List of Tables

The CompositionC# and theof.NETa C#Platform,ApplicationSe ond Edition

Currently, our HelloClass type has been constructed to perform two duties. First, the class defines the

Apress © 2003 (1200 pages)

entry point of the application. Second, HelloClass maintains two custom data members and a few

This comprehensive text starts with a brief overview of the

overloaded constructorsC# language. Whileandthisthenis allquicklywell andmovesgood,to keyit maytechnicalseemanda bit strange (although perfectly legal) that the staticar hitecturalMain() methodissuescreatesfor .NETandevelopersinstance. of the very class in which it was defined:

class HelloClass

Table of Contents

{

C# and the .NET Platform, Second Edition

...

Introduction

public static int Main(string[] args)

Part One - Introducing C# and the .NET Platform

{

Chapter 1 - The Philosophy of .NET

HelloClass c1 = new HelloClass();

Chapter 2 - Building C# Applications

...

Part Two - The C# Programming Language

}

Chapter 3 - C# Language Fundamentals

}

Chapter 4 - Object-Oriented Programming with C#

Chapter 5 - Exceptions and Object Lifetime

Many of my initial examples take this approach, just to keep focused on illustrating the task at hand.

Chapter 6 - Interfaces and Collections

However, a more natural design would be to factor the HelloClass type into two distinct classes:

Chapter 7 - Callback Interfaces, Delegates, and Events

HelloClass and HelloApp. In OO parlance, this is termed the "separation of concerns." Thus, you could

Chapter 8 - Advanced C# Type Construction Techniques

reengineer the application as the following (notice you have added a new member named SayHi() to the

Part Three - Programming with .NET Assemblies

HelloClass type):

Chapter 9 - Understanding .NET Assemblies

Chapter 10 - Processes, AppDomains, Contexts, and Threads

classHelloClass

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

{

Part Four - Leveraging the .NET Libraries

public HelloClass(){ Console.WriteLine("Default ctor called!"); }

Chapter 12 - Object Serialization and the .NET Remoting Layer

public HelloClass (int x, int y)

Chapter 13 - Building a Better Window (Introducing Windows Forms)

{

Chapter 14 - A Better Painting Framework (GDI+) Chapter 15 - Programming with Windows Forms Controls

Chapter 16 - The System.IO Namespace

}

Chapter 17 - Data Access with ADO.NET public int intX, intY;

Part Five - Web Applications and XML Web Services

public void SayHi() { Console.WriteLine("Hi there!"); }

Chapter 18 - ASP.NET Web Pages and Web Controls

}

Chapter 19 - ASP.NET Web Applications

Chapter 20 - XML Web Services

classHelloApp

Index

{

List of Figurespublic static int Main(string[] args)

List of Tables{

// Make some HelloClass objects and say howdy.

HelloClass c1 = new HelloClass();

c1.SayHi();

...

}

}

When you build your C# applications, it becomes quite common to have one type functioning as the "application object" (the type that defines the Main() entry point) and numerous other types that constitute the application at large. On the other hand, it is permissible to create an application object that defines any number of members called from the type's Main() method. You will see examples of each approach during the remainder of this text.

Note If you are coming to .NET from an MFC background, be aware that there is no intrinsic doc / view / frame / app model under .NET. If you desire such a paradigm, you must roll your own.

Default AssignmentsC# a d the .NETandPlatform,VariableSecond EditiScopen

As seen in the previous example, all intrinsic .NET data types have a default value. When you create custom

Apress © 2003 (1200 pages)

types, all member variables are automatically assigned to their appropriate default value. To illustrate, assume

This comprehensive text starts with a brief overview of the

you have createdC#a newlanguageConsoleand applicationthen quicklycontainingmoves to keythe technicalfollowingandclass type:

architectural issues for .NET developers.

// C# automatically sets all member variables to a safe default value.

class DefaultValueTester

Table of Contents

{

C# and the .NET Platform, Second Edition

// Here are a number of fields...

Introduction

public sbyte theSignedByte;

Part One - Introducing C# and the .NET Platform

public byte theByte;

Chapter 1 - The Philosophy of .NET

public short theShort;

Chapter 2 - Building C# Applications

public ushort theUShort;

Part Two - The C# Programming Language

public int theInt;

Chapter 3 - C# Language Fundamentals

public uint theUInt;

Chapter 4 - Object-OrientheLong;ed Programming with C# public long

Chapter public5 - Ex eptionsulongandtheULong;Object Lifetime

Chapter public6 - InterfacescharandtheChar;Collections

Chapter public7 - CallbackfloatIn erfactheFloat;s, Delegates, and Events

public double theDouble;

Chapter 8 - Advanced C# Type C nstruction Techniques

public bool theBool;

Part Three - Programming with .NET Assemblies

public decimal theDecimal;

Chapter 9 - Understanding .NET Assemblies

public string theStr;

Chapter 10 - Processes, AppDomains, Contexts, and Threads

public object theObj;

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

public static int Main(string[] args)

Part Four - Leveraging the .NET Libraries

{

Chapter 12 - Object Serialization and the .NET Remoting Layer

DefaultValueTester v = new DefaultValueTester();

Chapter 13 - Building a Better Window (Introducing Windows Forms)

return 0; // Set breakpoint here and check out the Locals windo

Chapter 14 - A Better Painting Framework (GDI+)

}

Chapter 15 - Programming with Windows Forms Controls

}

Chapter 16 - The System.IO Namespace Chapter 17 - Data Access with ADO.NET

PartIf youFivewere- Webto nowApplicationscreate anandinstanceXML Webof theServicesDefaultValueTester class and begin a debugging session, you wou

Chaptersee that18each- ASPmember.NET WebvariableP ges andhas WbeenConautomaticallyrols assigned to a corresponding default value, as seen in

ChapterFigure 193-4-. ASP.NET Web Applications

Chapter 20 - XML Web Services

Index

List of

List of

Figure 3-4: Viewing default values for member data

The story is very different, however, when you create variables within a method scope. When you define variabl within a method scope, you must assign an initial value before you use them, as they do not receive a default assignment. For example, the following code results in a compiler error:

C# and the .NET Platform, Second Edition

// Compiler error! Must assign localInt to an initial value before use.

{Apress © 2003 (1200 pages)

int localInt;This comprehensive text starts with a brief overview of the

C# language and then quickly moves to key technical and

Console.WriteLine(localInt);

architectural issues for .NET developers.

}

Table of Contents

Fixing the problem is trivial. Simply make an initial assignment:

C# and the .NET Platform, Second Edition

Introduction

// Better. Everyone is happy.

Part One - Introducing C# and the .NET Platform

public static void Main()

Chapter 1 - The Philosophy of .NET

{

Chapter 2 - Building C# Applications

int localInt = 0;

Part Two - The C# Programming Language

Console.WriteLine(localInt);

Chapter 3 - C# Language Fundamentals

}

Chapter 4 - Object-Oriented Programming with C#

Chapter 5 - Exceptions and Object Lifetime

Chapter 6 - Interfaces and Collections

There is one exception to the mandatory assignment of local variables. If the variable is functioning as an "outp

Chapter 7 - Callback Interfaces, Delegates, and Events

parameter (examined a bit later in this chapter) the variable does not need to be assigned an initial value. The

Chapter 8 - Advanced C# Type Construction Techniques

rationale for this is simple: Methods that define output parameters assign incoming variables within their functio

Part Three - Programming with .NET Assemblies

scope before the caller makes direct use of them.

Chapter 9 - Understanding .NET Assemblies

Chapter 10 - Processes, AppDomains, Contexts, and Threads

SOURCE The DefaultValues project is located under the Chapter 3 subdirectory.

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

CODE

Part Four - Leveraging the .NET Libraries

Chapter 12 - Object Serialization and the .NET Remoting Layer

Chapter 13 - Building a Better Window (Introducing Windows Forms)

Chapter 14 - A Better Painting Framework (GDI+)

Chapter 15 - Programming with Windows Forms Controls

Chapter 16 - The System.IO Namespace

Chapter 17 - Data Access with ADO.NET

Part Five - Web Applications and XML Web Services

Chapter 18 - ASP.NET Web Pages and Web Controls

Chapter 19 - ASP.NET Web Applications

Chapter 20 - XML Web Services

Index

List of Figures

List of Tables

The C# MemberC# and Variablethe .NET Platform,InitializationSecond EditionSyntax

Class types tend to have numerous member variables. Given that a class may define various custom

Apress © 2003 (1200 pages)

constructors, you can find yourself in the annoying position of having to write the same initialization code in

This comprehensive text starts with a brief overview of the

each and every constructorC# languageimplementationand then quickly. Thismovesis particularlyto key technecessaryical and if you do not wish to accept the default values assignedarchitecturalto yourissuesstatefordata.NET. Fordevelopersexample,. if you wish to ensure that an integer member variable always begins life with the value of 9, you could write:

Table of Contents

// This is OK, but redundant...

C# and the .NET Platform, Second Edition

class Test

Introduction

{

Part One - Introducing C# and the .NET Platform

private int myInt;

Chapter 1 - The Philosophy of .NET

Test() { myInt = 9; }

Chapter 2 - Building C# Applications

Test(string someStringParam)

Part Two - The C# Programming Language

{ myInt = 9; }

Chapter 3 - C# Language Fundamentals

Test(bool someBoolParam)

Chapter 4 - Object-Oriented Programming with C#

{ myInt = 9; }

Chapter...5 - Exceptions and Object Lifetime

Chapter} 6 - Interfaces and Collections

Chapter 7 - Callback Interfaces, Delegates, and Events

Chapter 8 - Advanced C# Type Construction Techniques

An alternative would be to define a private helper function for your class type that is called by each

Part Three - Programming with .NET Assemblies

constructor. While this will reduce the amount of repeat assignment code, you are now stuck with the

Chapter 9 - Understanding .NET Assemblies

following redundancy:

Chapter 10 - Processes, AppDomains, Contexts, and Threads

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

// This is still rather redundant...

Part Four - Leveraging the .NET Libraries

class Test

Chapter 12 - Object Serialization and the .NET Remoting Layer

{

Chapter 13 - Building a Better Window (Introducing Windows Forms)

private int myInt;

Chapter 14 - A Better Painting Framework (GDI+)

Test() { InitData(); }

Chapter 15 - Programming with Windows Forms Controls

Test(string someStringParam)

Chapter 16 - The System.IO Namespace

{ InitData(); }

Chapter 17 - Data Access with ADO.NET

Test(bool someBoolParam)

Part Five - Web Applications and XML Web Services

{ InitData(); }

Chapter 18 - ASP.NET Web Pages and Web Controls

private void InitData()

Chapter 19 - ASP.NET Web Applications

{ myInt = 9; }

Chapter 20 - XML Web Services

...

Index

}

List of Figures

List of Tables

While both of these techniques are still valid, C# allows you to assign a type's member data to an initial value at the time of declaration [as you may be aware, other object-oriented languages (such as C++) do not allow you to initialize a member in this way]. Notice in the following code blurb that member initialization may be used with internal object references as well as numerical data types:

//This technique is useful when you don't want to accept default values

//and would rather not write the same initialization code in each constructor.

class Test

{

private int myInt = 9;

private string myStr = "My initial value.";

private HotRod viper = new HotRod(200, "Chucky", Color.Red);

...

}

C# and the .NET Platform, Second Edition

Note Be aware that member assignment happens before constructor logic. Thus, if you assign a

Apress © 2003 (1200 pages)

member to a value within the scope of a constructor, it effectively cancels out the previous member

This comprehensive text starts with a brief overview of the assignment.

C# language and then quickly moves to key technical and

architectural issues for .NET developers.

In addition to each of these member variable initialization techniques, yet another option is to forward calls from one constructor to another "master" constructor. You will see this technique later in Chapter 4 during

our discussion of the "this" keyword.

Table of Contents

C# and the .NET Platform, Second Edition

Introduction

Part One - Introducing C# and the .NET Platform

Chapter 1 - The Philosophy of .NET

Chapter 2 - Building C# Applications

Part Two - The C# Programming Language

Chapter 3 - C# Language Fundamentals

Chapter 4 - Object-Oriented Programming with C#

Chapter 5 - Exceptions and Object Lifetime

Chapter 6 - Interfaces and Collections

Chapter 7 - Callback Interfaces, Delegates, and Events

Chapter 8 - Advanced C# Type Construction Techniques

Part Three - Programming with .NET Assemblies

Chapter 9 - Understanding .NET Assemblies

Chapter 10 - Processes, AppDomains, Contexts, and Threads

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

Part Four - Leveraging the .NET Libraries

Chapter 12 - Object Serialization and the .NET Remoting Layer

Chapter 13 - Building a Better Window (Introducing Windows Forms)

Chapter 14 - A Better Painting Framework (GDI+)

Chapter 15 - Programming with Windows Forms Controls

Chapter 16 - The System.IO Namespace

Chapter 17 - Data Access with ADO.NET

Part Five - Web Applications and XML Web Services

Chapter 18 - ASP.NET Web Pages and Web Controls

Chapter 19 - ASP.NET Web Applications

Chapter 20 - XML Web Services

Index

List of Figures

List of Tables

Second Edition

ISBN:1590590554

a brief overview of the

moves to key technical and

developers.

Figure 3-7: String format flags in action

Table of Contents

C# andSOURCEthe .N T Platform,TheSecondBasicIOEditionproject is located under the Chapter 3 subdirectory.

IntroductionCODE

Part One - Introducing C# and the .NET Platform

Chapter 1 - The Philosophy of .NET

Chapter 2 - Building C# Applications

Part Two - The C# Programming Language

Chapter 3 - C# Language Fundamentals

Chapter 4 - Object-Oriented Programming with C#

Chapter 5 - Exceptions and Object Lifetime

Chapter 6 - Interfaces and Collections

Chapter 7 - Callback Interfaces, Delegates, and Events

Chapter 8 - Advanced C# Type Construction Techniques

Part Three - Programming with .NET Assemblies

Chapter 9 - Understanding .NET Assemblies

Chapter 10 - Processes, AppDomains, Contexts, and Threads

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

Part Four - Leveraging the .NET Libraries

Chapter 12 - Object Serialization and the .NET Remoting Layer Chapter 13 - Building a Better Window (Introducing Windows Forms) Chapter 14 - A Better Painting Framework (GDI+)

Chapter 15 - Programming with Windows Forms Controls

Chapter 16 - The System.IO Namespace

Chapter 17 - Data Access with ADO.NET

Part Five - Web Applications and XML Web Services

Chapter 18 - ASP.NET Web Pages and Web Controls

Chapter 19 - ASP.NET Web Applications

Chapter 20 - XML Web Services

Index

List of Figures

List of Tables

ISBN:1590590554

overview of the technical and

Table

C# and

Part

Chapter 1 - The Philosophy of .NET

Figure 3-8: Assignment of value types results in a verbatim copy of each field.

Chapter 2 - Building C# Applications

Part Two - The C# Programming Language

Chapter 3 - C# Language Fundamentals

class ValRefClass

Chapter{ 4 - Object-Oriented Programming with C#

Chapter //5 -ExerciseExcept ons andsomeObjectvaluLifetimetypes.

Chapter public6 - Interfacesstaticand intCollectionsMain(string[] args)

{

Chapter 7 - Callback Interfaces, Delegates, and Events

// The 'new' keyword is optional when creating structures

Chapter 8 - Advanced C# Type Construction Techniques

// using the default constructor, however you must assign

Part Three - Programming with .NET Assemblies

Here you have created a structure of type FOO (named f1) that is then assigned to another FOO structure (f2). Because FOO is a value type, you have two copies of the FOO type on the stack, each of which can be independently manipulated. Therefore, when you change the value of f2.x, the value of f1.x is unaffected (just like the behavior seen in the previous integer example).

In stark contrast, reference types (classes) are allocated on the garbage-collected heap. These entities stay in memory until the .NET garbage collector destroys them. By default, assignment of reference types results in a new reference to the same object in memory. To illustrate, let's change the definition of the FOO type from a C# structure to a C# class:

If you were to run our test program once again, you would notice the change in behavior (Figure 3-9). Here,

Table of Contents

you have two references pointing to the same object on the managed heap. Therefore, when you change

C# and the .NET Platform, Second Edition

the value of x using the f2 reference, f1.x reflects the same value.

Introduction

Part One - Introducing C# and the .NET Platform

Chapter

Chapter

Part

Chapter

Chapter

Chapter

Chapter

Chapter

Chapter

Part

Figure 3-9: Assignment of reference types copies the reference.

Part Four - Leveraging the .NET Libraries

Chapter 12 - Object Serialization and the .NET Remoting Layer

Chapter 13 - Building a Better Window (Introducing Windows Forms)

Value Types Containing Reference Types

Chapter 14 - A Better Painting Framework (GDI+)

Chapter 15 - Programming with Windows Forms Controls

Now that you have a better feeling for the core differences between value types and reference types, let's

Chapter 16 - The System.IO Namespace

see a more complex example. Assume you have the following reference (class) type:

Chapter 17 - Data Access with ADO.NET

Part Five - Web Applications and XML Web Services

class TheRefType

Chapter 18 - ASP.NET Web Pages and Web Controls

{

Chapter 19 - ASP.NET Web Applications public string x;

Chapter 20 - XML Web Services

public TheRefType(string s) {x = s;}

Index

}

List of Figures

List of Tables

Now assume that you want to contain a variable of this reference type within a value type (structure) named InnerRef. In addition to this internal reference type, also assume that InnerRef defines a simple integer (value type) data member. Finally, to allow the outside world to set the value of the inner TheRefType, we also provide the following custom constructor (as explained in just a bit, the default constructor of a structure is reserved and cannot be redefined):

The MasterC#Node:and theSystem.NET Platform,.ObjectS ond Edition

In C#, every data type (value or reference based) is ultimately derived from a common base class:

Apress © 2003 (1200 pages)

System.Object. The Object class defines a common polymorphic behavior for every type in the .NET

This comprehensive text starts with a brief overview of the

universe. In the previousC# languageHelloClassand thentypequicklydefinition,m vesyouto keydid nottechnicalexplicitlyandindicate that Object was the base class, but this is assumedarchitecturalif youissuesdo notf r say.NETotherwise:develop rs.

// Implicitly deriving from System.Object.

Table of Contents

class HelloClass {...}

C# and the .NET Platform, Second Edition

Introduction

PartIf youOnewish- Introducto explicitlyng C#stateandSystemthe .NET.ObjectPlatformas your base class, you are free to define your class definitions

Chapterusing either1 - Theof thePhilfollowings phy ofnotations:.NET

Chapter 2 - Building C# Applications

Part Two - The C# Programming Language

// Here we are explicitly deriving from System.Object.

Chapter 3 - C# Language Fundamentals

class HelloClass : System.Object {...}

Chapter 4 - Object-Oriented Programming with C#

// Same story here...

Chapter 6 - Interfaces and Collections

Chapter 7 - Callback Interfaces, Delegates, and Events

Like most .NET classes, System.Object defines a set of instance-level and class-level (static) members.

Chapter 8 - Advanced C# Type Construction Techniques

Note that some of these items are declared "virtual," and can therefore be overridden by a derived class:

Part Three - Programming with .NET Assemblies

Chapter 9 - Understanding .NET Assemblies

// The topmost class in the .NET world: System.Object

Chapter 10 - Processes, AppDomains, Contexts, and Threads

namespaceSystem

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

{

Part Four - Leveraging the .NET Libraries

public class Object

Chapter 12 - Object Serialization and the .NET Remoting Layer

{

Chapter 13 - Building a Better Window (Introducing Windows Forms)

public Object();

Chapter 14 - A Better Painting Framework (GDI+) Chapter 15 - Programming with Windows Forms Controls Chapter 16 - The System.IO Namespace

Chapter 17 - Data Access with ADO.NET

public virtual String ToString();

Part Five - Web Applications and XML Web Services

protected virtual void Finalize();

Chapter 18 - ASP.NET Web Pages and Web Controls protected Object MemberwiseClone();

Chapter 19 - ASP.NET Web Applications

public static bool Equals(object objA, object objB);

Chapter 20 - XML Web Services

public static bool ReferenceEquals(object objA, object objB);

Index }

List of Figures

}

List of Tables

Table 3-3 offers a rundown of the functionality provided by each instance-level method.

Table 3-3: Core Members of System.Object

Chapter 20 - XML Web Services

To illustrate some of the default behavior provided by the System.Object base class, consider the

Index

following class definition:

List of Figures

List of Tables

// Create some objects and exercise the inherited System.Object methods.

using System;

class ObjTest

{

public static int Main(string[] args)

{

// Make an instance of ObjTest.

ObjTest c1 = new ObjTest();

// Pump info to console.

Console.WriteLine("ToString: {0} ", c1.ToString()); Console.WriteLine("Hash code: {0} ", c1.GetHashCode()); Console.WriteLine("Base class: {0} ", c1.GetType().BaseType);

// Make some other references to c1.

ObjTest c2 = c1;

object o = c2;

Apress © 2003 (1200 pages)

Let's also override the behavior of System.Object.Equals() to work with value-basedsemantics. Recall

This comprehensive text starts with a brief overview of the

that by default, Equals() returns true only if the two references being compared are referencing the same

C# language and then quickly moves to key technical and

object in memory. For our Person class, it may be helpful to implement Equals() to return true if the two architectural issues for .NET developers.

variables being compared contain the same state values (e.g., name, SSN, and age):

Table// Aof PersonContentsclass implements Equals() as so:

C#classand thePerson.NET Platform, Second Edition

{

Introduction

public override bool Equals(object o)

Part One - Introducing C# and the .NET Platform

{

Chapter 1 - The Philosophy of .NET

// Does the incoming object instance have the same values as me?

Chapter 2 - Building C# Applications

Person temp = (Person)o;

Part Two - The C# Programming Language

if(temp.firstName == this.firstName &&

Chapter 3 - C# Language Fundamentals

temp.lastName == this.lastName &&

Chapter 4 - Object-Oriented Programming with C#

temp.SSN == this.SSN &&

Chapter 5 - Exceptions and Object Lifetime temp.age == this.age)

Chapter 6 - Interfaces and Collections return true;

Chapter 7 - Callback Interfaces, Delegates, and Events else

Chapter 8 - Advanced C# Type Construction Techniques return false;

Part Three - Programming with .NET Assemblies

}

Chapter 9 - Understanding .NET Assemblies

...

Chapter 10 - Processes, AppDomains, Contexts, and Threads

}

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

Part Four - Leveraging the .NET Libraries

ChapterHere you12 are- ObjectexaminingSerializationthe valuesand theof the.NETincomingRe otingobjectLayeragainst the values of our internal values (note

the use of the "this" keyword, which refers to the current object). If the name, SSN, and age of each are

Chapter 13 - Building a Better Window (Introducing Windows Forms)

identical, you have two objects with the exact same state data and therefore return true.

Chapter 14 - A Better Painting Framework (GDI+)

Chapter 15 - Programming with Windows Forms Controls

The prototype of System.Object.Equals() takes a single argument of type object. Thus, we are required to

Chapter 16 - The System.IO Namespace

perform an explicit cast (further examined in Chapter 4) within the Equals() method to access the

Chapter 17 - Data Access with ADO.NET

members of the Person type. Now, for the sake of argument, assume that an object user passed in a Car

Part Five - Web Applications and XML Web Services

object to the Equals() method as so:

Chapter 18 - ASP.NET Web Pages and Web Controls

Chapter 19 - ASP.NET Web Applications

// Cars are not people!

Chapter 20 - XML Web Services

Car c = new Car();

Index

Person p = new Person();

List of Figures

p.Equals(c);

List of Tables

This is obviously a problem. In fact, if this was attempted, an InvalidCastException would be thrown by the runtime. Furthermore, what if the end user passed in a null object reference to the Equals() method as follows:

// Forgot to create the Person!

Person theGhost = null;

p.Equals(theGhost);

To design a more bullet-proof Equals() method, you would do well to check for a null value on the incoming parameter, as well as wrap the explicit cast logic within a try / catch statement. I'll examine structured exception handling in Chapter 4, so for the time being, let's assume that the world is a perfect place and the object user will only pass in like-minded (and allocated) types.

Overriding GetHashCode()

C# and the .NET Platform, Second Edition

Before you see the output of this modified Person type, you have one final detail to attend to. When a class

overrides the Equals() method, you should also override the default implementation of GetHashCode() (if

This comprehensive text starts with a brief overview of the

you do not, you are issued a compiler warning). This method returns a numerical value used to identify an

object in memory, and is commonly used with hash-based collections. architectural issues for .NET developers.

Under the hood, if you place a custom object into a System.Collections.Hashtable type, its Equals() and

GetHashCode() members will be called behind the scenes to determine the correct type to return from the

Table of Contents

container. Given this factoid, your custom types should redefine the hashing algorithm used to identify itself

C# and the .NET Platform, Second Edition within such a type.

Introduction

Part One - Introducing C# and the .NET Platform

There are many algorithms that can be used to create a hash code, some fancy, others not so fancy. In

Chapter 1 - The Philosophy of .NET

the simplest case, an object's hash value will be generated by taking its state data into consideration, and

Chapterbuilding2a -uniqueBuildingnumericalC# Applicationsidentifier for the type. For our purposes, let's assume that the hash code of the

PartstringTworepresenting- The C# Programmingan individual'sLanguageSSN is unique enough. System.String has a very solid implementation of

Part Threereturn- P ogrammingSSN.GetHashCodewith .NET Assemblies();

Chapter} 9 - Understanding .NET Assemblies

Chapter 10 - Processes, AppDomains, Contexts, and Threads

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

With this, here is our new Person class in action (check out Figure 3-12 for output):

Part Four - Leveraging the .NET Libraries

Chapter 12 - Object Serialization and the .NET Remoting Layer

// Make a few people and play with the overridden Object methods.

Chapter 13 - Building a Better Window (Introducing Windows Forms)

public static int Main(string[] args)

Chapter 14 - A Better Painting Framework (GDI+)

{

Chapter 15 - Programming with Windows Forms Controls

...

Chapter 16 - The System.IO Namespace

Chapter 17 - Data Access with ADO.NET

Person p1 = new Person("Fred", "Jones", "222-22-2222", 98);

Part Five - Web Applications and XML Web Services

Person p2 = new Person("Fred", "Jones", "222-22-2222", 98);

Chapter 18 - ASP.NET Web Pages and Web Controls

Chapter 19 - ASP.NET Web Applications

// Equals() now uses value semantics.

Chapter 20 - XML Web Services

// As well, given that each object has the same SSN, they should have Index // the same hash-code (given the work performed by System.String).

Console.WriteLine("P1 and P2 are DIFFERENT\ n");

// Change state of p2.

Console.WriteLine("Changing the age of p2"); p2.age = 2;

// Test again.

if(p1.Equals(p2) && p1.GetHashCode() = = p2.GetHashCode()) Console.WriteLine("P1 and P2 have same state\ n");

else

Console.WriteLine("P1 and P2 are DIFFERENT\ n");

// Get 'stringified' version of objects.

Console.WriteLine("Stringified people!");

Console.WriteLine(p1.ToString());

return 0;

}

C# and the .NET Platform, Second Edition

Apress © 2003 (1200 pages)

This comprehensive text starts with a brief overview of the key technical and

Table

C# and

IntroductionFigure 3-12: Overridden System.Object members in action

Part One - Introducing C# and the .NET Platform

Chapter 1 - The Philosophy of .NET

ChapterStatic2 Members- Building C# Applicationsof System.Object

Part Two - The C# Programming Language

ChapterIn addition3 -toC#theLainstanceguage Fundamentals-level members you have just examined, System.Object does define two static

members (Object.Equals() and Object.ReferenceEquals()) that also test for value-based or reference-

Chapter 4 - Object-Oriented Programming with C#

based equality. Consider the following code:

Chapter 5 - Exceptions and Object Lifetime

Chapter 6 - Interfaces and Collections

Chapter// Static7 - CallbackmembersInterfaces,of SystemDel gates,.Objectand Events.

Person p3 = new Person("Sally", "Jones","333", 4);

Chapter 8 - Adva ced C# Type Construction Techniques

Person p4 = new Person("Sally", "Jones","333", 4);

Part Three - Programming with .NET Assemblies

// Do P3 and P4 have the same state? TRUE!

Chapter 9 - Understanding .NET Assemblies

Console.WriteLine("P3 and P4 have same state: {0} ", object.Equals(p3, p4));

Chapter 10 - Processes, AppDomains, Contexts, and Threads

// Are they the same object in memory? FALSE!

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

Console.WriteLine("P3 and P4 are pointing to same object: {0} ",

Part Four - Leveraging the .NET Libraries

object.ReferenceEquals(p3, p4));

Chapter 12 - Object Serialization and the .NET Remoting Layer Chapter 13 - Building a Better Window (Introducing Windows Forms)

Chapter 14 - A Better Painting Framework (GDI+)

Here, you are able to simply send in two objects (of any type) and allow the System.Object class to

Chapter 15 - Programming with Windows Forms Controls determine the details automatically.

Chapter 16 - The System.IO Namespace

Excellent! At this point you have a solid understanding of the topmost base class in the .NET class

Chapter 17 - Data Access with ADO.NET

hierarchy. Understand that every class, structure, enumeration, and delegate defined in the .NET base

Part Five - Web Applications and XML Web Services

class libraries are always guaranteed to support the public members of System.Object (interface types

Chapter 18 - ASP.NET Web Pages and Web Controls

however, do not derive from System.Object, or any base class for that matter). Next up, let's examine the

Chapter 19 - ASP.NET Web Applications

C# intrinsic data types in a bit more detail.

Chapter 20 - XML Web Services

IndexSOURCE The ObjectMethods project is located under the Chapter 3 subdirectory.

List of Figures

CODE

List of Tables

example, System.Double type allows you to obtain the values for Epsilon, and infinity values:

C# and the .NET Platform, Second Edition

Console.WriteLine("-> double.Epsilon: {0}", double.Epsilon);

Apress © 2003 (1200 pages)

Console.WriteLine("-> double.PositiveInfinity: {0}", double.PositiveInfinity);

This comprehensive text starts with a brief overview of the

Console.WriteLine("-> double.NegativeInfinity: {0}", double.NegativeInfinity);

C# language and then quickly moves to key technical and

Console.WriteLine("-> double.MaxValue: {0}", double.MaxValue); architectural issues for .NET developers.

Console.WriteLine("-> double.MinValue: {0}",double.MinValue);

Table of Contents

C#Membersand the .NET ofPlatform,SystemSecond.BooleanEditi n

Introduction

PartNext,Oneconsider- Introducingthe SystemC# and.Booleanthe .NETdataPl typeform. Unlike C(++), the only valid assignment a C# bool can take is

Chapterfrom the1 set- The{truePhilosophy| false}. Youof .NETcannot assign makeshift values (e.g., -1, 0, 1) to a C# bool, which (to most

Chapterprogrammers)2 - Buildingis a welcomeC# Applicatiochanges . Given this point, it should be clear that System.Boolean does not support

PartMinValue/MaxValueTwo - The C# ProgrammingpropertyLanguageset, but rather TrueString/FalseString:

Chapter 3 - C# Language Fundamentals

Chapter 4 - Object-Oriented Programming with C#

// No more ad hoc Boolean types in C#!

Chapterbool b5 =- Exceptions0; and//ObjectIllegal!Lifetime

Chapterbool b26 -=Interfaces-1; and //CollectionsAlso illegal!

Chapterbool b37 -=Callbacktrue;Interfaces,// NoDelegates,problemand. Events

bool b4 = false; // No problem.

Chapter 8 - Adv nced C# Type C nst uction Techniques

Console.WriteLine("-> bool.FalseString: {0}", bool.FalseString);

Part Three - Programming with .NET Assemblies

Console.WriteLine("-> bool.TrueString: {0}", bool.TrueString);

Chapter 9 - Understanding .NET Assemblies

Chapter 10 - Processes, AppDomains, Contexts, and Threads

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

Part Four - Leveraging the .NET Libraries

ChapterMembers12 - ObjectofSerializationSystem.andCharthe .NET Remoting Layer

Chapter 13 - Building a Better Window (Introducing Windows Forms)

It is important to note that C# textual data is represented by the intrinsic C# string and char data types. Thus,

Chapter 14 - A Better Painting Framework (GDI+)

no more nasty char*, wchar_t*, LPSTR, LPCSTR, BSTR or OLECHAR string types! I am sure you agree with

Chapter 15 - Programming with Windows Forms Controls

me that string manipulation in the COM and Win32 universe was horrifying. Utterly and completely horrifying.

Chapter 16 - The System.IO Namespace

On a happy note, .NET offers a very simplified view of string management, as all .NET-aware languages map

Chapter 17 - Data Access with ADO.NET

textual data to the same underlying types (System.String and System.Char), both of which are Unicode under

Part Five - Web Applications and XML Web Services

the hood.

Chapter 18 - ASP.NET Web Pages and Web Controls

Chapter 19 - ASP.NET Web Applications

The System.Char type (represented by the C# "char" keyword) provides you with a great deal of functionality

Chapter 20 - XML Web Services

beyond the ability to hold a single point of character data (which must be placed between single tick marks). IndexMore interestingly, using the static methods of System.Char, you are able to determine if a given character is

Listnumerical,of Figuresalphabetical, a point of punctuation, or whatnot. To illustrate, check out the following:

List of Tables

// Test the truth or falsity of the following statements...

Console.WriteLine("-> char.IsDigit('K'): {0}", char.IsDigit('K')); Console.WriteLine("-> char.IsDigit('9'): {0}", char.IsDigit('9')); Console.WriteLine("-> char.IsLetter('10', 1): {0}", char.IsLetter("10", 1)); Console.WriteLine("-> char.IsLetter('p'): {0}", char.IsLetter('p')); Console.WriteLine("-> char.IsWhiteSpace('Hello There', 5): {0}",

char.IsWhiteSpace("Hello There", 5));

Console.WriteLine("-> char.IsWhiteSpace('Hello There', 6): {0}", char.IsWhiteSpace("Hello There", 6));

Console.WriteLine("-> char.IsLetterOrDigit('?'): {0}",

char.IsLetterOrDigit('?'));

Console.WriteLine("-> char.IsPunctuation('!'): {0}",

char.IsPunctuation('!'));

Console.WriteLine("-> char.IsPunctuation('>'): {0}",

char.IsPunctuation('>'));

Console.WriteLine("-> char.IsPunctuation(','): {0}",

C# and the .NET Platform, Second Edition char.IsPunctuation(','));

Apress © 2003 (1200 pages)

As you can see, eachThis cofmprehensivethese static textmembersstarts withof Systema brief.Charoverviewhas oftwothecalling conventions: a single character or a string with a C#numericallanguageindexand thatthenspecifiedqui kly movesthe positionto key oftecthenicalcharacternd to test.

architectural issues for .NET developers.

Parsing Values from String Data

Table of Contents

Finally, also understand that the .NET data types provide the ability to generate a variable of their underlying

C# and the .NET Platform, Second Edition

type given a textual equivalent (e.g., parsing). This technique can be extremely helpful when you wish to

Introduction

convert a bit of user input data (such as a listbox selection) into a numerical value. Ponder the following

Part One - Introducing C# and the .NET Platform

parsing logic:

Chapter 1 - The Philosophy of .NET

Chapter 2 - Building C# Applications

bool myBool = bool.Parse("True");

Part Two - The C# Programming Language

Console.WriteLine("-> Value of myBool: {0}", myBool);

Chapter 3 - C# Language Fundamentals

double myDbl = double.Parse("99.884");

Chapter 4 - Object-Oriented Programming with C#

Console.WriteLine("-> Value of myDbl: {0}", myDbl);

Chapter 5 - Exceptions and Object Lifetime int myInt = int.Parse("8");

Chapter 6 - Interfaces and Collections

Console.WriteLine("-> Value of myInt: {0}", myInt);

Chapter 7 - Callback Interfaces, Delegates, and Events char myChar = char.Parse("w");

Chapter 8 - Advanced C# Type Construction Techniques

Console.WriteLine("-> Value of myChar: {0}\n", myChar);

Part Three - Programming with .NET Assemblies

Chapter 9 - Understanding .NET Assemblies

Chapter 10 - Processes, AppDomains, Contexts, and Threads

ChapterSOURCE11 - Type Reflection,The DataTypesL te Binding,projectandisAttributelocated-BasedunderProgrammingthe Chapter 3 subdirectory.

Part FourCODE- Leveraging the .NET Libraries

Chapter 12 - Object Serialization and the .NET Remoting Layer

Chapter 13 - Building a Better Window (Introducing Windows Forms)

Chapter 14 - A Better Painting Framework (GDI+)

Chapter 15 - Programming with Windows Forms Controls

Chapter 16 - The System.IO Namespace

Chapter 17 - Data Access with ADO.NET

Part Five - Web Applications and XML Web Services

Chapter 18 - ASP.NET Web Pages and Web Controls

Chapter 19 - ASP.NET Web Applications

Chapter 20 - XML Web Services

Index

List of Figures

List of Tables

ConvertingC#Betweenand the .NETValueP atform,TypesSecondandEditionReference Types: Boxing and

This comprehensive text starts with a brief overview of the

Given that .NET defines two broad categories of types (value-based and reference-based), you may

C# language and then quickly moves to key technical and

occasionally need to represent a variable of one category as a variable of the other category. C# provides a architectural issues for .NET developers.

very simple mechanism to convert between value types and reference types, termed boxing. To illustrate, assume that you have created a simple value data type of type short:

Table of Contents

// Make a simple value data point.

C# and the .NET Platform, Second Edi ion

short s = 25;

Introduction

Part One - Introducing C# and the .NET Platform

Chapter 1 - The Philosophy of .NET

If, during the course of your application, you wish to represent this value type as a reference type, you would

Chapter 2 - Building C# Applications

"box" the value as follows:

Part Two - The C# Programming Language

Chapter 3 - C# Language Fundamentals

// Box the value into an object reference.

Chapter 4 - Object-Oriented Programming with C#

object objShort = s;

Chapter 5 - Exceptions and Object Lifetime Chapter 6 - Interfaces and Collections

Chapter 7 - Callback Interfaces, Delegates, and Events

Boxing can be formally defined as the process of explicitly converting a value type into a corresponding

Chapter 8 - Advanced C# Type Construction Techniques

reference type. When you box a value, essentially all you are doing is allocating a new object on the heap and PartcopyingThreethe- Programminginternal valuewith(in this.NETcaseA semblies25) into that instance. What is returned to you is a true-blue reference to Chapterthe newly9 allocated- Understandingobject..NETUsingAssembliesthis technique, .NET developers have no need to make use of a set of

Chapterwrapper10classes- Procesuseds, AppDomains,to temporarilyContexts,treat intrinsicand Threadsdata as heap-allocated objects (as is the case in Java).

Chapter 11 - Type Reflection, Late Binding, and Attribute-Based Programming

The opposite operation is also permitted through unboxing. Unboxing is the term given to the process of

Part Four - Leveraging the .NET Libraries

converting the value held in the object reference back into a corresponding value type on the stack. The