Latest web development tutorials

C # reflection (Reflection)

Reflection means can access the program, its ability to detect and modify their own state or behavior.

Assembly contains the module, which contains types, which in turn contains members. Reflection provides an object package assemblies, modules and types.

You can use reflection to dynamically create an instance of the type, the type is bound to an existing object, or get the type from an existing object. You can then call the type of approach or access its fields and properties.

Pros and cons

advantage:

  • 1, reflecting improved process flexibility and scalability.
  • 2, reduce coupling, increase adaptive capacity.
  • 3, which allows the program to create and control any type of object, without prior hard-coded target class.

Disadvantages:

  • 1, performance problems: use is essentially a reflection explaining the operation, when the fields and methods for access to much slower than direct code. Thus reflection on the main application flexibility and scalability demanding framework, the general procedure is not recommended.
  • 2, the use of fuzzy reflections within the program logic; programmers want to see the logic in the source code, but reflection bypass the source code technology, which will bring maintenance issues, and reflection code more complex than the corresponding code directly .

Reflex (Reflection) uses

Reflex (Reflection) for the following purposes:

  • It allows you to view properties at runtime (attribute) information.
  • It allows reviewing the collection of various types, as well as examples of these types.
  • It allows late binding of methods and properties (property).
  • It allows the creation of a new type at run time, and then using these types perform some tasks.

View Metadata

We have already mentioned in the section above, the use of reflection (Reflection) can view the properties (attribute) information.

ObjectSystem.Reflection MemberInfoclass needs to be initialized, for discovering the properties associated with the class (attribute). To do this, you can define a target object class, as follows:

System.Reflection.MemberInfo info = typeof (MyClass);

The following program demonstrates this point:

using System;

[AttributeUsage (AttributeTargets.All)]
public class HelpAttribute: System.Attribute
{
   public readonly string Url;

   public string Topic // Topic is a named (named) parameters {
      get
      {
         return topic;
      }
      set
      {

         topic = value;
      }
   }

   public HelpAttribute (string url) // url is a positioning (positional) parameter {
      this.Url = url;
   }

   private string topic;
}
[HelpAttribute ( "Information on the class MyClass")]
class MyClass
{
}

namespace AttributeAppl
{
   class Program
   {
      static void Main (string [] args)
      {
         System.Reflection.MemberInfo info = typeof (MyClass);
         object [] attributes = info.GetCustomAttributes (true);
         for (int i = 0; i <attributes.Length; i ++)
         {
            System.Console.WriteLine (attributes [i]);
         }
         Console.ReadKey ();

      }
   }
}

When the above code is compiled and executed, it will display the custom properties attached to a classMyClasson:

HelpAttribute

Examples

In this example, we will useDeBugInfoproperty created in the last chapter, and uses reflection (Reflection) to read theRectangleclass metadata.

using System;
using System.Reflection;
namespace BugFixApplication
{
   // BugFix a custom property is assigned to the class and its members [AttributeUsage (AttributeTargets.Class |
   AttributeTargets.Constructor |
   AttributeTargets.Field |
   AttributeTargets.Method |
   AttributeTargets.Property,
   AllowMultiple = true)]

   public class DeBugInfo: System.Attribute
   {
      private int bugNo;
      private string developer;
      private string lastReview;
      public string message;

      public DeBugInfo (int bg, string dev, string d)
      {
         this.bugNo = bg;
         this.developer = dev;
         this.lastReview = d;
      }

      public int BugNo
      {
         get
         {
            return bugNo;
         }
      }
      public string Developer
      {
         get
         {
            return developer;
         }
      }
      public string LastReview
      {
         get
         {
            return lastReview;
         }
      }
      public string Message
      {
         get
         {
            return message;
         }
         set
         {
            message = value;
         }
      }
   }
   [DeBugInfo (45, "Zara Ali", "12/8/2012",
	Message = "Return type mismatch")]
   [DeBugInfo (49, "Nuha Ali", "10/10/2012",
	Message = "Unused variable")]
   class Rectangle
   {
      // Member variables protected double length;
      protected double width;
      public Rectangle (double l, double w)
      {
         length = l;
         width = w;
      }
      [DeBugInfo (55, "Zara Ali", "19/10/2012",
	   Message = "Return type mismatch")]
      public double GetArea ()
      {
         return length * width;
      }
      [DeBugInfo (56, "Zara Ali", "19/10/2012")]
      public void Display ()
      {
         Console.WriteLine ( "Length: {0}", length);
         Console.WriteLine ( "Width: {0}", width);
         Console.WriteLine ( "Area: {0}", GetArea ());
      }
   } // End class Rectangle  
   
   class ExecuteRectangle
   {
      static void Main (string [] args)
      {
         Rectangle r = new Rectangle (4.5, 7.5);
         r.Display ();
         Type type = typeof (Rectangle);
         // Traverse the Rectangle class attributes foreach (Object attributes in type.GetCustomAttributes (false))
         {
            DeBugInfo dbi = (DeBugInfo) attributes;
            if (null! = dbi)
            {
               Console.WriteLine ( "Bug no: {0}", dbi.BugNo);
               Console.WriteLine ( "Developer: {0}", dbi.Developer);
               Console.WriteLine ( "Last Reviewed: {0}",
					dbi.LastReview);
               Console.WriteLine ( "Remarks: {0}", dbi.Message);
            }
         }
         
         // Iterate method attributes foreach (MethodInfo m in type.GetMethods ())
         {
            foreach (Attribute a in m.GetCustomAttributes (true))
            {
               DeBugInfo dbi = (DeBugInfo) a;
               if (null! = dbi)
               {
                  Console.WriteLine ( "Bug no: {0}, for Method: {1}",
						dbi.BugNo, m.Name);
                  Console.WriteLine ( "Developer: {0}", dbi.Developer);
                  Console.WriteLine ( "Last Reviewed: {0}",
						dbi.LastReview);
                  Console.WriteLine ( "Remarks: {0}", dbi.Message);
               }
            }
         }
         Console.ReadLine ();
      }
   }
}

When the above code is compiled and executed, it produces the following results:

Length: 4.5
Width: 7.5
Area: 33.75
Bug No: 49
Developer: Nuha Ali
Last Reviewed: 10/10/2012
Remarks: Unused variable
Bug No: 45
Developer: Zara Ali
Last Reviewed: 12/8/2012
Remarks: Return type mismatch
Bug No: 55, for Method: GetArea
Developer: Zara Ali
Last Reviewed: 19/10/2012
Remarks: Return type mismatch
Bug No: 56, for Method: Display
Developer: Zara Ali
Last Reviewed: 19/10/2012
Remarks: