Scribd Logo
Upload

Welcome to Scribd!

  • 94 views

    Reflection & Attributes in C#

    Uploaded by

    eshamu
    This document provides an overview of .NET reflection and its core concepts. Reflection allows programs to explore type information and build types at runtime. It allows interrogating objects and types inside a running program. All .NET types are self-describing through metadata that contains type information and code. Reflection is used for serialization, dynamic code generation, and other tasks.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PDF, TXT or read online from Scribd

    Reflection & Attributes in C#

    Uploaded by

    eshamu
    94 views30 pages
    This document provides an overview of .NET reflection and its core concepts. Reflection allows programs to explore type information and build types at runtime. It allows interrogating objects and types inside a running program. All .NET types are self-describing through metadata that contains type information and code. Reflection is used for serialization, dynamic code generation, and other tasks.

    Original Description:

    From these documents you will able to learn step by step

    Original Title

    csession7

    Copyright

    © Attribution Non-Commercial (BY-NC)

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    This document provides an overview of .NET reflection and its core concepts. Reflection allows programs to explore type information and build types at runtime. It allows interrogating objects and types inside a running program. All .NET types are self-describing through metadata that contains type information and code. Reflection is used for serialization, dynamic code generation, and other tasks.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    94 views30 pages

    Reflection & Attributes in C#

    Uploaded by

    eshamu
    This document provides an overview of .NET reflection and its core concepts. Reflection allows programs to explore type information and build types at runtime. It allows interrogating objects and types inside a running program. All .NET types are self-describing through metadata that contains type information and code. Reflection is used for serialization, dynamic code generation, and other tasks.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    You are on page 1of 30

    Reflection & Attributes in C#

    Objectives
    Provide an introduction to .NET Reflection Explain how applications can use Reflection to explore type information and how they can build types at runtime

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

    Section 1: Overview
    .NET Compile-Execution Cycle .NET Reflection Core Concepts

    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

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

    Dynamic Type System

    Reflection is fundamental to the CLR

    RMI JVM COM Directory DBMS XML Proxies

    Serialization
    Code Generation Analysis, Documentation

    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)

    Section 2: Exploring Metadata


    Who are you? What are you? Anything special about you? Now tell me what you have! Types and Instances

    Type Reflection
    Savings.BaseType ==Account Savings.BaseType.BaseType == Object
    Object

    Ixfer.BaseType == null Account.IsSubClassof(IEnquire) == false Savings.IsSubClassof(Account) == true

    IEnquire

    Account

    Savings.GetInterfaces() == { Iprint, Ixfer, Ienquire }


    Ienquire.IsAssignableFrom(Savings) == true

    IPrint IXfer
    Savings

    Reflection and the CLR type system

    System.Object

    Assembly

    Module

    MemberInfo

    ParameterInfo

    System.Type

    MethodBase

    FieldInfo

    PropertyInfo

    EventInfo

    MethodInfo

    ConstructorInfo

    MetaData: Type Info at Runtime


    System.Type Attributes Events Fields Properties Constructors Parameters Methods
    [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() ) { ... } }

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

    Serialization

    Save state of an object on disk or send to a stream:


    public class Point : { public double x; public double y; public double length; // computed from x, y };

    Solutions
    Inherit from a base type:
    class Point : Serializable { } but base type does not know derived type requires multiple inheritance

    Solution: Attributes

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

    Reflection Emit
    Abstractions correspond closely to the CTS that underlies the CLR:
    Assemblybuilder ConstructorBuilder CustomAttributeBuilder EnumBuilder EventBuilder FieldBuilder ILGenerator Label LocalBuilder MethodBuilder ModuleBuilder ParameterBuilder PropertyBuilder TypeBuilder

    Who are you?


    Accessing meta-data: System.Object.GetType()
    All .NET classes (implicitly) inherit System.Object Available on every .NET class; simple types too C#, JScript.NET: typeof() VB.NET: If TypeOf Is Then Types have unique identity across any assembly Types can be compared for identity
    if (a.GetType() == b.GetType()) { };

    Explicit language support for type meta-data Determining Type Identity

    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

    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"

    Anything special about you?


    Special Memory Layout?
    IsAutoLayout IsExplicitLayout IsLayoutSequential

    COM Objects?
    IsCOMObject

    More
    IsUnicodeClass IsSpecialName, etc.

    Type and Instances


    Type Safety First! Type checking at runtime
    C#: if VB: If
    (o is Customer) { } TypeOf o Is Customer Then End If

    Dynamic Invocation through Reflection


    Support for late binding
    MethodInfo.Invoke() FieldInfo.SetValue() PropertyInfo.SetValue()

    Section 3: Detail Information


    MemberInfo FieldInfo, PropertyInfo ConstructorInfo, MethodInfo

    MemberInfo
    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

    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

    Attributes
    Custom attributes are the killer-app for Reflection! Attributes enable declarative behavior 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 { ...

    Custom Attributes
    [BugFix(121,GA","01/03/05")] [BugFix(107,GA","01/04/05", Comment="Fixed off by one errors")] public class MyMath { public double DoFunc1(double param1) { return param1 + DoFunc2(param1); } public double DoFunc2(double param1) { return param1 / 3; } }

    Definining a Custom Attribute


    public class BugFixAttribute : System.Attribute { public BugFixAttribute(int bugID, string programmer, string date) { this.bugID = bugID; this.programmer = programmer; this.date = date; } // Named parameters are implemented as properties: public string Comment { get { return comment; } set { comment = value; } }}

    Using Attributes
    MyMath mm = new MyMath( ); Console.WriteLine("Calling DoFunc(7). Result: {0}", mm.DoFunc1(7)); // get the member information and use it to retrieve the custom attributes System.Reflection.MemberInfo inf = typeof(MyMath); BugFixAttribute[] attributes = (BugFixAttribute[])inf.GetCustomAttributes(typeof(BugFixAttribute), false); // iterate through the attributes, retrieving the properties foreach(BugFixAttribute attribute in attributes) { Console.WriteLine("\nBugID: {0}", attribute.BugID); Console.WriteLine("Programmer: {0}", attribute.Programmer); Console.WriteLine("Date: {0}", attribute.Date); Console.WriteLine("Comment: {0}", attribute.Comment); } Output: Calling DoFunc(7). Result: 9.33 BugID: 121 Programmer: GA Date: 01/03/05 Comment: BugID: 107 Programmer: GA Date: 01/04/05 Comment: Fixed off by one errors

    You might also like