如何简化重复if-then-assign构造？

Question

我有以下方法：

protected override bool ModifyExistingEntity(Product entity, ProductModel item)
{
    bool isModified = false;

    if (entity.Title != item.Title)
    {
        isModified = true;
        entity.Title = item.Title;
    }

    if (entity.ServerId != item.Id)
    {
        isModified = true;
        entity.ServerId = item.Id;
    }

    return isModified;
}

我想知道您是否可以建议更好的方法来实施该方法。

问题很明显：每个属性有5行几乎复制粘贴的代码太多了。我可以使用Func - s / Expression来解决这个问题。

Answer 1

你有一个时间耦合的情况，即你正在混合检查实体是否随着分配而改变了。如果你将两者分开，你的代码会变得更加清晰：

protected override bool ModifyExistingEntity(Product entity, ProductModel item)
{
    bool isModified = this.IsEntityModified(entity, item);

    if (isModified)
    {
        this.UpdateEntity(entity, item);
    }

    return isModified;
}

private bool IsEntityModified(Product entity, ProductModel item)
{
    return entity.Title != item.Title || entity.ServerId != item.ServerId;
}

private void UpdateEntity(Product entity, ProductModel item)
{
    entity.Title = item.Title;
    entity.ServerId = item.Id;
}

使用Func<>或类似的东西做任何智能和时髦的东西（TM）在这种情况下似乎没有用，因为它不能清楚地表达你的意图。

Answer 2

这样的事情应该有效

protected bool ModifyExistingEntity(Person entity, ProductModel item)
{
    bool isModified = CompareAndModify(() => entity.Title = item.Title, () => entity.Title != item.Title);
    isModified |= CompareAndModify(() => entity.ServerId = item.Id, () => entity.ServerId != item.Id);

    return isModified;
}

private bool CompareAndModify(Action setter, Func<bool> comparator)
{
    if (comparator())
    {
        setter();
        return true;
    }
    return false;
}

不确定这是否可读。这是主观的。

Answer 3

我认为this answer的扩展可能适合您：

public static bool SetIfModified<CLeft, T>(Expression<Func<CLeft, T>> exprLeft, CLeft leftType, T rightValue)
{
    var getterLeft = exprLeft.Compile();

    if (EqualityComparer<T>.Default.Equals(getterLeft(leftType), rightValue))
    {
        var newValueLeft = Expression.Parameter(exprLeft.Body.Type);
        var assignLeft = Expression.Lambda<Action<CLeft, T>>(Expression.Assign(exprLeft.Body, newValueLeft), exprLeft.Parameters[0], newValueLeft);

        var setterLeft = assignLeft.Compile();

        setterLeft(leftType, rightValue);
        return true;
    }
    else
    {
        return false;
    }
}

需要表达式来检查值。它动态编译和执行它。

像这样使用：

public class Product { public string Title { get; set; } }
public class ProductModel { public string Title { get; set; } }

static void Main(string[] args)
{
    Product lc = new Product();
    ProductModel rc = new ProductModel();
    rc.Title = "abc";
    bool modified = SetIfModified(l => l.Title, lc, r.Title);

    // modified is true
    // lc.Title is "abc"

}

Answer 4

使用T4进行元编程

另一种方法 - 通常当我们有重复的代码实际上简单并且可能非常快时。在这种情况下，每个重复的if块都不相同 - 它拥有一点知识 - 从一个属性到另一个属性的映射。

写和维护重复的块很烦人。
避免编写有用的重复代码的一种方法是自动生成它。

使用我的解决方案，映射非常简单：

var mappings = new []{
    new Mapper("ProductModel", "Product")
    { 
        "Title",               // ProductModel.Title goes to Product.Title
        {"Id", "ServiceId"},   // ProductModel.Id goes to Product.ServiceId
    },
};

这是一个t4文本模板（Visual Studio的内置功能）：

