Effective C# Item42：利用特性简化反射

    当我们在构建基于反射的系统时，我们应该为期望使用的类型、方法和属性创建定制特性，从而简化对它们的访问。定制特性描述了我们对于“方法如何在运行时被使用”所做的期望，它可以测试目标对象的某些属性，可以将“伴随反射发生的拼写错误”的可能性降至最低。

    当我们需要通过反射来访问某种类型的对象时，需要加载某个dll文件中的程序集，然后遍历程序集中的类型，由于程序集中的类型会非常多，如何确定遍历的类型是我们需要的类型呢？如果在类型中，添加一个定制特性，那么我们可以通过对类型特性的判断，来确定这个类型是否是我们需要的类型。

    来看下面的代码。

// Find all the assemblies in the Add-ins directory:
 string AddInsDir = string.Format( "{0}/Addins", Application.StartupPath);
 string[] assemblies = Directory.GetFiles( AddInsDir, "*.dll" );
 foreach ( string assemblyFile in assemblies )
{
  Assembly asm = Assembly.LoadFrom( assemblyFile );
  // Find and install command handlers from the assembly.
   foreach( System.Type t in asm.GetExportedTypes( ))
  {
    if (t.GetCustomAttributes(
      typeof( CommandHandlerAttribute ), false ).Length > 0 )
    {
      // Found the command handler attribute on this type.
      // This type implements a command handler.
      // configure and add it.
     }
    // Else, not a command handler. Skip it.
   }
}

    上面代码中说明，如果指定类型中包含CommandHandlerAttribute特性，那么这个类型就是我们期望的类型。

    定制特性除了可以标识期望类型外，它还有其他作用，我们可以利用特性构造函数来设置业务中使用的一些数据，虽然这样做有时不是很合适。

    来看以下的代码。

[AttributeUsage( AttributeTargets.Property ) ]
 public class DynamicMenuAttribute : System.Attribute
{
  private string _menuText;
  private string _parentText;

  public DynamicMenuAttribute( string CommandText,
    string ParentText )
  {
    _menuText = CommandText;
    _parentText = ParentText;
  }

  public string MenuText
  {
    get { return _menuText; }
    set { _menuText = value; }
  }

  public string ParentText
  {
    get { return _parentText; }
    set { _parentText = value; }
  }
}

    上面代码定义了一个定制特性，其中包含了两个属性，下面的代码说明了如何使用这个特性。

// Find the types in the assembly
 foreach( Type t in asm.GetExportedTypes( ) )
{
  if (t.GetCustomAttributes(
    typeof( CommandHandlerAttribute ), false).Length > 0 )
  {
    // Found a command handler type:
     ConstructorInfo ci =
      t.GetConstructor( new Type[0] );
    if ( ci == null ) // No default ctor
      continue;
    object obj = ci.Invoke( null );
    PropertyInfo [] pi = t.GetProperties( );

    // Find the properties that are command
    // handlers
    foreach( PropertyInfo p in pi )
    {
      string menuTxt = "";
      string parentTxt = "";
      object [] attrs = p.GetCustomAttributes(
        typeof ( DynamicMenuAttribute ), false );
      foreach ( Attribute at in attrs )
      {
        DynamicMenuAttribute dym = at as 
          DynamicMenuAttribute;
        if ( dym != null )
        {
          // This is a command handler.
          menuTxt = dym.MenuText;
          parentTxt = dym.ParentText;
          MethodInfo mi = p.GetGetMethod();
          EventHandler h = mi.Invoke( obj, null )
            as EventHandler;
          UpdateMenu( parentTxt, menuTxt, h );
        }
      }
    }
  }
}

private void UpdateMenu( string parentTxt, string txt,
  EventHandler cmdHandler )
{
  MenuItem menuItemDynamic = new MenuItem();
  menuItemDynamic.Index = 0;
  menuItemDynamic.Text = txt;
  menuItemDynamic.Click += cmdHandler;

  //Find the parent menu item.
  foreach ( MenuItem parent in mainMenu.MenuItems )
  {
    if ( parent.Text == parentTxt )
    {
      parent.MenuItems.Add( menuItemDynamic );
      return;
    }
  }
  // Existing parent not found:
  MenuItem newDropDown = new MenuItem();
  newDropDown.Text = parentTxt;
  mainMenu.MenuItems.Add( newDropDown );
  newDropDown.MenuItems.Add( menuItemDynamic );
}

    一般来说，是不会在定制特性中包含业务数据的，上述代码只是说明的作用。

 

    特性实际上声明的是我们在运行时的意图，在一个元素上标记特性可以描述它的用途，以及降低在运行时查找该元素的难度，如果没有特性，我们就需要定义某种命名约定，来支持在运行时查找类型及其元素，命名约定是错误的源头，用特性来表达意图可以将更多的责任由开发人员转移到编译器上。

    我们通常使用反射来创建可以被重新配置的动态代码。通过设计和实现特性类，强制开发人员用它们来声明可以被动态使用的类型、方法和属性，可以减少应用程序的运行时错误。