Question

我想要做的是将lambda语法与“params”结合起来对一系列对象执行操作。

假设我想让一堆控件不可见。

经过一番摆弄后，我最终得到了一个扩展方法：

public static void On<T>(this Action<T> actionToCarryOut,params T[] listOfThings)
{
    foreach (var thing in listOfThings)
    {
        actionToCarryOut(thing);
    }
}

然后我可以创建一个动作：

Action<Control> makeInvisible = c => c.Visible = false;

然后调用它：

makeInvisible.On(control1,control2, control3,control4);

这不是很好的语法 - 它感觉非常笨拙。

我可以在我的基类中创建一个方法“Apply”：

protected void Apply<T>(Action<T> action, params T[] appliedTo)
{
    foreach (var item in appliedTo)
    {
        action(item);
    }
}

然后像这样调用它：

Apply<Control>(
    c => c.Visible = false,
    control1,
    control2,
    control3,);

但这意味着在我需要的每个基类中重复该方法，并且我失去了类型推断的优势。

这样做的方法不那么笨拙吗？

编辑：到目前为止，我见过的最好的方法是流畅的方法，（通过几个调整）可以让我写：

Apply.Method((Control c) => c.Visible = false).To(
    control1, 
    control2, 
    control3, 
    control4};

这是91个字符，而使用简单的“foreach”则为107个字符。这让我相信“foreach”可能实际上是最好的方法！

Answer 1

您可以使用这样的扩展方法：

static void ForEach<T>(this IEnumerable<T> items, Action<T> action)
{
    foreach (var item in items)
    {
        action(item);
    }
}

然后称之为：

new Control[] { control1, control2, control3 }.ForEach(makeInvisible);

或者只是

new Control[] { control1, control2, control3 }.ForEach(x => x.Visible = false);

如果control1..n都是相同的类型，则可以省略基类：

new[] { control1, control2, control3 }.ForEach(x => x.Visible = false);

Answer 2

也许您想通过构建一组对象然后在该集合上调用方法来采用更多面向对象的方法：

new[] { control1, control2, control3 }.ForEach(x => x.Visible = false);

ForEach扩展功能在LinqKit toolset。

中定义

Answer 3

为什么不把它称为常规静态方法而不是扩展？

public static class Apply
{
    public static void To<T>(this Action<T> actionToCarryOut,params T[] listOfThings)
    {
        foreach (var thing in listOfThings)
        {
            actionToCarryOut(thing);
        }
    }
}

然后这样称呼：

Apply.To<Control>(c => c.Visible = false,control1,control2, control3,control4);

修改

这是一个使用Fluent语法的版本：

public class Apply<T> { private Action<T> _action; public Apply(Action<T> action) { _action = action; } public static Apply<T> Method(Action<T> actionToCarryOut) { return new Apply<T>(actionToCarryOut); } public void To(params T[] listOfThings) { foreach (var thing in listOfThings) { _action(thing); } } }

用法：

Apply<Control>.Method(c => c.Visible = false).To(control1,control2, control3,control4);

Answer 4

或者，您可以这样做，

control1.Visible = false;
control2.Visible = false;
control3.Visible = false;
control4.Visible = false;

代码行数减少，运行速度更快。但是，如果你想要一个比你的例子更简单的案例的扩展，那么。

public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
{
    foreach(var t in source)
    {
        action(t);
    }
}

然后你可以，稍微改写你的原件

public static void Act<T>(Action<T> action, params T[] targets)
{
    targets.ForEach(action);
}

允许，

Act(ctl => ctl.Visible = false, control1, control2, control3, control4);

但是，我建议

var controls = new[] { control1, control2, control3, control4 };

foreach (var control in controls)
{
    control.Visible = false;
}

比任何扩展方法都更具可读性，或者如果你把它放在一行上就非常熟悉了。

foreach (var control in new[] { control1, control2, control3, control4 })
    control.Visible = false;

我认为这些最后的例子说明了为什么从框架中省略了这个看似有用的扩展。

用于将操作应用于不同数量的对象的C＃语法

4 个答案: