0

DTOを比較する方法は次のとおりです。

bool Equals<T1, T2>(T1 t1, T2 t2, params Expression<Func<T1, object>>[] accessors)
{
  return !(
    from accessor in accessors 
    select ((MemberExpression) accessor.Body).Member.Name into propertyName 
    let p1 = typeof (T1).GetProperty(propertyName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) 
    let p2 = typeof (T2).GetProperty(propertyName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) 
    let p1val = p1.GetValue(t1, null) 
    let p2val = p2.GetValue(t2, null) 
    where !Equals(p1val, p2val) 
    select p1val
  ).Any();
}

これは、（慣例により同じプロパティを共有するが、同じオブジェクトではないオブジェクトのインスタンスです）を使用aして呼び出すことができます。b

Equals(a, b, x => x.PropertyOne, x => x.PropertyTwo );

これは、オブジェクトのプロパティをプロパティごとに比較します。これはほとんどの場合問題ありません。

しかし、複合型のプロパティを持つオブジェクトを比較する必要があり、オブジェクトではなく複合型のプロパティを比較したい場合がありました。このようなもの：

Equals(a, b, x => x.ComplexTypeProperty.ChildProp );

快適なリフレクション比較を離れてエクスプレッションランドに入る必要があることに気づきましたが、ここでの主なタスクは、複合型プロパティを介してプロパティアクセサーとプロパティアクセサーの両方を表現できるようにすることであり、そこで迷子になります。

どんなポインタでもいいでしょう、ありがとう！

4

1 に答える 1

1

タスクはそれほど複雑ではありません：

  1. 式によって与えられるプロパティパスまたは式を決定します。たとえば、この拡張メソッドはこれを提供します：

    public static IEnumerable<string> GetPropertiesNames<T, G>(this Expression<Func<T, G>> pathExpression)
{
    List<string> _propertyNames = new List<string>();

    Expression expression = pathExpression.Body;

    if (expression.NodeType == ExpressionType.Convert)
    {
        var convert = (UnaryExpression)pathExpression.Body;
        expression = convert.Operand;
    }

    while (expression.NodeType == ExpressionType.MemberAccess)
    {
        MemberExpression memberExpression = (MemberExpression)expression;
          if(!(memberExpression.Member is PropertyInfo)) 
                throw new InvalidOperationException();
        _propertyNames.Add(memberExpression.Member.Name);
        expression = memberExpression.Expression;
    }

    if (expression.NodeType != ExpressionType.Parameter)
        throw new InvalidOperationException();

    return _propertyNames;
}

  2. 2番目のタイプの式を集計して、値を返す関数を作成します。

    var parameter = Expression.Parameter(typeof(T2));      
var expressionToConvert =  accessors[0]; //for future loop

    var propertyChainDescriptor = expressionToConvert.GetPropertiesNames() 
         .Aggregate(new { Expression = (Expression)parameterCasted, Type = typeof(T2)},
             (current, propertyName) =>
             {
                 var property = current.Type.GetProperty(propertyName);
                 var expression = Expression.Property(current.Expression, property);
                 return new { Expression = (Expression)expression, Type = property.PropertyType };
             });

    var body = propertyChainDescriptor.Expression;

    if (propertyChainDescriptor.Type.IsValueType)
    {
        body = Expression.Convert(body, typeof(object));
    }

    var t2PropertyRetriver = Expression.Lambda<Func<T2, object>>(body, parameter).Compile();

  3. 次に、値を取得して比較するメソッドを実行します。

        var t1PropertyRetriver = accessor[0].Compile();
    var t1Value = t1PropertyRetriver(t1);
    var t2Value = t2PropertyRetriver(t2);

    var areEqual = object.Equals(t1Value,t2Value);

コンパイルプロセスはコストがかかるため、生成されたメソッドのキャッシュを追加することをお勧めします。

于 2012-10-02T12:53:51.240 に答える