C# Reflection

Reflection refers to the ability of a program to access, inspect, and modify its own state or behavior.

Assemblies contain modules, modules contain types, and types contain members. Reflection provides objects 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. Then, you can call the type's methods or access its fields and properties.

Advantages and Disadvantages

Advantages:

1. Reflection improves the flexibility and extensibility of programs.
2. It reduces coupling and improves self-adaptability.
3. It allows programs to create and control objects of any class without hard-coding the target class in advance.

Disadvantages:

1. Performance issues: Using reflection is essentially an interpretive operation, which is much slower than direct code when accessing fields and methods. Therefore, reflection is mainly used in system frameworks that require high flexibility and extensibility; it is not recommended for ordinary programs.
2. Using reflection obscures the internal logic of programs; programmers expect to see the program logic in the source code, but reflection bypasses source code techniques, thus causing maintenance issues. Reflection code is more complex than equivalent direct code.

Purpose of Reflection

Reflection has the following uses:

It allows you to view attribute information at runtime.
It allows you to examine the various types in an assembly and instantiate those types.
It allows late binding of methods and properties.
It allows you to create new types at runtime and then use these types to perform some tasks.

View metadata

As we mentioned in the previous chapters, reflection can be used to view attribute information.

System.ReflectionClassMemberInfoAn object needs to be initialized in order to discover the attributes associated with the class. 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:

Example

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 aPositioning（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 attributes attached to the classMyClassThe custom attributes on:

HelpAttribute

Example

In this example, we will use what was created in the previous chapter.DeBugInfoattributes, and use reflection to read themRectangleMetadata in the class.

Example

using System;
using System.Reflection;
namespace BugFixApplication
{
// aCustomFeatures BugFix By赋Giveclass anditsmember
[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);
// Iterate through the attributes 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);
}
}

// Iteration method features
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:

other extensions