Summary C# and the .NET Platform, Second Edition

by Andrew Troelsen ISBN:1590590554

The point of this chapter was to expose the internal composition of a .NET executable image. As you have

Apress © 2003 (1200 pages)

seen, the long-standing notion of a Win32 process has been altered under the hood to accommodate the

This comprehensive text starts with a brief overview of the

needs of the CLRC#. Alanguagesingle processand then(whichquicklycanmovesbe programmaticallyto key technical andmanipulated via the System.Diagnosticsarchitectural.Process type)issuesisfornow.NETcomposeddeveloperson. multiple application domains, which represent isolated and independent boundaries within a process. As you recall, a single process can host multiple application domains, each of which is capable of hosting and executing any number of related assemblies.

Table of Contents

Furthermore, a single application domain can contain any number of contextual boundaries. Using this

C# and the .NET Platform, Second Edition

additional level of type isolation, the CLR can ensure that special-need objects are handled correctly.

Introduction

The remainder of this chapter examined the role of the System.Threading namespace. As you have seen,

Part One - Introducing C# and the .NET Platform

when an application creates additional threads of execution, the result is that the program in question is

Chapter 1 - The Philosophy of .NET

able to carry out numerous tasks at (what appears to be) the same time. Finally, the chapter examined

Chapter 2 - Building C# Applications

various manners in which you can mark thread-sensitive blocks of code to ensure that shared resources

Part Two - The C# Programming Language

do not become unusable units of bogus data.

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

First, understand that each type contained within an assembly is documented using a "TypeDef #n" token (where TypeDef is short for type definition). If the type being described uses a type defined within a separate

.NET assembly, the referenced type is documented using the "TypeRef #n" token (where TypeRef is short for

type reference). A "TypeRef" token is a pointer (if you will) to the referenced type's full metadata definition. In a

This comprehensive text starts with a brief overview of the

nutshell, .NET metadata is a set of tables that clearly mark all internal type definitions (TypeDefs) and

referenced entities (TypeRefs), all of which can be viewed using ildasm.exe's metadata window. architectural issues for .NET developers.

