Reflection Reflection Leveraging the Power of Metadata

Document Sample
Reflection Reflection Leveraging the Power of Metadata Powered By Docstoc
Leveraging the Power of Metadata

 Provide  Explain

an introduction to .NET Reflection

how applications can use Reflection to explore type information and how they can build types at runtime

 Section  Section  Section  Section  Section

1: Overview 2: Exploring Metadata 3: Detail Information 4: Building Types at Runtime 5: Putting it together

 Summary

Section 1: Overview
 Looking  What's  .NET

back: Automation and COM Type Info

wrong with that?

Reflection Core Concepts

Looking Back: Automation
 TypeLibraries

contain type information

Exploration through ITypeLib/ITypeInfo

 Attributes
 

describe behavior of elements

e.g. Directionality of parameters e.g. Method role (instance method, property)

 Dynamic  Type

Invocation using IDispatch

system supports most popular simple types types using VARIANT

 Dynamic  Arrays  Strings

passed using SAFEARRAY
expressed as BSTR

What's wrong with that?
 Automation  Automation  ITypeInfo

client model favors VisualBasic server model favors C/C++

and IDispatch are way too complicated model is limited

 Information  No

sufficient support for complex types are a pain from C/C++


are difficult to manage from C/C++

information separate from code

.NET Reflection Core Concepts
 Metadata
   

Single location for type information and code
Code is literally contained within type information Every .NET object can be queried for its type Types' metadata can be explored with Reflection

 Dynamic
 

Type System

Highly dynamic and language independent Types may be extended and built at run-time


Allows on-the-fly creation of assemblies
.NET Compilers use .NET to emit .NET code

Section 2: Exploring Metadata
 Who

are you? are you? special about you?

 What

 Anything  Now

tell me what you have! and Instances

 Types