<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    // Consider including the namespace in the class names.
    // You only need to change the mappings.
    var product = new Mapper("Product", "ProductEntity") { "Name", {"Id", "ServiceId"} };
    var person = new Mapper("Person", "DbPerson") { "Employee", {"Name", "FullName"}, {"Addredd", "HomeAddress"} };

    var mappings = new [] {product, person};
#>
// !!!
// !!!  Do not modify this file, it is automatically generated. Change the .tt file instead.     !!!
// !!!
namespace Your.Mapper
{
    partial class Mapper
    {
        <# foreach(var mapping in mappings) { 
        #>/// <summary>
        /// Set <paramref name="target"/> properties by copying them from <paramref name="source"/>.
        /// </summary>
        /// <remarks>Mapping:<br/>
        <#foreach(var property in mapping){
        #>/// <see cref="<#=mapping.SourceType#>.<#=property.SourceProperty#>"/> → <see cref="<#=mapping.TargetType#>.<#=property.TargetProperty#>"/> <br/>
        <#}
        #>/// </remarks>
        /// <returns><c>true</c> if any property was changed, <c>false</c> if all properties were the same.</returns>
        public bool ModifyExistingEntity(<#=mapping.SourceType#> source, <#=mapping.TargetType#> target)
        {
            bool dirty = false;
            <# foreach(var property in mapping) {
            #>if (target.<#=property.TargetProperty#> != source.<#=property.SourceProperty#>)
            {
                dirty = true;
                target.<#=property.TargetProperty#> = source.<#=property.SourceProperty#>;
            }           
            <#}
            #>return dirty;
        }
        <#
         } 
        #>

    }
}

<#+
class Mapper : IEnumerable<PropertyMapper>
{
    private readonly List<PropertyMapper> _properties;

    public Mapper(string sourceType, string targetType)
    {
        SourceType = sourceType;
        TargetType = targetType;
        _properties = new List<PropertyMapper>();
    }

    public string SourceType { get; set; }
    public string TargetType { get; set; }

    public void Add(string fieldName)
    {
        _properties.Add(new PropertyMapper {SourceProperty = fieldName, TargetProperty = fieldName});
    }

    public void Add(string sourceProperty, string targetProperty)
    {
        _properties.Add(new PropertyMapper { SourceProperty = sourceProperty, TargetProperty = targetProperty });
    }

    IEnumerator<PropertyMapper> IEnumerable<PropertyMapper>.GetEnumerator() { return _properties.GetEnumerator(); }
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return _properties.GetEnumerator(); }
}

class PropertyMapper
{
    public string SourceProperty { get; set; }
    public string TargetProperty { get; set; }
}
#>

此模板生成以下代码：https://gist.github.com/kobi/d52dd1ff27541acaae10

优点：

• 在编译时完成繁重的工作（实际上在编译时间之前一次） - 生成的代码很快。
• 记录生成的代码。
• 易于维护 - 您可以在一个点上更改所有映射器。
• 记录生成的方法。
• 否copy-paste bugs。
• 这很有趣。

缺点：

• 使用字符串获取属性名称。请记住 - 这不是生产代码，它只是用于生成代码。可以使用真实类型和表达式树（下面的示例）。
• 静态分析可能会错过模板中的用法（即使我们使用表达式，并非所有工具都会查看tt文件）。
• 很多人不知道发生了什么事。
• 如果您使用的是表达式，那么引用您的类型会很棘手。

说明：

• 我已将参数命名为source和target，并更改了订单，因此source始终是第一位。

我一直担心我会使用字符串而不是真正的属性。虽然在这种情况下这是一个小问题（编译输出），但这是一个适用于您的真实对象的附加功能。

在顶部，添加此内容（第三个应该是您的命名空间）：

<#@ assembly name="$(TargetPath)" #>
<#@ import namespace="System.Linq.Expressions" #>
<#@ import namespace="ConsoleApplicationT4So29913514" #>  

在底部，添加：

class Mapper<TSource, TTarget> : Mapper
{
    public Mapper()
        : base(typeof(TSource).FullName, typeof(TTarget).FullName)
    {

    }

