C# 使用Ti和Ti+的通用方法；1.

我有以下使用C#6的泛型类：

公共类IncludeMapper{
专用只读词典_properties=new Dictionary（）；
公共IncludeMapper添加（字符串属性、表达式路径1、表达式路径2）{
if（！\u properties.ContainsKey（property））
_添加（属性，新列表{path1，path2}）；
归还这个；
}
公共IncludeMapper添加（字符串属性、表达式路径1、表达式路径2、表达式路径3）{
if（！\u properties.ContainsKey（property））
_添加（属性，新列表{path1，path2，path3}）；
归还这个；
}
}

Add方法有几个表达式（路径），它们取一个Ti和Ti+1

有没有办法简化我的代码？在路径7之前，我至少还需要4种类似的方法

有没有办法简化我的代码

好吧，你可以简化一下：

公共类IncludeMapper{
专用只读字典\u属性=
新字典（）；
专用IncludeMapper AddImpl(
字符串属性，
参数LambdaExpression[]表达式）
{
if（！\u properties.ContainsKey（property））
{
_Add（property，path.ToList（））；
} 
归还这个；
}
公共IncludeMapper添加(
字符串属性，
表达式路径1，
表达式路径2）=>
AddImpl（路径1、路径2）；
公共IncludeMapper添加(
字符串属性，
表达式路径1，
表达式路径2，
表达式路径3）=>
AddImpl（路径1、路径2、路径3）；
...
}

对于希望支持的每个“泛型arity”，您仍然需要另一个方法，但至少实现是微不足道的

当然，如果您希望能够指定多个路径，但每个路径必须是同一类型的，这很容易，因为这样您就可以将

params

与单一类型的参数一起使用。但是，如果希望能够使用lambda表达式作为参数，并且希望能够改变所涉及的类型，那么参数必须是特定的

表达式
类型

有没有办法简化我的代码

好吧，你可以简化一下：

公共类IncludeMapper{
专用只读字典\u属性=
新字典（）；
专用IncludeMapper AddImpl(
字符串属性，
参数LambdaExpression[]表达式）
{
if（！\u properties.ContainsKey（property））
{
_Add（property，path.ToList（））；
} 
归还这个；
}
公共IncludeMapper添加(
字符串属性，
表达式路径1，
表达式路径2）=>
AddImpl（路径1、路径2）；
公共IncludeMapper添加(
字符串属性，
表达式路径1，
表达式路径2，
表达式路径3）=>
AddImpl（路径1、路径2、路径3）；
...
}

对于希望支持的每个“泛型arity”，您仍然需要另一个方法，但至少实现是微不足道的

当然，如果您希望能够指定多个路径，但每个路径必须是同一类型的，这很容易，因为这样您就可以将
params
与单一类型的参数一起使用。但是，如果您希望能够使用lambda表达式作为参数，并且希望能够改变所涉及的类型，则参数必须是特定的
表达式
类型。
简短回答：否。扩展回答：简短回答：否。扩展回答：
public class IncludeMapper<T1> {

  private readonly Dictionary<String, List<LambdaExpression>> _properties = new Dictionary<String, List<LambdaExpression>>();

  public IncludeMapper<T1> Add<T2, T3>(String property, Expression<Func<T1, T2>> path1, Expression<Func<T2, T3>> path2) {

    if (!_properties.ContainsKey(property))
      _properties.Add(property, new List<LambdaExpression> { path1, path2 });

    return this;

  }

  public IncludeMapper<T1> Add<T2, T3, T4>(String property, Expression<Func<T1, T2>> path1, Expression<Func<T2, T3>> path2, Expression<Func<T3, T4>> path3) {

    if (!_properties.ContainsKey(property))
      _properties.Add(property, new List<LambdaExpression> { path1, path2, path3 });

    return this;

  }

}

public class IncludeMapper<T1> {

    private readonly Dictionary<String, List<LambdaExpression>> _properties =
        new Dictionary<String, List<LambdaExpression>>();

    private IncludeMapper<T1> AddImpl(
        string property,
        params LambdaExpression[] expressions)
    {
        if (!_properties.ContainsKey(property))
        {
            _properties.Add(property, paths.ToList());
        } 
        return this;
    }

    public IncludeMapper<T1> Add<T2, T3>(
        String property,
        Expression<Func<T1, T2>> path1,
        Expression<Func<T2, T3>> path2) =>
        AddImpl(path1, path2);

    public IncludeMapper<T1> Add<T2, T3, T4>(
        String property,
        Expression<Func<T1, T2>> path1,
        Expression<Func<T2, T3>> path2,
        Expression<Func<T3, T4>> path3) =>
        AddImpl(path1, path2, path3);

    ...
}