Summary C# and the .NET Platform, Second Edition

by Andrew Troelsen ISBN:1590590554

In this chapter, you have examined a number of ways in which multiple objects can partake in a

Apress © 2003 (1200 pages)

bidirectional conversation under .NET. First, you examined the use of callback interfaces, which provide a

This comprehensive text starts with a brief overview of the

way to have objectC#Blanguagemake callsandonthenobjectquicklyA viamovesan interfaceto key technicalreferenceand. Do understand that this design pattern is not specificarchitoectural.NET,issbutesmayfor .beNETemployeddevelopersin.any language or platform that honors the use of interface types.

TableNext,ofyouContentsexamined the C# "delegate" keyword, which is used to indirectly construct a class derived from C#Systemand the.MulticastDelegate.NET Platform, Second. As youEditionhave seen, a delegate is simply an object that maintains a list of

methods to call when told to do so. These invocations may be made synchronously (using the Invoke()

Introduction

method) or asynchronously (via the BeginInvoke() and EndInvoke() methods).

Part One - Introducing C# and the .NET Platform

Chapter 1 - The Philosophy of .NET

Finally, you examined the C# "event" keyword which, when used in conjunction with a delegate type, can simplify the process of sending your event notifications to awaiting callers. As seen via the resulting CIL,

the .NET event model maps to hidden calls on the System.Delegate/System.MulticastDelegate types. In

Chapter 3 - C# Language Fundamentals

this light, the C# "event" keyword is purely optional in that it simply saves you some typing time.

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

Chapter C#8:andAdvancedthe .NET Platform,C#SecondTypeEditionConstruction

This comprehensive text starts with a brief overview of the

C# language and then quickly moves to key technical and

This chapter wraps up our investigation of the C# programming language by examining a number of

architectural issues for .NET developers.

advanced (but extremely useful) syntactic constructs. To begin, we will examine a small set of C# keywords that we have not yet formally examined. For example, you will learn how to programmatically

account for overflow/underflow conditions using the "checked"/"unchecked" keywords as well as how to

Table of Contents

create an "unsafe" code context in order to directly manipulate pointer types using C#.

C# and the .NET Platform, Second Edition

Introduction

Next, you learn how to construct and use an indexer method. This C# mechanism enables you to build PartcustomOne -typesIntroducingthat exposeC# andinternalthe .NETsubtypesPlatformusing the familiar bracket operator (i.e., []). If you have a C++ Chbackground,pter 1 - TheyouPhilosophywill find thatof .creatingNET a C# indexer method is analogous to overloading the [] operator on

Chaptera C++ class2 - .BuildingOnce youC# learnApplicationshow to build an indexer method, you then examine how to overload various

