[linq] IEnumerable <T>에 대해 foreach와 동일한 LINQ

2012 년 7 월 17 일 업데이트 : 분명히 C # 5.0부터 foreach아래 설명 된 동작 이 변경되었으며 ” 중첩 된 람다 식에서 반복 변수를 사용해 foreach도 더 이상 예기치 않은 결과 가 발생하지 않습니다 . “이 답변은 C # ≥ 5.0에는 적용되지 않습니다 . .

@John Skeet 및 foreach 키워드를 선호하는 모든 사람.

5.0 이전의 C #에서 “foreach”의 문제점 은 다른 언어에서 동등한 “이해”가 작동하는 방식과 작동 할 것으로 예상되는 방식과 일치하지 않는다는 것입니다 (다른 사람들이 가독성에 관한 의견). ” 유해한 것으로 간주되는 루프 변수 닫기 “뿐만 아니라 ” 수정 된 클로저에 액세스 “와 관련된 모든 질문을 참조하십시오 . 이것은 “foreach”가 C #에서 구현되는 방식 때문에 “유해”입니다.

@Fredrik Kalseth의 답변과 기능적으로 동등한 확장 방법을 사용하여 다음 예를 살펴보십시오.

public static class Enumerables
{
    public static void ForEach<T>(this IEnumerable<T> @this, Action<T> action)
    {
        foreach (T item in @this)
        {
            action(item);
        }
    }
}

지나치게 고안된 사례에 대한 사과. 나는 Observable 만 사용하고 있습니다. 이와 같은 일을하기 위해 완전히 가져 오지 않았기 때문입니다. 분명히이 관찰 가능 객체를 만드는 더 좋은 방법이 있습니다. 저는 요점을 보여 주려고합니다. 일반적으로 Observable에 가입 ​​된 코드는 비동기 적으로 잠재적으로 다른 스레드에서 실행됩니다. “foreach”를 사용하면 매우 이상하고 결정적이지 않은 결과가 발생할 수 있습니다.

“ForEach”확장 방법을 사용한 다음 테스트는 통과합니다.

[Test]
public void ForEachExtensionWin()
{
    //Yes, I know there is an Observable.Range.
    var values = Enumerable.Range(0, 10);

    var observable = Observable.Create<Func<int>>(source =>
                            {
                                values.ForEach(value =>
                                    source.OnNext(() => value));

                                source.OnCompleted();
                                return () => { };
                            });

    //Simulate subscribing and evaluating Funcs
    var evaluatedObservable = observable.ToEnumerable().Select(func => func()).ToList();

    //Win
    Assert.That(evaluatedObservable,
        Is.EquivalentTo(values.ToList()));
}

다음은 오류와 함께 실패합니다.

예상 : <0, 1, 2, 3, 4, 5, 6, 7, 8, 9>와 같음 : <9, 9, 9, 9, 9, 9, 9, 9, 9, 9>

[Test]
public void ForEachKeywordFail()
{
    //Yes, I know there is an Observable.Range.
    var values = Enumerable.Range(0, 10);

    var observable = Observable.Create<Func<int>>(source =>
                            {
                                foreach (var value in values)
                                {
                                    //If you have resharper, notice the warning
                                    source.OnNext(() => value);
                                }
                                source.OnCompleted();
                                return () => { };
                            });

    //Simulate subscribing and evaluating Funcs
    var evaluatedObservable = observable.ToEnumerable().Select(func => func()).ToList();

    //Fail
    Assert.That(evaluatedObservable,
        Is.EquivalentTo(values.ToList()));
}

답변

IEnumerable<Item> items = GetItems();
items.FirstOrDefault(i => { i.DoStuff(); return false; });

public static IEnumerable<T> ForEach<T>(this IEnumerable<T> enumeration, Action<T> action)
{
    foreach (T item in enumeration)
    {
        action(item);
        yield return item;
    }
}

[Test]
public void TestDefferedExecutionOfIEnumerableForEach()
{
    IEnumerable<char> enumerable = new[] {'a', 'b', 'c'};

    var sb = new StringBuilder();

    enumerable
        .ForEach(c => sb.Append("1"))
        .ForEach(c => sb.Append("2"))
        .ToList();

    Assert.That(sb.ToString(), Is.EqualTo("121212"));
}

foreach (var i in items) i.DoStuff();

items.Aggregate(initial, (acc, x) => ComputeAccumulatedValue(acc, x));

items.Select(x => Transform(x));

items.ToLookup(x, x => GetTheKey(x))

public static class EnumerableExtensions
{
    public static IEnumerable<T> ForEach<T>(this IEnumerable<T> enumeration, Action<T> action)
    {
        foreach (var item in enumeration)
        {
            action(item);
            yield return item;
        }
    }
}