This document discusses attributes and reflection in C#. It begins by explaining what attributes are and how they can be used to associate declarative metadata with code entities. It then provides examples of using predefined attributes like Obsolete. It discusses user-defined attributes and the AttributeUsage attribute. It covers conditional methods and the Conditional attribute. The document explains reflection and how the Type class is central to it. It provides examples of using reflection to identify types that implement an interface or are subclasses of a given type. It concludes with a test case that gets the constructors of the String class using reflection.

1. Mohammad Shaker
mohammadshaker.com
@ZGTRShaker
2011, 2012, 2013, 2014
C# Advanced
L05-Attributes, Conditional Methods and Reflection

2. Attributes

3. AttributesMuch of the C# language enables the programmer to specify declarative information about the entities defined in the program. For example, the accessibility of a method in a class is specified by decorating it with the method-modifiers public, protected, internal, and private. C# enables programmers to invent new kinds of declarative information, called attributes. Programmers can then attach attributes to various program entities, and retrieve attribute information in a run-time environment. For instance, a framework might define a HelpAttributeattribute that can be placed on certain program elements (such as classes and methods) to provide a mapping from those program elements to their documentation. (from MSDN)

4. "DLL Hell“ problem

5. "DLL Hell“ problem
•can be caused by one application overwritinga sharedlibrary of another application, usually with a different version.
•Imagine you write an application with a shared library and then years later create a new application with an updated library.
•In order not to break old programs, what do you do with the new library? You give it a different name, store it in a different location, or overwrite the old ones?

6. "DLL Hell“ problem
•can be caused by one application overwritinga sharedlibrary of another application, usually with a different version.
•Imagine you write an application with a shared library and then years later create a new application with an updated library.
•In order not to break old programs, what do you do with the new library? You give it a different name, store it in a different location, or overwrite the old ones?

7. Assemblies

8. Assemblies
•What’s an assembly?
–An assembly is a file that is automatically generated by the compiler upon successful compilation of every.NET application. It can be either a Dynamic Link Library or an executable file. It is generated only once for an application and upon each subsequent compilation the assembly gets updated.
–contains the intermediate code, resources, and the metadata for itself.
–We can have a look inside the assembly using the ildasm(Intermediate Language Disassembler) tool that comes as part of Visual Studio.
–To access it you need to open the Visual Studio Command Prompt and type ildasm.exe. This will launch a Windows application that you can use to explore any.Netapplication.

9. Attributes and Reflection
•Attributes
–Attributes provide a powerful method of associating declarative information with C# code (types, methods, properties, and so forth).
–Once associated with a program entity, the attribute can be queried at run time and used in any number of ways.

10. Attributes and Reflection
•Example usage of attributes includes:
–Associating help documentation with program entities (through aHelpattribute).
–Associating value editors to a specific type in a GUI framework (through aValueEditorattribute).

11. Example at the start!

12. Example at the start! If you understand this, it’s over

13. Example at the start
enumCarColour
{
[Description("Ice Cream White")]
White,
[Description("Carbon Black")]
Black,
[Description("Sterling Silver")]
Silver,
Red
}

14. Example at the start
enumCarColour
{
[Description("Ice Cream White")]
White,
[Description("Carbon Black")]
Black,
[Description("Sterling Silver")]
Silver,
Red
}
Attributes

15. Example at the start
public static class EnumExtensions
{
public static string Description(this EnumenumValue)
{
varenumType= enumValue.GetType();
varfield = enumType.GetField(enumValue.ToString());
varattributes = field.GetCustomAttributes(typeof(DescriptionAttribute), false);
return ((DescriptionAttribute)attributes[0]).Description;
}
}
enumCarColour
{
[Description("Ice Cream White")]
White,
[Description("Carbon Black")]
Black,
[Description("Sterling Silver")]
Silver,
Red
}

16. Example at the start
public static class EnumExtensions
{
public static string Description(this EnumenumValue)
{
varenumType= enumValue.GetType();
varfield = enumType.GetField(enumValue.ToString());
varattributes = field.GetCustomAttributes(typeof(DescriptionAttribute), false);
return ((DescriptionAttribute)attributes[0]).Description;
}
}
enumCarColour
{
[Description("Ice Cream White")]
White,
[Description("Carbon Black")]
Black,
[Description("Sterling Silver")]
Silver,
Red
}
Extension Method