MetaData: Type Info at Runtime
[serializable] public class Person : { public event OnSaveChange onsv; public Date DOB; public string FirstName; public string LastName; public string Name { get { return FirstName + " " + LastName; } } public void Person(string First,string Last) { FirstName=First;LastName=Last; } public bool Save() { System.Type t = this.GetType(); foreach( FieldInfo f in t.GetFields() ) { ... } }


Events Fields

Constructors Parameters


Who are you?
 Accessing
 

meta-data: System.Object.GetType()

All .NET classes (implicitly) inherit System.Object

Available on every .NET class; simple types too

 Explicit
 

language support for type meta-data
If TypeOf … Is … Then …

C#, JScript.NET: typeof(…) VB.NET:

 Determining
 

Type Identity

Types have unique identity across any assembly Types can be compared for identity

if ( a.GetType() == b.GetType() ) { … };

 Access

to meta-data for any .NET type by System.Object.GetType()

 Returned  Allows
 

drilling down into all facets of a type

Category: Simple, Enum, Struct or Class Methods and Constructors, Parameters and Return


Fields and Properties, Arguments and Attributes
Events, Delegates and Namespaces

What are you?
 Value,

Interface or Class?

IsValueType, IsInterface, IsClass

 Public,

Private or Sealed ?
or Implementation?

IsNotPublic, IsSealed

 Abstract


 Covers  Very

all possible properties of a managed type

intuitive API, no "Parameter Hell"

Anything special about you?
 Special
  

Memory Layout?

IsAutoLayout IsExplicitLayout IsLayoutSequential




 More…
 

IsUnicodeClass IsSpecialName, etc.

Now tell me what you have!
 Finding

and Exploring Members

MemberInfo: GetMembers(), FindMembers()

 Exploring

Fields and Properties
Constructors, Methods and Events

FieldInfo: GetFields(), PropertyInfo: GetProperties()

 Exploring

GetConstructors(), GetMethods(), GetEvents()

 Exploring

attributes, determining implemented interfaces, enumerating nested types, … Everything you may ever want to know

 Summary:

Type and Instances
 Type
 

Safety First! Type checking at runtime

C#: if ( o is Customer ) { … } VB: If TypeOf o Is Customer Then … End If

 Dynamic

Invocation through Reflection

Support for late binding
 

FieldInfo.SetValue() PropertyInfo.SetValue()

Section 3: Detail Information
 MemberInfo  FieldInfo,

PropertyInfo MethodInfo

 ConstructorInfo,

 Base

class for all "member" element descriptions member kind, name and declaring class

Fields, Properties, Methods, etc.

 Provides








FieldInfo, PropertyInfo
 FieldInfo
  

Field data type and attributes Static or Instance field, protection level Can set value through reflection

Provides low-level, direct access with SetValueDirect()

 PropertyInfo
   

Property type and attributes
Test methods for readability, writeability "get" and "set" MethodInfo Indexer ParameterInfo Can invoke "set" and "get" through Reflection

MethodInfo, ConstructorInfo
 MethodInfo
   

Return type and attributes List of all parameters as ParameterInfo array Detail implementation information through flag-field Can invoke method through Reflection

 ConstructorInfo

Same features as MethodInfo, just for constructors

 Custom

attributes are the killer-app for Reflection! enable declarative behavior

 Attributes  Attributes

allow data augmentation

[dbcolumn("Address1")] string Street; [dbcolumn("Postcode")] string ZIP;
Mark class as serializable Type.GetCustomAttributes() Map fields to database columns with FieldInfo.GetCustomAttributes()

[serializable] class Person { ...

The Bigger picture
 Types

know their Module, Modules know their types know their Assembly and vice versa

 Modules

 Code

can browse and search its entire context

Assembly Module Class
Constructor Method Method

Module Struct Class Interface Class

Module Delegate Class Interface



The Unmanaged Spy: Metadata API
 Unmanaged  Used  Full

(COM) Version of Reflection

by VisualStudio.NET and Compilers

Access to all Reflection Information for Tools documented in the "Tool Developer's Guide" Assembly Metadata API

 Fully

 Buddy:

Reads/writes Assembly Manifests

Section 4: Building Types at Runtime
 Introducing  Why?


Some scenarios Modules and Assemblies Types and Classes

 Dynamic  Creating  Writing


Introducing System.Reflection.Emit
 Full

representation of physical structure building modules and assemblies at runtime

 Allows

Transient code only used at runtime


Persistent code for reuse

 Create  Used

classes, types and emit IL

by .NET compilers to build .NET apps

Why? Some Scenarios…
 Build

classes dynamically from script-like code

ASP.NET, Regular Expressions do just that !

 Generate

code from visual development tools

e.g. build interfaces, base classes from UML

 Create

dynamic wrappers for existing code

 Transfer

code-chunks to remote machines

Distributed processing scenarios (like SETI@home)

Building Assemblies
 System.Reflection.Emit.AssemblyBuilder  Dynamically
  

create new assemblies

Create manifest and resources Add modules Specify security requirements

 Can
 Act

be persisted as files or held in memory

and behave like any other assembly

Building Modules
 System.Reflection.Emit.ModuleBuilder  Modules  Allows  Can  Emit  Acts

contain types, classes and code

creating fully functional modules with code

associate source code debug symbols like any module created by any .NET compiler

Writing IL
 Emit

accepts IL (Intermediate Language) code code as emitted by C#, VB.NET, Eiffel#

 Same  IL

is optimized and translated into machine code puts you "on-par"
Same backend as .NET compilers Same access to code-generation Languages are mostly scanners and parsers

 Reflection.Emit
  

 For

more info see System.CodeDOM

Section 5: Putting It Together
 VisualStudio.NET  What

and Reflection

ASP+ really does with a page

VisualStudio.NET and Reflection
Toolbox Component Class

DefaultValue Help Localizable ReadOnly Designers

Properties Window

ComponentModel Attributes


What ASP.NET does with a Page
IIS ASP.NET runtime file exists? 1 2a no? compile
<%Page codebehind="pg"%> <html> <body> <asp:label/> <asp:textbox/> </html> </body>

assembly exists, 2 same timestamp? 3 run

ASP.NET compiler Page Assembly

class pg : Page { ... }

 Reflection  Explore  Enables  Use

= System.Type + GetType()

Type Information at Runtime Attribute-Driven Programming

Emit Classes to Produce .NET Assemblies Line: Fully Self-Contained Structural Model

 Bottom