    private static string GetExpressionMemberAccess(LambdaExpression getProperty)
    {
        var member = (MemberExpression)getProperty.Body;
        //var lambdaParameterName = (ParameterExpression)member.Expression;
        var lambdaParameterName = getProperty.Parameters[0]; // `x` in `x => x.PropertyName`
        var labmdaBody = member.ToString();
        //will not work with indexer.
        return labmdaBody.Substring(lambdaParameterName.Name.Length + 1); //+1 to remove the `.`, get "PropertyName"
    }

    public void Add<TProperty>(Expression<Func<TSource, TProperty>> getSourceProperty, Expression<Func<TTarget, TProperty>> getTargetProperty)
    {
        Add(GetExpressionMemberAccess(getSourceProperty), GetExpressionMemberAccess(getTargetProperty));
    }

    /// <summary>
    /// The doesn't really make sense, but we assume we have <c>source=>source.Property</c>, <c>target=>target.Property</c>
    /// </summary>
    public void Add<TProperty>(Expression<Func<TSource, TProperty>> getProperty)
    {
        Add(GetExpressionMemberAccess(getProperty));
    }
}

用法：

var mappings = new Mapper[] {
    new Mapper<Student,StudentRecord>
    {
        {s=>s.Title, t=>t.EntityTitle},
        {s=>s.StudentId, t=>t.Id},
        s=>s.Name,
        s=>s.LuckyNumber,
    },
    new Mapper<Car,RaceCar>
    {
        c=>c.Color,
        c=>c.Driver,
        {c=>c.Driver.Length, r=>r.DriverNameDisplayWidth},
    },
};

整个文件应如下所示：https://gist.github.com/kobi/6423eaa13cca238447a8
输出看起来仍然相同：https://gist.github.com/kobi/3508e9f5522a13e1b66b

注意：

• 表达式仅用于将属性名称作为字符串获取，我们不编译它们或运行它们。
• 在C＃6中，我们将拥有nameof() operator，这是表达式和​​无魔术字符串之间的一个很好的折衷方案。

Answer 5

没有魔杖来简化这一点。

您可以让实体本身提供IsModified属性，然后由属性设置者设置，例如：

public string Title {
   get { return _title; }
   set {
         if (value != _title)
         {
             _title = value;
             IsModified = true;
         }
    }
}

如果工作太多，你的解决方案就可以了。

Answer 6

如果您想让它具有可读性，您可以使用非常简单的用法为此目的创建一个类，以避免重复代码：

protected override bool ModifyExistingEntity(Product entity, ProductModel item)
{
    return new Modifier<Product>(entity)
               .SetIfNeeded(e => e.Title, item.Title);
               .SetIfNeeded(e => e.ServerId, item.Id);
               .EntityWasModified;
}

<强>实施

我从Patrick Hofman那里拿了一些代码，用getter表达式生成一个setter。

public class Modifier<TEntity>
{    
    public Modifier(TEntity entity)
    {
        Entity = entity;
    }

    public TEntity Entity { get; private set; }

    public bool EntityWasModified { get; private set; }

    public Modifier<TEntity> SetIfNeeded<TProperty>(Expression<Func<TEntity, TProperty>> entityPropertyGetter, TProperty modelValue)
    {
        var getter = entityPropertyGetter.Compile();
        var setter = GetSetterExpression(entityPropertyGetter).Compile();

        if (!object.Equals(getter(Entity), modelValue))
        {
            setter(Entity, modelValue);
            EntityWasModified = true;
        }
        return this;
    }

    private static Expression<Action<TEntity, TProperty>> GetSetterExpression(Expression<Func<TEntity, TProperty>> getterExpression)
    {
        var newValue = Expression.Parameter(getterExpression.Body.Type);

        return Expression.Lambda<Action<TEntity, TProperty>>(
            Expression.Assign(getterExpression.Body, newValue),
            getterExpression.Parameters[0], newValue);
    }
}

您可能希望缓存.Compile的结果以提高效果。

Answer 7

查看我自己的（几乎和其他人一样奇怪）解决方案