17. Example at the start
public static class EnumExtensions
{
public static string Description(this EnumenumValue)
{
varenumType= enumValue.GetType();
varfield = enumType.GetField(enumValue.ToString());
varattributes = field.GetCustomAttributes(typeof(DescriptionAttribute), false);
return ((DescriptionAttribute)attributes[0]).Description;
}
}
enumCarColour
{
[Description("Ice Cream White")]
White,
[Description("Carbon Black")]
Black,
[Description("Sterling Silver")]
Silver,
Red
}
Reflection

18. Example at the start
public static class EnumExtensions
{
public static string Description(this EnumenumValue)
{
varenumType= enumValue.GetType();
varfield = enumType.GetField(enumValue.ToString());
varattributes = field.GetCustomAttributes(typeof(DescriptionAttribute), false);
return ((DescriptionAttribute)attributes[0]).Description;
}
}
enumCarColour
{
[Description("Ice Cream White")]
White,
[Description("Carbon Black")]
Black,
[Description("Sterling Silver")]
Silver,
Red
}

19. Example at the start
public static class EnumExtensions
{
public static string Description(this EnumenumValue)
{
varenumType= enumValue.GetType();
varfield = enumType.GetField(enumValue.ToString());
varattributes = field.GetCustomAttributes(typeof(DescriptionAttribute), false);
return ((DescriptionAttribute)attributes[0]).Description;
}
}
enumCarColour
{
[Description("Ice Cream White")]
White,
[Description("Carbon Black")]
Black,
[Description("Sterling Silver")]
Silver,
Red
}

20. Example at the start
public static class EnumExtensions
{
public static string Description(this EnumenumValue)
{
varenumType= enumValue.GetType();
varfield = enumType.GetField(enumValue.ToString());
varattributes = field.GetCustomAttributes(typeof(DescriptionAttribute), false);
return ((DescriptionAttribute)attributes[0]).Description;
}
}
for (CarColourcc = CarColour.White; cc <= CarColour.Red; cc++)
{
Console.WriteLine(cc.Description());
}
enumCarColour
{
[Description("Ice Cream White")]
White,
[Description("Carbon Black")]
Black,
[Description("Sterling Silver")]
Silver,
Red
}

21. Example at the start
public static class EnumExtensions
{
public static string Description(this EnumenumValue)
{
varenumType= enumValue.GetType();
varfield = enumType.GetField(enumValue.ToString());
varattributes = field.GetCustomAttributes(typeof(DescriptionAttribute), false);
return ((DescriptionAttribute)attributes[0]).Description;
}
}
for (CarColourcc = CarColour.White; cc <= CarColour.Red; cc++)
{
Console.WriteLine(cc.Description());
}
enumCarColour
{
[Description("Ice Cream White")]
White,
[Description("Carbon Black")]
Black,
[Description("Sterling Silver")]
Silver,
Red
}
Ice Cream White
Carbon Black
Sterling Silver
Red

22. Concept of Attributes

23. Attributes Basics
•Attributes are generally applied physically in front of type and type member declarations. They're declared with square brackets, "[" and "]", surrounding the attribute such as the followingObsoleteAttributeattribute:
•[ObsoleteAttribute]
AttributeUsage
Describes how a custom attribute class can be used.
Conditional
Marks a conditional method, a method whose execution depends on a specified preprocessing identifier.
Obsolete
Marks a program entity that should not be used.

24. Attribute, Obsolete

