0

我有这个：

public void AssertReadWorks<T>(
    IRepository<T> repository, 
    T entity, 
    Expression<Func<T, T, bool>> keyComparer) where T : class
{
    entity = repository.GetAll().Single(x => x.Id == entity.Id);
}

[TestMethod]
public void ReadTest_DataFieldGroup()
{
    AssertReadWorks(
            _unitOfWork.DataFieldSetRepository, 
            new DataFieldSet { Label = "test", Title = "test" }, 
            (a, b) => a.Id == b.Id);
}

这不会编译，因为不知道 T 具有 Id 属性。请注意，该keyComparer参数目前未使用。我想使用 keyComparer 参数（或另一个适当的参数）来动态生成谓词Single()：

Expression<Func<T, bool>> keyComparingPredicate = 
    x => a predicate that compares the key of x with the key of `entity`;
entity = repository.GetAll().Single(keyComparingPredicate);

关键是不是所有的 T 都会有 Id 属性，有些会有不同的名字，有些会有复合键。AssertReadWorks()如果它不是通用的，则原件可以正常工作。问题只是在一般情况下动态构建谓词。如果它可以用与 keyComparer 参数不同的东西来完成，我很好。

有任何想法吗？:)

4

2 回答 2

1

检查，如果这适合你

public T AssertReadWorks<T>(
    IRepository<T> repository,
    Func<T, bool> keyComparer)
{
    return repository.GetAll().Single(keyComparer);
}

使用

[TestMethod]
public void TestInt()
{
    var repository = new Repository<int>( new[] {1, 2, 3} );
    var intEntity = 3;
    AssertReadWorks(repository, e => e == intEntity);
}

[TestMethod]
public void TestString()
{
    var repository = new Repository<string>(new[] { "a", "b", "c" });
    var stringEntity = "A";
    AssertReadWorks(repository, e => string.Equals(e, stringEntity, StringComparison.OrdinalIgnoreCase));
}

[TestMethod]
public void TestThread()
{
    var threadEntity = new Thread(() => { });
    var repository = new Repository<Thread>(new[] { threadEntity, new Thread(() => { }), new Thread(() => { }) });
    AssertReadWorks(repository, e => e.ManagedThreadId == threadEntity.ManagedThreadId);
}

编辑： 评论回复：

public void AssertReadWorks<T>(
    IRepository<T> repository,
    ref T entity,
    Func<T, T, bool> keyComparer)
{
    var localEntity = entity;
    entity = repository.GetAll().Single(e => keyComparer(e, localEntity));
}
于 2013-06-07T10:09:08.200 回答
0

如果我错了，请纠正我，但这个函数的重点是检查平等吗？要在一般意义上做到这一点，您可以使用IEquatable Interface。这样，您的对象就知道如何将自己与同一个对象进行比较。这应该会减少您的代码重用，并有助于避免在多个地方创建相同的表达式。

所以你的班级看起来像这样：

public class DataFieldSet : IEquatable<DataFieldSet>
{
    public int Id { get; set; }

    public bool Equals(DataFieldSet other)
    {
        return other != null && this.Id == other.Id;
    }
}

还有你的 Assert 函数

public void AssertReadWorks<T>(
    IRepository<T> repository, 
    T entity) where T : IEquatable<T>
{
    entity = repository.GetAll().Single(x => entity.Equals(x);
}
于 2013-06-07T09:00:40.983 回答