C#语法-Lambda表达式示例-泛型列表上的ForEach（）

首先，我知道框架中已经有了泛型

List

类之外的方法，可以迭代

List

但作为一个例子，编写ForEach方法来迭代

列表

的每个对象，并对每个对象执行

控制台.WriteLine（object.ToString（））

的正确语法是什么。 将

列表

作为第一个参数，将lambda表达式作为第二个参数的内容

---

我看到的大多数示例都是作为扩展方法完成的，或者涉及LINQ。我正在寻找一个简单的旧方法示例。

上面的代码也可以用更少的代码编写，如下所示：

public void Each<T>(IEnumerable<T> items, Action<T> action)
{
    foreach (var item in items)
        action(item);
}

new List<SomeType>(items).ForEach(
    i => Console.WriteLine(i)
);

新列表（项目）。ForEach(
i=>Console.WriteLine（i）
);

---

这将创建一个泛型列表，并用IEnumerable填充它，然后调用列表对象ForEach。

您可以遍历列表中的每个字符串，甚至可以使用单个语句在整个泛型中搜索，这使得搜索更容易

public static void main(string[] args)
{
List names = new List();

names.Add(“Saurabh”);
names.Add("Garima");
names.Add(“Vivek”);
names.Add(“Sandeep”);

string stringResult = names.Find( name => name.Equals(“Garima”));
}

---

这就是你想要的吗

int[] numbers = { 1, 2, 3 };
numbers.ToList().ForEach(n => Console.WriteLine(n));

---

我想说的是，如果有人提供一个答案作为扩展方法，那么就不需要太担心了，因为扩展方法只是调用实例方法的一种很酷的方式。我知道你想要的答案没有使用扩展方法。不管该方法定义为静态、实例还是扩展，结果都是一样的

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

[TestFixture]
public class ForEachTests
{
    public void Each<T>(IEnumerable<T> items, Action<T> action)
    {
        foreach (var item in items)
        {
            action(item);
        }
    }

    private string _extensionOutput;

    private void SaveExtensionOutput(string value)
    {
        _extensionOutput += value;
    }

    private string _instanceOutput;

    private void SaveInstanceOutput(string value)
    {
        _instanceOutput += value;
    }

    [Test]
    public void Test1()
    {
        string[] teams = new string[] {"cowboys", "falcons", "browns", "chargers", "rams", "seahawks", "lions", "heat", "blackhawks", "penguins", "pirates"};

        Each(teams, SaveInstanceOutput);

        teams.Each(SaveExtensionOutput);

        Assert.AreEqual(_extensionOutput, _instanceOutput);
    }
}

下面的代码使用接受答案中的代码来定义扩展方法和实例方法，并创建一个单元测试，以显示输出是相同的

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

[TestFixture]
public class ForEachTests
{
    public void Each<T>(IEnumerable<T> items, Action<T> action)
    {
        foreach (var item in items)
        {
            action(item);
        }
    }

    private string _extensionOutput;

    private void SaveExtensionOutput(string value)
    {
        _extensionOutput += value;
    }

    private string _instanceOutput;

    private void SaveInstanceOutput(string value)
    {
        _instanceOutput += value;
    }

    [Test]
    public void Test1()
    {
        string[] teams = new string[] {"cowboys", "falcons", "browns", "chargers", "rams", "seahawks", "lions", "heat", "blackhawks", "penguins", "pirates"};

        Each(teams, SaveInstanceOutput);

        teams.Each(SaveExtensionOutput);

        Assert.AreEqual(_extensionOutput, _instanceOutput);
    }
}

变成

public void Each<T>(Action<T> action)
{
    foreach (var item in items)
    {
        action(item);
    }
 }

公共作废每个（操作）
{
foreach（项目中的var项目）
{
行动（项目）；
}
}

很酷。现在我看到的Func语法在哪里发挥作用了？Func委托是具有返回值的方法的通用委托。动作委托是没有返回值的方法的泛型委托。这是唯一的区别。因此，在您的情况下，您不需要返回某些内容（从console.writeline-因此操作就足够了。此外，您可以使用methodgroup“console.writeline”而不是lambda“i=>console.writeline（i）”。问题是如何编写该方法（而不是如何调用它），并指定他不希望使用LINQ或扩展方法。这很方便，但不是创建新列表的开销（意味着至少再重复一次项）通常是不值得的吗？是的。这很方便，我已经用过了。+ 1。在我问这个问题的时候，我想我只是想在使用泛型时尝试掌握基本的Cλlambda语法。好的，但是我们必须考虑到，TelSist.（）是一个O（n）运算，用于显示每个方法中的多个操作。

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

[TestFixture]
public class ForEachTests
{
    public void Each<T>(IEnumerable<T> items, Action<T> action)
    {
        foreach (var item in items)
        {
            action(item);
        }
    }

    private string _extensionOutput;

    private void SaveExtensionOutput(string value)
    {
        _extensionOutput += value;
    }

    private string _instanceOutput;

    private void SaveInstanceOutput(string value)
    {
        _instanceOutput += value;
    }

    [Test]
    public void Test1()
    {
        string[] teams = new string[] {"cowboys", "falcons", "browns", "chargers", "rams", "seahawks", "lions", "heat", "blackhawks", "penguins", "pirates"};

        Each(teams, SaveInstanceOutput);

        teams.Each(SaveExtensionOutput);

        Assert.AreEqual(_extensionOutput, _instanceOutput);
    }
}

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

public void Each<T>(Action<T> action)
{
    foreach (var item in items)
    {
        action(item);
    }
 }