今天就平常用到的非常多的反射这个技术来做一个总结，当然关于反射需要讲解的东西实在是太多的内容，在一片文章中想要讲解清楚是非常难的，本篇博客也是就自己本人对这些内容学习后的一个总结，当然包括看书和自己写过的一些代码中抽取的一些示例，而且本文也仅限于此时对于这个知识点的理解，希望通过以后的逐步学习能够不断加深对这个知识点的理解。
首先来看看对于反射的基础知识点。
1 定义：首先看看MSDN怎样对它进行解释吧
反射提供了封装程序集、模块和类型的对象（Type 类型）。可以使用反射动态创建类型的实例，将类型绑定到现有对象，或从现有对象获取类型并调用其方法或访问其字段和属性。如果代码中使用了属性，可以利用反射对它们进行访问。
2 反射有什么作用？
A、将类型绑定到现有对象，或从现有对象中获取类型信息，这些信息包括(Assembly MemberInfo EventInfo FieldInfo MethodBase ConstructorInfo MethodInfo PropertyInfo 等等 )另外可以使用反射动态地创建类型的实例，
例如：
1、System.Activator 的CreateInstance方法。该方法返回新对象的引用。
2、System.Activator 的CreateInstanceFrom 与上一个方法类似，不过需要指定类型及其程序集
3、System.Appdomain 的方法：CreateInstance,CreateInstanceAndUnwrap,CreateInstranceFrom和CreateInstraceFromAndUnwrap
4、System.Type的InvokeMember 实例方法：这个方法返回一个与传入参数相符的构造函数，并构造该类型。
5、System.Reflection.Constructinfo 的Invoke实例方法
下面通过一段代码来了解这5种创建实例的方法
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Diagnostics;
using OptimizeReflection;
using System.Collections;
using System.Web;
namespace TestOptimizeReflection
{
public class OrderInfo
{
public int OrderID { get; set; }
public DateTime OrderDate { get; set; }
public decimal SumMoney { get; set; }
public string Comment { get; set; }
public bool Finished { get; set; }
public int Add(int a, int b)
{
return a + b;
}
}
class Program
{
static void Main()
{
TestNewInstance();
}
static void TestNewInstance()
{
//常规方法创建对象
OrderInfo testObj = new OrderInfo();
#region 常规反射创建
//利用反射来动态创建对象
Type instanceType = typeof(OrderInfo);
OrderInfo orderInfo = (OrderInfo)Activator.CreateInstance(instanceType);
#endregion
#region Activator.CreateInstanceFrom 创建
//注意Assembly.GetEntryAssembly().CodeBase表示当前执行的exe所在的路径，instanceType.FullName表示当前OrderInfo的类型名称TestOptimizeReflection.OrderInfo
System.Runtime.Remoting.ObjectHandle oh= Activator.CreateInstanceFrom(Assembly.GetEntryAssembly().CodeBase, instanceType.FullName);
//返回被包装的对象
OrderInfo orderInfoEx = (OrderInfo)oh.Unwrap();
#endregion
#region System.AppDomain.CurrentDomain实例创建对象
System.Runtime.Remoting.ObjectHandle ohEx = System.AppDomain.CurrentDomain.CreateInstance(Assembly.GetEntryAssembly().FullName, instanceType.FullName);
OrderInfo orderInfoExEx = (OrderInfo)ohEx.Unwrap();
//合并上面的两步
OrderInfo orderInfoExExEx = (OrderInfo)System.AppDomain.CurrentDomain.CreateInstanceAndUnwrap(Assembly.GetEntryAssembly().FullName, instanceType.FullName);
#endregion
#region InvokeMember方法创建实例
OrderInfo invokeMemberOrderInfo = (OrderInfo)instanceType.InvokeMember(null, BindingFlags.Public| BindingFlags.Instance | BindingFlags.Static|BindingFlags.CreateInstance, System.Type.DefaultBinder, null, null);
#endregion
#region 调用构造器创建
//调用无参数的默认构造函数
ConstructorInfo ci = instanceType.GetConstructor(new Type[] { });
OrderInfo ciOrderInfo = (OrderInfo)ci.Invoke(null);
#endregion
}
}
}
B、应用程序需要在运行时从某个特定的程序集中载入一个特定的类型，以便实现某个任务时可以用到反射。
这个该怎样去理解呢？这个可以用插件系统中的同类思想去解释，在构建插件系统的时候，我们有时候需要主程序去动态地调用插件，可能应用程序只有在执行某一操作的时候才能够去调用相关的DLL，这个时候我们就可以通过反射这种方式来动态调用dll中分特定方法或者类型，这个也是经常使用到的。
C、反射主要应用与类库，这些类库需要知道一个类型的定义，以便提供更多的功能。
D、反射能够调用一些私有方法和字段等。
这个需要重点去讲述，我们知道常规的实例方法由于受到作用域的影响，很多时候当方法设置为Private或者是其它的限制访问的关键字时就无能为力了，这个也是完全能够体现类的封装性，但是通过反射就能够完全绕开这些限制，下面举出一些对私有变量或字段、方法的一些访问方式，能够直接进行访问，这样还是非常方便的，具体请参考下面的代码。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
namespace Dvap.Infrastructure.Utils
{
public static class ReflectionUtil
{
/// <summary>
/// 得到私有字段的值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="instance"></param>
/// <param name="fieldname"></param>
/// <returns></returns>
public static T GetPrivateField<T>(this object instance, string fieldname)
{
BindingFlags flag = BindingFlags.Instance | BindingFlags.NonPublic;
Type type = instance.GetType();
FieldInfo field = type.GetField(fieldname, flag);
return (T)field.GetValue(instance);
}
/// <summary>
/// 设置私有成员的值
/// </summary>
/// <param name="instance"></param>
/// <param name="fieldname"></param>
/// <param name="value"></param>
public static void SetPrivateField(this object instance, string fieldname, object value)
{
BindingFlags flag = BindingFlags.Instance | BindingFlags.NonPublic;
Type type = instance.GetType();
FieldInfo field = type.GetField(fieldname, flag);
field.SetValue(instance, value);
}
/// <summary>
/// 得到私有属性的值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="instance"></param>
/// <param name="propertyname"></param>
/// <returns></returns>
public static T GetPrivateProperty<T>(this object instance, string propertyname)
{
BindingFlags flag = BindingFlags.Instance | BindingFlags.NonPublic;
Type type = instance.GetType();
PropertyInfo field = type.GetProperty(propertyname, flag);
return (T)field.GetValue(instance, null);
}
/// <summary>
/// 设置私有属性的值
/// </summary>
/// <param name="instance"></param>
/// <param name="propertyname"></param>
/// <param name="value"></param>
public static void SetPrivateProperty(this object instance, string propertyname, object value)
{
BindingFlags flag = BindingFlags.Instance | BindingFlags.NonPublic;
Type type = instance.GetType();
PropertyInfo field = type.GetProperty(propertyname, flag);
field.SetValue(instance, value, null);
}
/// <summary>
/// 调用私有方法
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="instance"></param>
/// <param name="name"></param>
/// <param name="param"></param>
/// <returns></returns>
public static T CallPrivateMethod<T>(this object instance, string name, params object[] param)
{
BindingFlags flag = BindingFlags.Instance | BindingFlags.NonPublic;
Type type = instance.GetType();
MethodInfo method = type.GetMethod(name, flag);
return (T)method.Invoke(instance, param);
}
}
}
E 还可以通过反射来获取属性或者类上的特性
有时候我们需要在类或者属性上面添加自定义的特性，并且通过反射能够获取到这些特性，那么这个时候我们就可以使用反射来达到目的了。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Diagnostics;
using OptimizeReflection;
using System.Collections;
using System.Web;
namespace TestOptimizeReflection
{
/// <summary>
/// 自定义特性 属性或者类可用 支持继承
/// </summary>
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Class, Inherited = true)]
public class EnitityMappingAttribute : Attribute
{
private string tableName;
/// <summary>
/// 实体实际对应的表名
/// </summary>
public string TableName
{
get { return tableName; }
set { tableName = value; }
}
private string columnName;
/// <summary>
/// 中文列名
/// </summary>
public string ColumnName
{
get { return columnName; }
set { columnName = value; }
}
}
/// <summary>
/// 会员 ，实际的表名叫MemberInfo，并不是和实体名一致
/// </summary>
[EnitityMapping(TableName = "MemberInfo")]
public class Member
{
private int id;
[EnitityMapping(ColumnName = "关键字")]
public int Id
{
get { return id; }
set { id = value; }
}
private string userName;
[EnitityMapping(ColumnName = "会员注册名")]
public string UserName
{
get { return userName; }
set { userName = value; }
}
private string realName;
[EnitityMapping(ColumnName = "会员真实名")]
public string RealName
{
get { return realName; }
set { realName = value; }
}
private bool isActive;
/// <summary>
/// 是否活跃 没有附加自定义属性
/// </summary>
public bool IsActive
{
get { return isActive; }
set { isActive = value; }
}
}
class Program
{
/// <summary>
/// 通过反射取自定义属性
/// </summary>
/// <typeparam name="T"></typeparam>
private static void DisplaySelfAttribute<T>() where T : class, new()
{
string tableName = string.Empty;
List<string> listColumnName = new List<string>();
Type objType = typeof(T);
//取属性上的自定义特性
foreach (PropertyInfo propInfo in objType.GetProperties())
{
object[] objAttrs = propInfo.GetCustomAttributes(typeof(EnitityMappingAttribute), true);
if (objAttrs.Length > 0)
{
EnitityMappingAttribute attr = objAttrs[0] as EnitityMappingAttribute;
if (attr != null)
{
listColumnName.Add(attr.ColumnName); //列名
}
}
}
//取类上的自定义特性
object[] objs = objType.GetCustomAttributes(typeof(EnitityMappingAttribute), true);
foreach (object obj in objs)
{
EnitityMappingAttribute attr = obj as EnitityMappingAttribute;
if (attr != null)
{
tableName = attr.TableName;//表名只有获取一次
break;
}
}
if (string.IsNullOrEmpty(tableName))
{
tableName = objType.Name;
}
Console.WriteLine(string.Format("The TableName of the entity is:{0} ", tableName));
if (listColumnName.Count > 0)
{
Console.WriteLine("The Columns of the table are as follows:");
foreach (string item in listColumnName)
{
Console.WriteLine(item);
}
}
}
static void Main()
{
DisplaySelfAttribute<Member>(); //显示结果
Console.ReadLine();
}
}
}
最终呈现的效果：
这里简单说一下AttributeUsage的一些用法，AttributeUsage 有三个 属性 ，分别是
public bool AllowMultiple { get; set; } 作用：是否能在一个目标身上多次使用
public bool Inherited { get; set; } 作用 ：特性是否能继承到子类身上
public AttributeTargets ValidOn { get; } 作用：设置特性的可使用范围
这里面就是要解释一下AttributeTargets 的特性使用范围，这个主要是用在继承自Attribute的子类里面，在本例中我们自定义的特性主要用于标识类和属性
public enum AttributeTargets
{
// 摘要:
// 可以对程序集应用特性。
Assembly = 1,
//
// 摘要:
// 可以对模块应用特性。
Module = 2,
//
// 摘要:
// 可以对类应用特性。
Class = 4,
//
// 摘要:
// 可以对结构应用特性，即值类型。
Struct = 8,
//
// 摘要:
// 可以对枚举应用特性。
Enum = 16,
//
// 摘要:
// 可以对构造函数应用特性。
Constructor = 32,
//
// 摘要:
// 可以对方法应用特性。
Method = 64,
//
// 摘要:
// 可以对属性应用特性。
Property = 128,
//
// 摘要:
// 可以对字段应用特性。
Field = 256,
//
// 摘要:
// 可以对事件应用特性。
Event = 512,
//
// 摘要:
// 可以对接口应用特性。
Interface = 1024,
//
// 摘要:
// 可以对参数应用特性。
Parameter = 2048,
//
// 摘要:
// 可以对委托应用特性。
Delegate = 4096,
//
// 摘要:
// 可以对返回值应用特性。
ReturnValue = 8192,
//
// 摘要:
// 可以对泛型参数应用特性。
GenericParameter = 16384,
//
// 摘要:
// 可以对任何应用程序元素应用特性。
All = 32767,
}