PartoperatorsTwo - The(+, –C#, <,Programming>, and so forth)Languageand create custom conversion functions (the C# equivalent to

Chapteroverloading3 - C#theLanguage() operatorFundamentalsunder C++) for a type.

Chapter 4 - Object-Oriented Programming with C#

ChaptTherAdvanced5 - Exceptions andKeywordsObject Lifetimeof C#

Chapter 6 - Interfaces and Collections

ChapterOver the7 course- Callbackof theIntepreviousfaces, Delegates,seven chapters,and Eventsyou have seen a majority of the C# keywords in action. In

addition to those already investigated, C# does have a set of lesser used, but still intriguing, keywords,

Chapter 8 - Advanced C# Type Construction T chniques

specifically

Part Three - Programming with .NET Assemblies

Chapter 9 - Understanding .NET Assemblies

"checked"/"unchecked"

Chapter 10 - Processes, AppDomains, Contexts, and Threads

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

"unsafe"/"stackalloc"/"fixed"/"volatile"/"sizeof"

Part Four - Leveraging the .NET Libraries

"lock"

Chapter 12 - Object Serialization and the .NET Remoting Layer

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

The "lock" keyword will be examined later in this text during our formal examination of multithreaded

Chapter 14 - A Better Painting Framework (GDI+)

programming (see Chapter 10). The remaining members of the preceding list ("checked", "unchecked",

Chapter 15 - Programming with Windows Forms Controls

"unsafe", "stackalloc", "fixed", "volatile", and "sizeof") will be the focus of the first part of this chapter. To

Chapter 16 - The System.IO Namespace

start, let's check out how C# provides automatic detection of arithmetic overflow (and underflow).

Chapter 17 - Data Access with ADO.NET

Part Five - Web Applications and XML Web Services

The "checked" Keyword

Chapter 18 - ASP.NET Web Pages and Web Controls

Chapter 19 - ASP.NET Web Applications

As you are well aware, each numerical data type has a fixed upper and lower limit (which may be obtained

Chapter 20 - XML Web Services

programmatically using the MaxValue/MinValue properties). Now, when you are performing arithmetic

Index

operations on a specific type, it is very possible that you may accidentally overflow the maximum storage

List of Figures

of the type (assign a value that is greater than the maximum value) or underflow the minimum storage of

List of Tables

the type (assign a value that is less than the minimum value). To keep in step with the CLR, I will refer to both of these possibilities collectively as "overflow." (As you will see, both overflow and underflow conditions result in a System.OverflowException type. There is no System.UnderflowException type in the base class libraries.)

To illustrate the issue, assume you have created two System.Byte types, each of which have been assigned a value that is safely below the maximum value (255). If you were to add the values of these types (casting the result as a byte) and print out the result, you would assume that the result would be the exact sum of each member:

namespace CheckedUnchecked

{

class TheChecker

{

static void Main(string[] args)

{

// Overflow the max value of a System.Byte.

C# and the .NET Platform, Second Edition

Console.WriteLine("Max value of byte is {0}.", byte.MaxValue);

by Andrew Troelsen ISBN:1590590554

Console.WriteLine("Min value of byte is {0}.", byte.MinValue);

Apress © 2003 (1200 pages)

byte b1 = 100;

This comprehensive text starts with a brief overview of the byte b2 = 250;

C# language and then quickly moves to key technical and byte b3 = (byte)(b1 + b2);

architectural issues for .NET developers.

// b3 should hold the value 350, however...

Console.WriteLine("b3 = {0}", b3);

}

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

If you were to view the output of this application, you might be surprised to find that b3 contains the value

Chapter 2 - Building C# Applications

94 (rather than the expected 350). The reason is simple. Given that a System.Byte can only hold a value PartbetweenTwo -0TheandC#255Programming(inclusive, forLanguagea grand total of 256 slots), b3 now contains the overflow value (350 – Chapter256 = 94)3 .-AsC#youLanguagehave justFundamentalsseen, if you take no corrective course of action, overflow occurs without

Chapterexception4 .-AtObjecttimes,-Orientedthis hiddenProgrammingoverflow maywith causeC# no harm whatsoever in your project. Other times, this

Chapterloss of 5data- Exis completelyeptions andunacceptableObje Lifetime.

Chapter 6 - Interfaces and Collections

To handle overflow or underflow conditions in your application, you have two possibilities. Your first choice

Chapter 7 - Callback Interfaces, Delegates, and Events

is to leverage your wits and programming skills to handle all overflow conditions manually. Assuming you

Chapter 8 - Advanced C# Type Construction Techniques

were indeed able to find each overflow condition in your program, you could resolve the previous overflow

Part Three - Programming with .NET Assemblies

error as follows:

Chapter 9 - Understanding .NET Assemblies

Chapter 10 - Processes, AppDomains, Contexts, and Threads

// Store sum in an integer to prevent overflow.

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

byte b1 = 100;

Part Four - Leveraging the .NET Libraries

byte b2 = 250;

Chapter 12 - Object Serialization and the .NET Remoting Layer int answer = b1 + b2;

Chapter 13 - Building a Better Window (Introducing Windows Forms) Chapter 14 - A Better Painting Framework (GDI+)

Chapter 15 - Programming with Windows Forms Controls

ChapterOf course,16 -theTheproblemSyst .IOwithNamespacethis technique is the simple fact that we are humans, and even our best

Chapterattempts17may- DataresultAccessin errorswith ADOthat.NEThave escaped our eyes. Given this, C# provides the "checked" keyword.

PartWhenFiveyou- WebwrapApplica statementtions and(orXMLblockWebof Servicesstatements) within the scope of the "checked" keyword, the C#

Chaptercompiler18will- ASPemit.NETspecificWeb PagesCIL instructionsand Web Controlsthat test for overflow conditions that may result when adding, Chaptermultiplying,19 - subtracting,ASP.NET WeborApplicationsdividing two numerical data types. If an overflow has occurred, the runtime will

throw a System.OverflowException type. To illustrate, observe the following update:

Chapter 20 - XML Web Services

Index

Listclassof FiguresTheChecker

List{ of Tables

static void Main(string[] args)

{

// Overflow the max value of a System.Byte.

Console.WriteLine("Max value of byte is {0}.", byte.MaxValue); byte b1 = 100;

byte b2 = 250; try

{

byte b3 = checked((byte)(b1 + b2)); Console.WriteLine("b3 = {0}", b3);

}

catch(OverflowException e)

{ Console.WriteLine(e.Message); }

}

}

Part Two - The C# Programming Language

Chapter 3 - C# Language Fundamentals

ChapterNow, before4 - Objectwe dig-Orieninto theed Programmingdetails, let mewithpointC#out the fact that you will seldom ifever need to make use

Chaptof thertechniques5 - Exc ptionswe areandaboutObjecttoLifetiexamine. Although C# does allow you to drop down to the level of Chapterpointer6manipulations,- Interfaces understandCollectionsthat the .NET runtime has absolutely no clue of your intentions. Thus, if

you mismanage a pointer, you are the one in charge of dealing with the consequences. Given these

Chapter 7 - Callback Interfaces, Delegates, and Events

warnings, when exactly would you need to work with unsafe code (and therefore the operators seen in

Chapter 8 - Advanced C# Type Construction Techniques

Table 8-1)? There are two common situations:

Part Three - Programming with .NET Assemblies

Chapter 9 - Understanding .NET Assemblies

You are looking to optimize select parts of your application by bypassing the CLR. For example, you

Chapter 10 - Processes, AppDomains, Contexts, and Threads

want to build a function that copies an array using pointer arithmetic.

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

Part FourYou-areL veragingattemptingtheto.NETtriggerLibrariesthe functionality of a C-based *.dll (such as the Win32 API or a custom

ChapterC-based12 - Object*.dll) Serializationand need toandcreatethepointer.NET RemotingvariablesLayerto call various methods.

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

Beyond these two reasons, there will never be a need to declare, dereference, or manipulate direct

Chapter 14 - A Better Painting Framework (GDI+)

pointers using C#. In the event that you decide to make use of this C# language feature, you will also be

Chapter 15 - Programming with Windows Forms Controls

required to inform csc.exe of your intent! If you are making use of csc.exe in the raw, be sure you supply the /unsafe flag. From VS .NET, you will need to access your project's Property page and enable the

Allow Unsafe Code Blocks setting (Figure 8-2).

Part Five - Web Applications and XML Web Services

Chapter 18 - ASP.NET Web Pages and Web Controls

Chapter

Chapter

Index

List of

List of

Figure 8-2: Enabling VS .NET unsafe compilation

Now let's ponder the basics. In the examples that follow, I'm assuming that you do have some background in C(++) pointer manipulations. If this is not true in your case, don't sweat it. Again, writing unsafe code will not be a common task for a huge majority of .NET applications.

The "Unsafe" Keyword

C# and the .NET Platform, Second Edition

When you wish to work with pointers in C#, you must specifically declare a block of "unsafe" code using

Apress © 2003 (1200 pages)

the "unsafe" keyword (as you might guess, any code that is not marked with the "unsafe" keyword is

This comprehensive text starts with a brief overview of the considered "safe" automatically, thus there is not a "safe" keyword in C#):

C# language and then quickly moves to key technical and

architectural issues for .NET developers.

unsafe

{

Table of Contents

// Work with pointers here!

C# and the .NET Platform, Second Edition

}

Introduction

Part One - Introducing C# and the .NET Platform

In addition to declaring a scope of unsafe code, you are able to build structures, classes, type members,

Chapter 1 - The Philosophy of .NET

and parameters that are "unsafe." Here are a few examples to gnaw on:

Chapter 2 - Building C# Applications

Part Two - The C# Programming Language

Chapter// This3 -entireC# LanguagestructureFundamentalsis 'unsafe' and can

// only be used in an unsafe context.

Chapter 4 - Object-Oriented Programming with C#

publicunsafe struct Node

Chapter 5 - Exceptions and Object Lifetime

{

Chapter 6 - Interfaces and Collections

public int Value;

Chapter 7 - Callback Interfaces, Delegates, and Events

public Node* Left;

Chapter 8 - Advanced C# Type Construction Techniques

public Node* Right;

Part Three - Programming with .NET Assemblies

}

Chapter 9 - Understanding .NET Assemblies

// This struct is safe, but the Node* members

Chapter 10 - Processes, AppDomains, Contexts, and Threads

// are not. Technically, you may access 'Value' from

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

// outside a unsafe context, but not 'Left' and 'Right'.

Part Four - Leveraging the .NET Libraries

public struct Node

Chapter 12 - Object Serialization and the .NET Remoting Layer

{

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

public int Value;

Chapter 14 - A Better Painting Framework (GDI+)

// These can only be accessed in an unsafe context!

Chapter 15 - Programming with Windows Forms Controls public unsafe Node* Left;

Chapter 16 - The System.IO Namespace

public unsafe Node* Right;

Chapter} 17 - Data Access with ADO.NET

Part Five - Web Applications and XML Web Services

Chapter 18 - ASP.NET Web Pages and Web Controls

Methods (static or instance level) may be marked as unsafe as well. For example, assume that you know

Chapter 19 - ASP.NET Web Applications

a given static method will make use of pointer logic. To ensure that this method can only be called from an

Chapter 20 - XML Web Services

unsafe context, you could define the method as follows:

Index

List of Figures

unsafe public static void SomeUnsafeCode()

List of Tables

{

// Work with pointers here!

}

This configuration would demand that the caller invoke SomeUnsafeCode() as so:

static void Main()

{

unsafe{SomeUnsafeCode();}

}

Conversely, if you would rather not force the caller to wrap the invocation within an unsafe context, you could remove the "unsafe" keyword from the SomeUnsafeCode() method signature and opt for the following:

C# and the .NET Platform, Second Edition public static void SomeUnsafeCode()

unsafe

This comprehensive text starts with a brief overview of the

{

C# language and then quickly moves to key technical and

// Work with pointers here! architectural issues for .NET developers.

}

}

Table of Contents

C# and the .NET Platform, Second Edition

Introduction

which would simplify the call to:

Part One - Introducing C# and the .NET Platform

Chapter 1 - The Philosophy of .NET

static void Main()

Chapter 2 - Building C# Applications

{

Part Two - The C# Programming Language

SomeUnsafeCode();

Chapter 3 - C# Language Fundamentals

}

Chapter 4 - Object-Oriented Programming with C# Chapter 5 - Exceptions and Object Lifetime

Chapter 6 - Interfaces and Collections

Working with the * and & Operators

Chapter 7 - Callback Interfaces, Delegates, and Events

ChaptOnceryou8 -haveAdvancedestablishedC# TypeanConstructionunsafe context,Techniquesyou are then free to build pointers to data types using the *

PartoperatorThreeas- Progrwell asmmingobtainwiththe.addressNET A embliesof said pointer using the & operator. Using C#, the * operator is

Chaappliedter 9to-theUnderstandingunderlying type.NETonly,Assembliesnot as a prefix to each pointer variable name. For example, the

Chapterfollowing10declares- Proc ses,twoAppDomains,variables, bothContexts,of type int*and(aThreadspointer to an integer).

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

Part Four - Leveraging the .NET Libraries

// No! This is incorrect under C#!

Chapter 12 - Object Serialization and the .NET Remoting Layer int *pi, *pj;

Chapter// Yes!13 -ThisBu ldingisa Betterthe wayWindofw (IntroducingC#. Windows Forms)

Chapint*er pi,14 - Apj;Better Painting Framework (GDI+)

Chapter 15 - Programming with Windows Forms Controls

Chapter 16 - The System.IO Namespace

Given this, check out the following example:

Chapter 17 - Data Access with ADO.NET

Part Five - Web Applications and XML Web Services

unsafe

Chapter 18 - ASP.NET Web Pages and Web Controls

{

Chapter 19 - ASP.NET Web Applications

int myInt;

Chapter 20 - XML Web Services

Index // Define an int pointer, and

// assign it the address of myInt.

List of Figures

int* ptrToMyInt = &myInt;

List of Tables

// Assign value of myInt using pointer indirection.

*ptrToMyInt = 123;

// Print some stats.

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

Console.WriteLine("Address of myInt {0:X}", (int)ptrToMyInt);

}

An Unsafe (and Safe) Swap Function

Of course, declaring pointers to local variables simply to assign their value (as shown in the previous example) is never required. To illustrate a more useful example of unsafe code, assume you wish to build a swap function using pointer arithmetic:

unsafe public static void UnsafeSwap(int* i, int* j)

{

int temp = *i;

C# and the .NET Platform, Second Edition

*i = *j;

}Apress © 2003 (1200 pages)

This comprehensive text starts with a brief overview of the C# language and then quickly moves to key technical and architectural issues for .NET developers.

Very C-like, don't you think? However, given your work in Chapter 3, you should be aware that you could

write the following safe version of your swap algorithm using the C# "ref" keyword:

Table of Contents

C# and the .NET Platform, Second Edition

public static void SafeSwap(ref int i, ref int j)

Introduction

{

Part One - Introducing C# and the .NET Platform

int temp = i;

Chapter 1 - The Philosophy of .NET

i = j;

Chapter 2 - Building C# Applications

j = temp;

Part Two - The C# Programming Language

}

Chapter 3 - C# Language Fundamentals

Chapter 4 - Object-Oriented Programming with C#

ChapterThe functionality5 - Exceptionsof eachandmethodObject isLifetimeidentical, thus reinforcing the point that direct pointer manipulation is

Chapternot a mandatory6 - Interftaskcesundera CollectionsC#.

Chapter 7 - Callback Interfaces, Delegates, and Events

Field Access via Pointers (the –> Operator)

Chapter 8 - Advanced C# Type Construction Techniques

Part Three - Programming with .NET Assemblies

Now assume that you have a Point structure and wish to declare a pointer to a Point type. Like C(++), when you wish to invoke methods or trigger fields of a pointer type, you will need to make use of the

pointer-field access operator (–>). As mentioned in Table 8-1, this is the unsafe version of the standard

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

(safe) dot operator (.). In fact, using the pointer indirection operator (*), it is possible to dereference a

Part Four - Leveraging the .NET Libraries

pointer to (once again) apply the dot operator notation. Check out the following:

Chapter 12 - Object Serialization and the .NET Remoting Layer

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

Chapter 14 - A Better Painting Framework (GDI+)

{

Chapter 15 - Programming with Windows Forms Controls public int x;

Chapter 16 - The System.IO Namespace public int y;

Chapter 17 - Data Access with ADO.NET

public override string ToString()

Part Five - Web Applications and XML Web Services

{ return "(" + x + "," + y + ")"; }

Chapter 18 - ASP.NET Web Pages and Web Controls

}

Chapter 19 - ASP.NET Web Applications

static void Main(string[] args)

Chapter 20 - XML Web Services

{

Index // Access members via pointer.

List of Figuresunsafe

List of Tables{

Point point;

Point* p = &point;

p->x = 100;

p->y = 200;

Console.WriteLine(p->ToString());

}

// Access members via pointer indirection.

unsafe

{

Point point;

Point* p = &point;

(*p).x = 100;

(*p).y = 200;

Console.WriteLine((*p).ToString());

}

}

Apress © 2003 (1200 pages)

The "stackalloc"This comprehensiveKeyword text starts with a brief overview of the

C# language and then quickly moves to key technical and

architectural issues for .NET developers.

In an unsafe context, you may need to declare a local variable that allocates memory directly from the call stack (and is therefore not subject to .NET garbage collection). To do so, C# provides the "stackalloc"

keyword, which is the C# equivalent to the _alloca function of the C runtime library. Here is a simple

Table of Contents example:

C# and the .NET Platform, Second Edition

Introduction

unsafe

Part One - Introducing C# and the .NET Platform

{

Chapter 1 - The Philosophy of .NET

char* p = stackalloc char[256];

Chapter 2 - Building C# Applications

for (int k = 0; k < 256; k++)

Part Two - The C# Programming Language

p[k] = (char)k;

Chapter 3 - C# Language Fundamentals

}

Chapter 4 - Object-Oriented Programming with C# Chapter 5 - Exceptions and Object Lifetime

ChapterPinning6 -aInterfacesType viaandtheCollect"fixed"ons Keyword

Chapter 7 - Callback Interfaces, Delegates, and Events

As seen in the previous example, allocating a chunk of memory within an unsafe context may be facilitated

Chapt r 8 - Advanced C# Type Construction Techniques

via the "stackalloc" keyword. By the very nature of this operation, the allocated memory is cleaned up as

Part Three - Programming with .NET Assemblies

soon as the allocating method has returned (as the memory is acquired from the stack). However,

Chapter 9 - Understanding .NET Assemblies

assume a more complex example. During our examination of the –> operator, you created a value type

Chapter 10 - Processes, AppDomains, Contexts, and Threads

named Point. Like all value types, the allocated memory is popped off the stack once the executing scope

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

has terminated. For the sake of argument, assume Point was instead defined as a reference type:

Part Four - Leveraging the .NET Libraries

Chapter 12 - Object Serialization and the .NET Remoting Layer

class Point // <= Now a class!

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

{

Chapter 14 - A Better Painting Framework (GDI+)

public int x;

Chapter 15 - Programming with Windows Forms Controls

public int y;

Chapter 16 - The System.IO Namespace

public override string ToString()

Chapter 17 - Data Access with ADO.NET

{ return "(" + x + "," + y + ")"; }

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 Servicthes

As you are well aware, if caller declares a variable of type Point, the memory is allocated on the

Indexgarbage collected heap. The burning question then becomes: What if an unsafe context wishes to interact

ListwithofthisF gurestype (or any type on the heap)? Given that garbage collection can occur at any given moment

List(seeofChapterTables 5), imagine the pain of accessing the members of Point at the very time in which a sweep of the heap is underway. Theoretically, it is possible that the unsafe context is attempting to interact with a member that is no longer accessible or has been repositioned on the heap after surviving a generational sweep (which is an obvious problem).

To lock a reference type variable in memory from an unsafe context, C# provides the "fixed" keyword. The fixed statement sets a pointer to a managed type and "pins" that variable during the execution of statement. Without "fixed", pointers to managed variables would be of little use, since garbage collection could relocate the variables unpredictably. (In fact, the C# compiler will not allow you to set a pointer to a managed variable except in a fixed statement.) Thus, if you were to create a Point type (now redesigned as a class) and wish to interact with its members, you must write the following code (or receive a compiler error):

unsafe public static void Main()

{

Point pt = new Point();

{

}This comprehensive text starts with a brief overview of the

C# language and then quickly moves to key technical and

Console.WriteLine("The size of MyValueType is {0}.", architectural issues for .NET developers.

sizeof(MyValueType));

Table of Contents

C# and the .NET Platform, Second Edition

SOURCE The UnsafeCode project can be found under the Chapter 8 subdirectory.

Introduction

CODE

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

Chaptersealed10 - Processes, AppDomains,ThisContexts,keywordandis usedThreadsto build class types that cannot be extended.

Now that you have the bulk of the C# language keywords under your belt, we can direct our attention to the finer details of building C# types, beginning with the concept of an indexer.

Building a Custom# and the .IndexerNET Platform, Second Edition

As programmers, we are very familiar with the process of accessing discrete items held within a standard

Apress © 2003 (1200 pages)

array using the index (aka bracket) operator:

This comprehensive text starts with a brief overview of the C# language and then quickly moves to key technical and

architectural issues for .NET developers.

// Declare an array of integers.

int[] myInts = { 10, 9, 100, 432, 9874};

// Use the [] operator to access each element.

Table of Contents

for(int j = 0; j < myInts.Length; j++)

C# and the .NET Platform, Second Edition

Console.WriteLine("Index {0} = {1} ", j, myInts[j]);

Introduction

Part One - Introducing C# and the .NET Platform

ChapterThe previous1 - ThecodePhilosophyis by noofmeans.NET a major news flash. However, the C# language provides the capability

Chapterto build2custom- BuildingclassesC# Applicationsthat may be indexed just like an array of intrinsic types. It should be no big surprise

PartthatTwothe -methodThe C#thatProgrammingprovides theLanguagecapability to access items in this manner is termed an indexer.

Chapter 3 - C# Language Fundamentals

Before exploring how to create such a construct, let's begin by seeing one in action. Assume you have

Chapter 4 - Object-Oriented Programming with C#

added support for an indexer method to the Cars container developed in Chapter 6. Observe the following

Chapter 5 - Exceptions and Object Lifetime

usage:

Chapter 6 - Interfaces and Collections

Chapter 7 - Callback Interfaces, Delegates, and Events

// Indexers allow you to access items in an array-like fashion.

Chapter 8 - Advanced C# Type Construction Techniques

public class CarApp

Part Three - Programming with .NET Assemblies

{

Chapter 9 - Understanding .NET Assemblies

public static void Main()

Chapter 10 - Processes, AppDomains, Contexts, and Threads

{

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

// Assume the Cars type has an indexer method.

Part Four - Leveraging the .NET Libraries

Cars carLot = new Cars();

Chapter 12 - Object Serialization and the .NET Remoting Layer

// Make some cars and add them to the car lot.

Chapter 13 - Building a Better Window (Introducing Windows Forms) carLot[0] = new Car("FeeFee", 200, 0);

Chapter 14 - A Better Painting Framework (GDI+)

carLot[1] = new Car("Clunker", 90, 0);

Chapter 15 - Programming with Windows Forms Controls carLot[2] = new Car("Zippy", 30, 0);

Chapter 16 - The System.IO Namespace

// Now obtain and display each item.

Chapter 17 - Data Access with ADO.NET

for(int = 0; i < 3; i++)

Part Five - Web{Applications and XML Web Services

Chapter 18 - ASP.NET ConsoleWeb Pag s.WriteLine("Carand b Controls number {0} :", i);

Chapter 19 - ASP.NET WebConsoleApplications.WriteLine("Name: {0} ", carLot[i].PetName);

Chapter 20 - XML WebConsoleServices .WriteLine("Max speed: {0} ", carLot[i].MaxSpeed);

As you can see, indexers behave much like a custom collection supporting the IEnumerator and IEnumerable interfaces. The only major difference is that rather than accessing the contents using interface references, you are able to manipulate the internal collection of automobiles just like a standard array.

Now for the big question: How do you configure the Cars class (or any class) to do so? The indexer itself is represented as a slightly mangled C# property. In its simplest form, an indexer is created using the this[] syntax:

// Add the indexer to the existing class definition.

public class Cars : IEnumerable

{

...

// To contain the car types.

private ArrayList carArray = new ArrayList();

C# and the .NET Platform, Second Edition

// The indexer returns a Car based on a numerical index.

by Andrew Troelsen ISBN:1590590554

throw new IndexOutOfRangeException("Out of range!");

Table of Contents

else

C# and the .NET Platform, Second Edition

return (Car)carArray[pos];

Introduction

}

Part One - Introducing C# and the .NET Platform

// Or simply call carArray.Add(value);

Chapter 1 - The Philosophy of .NET

set {carArray.Insert(pos, value);}

Chapter 2 - Building C# Applications

}

Part Two - The C# Programming Language

}

Chapter 3 - C# Language Fundamentals

Chapter 4 - Object-Oriented Programming with C#

ChapterBeyond5the- useExceptionsof the "this"and Objectkeyword,Lifetimethe indexer looks just like any other C# property declaration. Do be Chapteraware that6 -indexersInterfacesdoanotd Collectionsprovide any array-like functionality beyond the use of the subscript operator. In

other words, the object user cannot write code such as the following:

Chapter 7 - Callback Interfaces, Delegates, and Events

Chapter 8 - Advanced C# Type Construction Techniques

Part// ThrUsee -SystemProgramming.Arraywith.Length?.NET AssembliNope!s

ChapterConsole9 .-WriteLine("CarsUndersta ding .NET Assembliesin stock: {0} ", carLot.Length);

Chapter 10 - Processes, AppDomains, Contexts, and Threads

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

To support this functionality, you would need to add your own Length property to the Cars type, and

Part Four - Leveraging the .NET Libraries

delegate accordingly:

Chapter 12 - Object Serialization and the .NET Remoting Layer

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

public class Cars

Chapter 14 - A Better Painting Framework (GDI+)

{

Chapter 15 - Programming with Windows Forms Controls

...

Chapter 16 - The System.IO Namespace

// Containment/delegation in action once again.

Chapter 17 - Data Access with ADO.NET

public int Length() { carArray.Count; }

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

At this point you have equipped a class to support an indexer method. As you can gather, this technique is Indexyet another form of syntactic sugar given that the semantics of a type indexer can also be represented by

Lisimplet of Figurespublic methods. For example, if the Cars type did not support an indexer, we would be able to allow

ListtheofoutsideTables world to interact with the internal array list using a named property or traditional accessor/mutator methods. Nevertheless, you will find that indexers can help make the manipulation of your types more natural. Also be aware that many key technologies within the .NET base class libraries (ADO.NET, ASP.NET, and so forth) already have numerous types that support array-like manipulations.

SOURCE The Indexer project is located under the Chapter 8 subdirectory.

CODE

Furthermore, if you want to get really exotic, you can also create an indexer that takes multiple

C# and the .NET Platform, Second Edition

parameters. Assume you have a custom collection that stores subitems in a two-dimensional array. If this

by Andrew Troelsen ISBN:1590590554 is the case, you may configure an indexer method as follows:

Apress © 2003 (1200 pages)

This comprehensive text starts with a brief overview of the

public class SomeContainer

C# language and then quickly moves to key technical and

{architectural issues for .NET developers.

private int[,] my2DintArray = new int[10, 10]; public int this[int row, int column]

Table of {Contents/* get or set value from 2D array */ }

}

C# and the .NET Platform, Second Edition Introduction

Part One - Introducing C# and the .NET Platform

Finally, understand that indexers can be defined on a given .NET interface type to allow implementing

Chapter 1 - The Philosophy of .NET

types to provide a custom implementation. Such an interface is seen here:

Chapter 2 - Building C# Applications

Part Two - The C# Programming Language

public interface IAmAnInterfaceWithAnIndexer

Chapter 3 - C# Language Fundamentals

{

Chapter 4 - Object-Oriented Programming with C#

Chapter 5 - Exceptions and Object Lifetime

// strings based on a numerical index.

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