25. Pre-Defined Attributes
usingSystem; classBasicAttributeDemo{ [Obsolete] publicvoidMyFirstdeprecatedMethod() { Console.WriteLine("Called MyFirstdeprecatedMethod()."); } [ObsoleteAttribute] publicvoidMySecondDeprecatedMethod() { Console.WriteLine("Called MySecondDeprecatedMethod()."); } [Obsolete("You shouldn't use this method anymore.")] publicvoidMyThirdDeprecatedMethod() { Console.WriteLine("Called MyThirdDeprecatedMethod()."); }

26. Pre-Defined Attributes
usingSystem; classBasicAttributeDemo{ [Obsolete] publicvoidMyFirstdeprecatedMethod() { Console.WriteLine("Called MyFirstdeprecatedMethod()."); } [ObsoleteAttribute] publicvoidMySecondDeprecatedMethod() { Console.WriteLine("Called MySecondDeprecatedMethod()."); } [Obsolete("You shouldn't use this method anymore.")] publicvoidMyThirdDeprecatedMethod() { Console.WriteLine("Called MyThirdDeprecatedMethod()."); }

27. Pre-Defined Attributes
usingSystem; classBasicAttributeDemo{ [Obsolete] publicvoidMyFirstdeprecatedMethod() { Console.WriteLine("Called MyFirstdeprecatedMethod()."); } [ObsoleteAttribute] publicvoidMySecondDeprecatedMethod() { Console.WriteLine("Called MySecondDeprecatedMethod()."); } [Obsolete("You shouldn't use this method anymore.")] publicvoidMyThirdDeprecatedMethod() { Console.WriteLine("Called MyThirdDeprecatedMethod()."); }

28. Pre-Defined Attributes
usingSystem; classBasicAttributeDemo{ [Obsolete] publicvoidMyFirstdeprecatedMethod() { Console.WriteLine("Called MyFirstdeprecatedMethod()."); } [ObsoleteAttribute] publicvoidMySecondDeprecatedMethod() { Console.WriteLine("Called MySecondDeprecatedMethod()."); } [Obsolete("You shouldn't use this method anymore.")] publicvoidMyThirdDeprecatedMethod() { Console.WriteLine("Called MyThirdDeprecatedMethod()."); }

29. Pre-Defined Attributes
// make the program thread safe for COM[STAThread] staticvoidMain(string[] args) { BasicAttributeDemoattrDemo=newBasicAttributeDemo(); attrDemo.MyFirstdeprecatedMethod(); attrDemo.MySecondDeprecatedMethod(); attrDemo.MyThirdDeprecatedMethod(); } }

30. Pre-Defined Attributes
// make the program thread safe for COM[STAThread] staticvoidMain(string[] args) { BasicAttributeDemoattrDemo=newBasicAttributeDemo(); attrDemo.MyFirstdeprecatedMethod(); attrDemo.MySecondDeprecatedMethod(); attrDemo.MyThirdDeprecatedMethod(); } }

31. Attribute, AttributeUsage

32. AttributeUsageDescribes how a custom attribute class can be used.
[AttributeUsage(
validon,
AllowMultiple=allowmultiple,
Inherited=inherited
)]

33. User-Defined Attributes
[Author("H. Ackerman", version = 1.1)]
classSampleClass

34. User-Defined Attributes
[Author("H. Ackerman", version = 1.1)]
classSampleClass
Author anonymousAuthorObject= newAuthor("H. Ackerman");
anonymousAuthorObject.version= 1.1;

35. User-Defined Attributes
[Author("H. Ackerman", version = 1.1)]
classSampleClass
Author anonymousAuthorObject= newAuthor("H. Ackerman");
anonymousAuthorObject.version= 1.1;
conceptually
equivalent

36. Attribute, Conditional

37. Conditional Methodsallow developers to create methods whose calls can be placed in the code and then either included or omitted during compilation based on a preprocessing symbol.

38. Conditional Methods
•TheConditional attribute takes one parameter —the preprocessing identifier that controls whether the method call is included when clients are compiled. If the preprocessing identifier is defined, the method is called; otherwise, the call is never inserted in the client's code.
using System;
using System.Diagnostics;
namespace TraceFunctions
{
public class Trace
{
[Conditional("DEBUG")]
public static void Message(string traceMessage)
{
Console.WriteLine("[TRACE] -" + traceMessage);
}
}
}

39. [Serializable]

40. [Serializable] Says that the object is Serializable

41. [Serializable] Says that the object is SerializableSo you can Stream it and save the object into, like, a file!

42. Reflection

43. ReflectionAsk the object itself about itself

44. Types

45. Types and Reflection
•Reflection
–Provides objects (of typeType) that encapsulate assemblies, modules and types.
–You can use reflection to dynamically create an instance of a type, bind the type to an existing object, or get the type from an existing object and invoke its methods or access its fields and properties.
–If you are using attributes in your code, Reflection enables you to access them.

46. Types and Reflection
•Reflection is useful in the following situations:
–When you need to access attributes in your program's metadata.
•“Accessing Attributes With Reflection”
–For examining and instantiating types in an assembly.
–For building new types at runtime. Use classes inSystem.Reflection.Emit
–For performing late binding, accessing methods on types created at run time.

47. Types and Reflection
•Reflection is useful in the following situations:
–When you need to access attributes in your program's metadata.
•“Accessing Attributes With Reflection”
–For examining and instantiating types in an assembly.
–For building new types at runtime. Use classes inSystem.Reflection.Emit
–For performing late binding, accessing methods on types created at run time.

48. System.Type class

49. System.Typeclass
•TheSystem.Typeclass is central to reflection.
•The common language runtime creates theTypefor a loaded type when reflection requests it. You can use aTypeobject's methods, fields, properties, and nested classes to find out everything about that type.

50. System.Typeclass
•Simple example of Reflection using the static methodGetType-inherited by all types from theObjectbase class -to obtain the type of a variable:
// Using GetTypeto obtain type information:
inti=42;
System.Typetype=i.GetType();
System.Console.WriteLine(type);

51. System.Typeclass
•Simple example of Reflection using the static methodGetType-inherited by all types from theObjectbase class -to obtain the type of a variable:
// Using GetTypeto obtain type information:
inti=42;
System.Typetype=i.GetType();
System.Console.WriteLine(type);
System.Int32

52. Types and Reflection
•Identifying all Types that Implement an Interface (http://www.blackwasp.co.uk/)
public interface IParent{ }
public class Parent { }
public class Child1 : Parent { }
public class Child2 : Parent { }
public class Grandchild11 : Child1 { }
public class Grandchild12 : Child1 { }
public class Grandchild21 : Child2 { }
public class Grandchild22 : Child2 { }
public class NotAChild{ }
public class NotAGrandchild: NotAChild{ }
Type parentType= typeof(IParent);
Assembly assembly= Assembly.GetExecutingAssembly();
Type[] types = assembly.GetTypes();

53. Types and Reflection
•Identifying all Types that Implement an Interface
public interface IParent{ }
public class Parent { }
public class Child1 : Parent { }
public class Child2 : Parent { }
public class Grandchild11 : Child1 { }
public class Grandchild12 : Child1 { }
public class Grandchild21 : Child2 { }
public class Grandchild22 : Child2 { }
public class NotAChild{ }
public class NotAGrandchild: NotAChild{ }
IEnumerable<Type> imp = types.Where(t => t.GetInterfaces().Contains(interfaceType));
foreach(Type typein imp)
{
Console.WriteLine(type.Name);
}
/* OUTPUT
Parent
Child1
Child2
Grandchild11
Grandchild12
Grandchild21
Grandchild22
*/
Type parentType= typeof(IParent);
Assembly assembly= Assembly.GetExecutingAssembly();
Type[] types = assembly.GetTypes();

54. Types and Reflection
•Identifying all Subclasses of a Class (http://www.blackwasp.co.uk/)
public interface IParent{ }
public class Parent { }
public class Child1 : Parent { }
public class Child2 : Parent { }
public class Grandchild11 : Child1 { }
public class Grandchild12 : Child1 { }
public class Grandchild21 : Child2 { }
public class Grandchild22 : Child2 { }
public class NotAChild{ }
public class NotAGrandchild: NotAChild{ }
Type parentType= typeof(IParent);
Assembly assembly= Assembly.GetExecutingAssembly();
Type[] types = assembly.GetTypes();

55. Types and Reflection
•Identifying all Subclasses of a Class
public interface IParent{ }
public class Parent { }
public class Child1 : Parent { }
public class Child2 : Parent { }
public class Grandchild11 : Child1 { }
public class Grandchild12 : Child1 { }
public class Grandchild21 : Child2 { }
public class Grandchild22 : Child2 { }
public class NotAChild{ }
public class NotAGrandchild: NotAChild{ }
IEnumerable<Type> subclasses = types.Where(t => t.IsSubclassOf(parentType));
foreach(Type typein subclasses)
{
Console.WriteLine(type.Name);
}
/* OUTPUT
Child1
Child2
Grandchild11
Grandchild12
Grandchild21
Grandchild22
*/
Type parentType= typeof(IParent);
Assembly assembly= Assembly.GetExecutingAssembly();
Type[] types = assembly.GetTypes();

56. Test CaseGetting Constructors of StringClass

57. Types and Reflection
// This program lists all the public constructors
// of the System.Stringclass.
usingSystem;
usingSystem.Reflection;
classListMembers
{
publicstaticvoidMain(String[] args)
{
Typet=typeof(System.String);
Console.WriteLine("Listing all the public constructors of the {0} type", t);
// Constructors.
ConstructorInfo[] ci=t.GetConstructors(BindingFlags.Public|BindingFlags.Instance);
Console.WriteLine("//Constructors");
PrintMembers(ci);
}
publicstaticvoidPrintMembers(MemberInfo[] ms)
{
foreach(MemberInfominms)
{
Console.WriteLine("{0}{1}", " ", m);
}
Console.WriteLine();
}
}

58. Types and Reflection
// This program lists all the public constructors
// of the System.Stringclass.
usingSystem;
usingSystem.Reflection;
classListMembers
{
publicstaticvoidMain(String[] args)
{
Typet=typeof(System.String);
Console.WriteLine("Listing all the public constructors of the {0} type", t);
// Constructors.
ConstructorInfo[] ci=t.GetConstructors(BindingFlags.Public|BindingFlags.Instance);
Console.WriteLine("//Constructors");
PrintMembers(ci);
}
publicstaticvoidPrintMembers(MemberInfo[] ms)
{
foreach(MemberInfominms)
{
Console.WriteLine("{0}{1}", " ", m);
}
Console.WriteLine();
}
}
Listing all the public constructors of the System.Stringtype
//Constructors
Void.ctor(Char*)
Void.ctor(Char*, Int32, Int32)
Void.ctor(SByte*)
Void.ctor(SByte*, Int32, Int32)
Void.ctor(SByte*, Int32, Int32, System.Text.Encoding)
Void.ctor(Char[], Int32, Int32)
Void.ctor(Char[])
Void.ctor(Char, Int32)
Press any key to continue...

59. Invoking Overloaded Methods Using Reflectionhttp://www.blackwasp.co.uk/

60. Invoking Overloaded Methods Using Reflection
public class Test
{
public void ShowMessage()
{
Console.WriteLine("Hello, world");
}
public void ShowMessage(string msg, inttimesToShow)
{
for (inti= 0; i< timesToShow; i++)
{
Console.WriteLine(msg);
}
}
}

61. Invoking Overloaded Methods Using Reflection
public class Test
{
public void ShowMessage()
{
Console.WriteLine("Hello, world");
}
public void ShowMessage(string msg, inttimesToShow)
{
for (inti= 0; i< timesToShow; i++)
{
Console.WriteLine(msg);
}
}
}
Test test= new Test();
Type type= test.GetType();
MethodInfomethod = type.GetMethod("ShowMessage", new Type[] { typeof(string), typeof(int) });
method.Invoke(test, new object[] { "Exterminate!", 3 });

62. Invoking Overloaded Methods Using Reflection
public class Test
{
public void ShowMessage()
{
Console.WriteLine("Hello, world");
}
public void ShowMessage(string msg, inttimesToShow)
{
for (inti= 0; i< timesToShow; i++)
{
Console.WriteLine(msg);
}
}
}
Test test= new Test();
Type type= test.GetType();
MethodInfomethod = type.GetMethod("ShowMessage", new Type[] { typeof(string), typeof(int) });
method.Invoke(test, new object[] { "Exterminate!", 3 });

63. Invoking Overloaded Methods Using Reflection
public class Test
{
public void ShowMessage()
{
Console.WriteLine("Hello, world");
}
public void ShowMessage(string msg, inttimesToShow)
{
for (inti= 0; i< timesToShow; i++)
{
Console.WriteLine(msg);
}
}
}
Test test= new Test();
Type type= test.GetType();
MethodInfomethod = type.GetMethod("ShowMessage", new Type[] { typeof(string), typeof(int) });
method.Invoke(test, new object[] { "Exterminate!", 3 });
Exterminate!
Exterminate!
Exterminate!

64. Accessing Attributes Through Reflection

65. Accessing Attributes Through ReflectionYou don’t have to read..

66. Accessing Attributes Through Reflection
class MainClass
{
public static void Main()
{
System.Reflection.MemberInfoinfo = typeof(MyClass);
object[] attributes = info.GetCustomAttributes(true);
for (inti = 0; i < attributes.Length; i++)
{
System.Console.WriteLine(attributes[i]);
}
}
}

67. Accessing Attributes Through Reflection
classMainClass
{
publicstaticvoidMain()
{
System.Reflection.MemberInfoinfo=typeof(MyClass);
object[] attributes=info.GetCustomAttributes(true);
for(inti=0; i<attributes.Length; i++)
{
System.Console.WriteLine(attributes[i]);
}
}
}

68. Accessing Attributes Through Reflection
•Let’s have the following giantexample!
publicclassIsTestedAttribute: Attribute
{
publicoverridestringToString()
{
return"Is Tested";
}
}

69. Concept of Attributes
[AttributeUsage(AttributeTargets.Class|AttributeTargets.Struct)]
publicclassAuthorAttribute: Attribute
{
publicAuthorAttribute(stringname)
{
this.name=name;
this.version=0;
}
publicstringName
{ get
{
returnname;
}
}
publicintVersion
{
get
{
returnversion;
}
set
{
version=value;
}
}
publicoverridestringToString()
{
stringvalue="Author : "+Name;
if(version!=0)
{
value+=" Version : "+Version.ToString();
}
returnvalue;
}
privatestringname;
privateintversion;
}

70. Concept of Attributes
[AttributeUsage(AttributeTargets.Class|AttributeTargets.Struct)]
publicclassAuthorAttribute: Attribute
{
publicAuthorAttribute(stringname)
{
this.name=name;
this.version=0;
}
publicstringName
{ get
{
returnname;
}
}
publicintVersion
{
get
{
returnversion;
}
set
{
version=value;
}
}
publicoverridestringToString()
{
stringvalue="Author : "+Name;
if(version!=0)
{
value+=" Version : "+Version.ToString();
}
returnvalue;
}
privatestringname;
privateintversion;
}

71. Concept of Attributes
[AttributeUsage(AttributeTargets.Class|AttributeTargets.Struct)]
publicclassAuthorAttribute: Attribute
{
publicAuthorAttribute(stringname)
{
this.name=name;
this.version=0;
}
publicstringName
{ get
{
returnname;
}
}
publicintVersion
{
get
{
returnversion;
}
set
{
version=value;
}
}
publicoverridestringToString()
{
stringvalue="Author : "+Name;
if(version!=0)
{
value+=" Version : "+Version.ToString();
}
returnvalue;
}
privatestringname;
privateintversion;
}

72. Concept of Attributes
[AttributeUsage(AttributeTargets.Class|AttributeTargets.Struct)]
publicclassAuthorAttribute: Attribute
{
publicAuthorAttribute(stringname)
{
this.name=name;
this.version=0;
}
publicstringName
{ get
{
returnname;
}
}
publicintVersion
{
get
{
returnversion;
}
set
{
version=value;
}
}
publicoverridestringToString()
{
stringvalue="Author : "+Name;
if(version!=0)
{
value+=" Version : "+Version.ToString();
}
returnvalue;
}
privatestringname;
privateintversion;
}

73. Accessing Attributes Through Reflection
[Author("Joe Programmer")]
classAccount
{
// Attach the IsTestedAttributecustom attribute to this method.
[IsTested]
publicvoidAddOrder(OrderorderToAdd)
{
orders.Add(orderToAdd);
}
privateArrayListorders=newArrayList();
}
[Author("Jane Programmer", Version=2), IsTested()]
classOrder
{
// add stuff here...
}

74. Accessing Attributes Through Reflection
[Author("Joe Programmer")]
classAccount
{
// Attach the IsTestedAttributecustom attribute to this method.
[IsTested]
publicvoidAddOrder(OrderorderToAdd)
{
orders.Add(orderToAdd);
}
privateArrayListorders=newArrayList();
}
[Author("Jane Programmer", Version=2), IsTested()]
classOrder
{
// add stuff here...
}

75. Accessing Attributes Through Reflection
[Author("Joe Programmer")]
classAccount
{
// Attach the IsTestedAttributecustom attribute to this method.
[IsTested]
publicvoidAddOrder(OrderorderToAdd)
{
orders.Add(orderToAdd);
}
privateArrayListorders=newArrayList();
}
[Author("Jane Programmer", Version=2), IsTested()]
classOrder
{
// add stuff here...
}

76. Accessing Attributes Through Reflection
classMainClass
{
privatestaticboolIsMemberTested(MemberInfomember)
{
foreach(objectattributeinmember.GetCustomAttributes(true))
{
if(attributeisIsTestedAttribute)
{
returntrue;
}
}
returnfalse;
}
privatestaticvoidDumpAttributes(MemberInfomember)
{
Console.WriteLine("Attributes for : "+member.Name);
foreach(objectattributeinmember.GetCustomAttributes(true))
{
Console.WriteLine(attribute);
}
}

77. Concept of Attributes
publicstaticvoidmain()
{ DumpAttributes(typeof(Account));
foreach(MethodInfomethodin(typeof(Account)).GetMethods())
{
if(IsMemberTested(method))
{
Console.WriteLine("Member {0} is tested!", method.Name);
}
else
{
Console.WriteLine("Member {0} is NOT tested!", method.Name);
}
}
Console.WriteLine();
// display attributes for Order class
DumpAttributes(typeof(Order));
// display attributes for methods on the Order class
foreach(MethodInfomethodin(typeof(Order)).GetMethods())
{
if(IsMemberTested(method))
{
Console.WriteLine("Member {0} is tested!", method.Name);
}
else
{
Console.WriteLine("Member {0} is NOT tested!", method.Name);
}
}
Console.WriteLine(); } }

78. Concept of Attributes
publicstaticvoidmain()
{ DumpAttributes(typeof(Account));
foreach(MethodInfomethodin(typeof(Account)).GetMethods())
{
if(IsMemberTested(method))
{
Console.WriteLine("Member {0} is tested!", method.Name);
}
else
{
Console.WriteLine("Member {0} is NOT tested!", method.Name);
}
}
Console.WriteLine();
// display attributes for Order class
DumpAttributes(typeof(Order));
// display attributes for methods on the Order class
foreach(MethodInfomethodin(typeof(Order)).GetMethods())
{
if(IsMemberTested(method))
{
Console.WriteLine("Member {0} is tested!", method.Name);
}
else
{
Console.WriteLine("Member {0} is NOT tested!", method.Name);
}
}
Console.WriteLine(); } }

79. Concept of Attributes
publicstaticvoidmain()
{ DumpAttributes(typeof(Account));
foreach(MethodInfomethod in (typeof(Account)).GetMethods())
{
if (IsMemberTested(method))
{
Console.WriteLine("Member {0} is tested!", method.Name);
}
else
{
Console.WriteLine("Member {0} is NOT tested!", method.Name);
}
}
Console.WriteLine();
// display attributes for Order class
DumpAttributes(typeof(Order));
// display attributes for methods on the Order class
foreach(MethodInfomethod in (typeof(Order)).GetMethods())
{
if (IsMemberTested(method))
{
Console.WriteLine("Member {0} is tested!", method.Name);
}
else
{
Console.WriteLine("Member {0} is NOT tested!", method.Name);
}
}
Console.WriteLine(); } }

80. Accessing Attributes Through Reflection
Attributes for : Account
Author : Joe Programmer
Member AddOrderis tested!
Member ToStringis NOT tested!
Member Equals is NOT tested!
Member GetHashCodeis NOT tested!
Member GetTypeis NOT tested!
Attributes for : Order
Author : Jane Programmer Version : 2
Is Tested
Member ToStringis NOT tested!
Member Equals is NOT tested!
Member GetHashCodeis NOT tested!
Member GetTypeis NOT tested!
Press any key to continue...

81. http://www.mohammadshaker.com
mohammadshakergtr@gmail.com
https://twitter.com/ZGTRShaker@ZGTRShakerhttps://de.linkedin.com/pub/mohammad-shaker/30/122/128/
http://www.slideshare.net/ZGTRZGTR
https://www.goodreads.com/user/show/11193121-mohammad-shaker
https://plus.google.com/u/0/+MohammadShaker/
https://www.youtube.com/channel/UCvJUfadMoEaZNWdagdMyCRA
http://mohammadshakergtr.wordpress.com/