As far as CarLibrary.dll goes, the first TypeDef we encounter (assuming that the CarLibrary.EngineState

enumeration is the first type encountered by the C# compiler) is the following metadata description:

Table of Contents

C# and the .NET Platform, Second Edition

TypeDef #1

Introduction

-------------------------------------------------------

Part One - Introducing C# and the .NET Platform

Field #2

Chapter 4 - Object-Oriented Programming with C#

-------------------------------------------------------

CallCnvntn: [FIELD]

Part Three - Programming with .NET Assemblies

Field type: ValueClass CarLibrary.EngineState

Chapter 9 - Understanding .NET Assemblies

...

Chapter 10 - Processes, AppDomains, Contexts, and Threads

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

Here, the "TypDefName" token is used to establish the name of the given type. The "Extends" metadata token

Part Four - Leveraging the .NET Libraries

is used to document the base class of a given .NET type (in this case, the referenced type, System.Enum).

Chapter 12 - Object Serialization and the .NET Remoting Layer

Each field of an enumeration is marked using the "Field #n" token. For brevity, I have simply listed the metadat

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

for EngineState.engineAlive.

Chapter 14 - A Better Painting Framework (GDI+)

Chapter 15 - Programming with Windows Forms Controls

ChapterViewing16 - The(Partial)Sys em.IOMetadataNamespace for the Car Type

Chapter 17 - Data Access with ADO.NET

Each of our automobiles is also completely documented using the .NET metadata format. As you may expect,

Part Five - Web Applications and XML Web Services

the complete metadata dump for a given type would be pages worth of data. To hit the highlights, here is a

Chapter 18 - ASP.NET Web Pages and Web Controls

partial dump of the Car type that illustrates (a) how fields are defined in terms of .NET metadata, (b) how

Chapter 19 - ASP.NET Web Applications

methods are documented via .NET metadata, and (c) how a single type property is mapped to two discrete

Chapter 20 - XML Web Services member functions:

Index

List of Figures

TypeDef #3

List of Tables

-------------------------------------------------------

[RTSpecialName] [.ctor] (00001886)

-------------------------------------------------------

This comprehensive text starts with a brief overview of the

Hash Algorithm : 0x00008004

C# language and then quickly moves to key technical and

Major Version: 0x00000001

architectural issues for .NET developers.

Minor Version: 0x00000000

Build Number: 0x000003d6

Revision Number: 0x00005da4

Table of Contents

Locale: <null>

C# and the .NET Platform, Second Edition

Flags : [SideBySideCompatible] (00000000)

Introduction

CustomAttribute #1 (0c000001)

Part One - Introducing C# and the .NET Platform

-------------------------------------------------------

Chapter 1 - The Philosophy of .NET

CustomAttribute Type: 0a000001

Chapter 2 - Building C# Applications

CustomAttributeName:

Part Two - The C# Programming Language

System.Reflection.AssemblyKeyNameAttribute ::

Chapter 3 - C# Language Fundamentals

instance void .ctor(class System.String)

Chapter 4 - Object-Oriented Programming with C#

Length: 5

Chapter 5 - Exceptions and Object Lifetime

Value : 01 00 00 00 00

Chapter 6 - Inteargs:faces and Collections

ctor ("")

Chapter 7 - Callback Interfaces, Delegates, and Events

Chapter 8 - Advanced C# Type Construction Techniques

Part Three - Programming with .NET Assemblies

Documenting Referenced Assemblies

Chapter 9 - Understanding .NET Assemblies

Chapter 10 - Processes, AppDomains, Contthexts, and Threads

In addition to the Assembly token and set of TypeDef and TypeRef blocks, .NET metadata also makes use Chapterof "AssemblyRef11 - Type Reflection,# " tokensLateto documentBinding, andeachAttributeexternal-BasedassemblyProgramming. Given that our CarLibrary.dll makes use of

ParttheFourMessageBox- Leveragingtype,thewe.NETfindLibrariesan AssemblyRef for System.Windows.Forms. For example:

Chapter 12 - Object Serialization and the .NET Remoting Layer

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

AssemblyRef #2

Chapter 14 - A Better Painting Framework (GDI+)

-------------------------------------------------------

ChaptToken:r 15 - Programming with Windows Forms Controls

0x23000002

ChapterPublic16Key- TheorSystemToken:.IO Namespb7 7ace5c 56 19 34 e0 89

ChName:pt r System17 - Data.WindowsAccess with.FormsADO.NET

PartMajorFive -Version:Web Applications0x00000001and XML Web Services

ChapterMinor18Version:- ASP.NET 0x00000000Web Pages and Web Controls

Build Number: 0x00000ce4

Chapter 19 - ASP.NET Web Applications

Revision Number: 0x00000000

Chapter 20 - XML Web Services

Locale: <null>

Index

HashValue Blob:

List of Figures

Flags: [none] (00000000)

List of Tables

Documenting String Literals

The final point of interest regarding .NET metadata is the fact that each and every string literal in your code base is documented under the "User Strings" token:

User Strings

-------------------------------------------------------

Apress © 2003 (1200 pages)

Now, don't be tooThisconcernedcomprehensivewith thetextexactstartssyntaxwithofa eachbrief overviewand everyofpiecethe of .NET metadata. The bigger point to absorb is that .C#NETlanguagemetadataandisthveryn quicklydescriptivemovesandto listskey technicaleach internallya d defined (and externally referenced)

architectural issues for .NET developers.

type found within a given code base. The next question on your mind may be (in the best-case scenario), "How can I leverage this information" or (in a worse case scenario), "Why do I care?" To address both points of view,

allow me to introduce .NET reflection services. Be aware that the pages that follow may be a bit of a head-

Table of Contents

scratcher until this chapter's endgame. So hang tight.

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

UnderstandingC# andReflectionthe .NET Platform, Second Edition

In the .NET universe, reflection is the process of runtime type discovery. Using reflection services, you are

Apress © 2003 (1200 pages)

able to load an assembly at runtime and discover the same sort of information presented by the

This comprehensive text starts with a brief overview of the

ildasm.exe metadataC# languagewindow,andusingthena friendlyquick objectmoves modelto key.technicalFor example,and through reflection, you can obtain a list of allarchitetypes containedtural issueswithinfor .NETa givendevelopassemblyrs. (or *.netmodule), including the methods, fields, properties, and events defined by a given type. You can also dynamically discover the set of interfaces supported by a given class (or structure), the parameters of a method as well as other related details

Table of Contents

(base class details, namespace information, manifest data, and so forth).

C# and the .NET Platform, Second Edition

To understand how to use reflection services to read .NET metadata, you need to come to terms with the

Introduction

Type class (defined in the System namespace) as well as a new namespace, System.Reflection. As you

Part One - Introducing C# and the .NET Platform

will see, the System.Type class contains a number of methods that allow you to extract valuable

Chapter 1 - The Philosophy of .NET

information about the current type you happen to be observing. The System.Reflection namespace

Chapter 2 - Building C# Applications

contains numerous related types to facilitate late binding and dynamic loading of assemblies. To begin,

Part Two - The C# Programming Language

let's investigate System.Type in some detail.

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

do so, call the static GetType() member and specify the textual name of the item you are interested in

C# and the .NET Platform, Second Edition

examining (and optionally, a System.Boolean to indicate case sensitivity):

Apress © 2003 (1200 pages)

// Get a Type using the static Type.GetType() method.

This comprehensive text starts with a brief overview of the

Type t = null;

C# language and then quickly moves to key technical and

t = Type.GetType("Foo");

architectural issues for .NET developers.

Table of Contents

Here, you are able to simply pass in the friendly name of the Type.GetType() method, assuming a type

C# and the .NET Platform, Second Edition

named Foo is within your same assembly. If this were not the case, Type.GetType() would require a string

Introduction

that describes the fully qualified name of the entity you are interested in examining, followed by the friendly name of the assembly containing the type (each of which is separated by a comma). Furthermore, the string passed into Type.GetType() may specify the plus token (+) to signify a nested type definition. Given this

information, ponder the following type request:

Part Two - The C# Programming Language

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

Part Four - Leveraging the .NET Libraries

ChapterNotice 12that-TypeObj ct.GetType()Serializationandandtypeof()the .NETareRemotinghelpful inLayerthat you do not need to first create an object instance Chapterto extract13 type- BuildinginformationBetter(whichWindowis obviously(IntroducingquiteWindowshelpfulForms)when employing late binding), whereas the use of

the inherited System.Object.GetType() method does. In any case, now that you understand how to obtain a

Chapter 14 - A Better Painting Framework (GDI+)

Type reference, let's examine how you can exercise it.

Chapter 15 - Programming with Windows Forms Controls

Chapter 16 - The System.IO Namespace

ChapterFun 17with- Dathea AccessTypewithClassADO.NET

Part Five - Web Applications and XML Web Services

To illustrate the usefulness of System.Type, assume you have a class named Foo that has been defined as

Chapter 18 - ASP.NET Web Pages and Web Controls

follows (the implementation of the various methods is irrelevant for this example):

Chapter 19 - ASP.NET Web Applications Chapter 20 - XML Web Services

Index// These are the items we will discover at runtime.

namespace TheType

List of Figures

{

List of Tables

// Two interfaces.

public interface IFaceOne

{void MethodA(); } public interface IFaceTwo

{void MethodB(); }

//Foo supports these 2 interfaces.

public class Foo: IFaceOne, IFaceTwo

{

// Fields.

public int myIntField; public string myStringField;

// A method.

public void myMethod(int p1, string p2){...}

// A property.

public int MyProp

{

C# and the .NET Platform, Second Edition get { return myIntField; }

}Apress © 2003 (1200 pages)

This comprehensive text starts with a brief overview of the

//IFaceOne and IFaceTwo methods.

C# language and then quickly moves to key technical and public void MethodA() {...}

architectural issues for .NET developers. public void MethodB() {...}

}

}

Table of Contents

C# and the .NET Platform, Second Edition

Introduction

Now, let's create a program that is able to discover the methods, properties, supported interfaces, and fields

Part One - Introducing C# and the .NET Platform

for a given Foo object (in addition to some other points of interest). The FooReader class defines a number

Chapter 1 - The Philosophy of .NET

of static methods that look more or less identical. First you have ListMethods(), which extracts each method

Chapter 2 - Building C# Applications

from Foo using a Type object. Notice how Type.GetMethods() returns an array of MethodInfo types:

Part Two - The C# Programming Language

Chapter 3 - C# Language Fundamentals

// Suck out all method names from Foo.

Chapter 4 - Object-Oriented Programming with C# public static void ListMethods(Foo f)

Chapter 5 - Exceptions and Object Lifetime

{

Chapter 6 - Interfaces and Collections

Console.WriteLine("***** Methods of Foo *****");

Chapter 7 - Callback Interfaces, Delegates, and Events

Type t = f.GetType();

Chapter MethodInfo8 - Adva ced[]C#miType=Construction.GetMethodsTechniques();

Part Threeforeach(MethodInfo- Programming with .NETmAssembliesin mi)

Chapter 9 - UnderstandingConsole.WriteLine("Method:.NET Assemblies {0} ", m.Name);

Chapter Console10 - Processes,.WriteLine("*************************\n");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

The implementation of ListFields() is similar. The only notable difference is the call to Type.GetFields() and

Chapter 13 - Building a Better Window (Introducing Windows Forms) the resulting FieldInfo array:

Chapter 14 - A Better Painting Framework (GDI+)

Chapter 15 - Programming with Windows Forms Controls

// Suck out all fields from Foo.

Chapter 16 - The System.IO Namespace

public static void ListFields(Foo f)

Chapter 17 - Data Access with ADO.NET

{

Part Five - Web Applications and XML Web Services

Console.WriteLine("***** Fields of Foo *****");

Chapter 18 - ASP.NET Web Pages and Web Controls

Type t = f.GetType();

Chapter 19 - ASP.NET Web Applications

FieldInfo[] fi = t.GetFields();

Chapter 20 - XML Web Services foreach(FieldInfo field in fi)

Index

Console.WriteLine("Field: {0} ", field.Name);

List of Figures

Console.WriteLine("*************************\n");

List of Tables

}

The ListVariousStats(), ListProps(), and ListInterfaces() methods should be self-explanatory at this point:

// Suck out some interesting statistics about Foo.

public static void ListVariousStats(Foo f)

{

public class Foo: IFaceOne, IFaceTwo

}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.

Recall that nested items can be identified using the "+" token. Thus, to obtain metadata information for

MyNestedEnum, you could write the following:

Table of Contents

C# and the .NET Platform, Second Edition

// Get info on nested enum.

Introduction

Type t = Type.GetType("TheType.Foo+MyNestedEnum");

Part One - Introducing C# and the .NET Platform

Console.WriteLine("Enum name? {0}", t.Name);

Chapter 1 - The Philosophy of .NET

Console.WriteLine("Is enum nested private? {0}", t.IsNestedPrivate);

Chapter 2 - Building C# Applications

Console.WriteLine("Is enum nested public? {0}", t.IsNestedPublic);

Part Two - The C# Programming Language

Chapter 3 - C# Language Fundamentals

ChapterObviously,4 -SystemObj ct-.OrientedType providesProgrammingadditionalwithmembersC# beyond the items seen thus far. One especially

Chaptinterestingr 5 -memberExceptionsis namedand ObjectGetInterfaceMap()Lif time . Recall that explicit interface implementation allows you to

Chaptermap a 6given- Interfacesinterface andmethodC llectionsto a particular class method. GetInterfaceMap() can be used to obtain these Chapterrelationships7 - CatllbackruntimeInterfaces,. To illustrate,Delegates,updateandtheEventsFoo type to make use of explicit interface implementation:

Chapter 8 - Advanced C# Type Construction Techniques

Part// ThreeUse -explicitProgramminginterfacewith .NET Assembliesimpl.

Chapterpublic9 class- UnderstandingFoo: IFaceOne,.NET Ass mbliesIFaceTwo

Chapter{ 10 - Processes, AppDomains, Contexts, and Threads

Chapter void11 - TypeIFaceOneReflection,.MethodA(){}Late Binding, and Attribute-Based Programming

Part Fourvoid- LeveragingIFaceTwothe .NETMethodB(){}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

Now, create the following additional helper method:

Chapter 16 - The System.IO Namespace

Chapter 17 - Data Access with ADO.NET

public static void MapInterfaceMethodsToClassMethods(Foo f)

Part Five - Web Applications and XML Web Services

{

Chapter 18 - ASP.NET Web Pages and Web Controls

Console.WriteLine("***** Explicit interface impl mappings *****");

Chapter 19 - ASP.NET Web Applications

Type t = f.GetType();

Chapter 20 - XML Web Services

// Get all interfaces on type.

Index

Type[] iFaces = t.GetInterfaces();

List of Figures

// Do the following for each interface on type.

List of Tables

for(int i = 0; i < iFaces.Length; i ++)

{

Console.WriteLine("Info on Interface named: {0}", iFaces[i]);

// Get method infos for name of method on the class.

MethodInfo[] classMethodNames = t.GetInterfaceMap(iFaces[i]).TargetMethods; MethodInfo[] interfaceMethodNames =

t.GetInterfaceMap(iFaces[i]).InterfaceMethods; for(int j = 0; j < classMethodNames.Length; j++)

{

Console.WriteLine("Interface method: {0}", interfaceMethodNames[j].Name);

Console.WriteLine("is implemented by class method: {0}", classMethodNames[j].Name);

}

Console.WriteLine();

}

}

This example is aApressbit more© 2003involved(1200 pages). First, we obtain a list of each interface supported by the Foo type using GetInterfaces(), whichT is comprehensiveis held in a Systemtext starts.Typewitharraya .briNext,f overviewwe loopofthroughthe each member in the array and extract an array ofC#MethodInfolanguage andtypesthentoquicklyrepresentmovesthe tonameskey technicalclass methods,and and another MethodInfo array

architectural issues for .NET developers.

representing the names of the interface methods. Once we have all the necessary information, we simply print out the association to the console window. Figure 11-2 shows partial output of your first reflection

application.

Table of Contents

C# and the .NET Platform, Second Edition

Part

Chapter

Chapter

Part

Chapter

Chapter

Chapter

Chapter

Chapter

Chapter

Part

Chapter

Chapter

Part

Chapter

Chapter

Chapter

Chapter

Chapter 16 - The System.IO Namespace

Figure 11-2: Reflecting on Foo

Chapter 17 - Data Access with ADO.NET

PartInterestingFive - Webstuff,Applicationshuh? WhileandtheXMLSystemWeb.TypeServicesclass can be very helpful on its own, reflection becomes even Chaptmorerpowerful18 - ASPwhen.NET Webyou makePages useand ofWebtheControlsAssembly class defined within the System.Reflection namespace.

Chapter 19 - ASP.NET Web Applications

SOURCE The TheType project can be found under the Chapter 11 subdirectory.

Chapter 20 - XML Web Services

CODE

Index

List of Figures

List of Tables

InvestigatingC# andthetheSystem.NET Platform,.ReflectionSe ond EditionNamespace

Like any namespace, System.Reflection contains a number of related types. Like any namespace, some

Apress © 2003 (1200 pages)

types are of more immediate interest than others. Table 11-2 lists some of the core items you should be

This comprehensive text starts with a brief overview of the familiar with, manyC#oflanguagewhich youandhavethenalreadyquickly seenmovesintothekeyprevioustechnicalFooandexample.

architectural issues for .NET developers.

Table 11-2: A Sampling of Members of the System.Reflection Namespace

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

a = Assembly.Load(

C# and the .NET Platform, Second Edition

@"CarLibrary, Version=1.0.982.23972, PublicKeyToken=null, Culture=""");

Also be aware that the System.Reflection namespace supplies the AssemblyName type, which allows you to

architectural issues for .NET developers.

represent the above string information in a handy object variable. Typically, this class is used in conjunction wit System.Version, which is an OO wrapper round an assembly's version number. Once you have established the

display name, it can then be passed into the overloaded Assembly.Load() method:

Table of Contents

C# and the .NET Platform, Second Edition

// Our OO-Aware display name.

Introduction

AssemblyName asmName;

Part One - Introducing C# and the .NET Platform

asmName = new AssemblyName();

Chapter 1 - The Philosophy of .NET asmName.Name = "CarLibrary";

Chapter 2 - Building C# Applications

Version v = new Version("1.0.982.23972");

Part Two - The C# Programming Language

asmName.Version = v;

Chapter 3 - C# Language Fundamentals

a = Assembly.Load(asmName);

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

ChapterNote7 The- CallbackAssemblyInterfactypes,alsoDelegates,definesandstaticEventsLoadFrom() method that allows you to load an assembly

using a given code base (for example, C:\MyAsms).

Chapter 8 - Advanced C# Type Construction Techniques

Part Three - Programming with .NET Assemblies

ChapterEnumerating9 - UnderstandingTypes.NET inAssemblia Referenceds Assembly

Chapter 10 - Processes, AppDomains, Contexts, and Threads

ChapterNow that11you- TypehaveReflection,a referenceLatetoBinding,the CarLibraryand Attributeassembly,-BasedyouProgrammingcan discover the name of each type it contains PartusingFourthe- staticLeveragingAssemblythe ..NETGetTypes()Librariesmethod. Here is a helper method named ListAllTypes() that does this ver

thing (assume this method is called within Main() after loading the CarLibrary.dll):

Chapter 12 - Object Serialization and the .NET Remoting Layer

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

Chapter// List14 -allA Bettypeser PaintingwithinFrameworkthe (GDI+)assembly.

Chapterprivate15 -staticProgrammingvoidwithListAllTypes(AssemblyWindows Forms Controls a)

{

Chapter 16 - The System.IO Namespace

Console.WriteLine("***** Types in Assembly *****");

Chapter 17 - Data Access with ADO.NET

Console.WriteLine("->{0}\n", a.FullName);

Part Five - Web Applications and XML Web Services

Type[] types = a.GetTypes();

Chapter 18 - ASP.NET Web Pages and Web Controls

foreach(Type t in types)

Chapter 19 - ASP.NET Web Applications

Console.WriteLine("Type: {0}", t);

Chapter 20 - XML Web Services

Console.WriteLine("******************************\n");

Index

}

List of Figures

List of Tables

Enumerating Class Members

Let's now assume you are interested in discovering the full set of members supported by one of our automobiles. To do so, you can make use of the GetMembers() method defined by the Type class. As you recall, the Type class also defines a number of related methods (GetInterfaces(), GetProperties(), GetMethods(), and so forth) that allow you to request a specific kind of member. GetMembers() returns an arra of MemberInfo types. Here is an example that lists the type and signature of each method defined by the MiniVan:

// Another static method of the CarReflector class.

private static void ListAllMembers(Assembly a)

{

Console.WriteLine("***** Members of MiniVan *****");

Type miniVan = a.GetType("CarLibrary.MiniVan");

MemberInfo[] mi = miniVan.GetMembers();

C# and the .NET Platform, Second Edition foreach(MemberInfo m in mi)

Apress © 2003 (1200 pages)

m.MemberType.ToString(), m);

This comprehensive text starts with a brief overview of the

Console.WriteLine("******************************\n");

C# language and then quickly moves to key technical and

}

architectural issues for .NET developers.

TableEnumeratingof Conten s Method Parameters

C# and the .NET Platform, Second Edition

Not only can you use reflection to gather information for the members of a type, you can also obtain information

Introduction

about the parameters of a given member. To illustrate, let's assume that the Car class has defined the followin

Part One - Introducing C# and the .NET Platform

additional method:

Chapter 1 - The Philosophy of .NET

Chapter 2 - Building C# Applications

Part// TwoA new- ThememberC# Programmingof the LanguageCar class.

public void TurnOnRadio(bool state, MusicMedia mm)

Chapter 3 - C# Language Fundamentals

{

Chapter 4 - Object-Oriented Programming with C#

if(state)

Chapter 5 - Exceptions and Object Lifetime

MessageBox.Show("Jamming with {0} ", mm.ToString());

Chapter 6 - Interfaces and Collections

else

Chapter 7 - Callback Interfaces, Delegates, and Events

MessageBox.Show("Quiet time...");

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

TurnOnRadio() takes two parameters, the second of which is a custom enumeration:

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

Part Four - Leveraging the .NET Libraries

// Holds source of music.

Chapter 12 - Object Serialization and the .NET Remoting Layer public enum MusicMedia

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

{ musicCD, musicTape, musicRadio }

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

ChapterExtracting16 -informationThe Systemfor.IOtheNamespaceparameters of TurnOnRadio() requires using MethodInfo.GetParameters(). This

method returns a ParameterInfo array. Each item in this array contains numerous properties for a given

Chapter 17 - Data Access with ADO.NET

parameter. Here is another static method of the CarReflector class, GetParams(), which displays various detail

Part Five - Web Applications and XML Web Services

for each parameter of the TurnOnRadio() method (see Figure 11-3 for partial output):

Chapter 18 - ASP.NET Web Pages and Web Controls

Chapter 19 - ASP.NET Web Applications

Chapter// Get20parameter- XML Web Servicesinformation for the TurnOnRadio() method.

private static void GetParams(Assembly a)

Index

{

List of Figures

Console.WriteLine("***** Here are the params for TurnOnRadio() *****");

List of Tables

// Get a MethodInfo type.

Type miniVan = a.GetType("CarLibrary.MiniVan");

MethodInfo mi = miniVan.GetMethod("TurnOnRadio");

// Show number of params.

Console.WriteLine("Here are the params for {0} ", mi.Name);

ParameterInfo[] myParams = mi.GetParameters();

Console.WriteLine("Method has {0} params", myParams.Length);

// Show some info for param.

foreach(ParameterInfo pi in myParams)

{

Console.WriteLine("Param name: {0} ", pi.Name);

Console.WriteLine("Position in method: {0} ", pi.Position);

Console.WriteLine("Param type: {0} ", pi.ParameterType);

}

Console.WriteLine("******************************\n");

}

C# and the .NET Platform, Second Edition

Apress © 2003 (1200 pages)

with a brief overview of the

moves to key technical and

developers.

Table

C# and

Introduction

Figure 11-3: Reflecting on a private assembly

Part One - Introducing C# and the .NET Platform

ChapterSOURCE1 - The PhilosophyThe CarReflectorof .NET project is included in the Chapter 11 subdirectory.

ChapterCODE2 - 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

Reflecting onC# andSharedthe .NETAssembliesPlatfor , Second Edition

The Assembly type can also be used to load a shared assembly (i.e., a GAC deployed .NET binary). To do so,

Apress © 2003 (1200 pages)

your Load() method must specify a full display name for the assembly to be loaded. Assume you wish to load

This comprehensive text starts with a brief overview of the

version 1.0.0.0 ofC#thelanguageSharedAssemblyand then quickly.dll youmovescreatedtoinkeyChaptertechnical9. Theand following code prints out various

statistics of this binaryarchitecturaland thenissueslistsforthe.NETnamesdevelopersof each. type (be sure to update the value of publickeytoken to use your own!):

Table of Contents

namespace SharedAsmReflector

C# and the .NET Platform, Second Edition

{

Introduction

public class SharedAsmReflector

foreach(Type t in types)

Part Three - Programming with .NET Assemblies

Console.WriteLine("Type: {0}", t);

Chapter 9 - Understanding .NET Assemblies

Console.WriteLine("******************************\n");

Chapter 10 - Processes, AppDomains, Contexts, and Threads

}

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

public static int Main(string[] args)

Part Four - Leveraging the .NET Libraries

Assembly a = null;

Chapter 15 - Programming with Windows Forms Controls

string displayName = "SharedAssembly," +

Of course, you may load any item installed in the GAC using a full display name, including standard .NET binaries. For example, to load System.Drawing.Design.dll from the GAC, you simply update the display name as follows (your version may differ):

// Load System.Drawing.Design.dll from GAC.

displayName = null;

displayName = "System.Drawing.Design," +

"Version=1.0.5000.0," +

"PublicKeyToken=b03f5f7f11d50a3a," +

@"Culture=""";

a = Assembly.Load(displayName);

Apress © 2003 (1200 pages)

Sweet! At this point you understand how to use some of the core items defined within the System.Reflection

This comprehensive text starts with a brief overview of the

namespace to discover a wealth of information at runtime. And, maybe you are already envisioning the code

C# language and then quickly moves to key technical and

behind tools sucharchas ildasmtectural.exeissuesandforwincv.NET.exed velopers. Next up,. let's check out how to create and interact with types on the fly via .NET late binding.

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

UnderstandingC# andDynamicthe .NET Platform,InvocationSecond Edition(Late Binding)

by Andrew Troelsen ISBN:1590590554

The System.Reflection namespace provides additional functionality beyond runtime type discovery. .NET

Apress © 2003 (1200 pages)

reflection services also provides the ability to exercise "late binding" to a type. Simply put, late binding is a

This comprehensive text starts with a brief overview of the

technique in whichC#youlanguageare ableandcreatethen quicklya givenmovtypesandto keyinvoketechnicalits membersand at runtime without having compile-time knowledgearchitecturalof itsissuesexistencefor .NET. Therefore,developerswhen. you are building an application that binds late to

a type in a given assembly, you have no reason to set a reference to the type (and therefore, the caller's manifest has no direct listing of the binary). Do be aware, however, that the CLR will still follow the same

(e.g., set an assembly reference and use the C# "new" keyword) you should opt to do so. Early binding

Chapter 1 - The Philosophy of .NET

allows you to determine errors at compile time, rather than runtime. Nevertheless, late binding does have

Chapter 2 - Building C# Applications

a place among tool builders, as well as COM/.NET interoperability. For example, using late binding, a

Part Two - The C# Programming Language

.NET programmer is able to obtain a COM object's IDispatch reference. Let's examine how to dynamically

Chapter 3 - C# Language Fundamentals

invoke a method on the MiniVan class.

Chapter 4 - Object-Oriented Programming with C#

Chapter 5 - Exceptions and Object Lifetime

ChaptTherActivator6 - InterfacesClassand Collections

Chapter 7 - Callback Interfaces, Delegates, and Events

The System.Activator class is the key to .NET late binding. Beyond the methods inherited from Object,

Chapter 8 - Advanced C# Type Construction Techniques

Activator only defines a small set of members. Activator.CreateInstance() is one core method that creates an instance of a type at runtime. This method has been overloaded numerous times to provide a good

deal of flexibility. The simplest variation of the CreateInstance() member takes a valid Type variable that

Chapter 10 - Processes, AppDomains, Contexts, and Threads describes the entity you wish to invoke:

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

Part Four - Leveraging the .NET Libraries

// Create a type dynamically.

Chapter 12 - Object Serialization and the .NET Remoting Layer

public class LateBind

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

{

Chapter 14 - A Better Painting Framework (GDI+)

public static int Main(string[] args)

Chapter 15 - Programming with Windows Forms Controls

{

Chapter 16 - The System.IO Namespace

// Assume the CarLibrary is in the app directory.

Chapter 17 - Data Access with ADO.NET

Assembly a = null;

Part Five - Web Applications and XML Web Services

try

Chapter 18 - ASP.NET Web Pages and Web Controls

{ a = Assembly.Load("CarLibrary"); }

Chapter 19 - ASP.NET Web Applications

catch(FileNotFoundException e)

Chapter 20 - XML Web Services

{ Console.WriteLine(e.Message);}

Index // Specify the fully qualified name of the Minivan type.

List of Figures Type miniVan = a.GetType("CarLibrary.MiniVan");

List of Tables // Create the Minivan on the fly.

object obj = Activator.CreateInstance(miniVan);

}

}

At this point, the "obj" variable is pointing to a MiniVan instance in memory that has been created indirectly using the Activator class. Now assume you wish to invoke the TurboBoost() method of the MiniVan. As you recall, this will set the state of the engine to "dead" and display an informational message box.

The first step is to obtain a MethodInfo type for the TurboBoost() method using Type.GetMethod(). From a MethodInfo type, you are then able to call the method it describes using Invoke(). MethodInfo.Invoke() requires you to send in all parameters that are to be given to the method represented by MethodInfo. These parameters are represented by an array of System.Object types (as the parameters for a given method could be any number of various entities). Given that TurboBoost() does not require any parameters, you can simply pass "null" (meaning "this method has no parameters"):

public static int Main(string[] args)

C# and the .NET Platform, Second Edition

{

by Andrew Troelsen ISBN:1590590554

// Use Assembly class to load the CarLibrary.

Apress © 2003 (1200 pages)

...

This comprehensive text starts with a brief overview of the

// Get the MiniVan type.

C# language and then quickly moves to key technical and

Type miniVan = a.GetType("CarLibrary.MiniVan"); architectural issues for .NET developers.

// Create the MiniVan on the fly.

object obj = Activator.CreateInstance(miniVan);

// Get info for TurboBoost.

Table of Contents

MethodInfo mi = miniVan.GetMethod("TurboBoost");

C# and the .NET Platform, Second Edition

// Invoke method ('null' for no parameters).

Introduction

mi.Invoke(obj, null);

Part One - Introducing C# and the .NET Platform

return 0;

Chapter 1 - The Philosophy of .NET

}

Chapter 2 - Building C# Applications

Part Two - The C# Programming Language

Figure 11-4: Late bound method invocation

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

Part Four - Leveraging the .NET Libraries

To illustrate invoking a method that does take some number of parameters, assume you added the

Chapter 12 - Object Serialization and the .NET Remoting Layer

following new method to the MiniVan type of the CarLibrary.dll assembly:

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

Chapter 14 - A Better Painting Framework (GDI+)

// Quiet down the troops...

Chapter 15 - Programming with Windows Forms Controls

public void TellChildToBeQuiet(string kidName, int shameIntensity)

Chapter 16 - The System.IO Namespace

{

Chapter 17 - Data Access with ADO.NET

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

Part Five - Web Applications and XML Web Services

MessageBox.Show("Be quiet {0} !!", kidName);

Chapter 18 - ASP.NET Web Pages and Web Controls

}

Chapter 19 - ASP.NET Web Applications

Chapter 20 - XML Web Services

IndexTellChildToBeQuiet() takes two parameters. In this case, the array of parameters must be fleshed out as

Listfollows:f Figures

mi = miniVan.GetMethod("TellChildToBeQuiet"); mi.Invoke(obj, paramArray);

If you run this program, you will see four message boxes popping up, shaming young Fredrick.

At this point you have seen the basic details regarding reflection services and late binding. As I am sure you might be guessing, System.Reflection defines additional functionality, which I will assume you will check out at your leisure.

SOURCE The LateBinding project is included in the Chapter 11 subdirectory.

CODE

C# and the .NET Platform, Second Edition

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.

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

UnderstandingC# andAttributedthe .NET Platform,ProgrammingSecond Edition

The official metalanguage of the component object model (COM) is IDL. As you may know, IDL is used to

Apress © 2003 (1200 pages)

describe the set of types defined within a given classic COM server. To describe these types in completely

This comprehensive text starts with a brief overview of the

unambiguous terms,C# languageIDL makesandusethenofquickly"attributes,"moveswhichto keyaret chnicalsimplyandIDL keywords placed in square brackets. A givenarchattributetecturalblockissuesalwaysfor .NETappliesdevelopersto the very. next thing. For example, when a COM programmer describes an interface, he or she is required to make use of the [uuid] and [object] attributes (at minimum). Parameters can be specified using the [in], [out], [in, out] ,and [out, retval] attributes. Here is

Table of Contents

an example of a classic COM interface, making use of various IDL attributes:

C# and the .NET Platform, Second Edition

Introduction

[object, uuid(4CB8B79A-E991-4AA4-8DB8-DD5D8751407D),

Part One - Introducing C# and the .NET Platform

oleautomation]

Chapter 1 - The Philosophy of .NET

interface IRememberCOM : IUnknown

Chapter 2 - Building C# Applications

{

Once a COM type has been assigned various attributes, it can be discovered at runtime programmatically,

Chapter 7 - Callback Interfaces, Delegates, and Events

or at design time using various tools. For example, notice how the TextManipulation() method has been

Chapter 8 - Advanced C# Type Construction Techniques

assigned a [helpstring] attribute, which is used to document how a given item is to be used. If you examine

Part Three - Programming with .NET Assemblies

this COM method using the Visual Basic 6.0 Object Browser utility, you will see the custom [helpstring] is

Chapter 9 - Understanding .NET Assemblies

automatically extracted and displayed (Figure 11-5).

Chapter 10 - Processes, AppDomains, Contexts, and Threads

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

Part

Part

Chapter 18 - ASP.NET Web Pages and Web Controls

Figure 11-5: Attributes in action

Chapter 19 - ASP.NET Web Applications

Chapter 20 - XML Web Services

Attributes have proven to be so helpful, that C# (as well as other .NET-aware languages) has integrated

Index

them as official aspects of the language. Using attributes, you are able to extend the metadata generated

List of Figures

by a given compiler with your custom information.

List of Tables

As you explore the .NET namespaces, you will find that there are many predefined attributes that you are able to make use of in your applications. Furthermore, you are free to build custom attributes to further qualify the behavior of your types. Keep in mind that .NET attributes (predefined or custom) are actually classes, all of which extend System.Attribute (contrast this to IDL, in which attributes are nothing more than simple keywords).

Working with Existing Attributes

Like IDL, C# attributes are nothing more than annotations that can be applied to a given type (class, interface, structure, etc.), member (property, method, etc.), assembly, or module. As mentioned, the .NET library defines a number of predefined attributes in various namespaces. Many of the predefined attributes are most useful in the context of COM and .NET interoperability, debugging, and other "exotic" aspects of building managed code. Table 11-3 gives a snapshot of some (but by absolutely no means all) predefined attributes.

Table 11-3: A Tiny Sampling of Predefined System Attributes

C# and the .NET Platform, Second Edition

Table of Contents

C#StructLayoutand the .NET Platform, SecondUsedEditionto configure the underlying representation of a structure.

Part One - Introducing C# and the .NET Platform

ChapterSerializable1 - The Philosophy ofMarks.NET a class or structure as being serializable.

Chapter 2 - Building C# Applications

Part Two - The C# Programming Language

ChapterWebMethod3 - C# Language FundMarksmentalsmethod as being invokable via HTTP requests.

Chapter 4 - Object-Oriented Programming with C#

ChapterAs an example,5 - ExceptionsassumeandthatObjectyou wishLifetimeto assign the [Serializable] attribute to a given item. The Motorcycle Chapterclass that6 follows- Interfaceshas assignednd Collectionsan attribute to the class itself, as well as a field named temp. As you can

see, C# attributes look very much like IDL attributes, in that they are enclosed within square brackets:

Chapter 7 - Callback Interfaces, Delegates, and Events

Chapter 8 - Advanced C# Type Construction Techniques

Part// ThreeThis- Programmiclass cang withbe saved.NET Assemblto diskes .

Chapter[Serializable]9 - Understanding .NET Assemblies

Chapterpublic10class- Processes,MotorcycleAppDomains, Contexts, and Threads

{

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

bool hasRadioSystem;

Part Four - Leveraging the .NET Libraries

bool hasHeadSet;

Chapter 12 - Object Serialization and the .NET Remoting Layer

bool hasSissyBar;

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

// But when you do, don't bother with this field.

Chapter 14 - A Better Painting Framework (GDI+)

[NonSerialized]

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

Using ildasm.exe (Figure 11-6), you can see that these attributes are now specified within the type

Chapter 19 - ASP.NET Web Applicatioands

metadata (note the "serializable" "notserialized" metadata tags).

Chapter 20 - XML Web Services

Index

List of

List of

Figure 11-6: Attributes seen via ildasm.exe

Be aware that if you wish to apply more than one attribute to a single type, simply separate each using a comma-delimited list or make use of multiple bracketed attributes stacked on top (or beside) one another:

[AttOne, AttTwo, AttThree]

public class SomeClass{...}

...

Apress © 2003 (1200 pages)

public class SomeOtherClass{...}

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.

Now at this point, don't concern yourself with who or what is on the lookout for the presence of these attributes. Just understand that attributed programming allows you to extend an assembly's metadata with

annotations.

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

RestrictingC#Attributeand the .NETUsagePl tform, Second Edition

Currently, the custom attribute has no mechanism to prevent a developer from making illogical aspect

Apress © 2003 (1200 pages)

specifications. For example, the following is syntactically correct, but semantically out of whack:

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.

// Syntactically OK, but an odd use of this custom attribute...

public class Winnebago

{

ChapterIdeally,3it would- C# Languagebe nice toFuendamforcentalsthe fact that this particular custom attribute should only be allowed to

Chaptermodify4a class- Object(and-Oriperhapsnted Programmingstructure),withbut nothingC# else. If you wish to constrain your attributes in this way,

you need to make use of the AttributeTargets enumeration:

Chapter 5 - Exceptions and Object Lifetime

Chapter 6 - Interfaces and Collections

Chapter// This7 -enumerationCallback Interfaceis, Delusedgates,to andcontrolEvents how a custom attribute can be applied.

Chapterpublic8 enum- AdvancedAttributeTargetsC# Type Construction Techniques

Part{ Three - Programming with .NET Assemblies

All, Assembly, Class, Constructor,

Chapter 9 - Understanding .NET Assemblies

Delegate, Enum, Event, Field,

Chapter 10 - Processes, AppDomains, Contexts, and Threads

Interface, Method, Module, Parameter,

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

Property, ReturnValue, Struct

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+)

These values are passed as a parameter to the AttributeUsage attribute. This pre-defined attribute is used by

Chapter 15 - Programming with Windows Forms Controls

the C# compiler to enforce the correct application of a custom attribute. The first parameter is an OR-ing

Chapter 16 - The System.IO Namespace

together of members from the AttributeTarget enumeration. The second (optional) parameter is typically a

Chnamedpter 17 - Data Access with ADO.NET

argument (AllowMultiple), which specifies if the custom attribute can be used more than once on the PartsameFivetype- Web. TheApplicationsfinal (optional)and XMLBooleanWebparameterServic s determines if the attribute should be inherited by derived

Chapterclasses18. - ASP.NET Web Pages and Web Controls

Chapter 19 - ASP.NET Web Applications

Thus, you can now configure the VehicleDescriptionAttribute to apply only to classes or structures as follows:

Chapter 20 - XML Web Services

Index

// This time, we are using the predefined AttributeUsage attribute

List of Figures

// to qualify our custom attribute!

List of Tables

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct)] public class VehicleDescriptionAttribute : System.Attribute

{

...

}

With this, if a developer attempted to apply the [VehicleDescription] attribute on anything other than a class or structure, they are issued a compile-time error.

Note Always get in the habit of explicitly marking the usage flags for any custom attribute you may create, as not all .NET programming languages honor the use of unqualified attributes!

Assembly-levelC# andAttributehe .NET Platform,MeaningSecond EdintionLife

AssemblyConfigurationAttributeThis c mprehensive text startsBuildwithinformation,a brief verviewsuch ofasthe"retail" or "debug."

C# language and then quickly moves to key technical and

AssemblyCopyrightAttributearchitectural issues for .NET Holdsdevelopersany .copyright information for the product or assembly.

ChapterAssemblyKeyFileAttribute6 - Interfaces and Collections Specifies the name of the file containing the key pair

used to sign the assembly (i.e. establish a shared

Chapter 7 - Callback Interfaces, Delegates, and Events

name).

Chapter 8 - Advanced C# Type Construction Techniques

List of Figures

List of Tables

Reflecting onC# andAttributeshe .NET Platform,at RuntimeSecond Edition

As you have seen, it is possible to obtain attributes at runtime using the Type class. The logic behind doing so

Apress © 2003 (1200 pages)

should be no surprise at this point:

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.

// Reflecting on the custom attributes...

public class AttReader

{

Table of Contents

public static int Main(string[] args)

C# and the .NET Platform, Second Edition

{

Introduction

// Get the Type of Winnebago.

Part One - Introducing C# and the .NET Platform

Type t = typeof(Winnebago);

Chapter 1 - The Philosophy of .NET

// Get all attributes in the assembly.

Chapter 2 - Building C# Applications

object[] customAtts = t.GetCustomAttributes(false);

Part Two - The C# Programming Language

// List all info.

Chapter 3 - C# Language Fundamentals

Console.WriteLine("***** Value of VehicleDescriptionAttribute *****\n"

Chapter 4 - Object-Oriented Programming with C# foreach(VehicleDescriptionAttribute v in customAtts)

Chapter 5 - ExceptionsConsolea d Object.WriteLine("fetime -> {0}\n", v.Desc);

Chapter 6 - Interfacesreturnand0;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

As the name implies, Type.GetCustomAttributes() returns an array (of System.Object types) that represent all t attributes applied to the member represented by the Type. From this array you are able to determine a specific

attribute on the fly. What you do with this information is (of course) up to you.

Part Four - Leveraging the .NET Libraries

Chapter 12 - Object Serialization and the .NET Remoting Layer

Note Be aware that the static Attribute.GetCustomAttribute() method allows you to obtain information for a

Chapter 13 specific- Buildingattribute,Be terratherWindowthan(Introducingan array ofWindowsall attributesForms)on a given type.

Chapter 14 - A Better Painting Framework (GDI+)

SOURCE The CustomAtt and AttReader applications are included under the Chapter 11 subdirector

Chapter 15 - Programming with Windows Forms Controls

CODE

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

Putting Reflection,C# and the .LateNET Platform,Binding,SecondandE itionCustom Attributes in

This comprehensive text starts with a brief overview of the

At this point, you may really be wondering if you will ever need to make use of reflection, late binding, or

C# language and then quickly moves to key technical and

custom attributes. To be sure, these topics (while fascinating) can seem a bit on the academic side of architectural issues for .NET developers.

programming (which may or may not be a bad thing, depending on your point of view). To help map these topics to a real-world situation, we need a solid example.

Table of Contents

Assume for the moment that you are on a programming team that is building an application that has the

C# and the .NET Platform, Second Edition following requirement:

Introduction

Part OneThe-productIntroducingmustC#beandextendiblethe .NETbyPlatformthe use of additional third party tools.

Chapter 1 - The Philosophy of .NET

So, what the heck does that mean? Well, consider Visual Studio .NET. When the VS .NET team was

Chapter 2 - Building C# Applications

constructing this application, it left various hooks that allow other software vendors to snap in custom

Part Two - The C# Programming Language

modules into the environment. Obviously the VS .NET team had no way to set references to external .NET

Chapter 3 - C# Language Fundamentals

assemblies it had not programmed (thus, no early binding)! However, to provide an open-ended model, the

Chapter 4 - Object-Oriented Programming with C#

VS .NET team had to provide a mechanism by which other individuals (including yourself) could plug in new

Chapter 5 - Exceptions and Object Lifetime behaviors.

Chapter 6 - Interfaces and Collections

ChapterExtendability7 - Callbackis an awesomeInterfaces,benefit,D legastes,thirdand-partyEventsvendors can build (and profit from) custom software

Chaptermodules8 . We- AdvabenefitcedasC#developersType Con tructionas well,Techniquesin that we are not required to by a brand-new (full price) IDE

PartsimplyThreeto gain- Programmiaugmentativewithfunctionality.NET Assemblies. So, how is it that tools such as VS .NET (and numerous other

Chaapplications)ter 9 - Understandinghave been programmed.NET Ass mbliesfor extendability?

Chapter 10 - Processes, AppDomains, Contexts, and Threads

As you would guess, there are many ways to skin the proverbial cat. First, a tool built for extendability must

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

provide some input vehicle to allow the user to specify the module to plug in (a dialog box, command line

Part Four - Leveraging the .NET Libraries

flag, or whatnot).

Chapter 12 - Object Serialization and the .NET Remoting Layer

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

Second, the application in question must be able to determine if the module in question supports the correct

Chapter 14 - A Better Painting Framework (GDI+)

functionality to be plugged into the environment. This advertisement of functionality could be provided via a Chapterspecific15interface- Programmingor customwithattributeWindows. TheFormskey,Controlshowever, is to make the entity as generic as possible. Given

Chapterthat attributes16 - TheareSystemnothing.IObutNamespaceadvertisements, they seem like the most logical choice.

Chapter 17 - Data Access with ADO.NET

Finally, if the extendible application is able to determine the type in question is compatible with its needs, it

Part Five - Web Applications and XML Web Services

will need to obtain an interface reference (again, think about the polymorphic nature of interface-types) to

Chapter 18 - ASP.NET Web Pages and Web Controls

trigger the real functionality of the snap-in. Once the snap-in has been loaded and used, the assembly may

Chapter 19 - ASP.NET Web Applications

be cached for further use or discarded (at the whim of the extendible application).

Chapter 20 - XML Web Services

Index

Simply put, if the extendible application has been preprogrammed to query for specific interfaces (and/or

List of Figures

attributes), it is able to determine at runtime if the item in question is worthy of activation. Once this Listverificationof Tablestest has been passed, the type in question may support additional interfaces that provide a polymorphic fabric to their functionality. This same generalized approach is the exact approach taken by the VS .NET team, and despite what you may be thinking, is not at all difficult!

Building a Custom Snap-In Consumer

In the sections that follow, I will walk through a complete example that illustrates the process of building an extendible Windows Forms application that can be augmented by the functionality of additional snap-in *.dll assemblies. What I will not do at this point is comment on the process of programming Windows Forms applications (Chapters 13-15 will tend to that chore). So, if you are not familiar with the process of building Windows Forms applications, feel free to simply open up the supplied sample code and follow along (or build a console-based alternative). To serve as a roadmap, our extendible application entails the following assemblies:

CommonSnappableTypes.dll: This assembly contains type definitions that will be implemented by each snap-in as well as referenced by the extendible Windows Forms application.

CSharpSnapIn.dll: A simple snap-in written in C#, which leverages the types of

C# and the .NET Platform, Second Edition

CommonSnappableTypes.dll.

by Andrew Troelsen ISBN:1590590554

Apress © 2003 (1200 pages)

VbNetSnapIn.dll: A simple snap-in written in VB .NET, which leverages the types of

CommonSnappableTypesThis comprehensive.dll. text starts with a brief overview of the

C# language and then quickly moves to key technical and

architectural issues for .NET developers.

MyPluggableApp.exe: This Windows Forms application will be the entity that may be extended by the functionality of each snap-in. Again, remember! This application will make use of reflection, late

binding, and custom attributes to dynamically gain the functionality of assemblies it has no

Table of Contents foreknowledge about.

C# and the .NET Platform, Second Edition

Introduction

Building the Common Snappable Types

Part One - Introducing C# and the .NET Platform

Chapter 1 - The Philosophy of .NET

Our first order of business is to create an assembly that contains the types that a given snap-in must

Chapter 2 - Building C# Applications

leverage to be plugged into our expandable Windows Forms application. If you are following along, create a

Part Two - The C# Programming Language

new C# code library (CommonSnappableTypes) that defines the following two types:

Chapter 3 - C# Language Fundamentals

Chapter 4 - Object-Oriented Programming with C# namespace CommonSnappableTypes

Chapter 5 - Exceptions and Object Lifetime

{

Chapter 6 - Interfaces and Collections

public interface IUseMyFunctionality

Chapter 7 - Callback Interfaces, Delegates, and Events

{ void DoIt(); }

Chapter 8 - Advanced C# Type Construction Techniques

Part Three - Programming with .NET Assemblies

[AttributeUsage(AttributeTargets.Class)]

Chapter 9 - Understanding .NET Assemblies

public class SnappableAttribute : System.Attribute

Chapter 10 - Processes,SnappableAttribute(){}Ap Domains, Contexts, and Threads

{ public }

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

Here, the CommonSnappableTypes.dll assembly offers a public interface (IUseMyFunctionality) that

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

provides a polymorphic interface for all snap-ins that can be consumed by the extendible Windows Forms

Chapter 14 - A Better Painting Framework (GDI+)

application. Of course, as this example is purely illustrative in nature, we supply a single method named

Chapter 15 - Programming with Windows Forms Controls

DoIt(). To map this to a more real world example, imagine an interface (or set of interfaces) that allows the

Chapter 16 - The System.IO Namespace

snapper to generate scripting code, render an image onto the application's toolbox, or integrate into the

Chapter 17 - Data Access with ADO.NET main menu.

Part Five - Web Applications and XML Web Services

ChapterSnappableAttribute18 - ASP.NET W b Pages and Web Controls

The type is a custom attribute that will be applied on any class type that wishes to be Chaptersnapped19in- toASPthe.NETcontainerWeb Applic. Again,tionsthe theory here is that if (and only if) a type has been adorned with the

Chapter[Snappable]20 - XMLattribute,Web Servicesit will support the functionality of the IUseMyFunctionality type.

Index

ListBuildingof Figures the C# Snap-In

List of Tables

Next up, we need to create a concrete type that supports the [Snappable] attribute and implements the IUseMyFunctionality interface. Again, to focus on the overall design of an extendible application, a trivial type is in order. Assume the following class type is defined in a new C# code library named CSharpSnapIn. Given that the contained class type must make use of the types defined in CommonSnappableTypes, be sure to set a reference to this binary (as well as System.Windows.Forms.dll to display a noteworthy message). This being said, here is the code:

using System;

using CommonSnappableTypes;

using System.Windows.Forms; namespace CSharpSnapIn

{

// This type is Snappable into other containers.

[Snappable]

public class TheCSharpSnapIn : IUseMyFunctionality

{

C# and the .NET Platform, Second Edition public TheCSharpSnapIn(){}

This comprehensive text starts with a brief overview of the

MessageBox.Show("You have just used the C# snap in!");

}C# language and then quickly moves to key technical and architectural issues for .NET developers.

}

}

Table of Contents

C# and the .NET Platform, Second Edition

Note that the TheCSharpSnapIn type has been marked with the [SnappableAttribute] type to flag itself as a

Introduction

type that can be plugged into the extendible application you have yet to build. Given that it has advertised its

Part One - Introducing C# and the .NET Platform

support for snap-in-ability, you also implement the IUseMyFunctionality.

Chapter 1 - The Philosophy of .NET

Chapter 2 - Building C# Applications

Building the VB .NET Snap-In

Part Two - The C# Programming Language

Chapter 3 - C# Language Fundamentals

Now, to simulate the role of a third-party vendor who prefers VB .NET over C#, create a new VB .NET code

Chapter 4 - Object-Oriented Programming with C#

library (VbNetSnapIn) that references the same external assemblies as the previous CSharpSnapIn project.

Chapter 5 - Exceptions and Object Lifetime

The code is (again) straightforward:

Chapter 6 - Interfaces and Collections

Chapter 7 - Callback Interfaces, Delegates, and Events

Imports System.Windows.Forms

Chapter 8 - Advanced C# Type Construction Techniques

Imports CommonSnappableTypes

Part Three - Programming with .NET Assemblies

<SnappableAttribute()> Public Class VbNetSnapIn

Chapter 9 - Understanding .NET Assemblies

Implements IUseMyFunctionality

Chapter 10 - Processes, AppDomains, Contexts, and Threads

Public Sub DoIt() Implements IUseMyFunctionality.DoIt

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

MessageBox.Show("You have used the VB .NET snap in!")

Part FourEnd- LeveragingSub the .NET Libraries

ChapterEnd Class12 - 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

Not too much to say here! This assembly contains another class type that is [Snappable] and implements

Chapter 16 - The System.IO Namespace

the functionality of the IUseMyFunctionality interface. Do notice that VB .NET applies attributes using angled

Chapter 17 - Data Access with ADO.NET brackets (< >) rather than square brackets ([ ]).

Part Five - Web Applications and XML Web Services

Chapter 18 - ASP.NET Web Pages and Web Controls

Building the Extendable Windows Forms Application

Chapter 19 - ASP.NET Web Applic tions

Chapter 20 - XML Web Services

Now, on to the good stuff! The final piece of the extendability puzzle is to create the Windows Forms

Index

application that allows the user to select a snap-in using a standard Windows Open dialog box (represented

by the System.Windows.Forms.OpenFileDialog type). Before I dive into the details, set a reference to the

List of Tables

CommonSnappableTypes.dll assembly, but not the CSharpSnapIn.dll or VbNetSnapIn.dll binaries! Remember the goal of this application is to make use of late binding and reflection to determine the "snapability" of independent binaries created by third-party vendors (thus, there is no hope of early binding).

Again, I won't bother to examine all the details of Windows Forms development at this point in the game. However, assuming you have placed a MainMenu type onto the Form template, we will launch an Open File dialog via a custom "Tools | Snap In Something..." menu item (Figure 11-8).

Edition

ISBN:1590590554

brief overview of the

key technical and

.

Table

C# and

Part

Chapter

Chapter 2 - Building C# Applications

Figure 11-8: Input for a snap-in module

Part Two - The C# Programming Language

ChapterBehind3the-Click# Languageevent handlerFundamentalsfor this menu item (which may be created simply by double-clicking the

Chaptermenu item4 -fromObjectthe-Oridesignnted-Programmingtime editor), ourwithgoalC# is to extract the path to the selected file, and using this

Chpath,pterperform5 - Exceptithe followingns and Objecttasks:Lifetime

Chapter 6 - Interfaces and Collections

Check to see if the user-selected assembly has any types marked with the [Snappable] attribute (by

Chapter 7 - Callback Interfaces, Delegates, and Events

reflecting over custom attributes).

Chapter 8 - Advanced C# Type Construction Techniques

Part Three - Programming with .NET Assemblies

For each type that does support the [Snappable] aspect, obtain the IUseMyFunctionality interface and

Chapter 9 - Understanding .NET Assemblies call the DoIt() method (via late binding).

Chapter 10 - Processes, AppDomains, Contexts, and Threads

Here is the relevant code behind the Form type:

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

Part Four - Leveraging the .NET Libraries

Chapterpublic12class- ObjectMainForm:Serialization andSystemthe .NET.WindowsRemoting.FormsLayer .Form

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

Chapter ...14 - A Better Painting Framework (GDI+)

// The " Tools | Snap In Something..." event handler.

Chapter 15 - Programming with Windows Forms Controls

private void mnuToolsSnapIn_Click(object sender, System.EventArgs e)

Chapter 16 - The System.IO Namespace

{

Chapter 17 - Data Access with ADO.NET

if(myOpenFileDialog.ShowDialog() == DialogResult.OK)

Part Five - Web Applications and XML Web Services

{

Chapter 18 - ASP.NET Web Pages and Web Controls

string pathToAsm = myOpenFileDialog.FileName;

Chapter 19 - ASP.NET Web Applications

if(TryToUseSnapIn(pathToAsm) == false)

Chapter 20 - XML Web Services

MessageBox.Show("This snap-in is bogus!");

Index

}

List of Figures

}

List of Tables

private bool TryToUseSnapIn(string path)

{

// Load the specified assembly.

bool foundSnapIn = false;

Assembly theSnapInAsm = Assembly.LoadFrom(path);

// Get all types in assembly.

Type[] theTypes = theSnapInAsm.GetTypes();

//Get custom attributes for each type, and

//see if one of them is [Snappable]

for(int i = 0; i < theTypes.Length; i++)

{

object[] theAtts = theTypes[i].GetCustomAttributes(false);

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

{

if(theAtts[j] is SnappableAttribute)

{

// It is snappable!

C# and the .NET Platform, Second Edition

// Get the IUseMyFunctionality interface.

This comprehensive text starts with a brief overview of the theSnapInAsm.CreateInstance(theTypes[i].FullName);

C# language and then quickly moves to key technical and

IUseMyFunctionality itfUseMe; architectural issues for .NET developers.

itfUseMe = o as IUseMyFunctionality;

if(itfUseMe != null)

{

Table of Contents

itfUseMe.DoIt();

C# and the .NET Platform, Second Edition

lstBoxSnapIns.Items.Add(theTypes[i].FullName);

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

return foundSnapIn;

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

This really does summarize all the information presented over the course of this chapter. Note how the

Chapter 8 - Advanced C# Type Construction Techniques

application is able to determine a bogus assembly (i.e., an assembly that contains no type that is

Part Three - Programming with .NET Assemblies

[Snappable]-aware) via the Boolean value returned from TryToUseSnapIn() helper function. Within this

Chapter 9 - Understanding .NET Assemblies

helper method, we first leverage the Assembly.LoadFrom() method to load the binary based on the user

Chapter 10 - Processes, AppDomains, Contexts, and Threads

specified path. Next, we iterate over each type and check to see if the item has been adorned with the

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

[Snappable] attribute. If so, we set our Boolean flag and trigger the IUseMyFunctionality.DoIt()

Part Four - Leveraging the .NET Libraries

implementation of the given snap-in (to return the correct value to the caller). Finally, for good measure, we

Chapter 12 - Object Serialization and the .NET Remoting Layer

log the name of the snap-in within the Form's ListBox type. Figure 11-9 shows the result.

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

Chapter 14 - A Better Painting Framework (GDI+)

Chapter

Chapter

Chapter

Part

Chapter

Chapter

Chapter

Index

List of

List of

Figure 11-9: Snapping in external assemblies

While this is a far cry from building real-world extendible applications, you should have a better understanding how such a program may be constructed. In a nutshell, building an extendible application demands the creation of an assembly that defines types implemented by the third-party snap-in vendor and queried for by the extendible application itself. If you wish, you can think of the CommonSnappableTypes.dll as the middleman that bridges the gap between snap-ins and snappee.

SOURCE The CommonSnappableTypes, CSharpSnapIn, VbNetSnapIn, and MyPluggableApp

CODE applications are included under the Chapter 11 subdirectory.

Note If you are interested in learning how to build custom snap-ins for VS .NET, check out Writing Addins for Visual Studio .NET (Smith, Apress 2002).

C# and the .NET Platform, Second Edition

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.

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