13 iec t1_s1_oo_ps_session_19

Object-Oriented Programming Using C#
Objectives

In this session, you will learn to:
Create custom attributes
Retrieve metadata using reflection

Ver. 1.0 Session 19 Slide 1 of 19

Creating Custom Attributes

The .NET Framework allows creation of custom attributes,
which can be used to store information and can be retrieved
at run time.
This information can be related to any target element
depending upon the design and the need of an application.
To create custom attributes, you need to:
1. Define a custom attribute.
2. Name the custom attribute.
3. Construct the custom attribute.
4. Apply the custom attribute to a target element.


Creating Custom Attributes (Contd.)

Defining a Custom Attribute:
– A New custom attribute class is derived from the
System.Attribute system class.
– You need to then apply the attribute target using a predefined
attribute to the new custom attribute class, AttributeUsage, as
shown in the following code statement:
[AttributeUsage(AttributeTargets.Class |
AttributeTargets.Constructor |
AttributeTargets.Field |
AttributeTargets.Method |
AttributeTargets.Property,
AllowMultiple = true)]



The AttributeUsage attribute allows two arguments.
• One argument is a set of flags that indicates the target element.
• The other argument is a flag that indicates whether a given
element might be applied with more than one such attribute.
– Besides the AllowMultiple property there are other
properties that can be used with the attributes. These
properties are:
Inherited
ValidOn



– The following table lists the various member names of the
AttributeTargets enumerator.
Member Name Attribute Targets
All Elements including assembly, class, class member, delegate, enum, event, field, interface, method,
module, parameter, property, or struct
Assembly Assembly only
Class Instances of the class
ClassMembers Classes, structs, enums, constructors, methods, properties, fields, events, delegates, and interfaces
Constructor Class constructors
Delegate Delegate methods
Enum Defined enumeration
Event Defined events
Field Fields
Interface Interfaces
Method Defined methods
Module A single module
Parameter Parameters of a method
Property Properties (both get and set, if implemented)
Struct Structs



Naming the Custom Attribute:
The normal convention is to append the word Attribute to the
attribute name.
The compiler supports appending by allowing you to call the
attribute with the shorter version of the name.



Constructing the Custom Attribute:
– Every attribute must contain at least one constructor.
– Positional parameters are passed through the constructor in
the order declared in the constructor, as shown in the following
code snippet:
public BugFixingAttribute(int BugNo, string
Developer,
string DateFixed)
{
this.BugNo = BugNo;
this.Developer = Developer;
this.DateFixed = DateFixed;
}



Named parameters are implemented as properties, as shown
in the following code snippet:
public string Remarks
{
get
{
return Remarks;
}
set
{
Remarks = value;
}
}



– It is common to create read-only properties for the positional
parameters:
public int BugNo
{
get
{
return BugNo;
}
}



Applying the Custom Attribute:
The attribute can be applied by placing it immediately before its
target.
To test the BugFixAttribute attribute for the preceding example,
you can create a program for a simple class named Calculator
and give it four functions.
You need to assign the BugFixAttribute to the target element
class to record its code-maintenance history, as shown in the
following code snippet:
[BugFixingAttribute(125,"Sara Levo","08/15/06",
Remarks="Return object not specified")]
[BugFixingAttribute(159,"Sara Levo","08/17/06",
Remarks="Data Type Mismatch")]
public class Calculator


Retrieving Metadata Using Reflection

• Reflection is used in the process of obtaining type
information at runtime.
• The classes that give access to the metadata of a running
program are in the System.Reflection namespace.
• The System.Reflection namespace contains classes
that allow programmers to obtain information about the
application that is running and to dynamically add types,
values, and objects to that application.


Retrieving Metadata Using Reflection (Contd.)

Reflection is generally used for the following tasks:
Viewing metadata
Performing type discovery
Late binding to methods and properties
Reflection emit



Viewing Metadata:
– To view metadata using reflection, the MemberInfo object of
the System.Reflection namespace needs to be initialized.
– This object helps discover the attributes of a member and to
provide access to metadata.



Performing Type Discovery:
– Reflection also helps to explore and examine the contents of
an assembly.
– It helps find the types associated with a module; the methods,
fields, properties, and events associated with a type, as well as
the signatures of each type of methods; the interfaces
supported by the type and the type's base class.
– Performing type discovery can also be achieved through the
Object Browser window of Visual Studio .NET IDE.



Late Binding:
– Binding a method at runtime is called late binding.
– Reflection provides the flexibility of choosing an object you will
bind at runtime and calling it programmatically.


Using Delegates with Events

Reflection Emit:
Reflection emit allows creation of new types at run time and
further use those types to perform certain tasks.
Reflection emit enables you to define new modules and new
types with methods.


Demo: Creating and Querying Custom Attribute Information

Problem Statement:
– John is a developer in a software development company. The
program manager wants John to ensure proper documentation
of the business logic of the Calculator application as a part of
development process. Although, the company maintains a
separate sheet to describe the use of classes and their version
number, the program manager wants to attach that sheet to
classes.
[Hint: Use the Calculator class given in the preceding section
for providing the business logic.]


Demo: Creating and Querying Custom Attribute Information
(Contd.)

Solution:
To create a console based application for Calculator
application, John needs to perform the following tasks:
1. Create a console-based application.
2. Build and execute an application.


Summary

In this session, you learned that:
Custom attributes are attributes that you create according to
your requirement.
The element to which you attach an attribute is called an
attribute target.
Reflection is used in the process of obtaining type information
at run time.
Reflection is generally used for the following tasks:
• Viewing metadata
• Performing type discovery
• Late binding to methods and properties
• Reflection emit


13 iec t1_s1_oo_ps_session_19

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (9)

Similar to 13 iec t1_s1_oo_ps_session_19

Similar to 13 iec t1_s1_oo_ps_session_19 (20)

More from Niit Care

More from Niit Care (20)

Recently uploaded

Recently uploaded (20)

13 iec t1_s1_oo_ps_session_19

Editor's Notes