Reflection Overview

1. Reflection Overview • All types in the CLR are self-describing • CLR provides a reader and writer for type definitions • System.Reflection & System.Reflection.emit • You can ‘read’ programs • You can map between type systems • You can interrogate objects and types inside a running program

2. Execution model VB Cobol C++ C# .NET languages Language compilers CIL code (+ metadata) Loader/verifier JIT compiler Uncompiled method call Managed Code Execution

3. 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 • Type 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 • See my CodeDom tutorial http://www.codeproject.com/KB/dotnet/CodeDomDelegates.aspx

4. Metadata uses • Allows type developed in a PL to be used by code in other PL • GC uses to traverse objects • Serialization (essential for Web Services) • IDE (e.g. IntelliSense)

5. Exploring Metadata • Who are you? • What are you? • Anything special about you? • Now tell me what you have! • Types and Instances

6. System.Type • Access to meta-data for any .NET type • Returned by System.Object.GetType() • 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 • C# also has the, typeof(), is and as operators.

7. What are you? • Value, Interface or Class? • IsValueType, IsInterface, IsClass • Public, Private or Sealed ? • IsNotPublic, IsSealed • Abstract or Implementation? • IsAbstract • Covers all possible properties of a managed type • Very intuitive API, no "Parameter Hell"

8. IEnquire Account IPrint ITransfer Savings Type Reflection Savings.BaseType ==Account Savings.BaseType.BaseType == Object ITransfer.BaseType == null Account.IsSubClassof(IEnquire) == false Savings.IsSubClassof(Account) == true Savings.GetInterfaces() == { IPrint, ITransfer, IEnquire } IEnquire.IsAssignableFrom(Savings) == true Object

9. Reflection and the CLR type system System.Object Assembly Module MemberInfo ParameterInfo MethodBase FieldInfo PropertyInfo EventInfo System.Type MethodInfo ConstructorInfo

10. 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 Person(string First,string Last) { FirstName=First;LastName=Last; } public bool Save() { System.Type t = this.GetType(); foreach( FieldInfo f in t.GetFields() ) { ... } } System.Type Attributes Events Fields Properties Constructors Parameters Methods

11. // Test sample classpublic class Test { private int n; public Test(int a) { n=a;} publicvoid Foo(float a, object b, string c) { } } //Retrieve the Type object public static int Main(string[] args) { Type type1 = typeof(Test); Test t1 = new Test(0); Type type2 = t1.GetType(); Console.WriteLine(“type of t1 is {0}”, type2); return 0 } Reflection MetaData Samples • Note: • type1==type2 • ReferenceEquals(type1, type2) == true

12. ReflectionType and Instances • Type Safety First! Type checking at run time • if (o is Customer) { … } • Dynamic Invocation through Reflection • Support for late binding: • MethodInfo.Invoke() • FieldInfo.SetValue()

13. //Get a list of methods supported by a class public static int Main(string[] args) { Type type1 = typeof(Test); MethodInfo[] minf = type1.GetMethods(); foreach (MethodInfo m in minf) { //Print out the method name and whether it is public Console.WriteLine(“Name: “+ m.Name + “,” + ((m.IsPublic) ? “ public” : “”) + ((m.IsVirtual) ? “virtual” : “”); //Get the list of parameters ParameterInfo[] pi = m.GetParameters(); foreach (ParameterInfo p in pi) Console.WriteLine(“ “ + p.ParameterType + “ “ + p.Name); } return 0 } ReflectionGetMethods Example Name: Foo, public System.Single a System.Object b System.String c Name: GetType, public Name: ToString, public virtual Name: Equals, public virtual System.Object obj Name: GetHashCode, public virtual Press any key to continue . . .

14. ReflectionMemberInfo • Base class for all "member" element descriptions • Fields, Properties, Methods, etc. • Provides member kind, name, and declaring class MemberInfo MethodBase ParameterInfo FieldInfo EventInfo PropertyInfo MethodInfo ConstructorInfo

15. Anything special about you? • Special Memory Layout? • IsAutoLayout • IsExplicitLayout • IsLayoutSequential • COM Objects? • IsCOMObject • More… • IsUnicodeClass • IsSpecialName, etc.

16. Now tell me what you have! • Finding and Exploring Members • MemberInfo: GetMembers(), FindMembers() • Exploring Fields and Properties • FieldInfo: GetFields(), PropertyInfo: GetProperties() • Exploring Constructors, Methods and Events • GetConstructors(), GetMethods(), GetEvents() • Exploring attributes, determining implemented interfaces, enumerating nested types, … • Summary: Everything you may ever want to know

17. 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 • MethodInfo.Invoke() • FieldInfo.SetValue() • PropertyInfo.SetValue()

18. Reflection Dynamic Creation Example • You can use CreateInstance and other methods to create instances at run-time and call their methods and properties. • See the example here for more info. • http://www.csharp-examples.net/reflection-examples/

19. Types know their module; modules know their types Modules know their assembly and vice versa Code can browse and search its entire context ReflectionThe Bigger Picture Assembly Module Module Module Struct Delegate Class Constructor Class Class Method Interface Interface Method Field Interface Class

20. Traverse every element in an assembly Using System.Reflection; public static void WalkAssembly(String assemblyName) { Assembly assembly = Assembly.Load (assemblyName); foreach (Module module in assembly.GetModules()) foreach (Type type in module.GetTypes()) foreach (MemberInfo member in type.GetMembers()) Console.WriteLine (“{0}.{1}”, type, member.Name; }

21. Object Creation • OK, now see my CodeDom tutorial http://www.codeproject.com/KB/dotnet/CodeDomDelegates.aspx

22. Serialization • Save state of an object on disk or send to a stream (we will cover this more later): public class Point : { public double x; public double y; public double length; // computed from x, y };

23. Solutions • Inherit from a base type: class Point : Serializable { … } but … • base type does not know derived type • requires multiple inheritance • Java solution: class Point implements Serializable { … } but … • method granularity • customization requires full rewrite of WriteObject, ReadObject

24. Solution: Attributes [Serializable] public class Point : { public double x; public double y; [NonSerialized] public double length; // computed from x, y };

25. ReflectionSummary • Reflection = System.Type + GetType() • Explore type information at runtime • Enables attribute-driven programming • Bottom line: Fully self-contained structural model • Used extensively in Visual Studio

26. VisualStudio.NET and Reflection Toolbox Component Class Description Properties Window DefaultValue Help Localizable Designers ReadOnly Help ComponentModel Attributes

27. System.AddIn • There is a new set of classes in the System.AddIn namespace for aiding in plug-in architectures. • I have not had a chance to look at this closely, but it appears to be more for creating Adapter’s (see the Adapter design pattern) and creating a common interface (called an IContract). In other words allowing a plug-in that did not support your interface in the first place. • See http://blogs.microsoft.co.il/blogs/bursteg/archive/2007/08/13/Build-AddIns-with-System-AddIn.aspx.