[TestMethod]
public void DifferentTitleAndId_ExpectModified()
{
    var entity = new Product
        {
            Id = 0,
            ServerId = 0,
            Title = "entity title"
        };

    var model = new ProductModel
        {
            Id = 1,
            Title = "model title"
        };

    bool isModified = ModifyExistingEntity(entity, model);

    Assert.IsTrue(isModified);
}

protected bool ModifyExistingEntity(Product entity, ProductModel model)
{
    return
        IsModified(entity.Title, model.Title, x => entity.Title = x) |
        IsModified(entity.ServerId, model.Id, x => entity.ServerId = x);
}

protected bool IsModified<T>(T value1, T value2, Action<T> setter)
{
    return IsModified(() => value1, () => value2, () => setter(value2));
}

protected bool IsModified<T>(Func<T> valueGetter1, Func<T> valueGetter2, Action setter)
{
    if (!Equals(valueGetter1(), valueGetter2()))
    {
        setter();
        return true;
    }

    return false;
}

Answer 8

我已经看到了这个问题最复杂的答案，但我认为你最适合使用一个相当简单，毫不含糊的简单解决方案。

我假设您在代码库中使用某种Data Mapper模式，而Product是您的DAL / Domain实体，ProductModel是您的应用级对象。在这种情况下，我只需要一个比较两者的方法（以后可以将其移动到一个单独的层），如果它们不相等，则映射。

但是这提出了一个问题，为什么你担心只有更新才会改变？每次更新都可能是可以接受的。

此外，您可能不应该将实体传递给期望更新的方法。

我会改变逻辑如下：

protected bool UpdateIfChanged(Product entity, ProductModel item)
{
    var areEqual = CompareProductAndProductModel(entity, item);

    if(!areEqual)
        UpdateProduct(MapProductModelToProduct(item));

    return !areEqual;
}

internal bool CompareProductAndProductModel(Product product, ProductModel productModel)
{
    return product.Title == productModel.Title && product.ServerId == productModel.Id; //could be abstracted to an equality comparer if you were inclined
}

此答案从其他答案中得出的最大偏离是它不会修改产品实体。相反，它会比较Product和ProductModel，但如果更改检测到后，它会使用ProductModel创建 new Product，然后将其传递给另一个实际执行更新工作的DAL方法。我相信这可能是最易维护的方法，因为你不必处理改变传递给它们的对象状态的方法（隐式耦合，即使方法和调用者存在于不同的地方），这意味着你不必在调试过程中逐步执行代码时，在心理上跟踪实体的状态更改。

Answer 9

＆＃34;更好的＆＃34;在这种背景下是主观的。由于你在抱怨行数，我有一个更简洁的方法：

protected override bool ModifyExistingEntity(Product entity, ProductModel item)
{
    bool isModified = false;

    isModified |= (entity.Title!= item.Title) ? (entity.Title = item.Title) == item.Title : false;
    isModified |= (entity.ServerId != item.Id) ? (entity.ServerId = item.Id) == item.Id : false;

    return isModified;
}

Answer 10

继续@bstenzel回答，这不应该也可以吗？

protected override bool ModifyExistingEntity(Product entity, ProductModel item)
{
    bool isEntityModified = entity.Title != item.Title || entity.ServerId != item.ServerId;
    entity.Title = item.Title;
    entity.ServerId = item.Id;
    return isEntityModified;
}

清洁简单。

Answer 11

我不确定Product课程是否可以为您扩展，也不确定您是否正在寻找一个＆＃34;幻想＆＃34;回答或者只是一个更简单的...但如果是这样的话，你可以做一些事情，把逻辑放在Product类本身; imho你最终得到一个相当可读的方法：

protected override bool ModifyExistingEntity(Product entity, ProductModel item)
{
    entity.SetTitle(item.Title);
    entity.SetServerId(item.Id);
    return entity.WasModified();
}

额外的好处是你可以将行为整齐地封装到Product（以及验证等）

