c#迭代父类型数组以在派生类型上调用非多态方法

Question

我使用非常相似的循环来迭代任何传递对象的所有公共字段和属性.我确定字段/属性是否使用特定的自定义属性进行修饰; 如果是,则对字段或属性的值执行操作.需要两个循环,因为获取字段值的方法与获取属性值的方法不同.

// Iterate all public fields using reflection
foreach (FieldInfo fi in obj.GetType().GetFields())
{
  // Determine if decorated with MyAttribute.
  var attribs = fi.GetCustomAttributes(typeof(MyAttribute), true);
  if (attribs.Length == 1)
  {
    // Get value of field.
    object value = fi.GetValue(obj);
    DoAction(value);
  }
}

// Iterate all public properties using reflection
foreach (PropertyInfo pi in obj.GetType().GetProperties())
{
  // Determine if decorated with MyAttribute.
  var attribs = pi.GetCustomAttributes(typeof(MyAttribute), true);
  if (attribs.Length == 1)
  {
    // Get value of property.
    object value = pi.GetValue(obj, null);
    DoAction(value);
  }
}

我想将循环放在一个通用的方法中,以便我可以更简单地编写:

DoEachMember(obj.GetType().GetFields());
DoEachMember(obj.GetType().GetProperties());

这需要DoEachMember()接受MemberInfo类型(两者的父类型FieldInfo和PropertyInfo).问题是班上没有GetValue方法MemberInfo.双方FieldInfo并PropertyInfo使用不同的方法来获得字段/属性值:

public void DoEachMember(MemberInfo mi, object obj)
{
  foreach (MemberInfo mi in obj.GetType().GetProperties())
  {
    object value mi.GetValue(obj); // NO SUCH METHOD!
  }
}

因此,我声明一个委托在循环中使用,它接受MemberInfo并返回该成员的值作为对象:

// Delegate to get value from field or property.
delegate object GetValue(MemberInfo mi, object obj);

问题

如何检测members[]数组中对象的类型,以便定义循环内使用的委托？目前,我正在使用数组的第一个元素,members[0].这是一个很好的设计吗？

public void DoEachMember(MemberInfo[] members, object obj)
{
  // Protect against empty array.
  if (members.Length == 0) return;

  GetValue getValue; // define delegate

  // First element is FieldInfo
  if (members[0] as FieldInfo != null)
    getValue = (mi, obj) => ((FieldInfo)mi).GetValue(obj);

  // First element is PropertyInfo
  else if (members[0] as PropertyInfo != null)
    getValue = (mi, obj) => ((PropertyInfo)mi).GetValue(obj, null);

  // Anything else is unacceptable
  else
    throw new ArgumentException("Must be field or property.");

  foreach (MemberInfo mi in members)
  {
    // Determine if decorated with MyAttribute.
    var attribs = mi.GetCustomAttributes(typeof(MyAttribute), true);
    if (attribs.Length == 1)
    {
      object value = getValue(mi, obj);
      DoStuff(value);
    }
  }
}

或者,我可以在每次迭代时检测到类型,但是单个数组成员应该没有理由不同:

foreach (MemberInfo mi in members)
{
  // ...

  object value;

  if ((var fi = mi as FieldInfo) != null)
    value = fi.GetValue(obj);

  else if ((var pi = mi as PropertyInfo) != null)
    value = pi.GetValue(obj, null);

  else
    throw new ArgumentException("Must be field or property.");

  DoStuff(value);
}

Answer 1

您可以先投影到对象值，然后在循环中处理这些值。你的整个代码可以归结为这个（加上你的循环）：

    /// <summary>
    /// Gets the value of all the fields or properties on an object that are decorated with the specified attribute
    /// </summary>
    private IEnumerable<object> GetValuesFromAttributedMembers<TAttribute>(object obj)
        where TAttribute : Attribute
    {
        var values1 = obj.GetType().GetFields()
                        .Where(fi => fi.GetCustomAttributes(typeof(TAttribute), true).Any())
                        .Select(fi => fi.GetValue(obj));
        var values2 = obj.GetType().GetProperties()
                        .Where(pi => pi.GetCustomAttributes(typeof(TAttribute), true).Any())
                        .Select(pi => pi.GetValue(obj, null));
        return values1.Concat(values2);
    }

您当前的代码混合了两个问题：查找值并用它们做一些事情。将这些问题分开会更清晰。上面的 LINQ 可以放置在一个方法中，该方法从类中获取与给定属性匹配的字段或属性中的所有值，而另一个方法则只是一个循环，对传递的任何内容进行处理。

不太干净，但坚持您最初的目标，您可以执行此操作并传入适合您正在检索的 MemberInfo 类型的委托：-

    public void DoEachMember<TAttribute, TMembertype>(IEnumerable<TMembertype> members,
                             Func<TMembertype, object> valueGetter)
        where TMembertype : MemberInfo
    {
        foreach (var mi in members)
        {
            if (mi.GetCustomAttributes(typeof(TAttribute), true).Any())
            {
                // Get value of field.
                object value = valueGetter(mi);
                DoAction(value);
            }
        }
    }