C # Tutorial C # Reflection (Reflection)

C # Reflection (Reflection)

The Reflection (Reflection) object is used to obtain type information at run time. The class is located in the System.Reflection namespace and can access the metadata of a running program.

The System.Reflection namespace contains classes that allow you to get information about your application and add types, values, and objects to your application dynamically.

Use of Reflection (Reflection)

Reflection (Reflection) has the following uses:

It allows you to view the property (attribute) information at run time.

It allows you to review the various types in the collection, as well as instantiate these types.

It allows lazy binding of methods and properties.

It allows you to create new types at run time and then use those types to perform some tasks.

View Meta data

We have already mentioned in the previous section that using Reflection (Reflection), you can view the properties (attribute) information.

The MemberInfo object of the System.Reflection class needs to be initialized to discover properties related to the Class (attribute). To do this, you can define an object of the target class, as follows:

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

The following program demonstrates this:

using System;

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

    public string Topic // Topic is a named parameter
    {
       get
       {
          return topic;
       }
       set
       {

          topic = value;
       }
    }

    public HelpAttribute (string url) // url is a 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 displays the custom attributes attached to the class MyClass:

HelpAttribute

Instance

In this example, we will use the Debuginfo property created in the previous chapter and use Reflection (Reflection) to read the metadata in the Rectangle class.

using System;
using System.Reflection;
namespace BugFixApplication
{
   // A custom attribute BugFix 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 properties of the Rectangle class
         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);
            }
         }
         
         // Traverse method properties
         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: 

The above is the "C # Tutorial" C # Reflection (Reflection) of the content, more relevant content please pay attention to topic.alibabacloud.com (www.php.cn)!