public partial class Product
{
    public void SetTitle(string title)
    {
       if(this.Title!=title) //and other validation, etc
       {
         this.Title = title;
         Modified();
       }
    }

    public void SetServerId(int serverId)
    {
       if(this.ServerId!=serverId)
       {
          this.ServerId=serverID;
          Modified();
        }
    }

    private bool _wasModified;

    private void Modified()
    {
        //Or implement INotifyPropertyChanged if you like
        _wasModified=true;
    }

    public bool WasModified()
    {
        return _wasModified;
    }
}

当然，如果您不需要任何＆＃34;业务逻辑＆＃34;这真的只是一个未经检查的映射操作，这里任何一个非常聪明的答案都会做:)

Answer 12

由于您很可能不想为每个实体和模型对编写代码，因此您应该依靠反射来映射实体和模型之间相同的属性，然后将这些值与属性Infos进行比较。

编辑：添加了修改后的值的复制并锁定了多个线程。

class Program
{
    static void Main(string[] args)
    {
        if (ModifyExistingEntity(new Product { Name = "bar" }, new ProductModel { Name = "test" }))
            Console.WriteLine("Product modified");

        if (ModifyExistingEntity(new Customer { Number = 1001 }, new CustomerModel { Number = 1002 }))
            Console.WriteLine("Customer was modified");

        if (!ModifyExistingEntity(new Customer { Number = 1001 }, new CustomerModel { Number = 1001 }))
            Console.WriteLine("Customer was not modified");

        Console.ReadKey();
    }

    protected static bool ModifyExistingEntity<TEntity, TModel>(TEntity entity, TModel model)
    {
        var isModified = false;

        GetProperties(entity, model).ForEach(
                propertyInfo =>
                {
                    var item2Value = propertyInfo.Item2.GetValue(model, null);
                    if (Equals(propertyInfo.Item1.GetValue(entity, null), item2Value)) 
                        return;

                    propertyInfo.Item1.SetValue(entity, item2Value);
                    isModified = true;
                });

        return isModified;
    }

    private static readonly object MappingLock = new object();
    private static readonly Dictionary<Tuple<Type, Type>, List<Tuple<PropertyInfo, PropertyInfo>>> Mapping =
            new Dictionary<Tuple<Type, Type>, List<Tuple<PropertyInfo, PropertyInfo>>>();

    protected static List<Tuple<PropertyInfo, PropertyInfo>> GetProperties<TEntity, TModel>(TEntity entity, TModel model)
    {
        lock (MappingLock)
        {
            var key = new Tuple<Type, Type>(typeof (TEntity), typeof (TModel));
            if (Mapping.ContainsKey(key))
            {
                return Mapping[key];
            }

            var modelProperties = typeof (TModel).GetProperties();

            var newMapping = (from propertyInfo in typeof (TEntity).GetProperties()
                let modelPropertyInfo = modelProperties.SingleOrDefault(mp => mp.Name == propertyInfo.Name)
                select new Tuple<PropertyInfo, PropertyInfo>(propertyInfo, modelPropertyInfo))
                .ToList();

            Mapping.Add(key, newMapping);

            return newMapping;
        }
    }
}

Answer 13

如果您只想要更短的代码行，可以将其压缩为此C样式分配：

ModifyExistingEntity( Product entity, ProductModel item )
{
    bool isModified = false;

    isModified |= ( entity.Title != item.Title )
        && retTrue( entity.Title =  item.Title );

    isModified |= ( entity.ServerId != item.Id )
        && retTrue( entity.ServerId =  item.Id );

    return isModified;
}

static bool RetTrue<T>(T dummy) { return true; } // Helper method.

Answer 14

这是一种适合宏观使用的情况：

#define CheckAndAssign(dst,src) (dst != src && (dst = src, true))

return (  CheckAndAssign (entity.Title, item.Title)
        | CheckAndAssign (entity.ServerId, item.Id));

#undef CheckAndAssign

好吧，只要语言是C，C ++，Objective-C或其他任何带有宏的语言。我希望在C ++中你能以某种方式把它变成一个模板。