LINQ tương đương với foreach cho IEn Countable <T>

Tôi muốn thực hiện tương tự như sau trong LINQ, nhưng tôi không thể tìm ra cách:

IEnumerable<Item> items = GetItems();
items.ForEach(i => i.DoStuff());

Cú pháp thực sự là gì?

Không có phần mở rộng ForEach cho IEnumerable; chỉ cho List<T>. Vì vậy, bạn có thể làm

items.ToList().ForEach(i => i.DoStuff());

Hoặc, viết phương thức mở rộng ForEach của riêng bạn:

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

Fredrik đã cung cấp bản sửa lỗi, nhưng có thể đáng để xem xét tại sao điều này không nằm trong khuôn khổ để bắt đầu. Tôi tin rằng ý tưởng là các toán tử truy vấn LINQ không có tác dụng phụ, phù hợp với cách nhìn hợp lý về thế giới. Rõ ràng ForEach hoàn toàn ngược lại - một cấu trúc hoàn toàn dựa trên hiệu ứng phụ.

Điều đó không phải để nói rằng đây là một điều xấu để làm - chỉ nghĩ về những lý do triết học đằng sau quyết định.

Cập nhật 17/07/2012: Rõ ràng là từ C # 5.0, hành vi foreachđược mô tả dưới đây đã được thay đổi và " việc sử dụng foreachbiến lặp trong biểu thức lambda lồng nhau không còn tạo ra kết quả bất ngờ. " Câu trả lời này không áp dụng cho C # 5.0 .

@ John Skeet và tất cả những người thích từ khóa foreach.

Vấn đề với "foreach" trong C # trước 5.0 , là nó không phù hợp với cách thức "hiểu" tương đương trong các ngôn ngữ khác và với cách tôi mong đợi nó hoạt động (ý kiến ​​cá nhân chỉ nêu ở đây vì những người khác đã đề cập ở đây ý kiến ​​về khả năng đọc). Xem tất cả các câu hỏi liên quan đến " Truy cập vào đóng cửa được sửa đổi " cũng như " Đóng trên biến vòng lặp được coi là có hại ". Điều này chỉ "có hại" vì cách "foreach" được thực hiện trong C #.

Lấy các ví dụ sau bằng cách sử dụng phương thức mở rộng tương đương về chức năng với câu trả lời của @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);
        }
    }
}

Lời xin lỗi cho ví dụ quá mức. Tôi chỉ sử dụng Observable vì nó không hoàn toàn xa để làm một cái gì đó như thế này. Rõ ràng có nhiều cách tốt hơn để tạo ra điều này có thể quan sát được, tôi chỉ đang cố gắng chứng minh một điểm. Thông thường, mã được đăng ký để có thể quan sát được thực thi không đồng bộ và có khả năng trong một luồng khác. Nếu sử dụng "foreach", điều này có thể tạo ra kết quả rất kỳ lạ và có khả năng không xác định.

Thử nghiệm sau bằng cách sử dụng phương thức mở rộng "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()));
}

Lỗi sau đây với lỗi:

Dự kiến: tương đương với <0, 1, 2, 3, 4, 5, 6, 7, 8, 9> Nhưng là: <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()));
}

Bạn có thể sử dụng FirstOrDefault()phần mở rộng, có sẵn cho IEnumerable<T>. Bằng cách trở về falsetừ vị ngữ, nó sẽ được chạy cho từng phần tử nhưng sẽ không quan tâm rằng nó không thực sự tìm thấy kết quả khớp. Điều này sẽ tránh được ToList()chi phí.

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

Tôi lấy phương pháp của Fredrik và sửa đổi kiểu trả về.

Theo cách này, phương thức hỗ trợ thực thi hoãn lại như các phương thức LINQ khác.

EDIT: Nếu điều này không rõ ràng, bất kỳ việc sử dụng phương thức này phải kết thúc bằng ToList () hoặc bất kỳ cách nào khác để buộc phương thức hoạt động trên toàn bộ số đếm. Nếu không, hành động sẽ không được thực hiện!

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

Và đây là bài kiểm tra để giúp xem nó:

[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"));
}

Nếu bạn loại bỏ ToList () cuối cùng, bạn sẽ thấy thử nghiệm thất bại do StringBuilder chứa một chuỗi rỗng. Điều này là do không có phương pháp nào buộc ForEach liệt kê.

Giữ tác dụng phụ của bạn ra khỏi IEnumerable của tôi

Tôi muốn thực hiện tương tự như sau trong LINQ, nhưng tôi không thể tìm ra cách:

Như những người khác đã chỉ ra ở đây và ở nước ngoài LINQ và IEnumerablecác phương pháp dự kiến ​​sẽ không có tác dụng phụ.

Bạn có thực sự muốn "làm một cái gì đó" cho từng mục trong IEnumerable không? Sau đó foreachlà sự lựa chọn tốt nhất. Mọi người không ngạc nhiên khi tác dụng phụ xảy ra ở đây.

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

Tôi cá là bạn không muốn có tác dụng phụ

Tuy nhiên, theo kinh nghiệm của tôi, tác dụng phụ thường không bắt buộc. Thường xuyên hơn không có một truy vấn LINQ đơn giản đang chờ được phát hiện kèm theo câu trả lời StackOverflow.com của Jon Skeet, Eric Lippert hoặc Marc Gravell giải thích cách làm những gì bạn muốn!

Vài ví dụ

Nếu bạn thực sự chỉ đang tổng hợp (tích lũy) một số giá trị thì bạn nên xem xét Aggregatephương pháp mở rộng.

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

Có lẽ bạn muốn tạo một cái mới IEnumerabletừ các giá trị hiện có.

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

Hoặc có thể bạn muốn tạo một bảng tra cứu:

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

Danh sách (chơi chữ không hoàn toàn dự định) các khả năng cứ lặp đi lặp lại.

Nếu bạn muốn đóng vai trò là bảng liệt kê, bạn nên nhường từng mục.

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;
        }
    }
}

Có một bản phát hành thử nghiệm của Microsoft về Phần mở rộng tương tác cho LINQ (cũng trên NuGet , xem hồ sơ của RxTeams để biết thêm liên kết). Video Kênh 9 giải thích điều đó tốt.

Tài liệu của nó chỉ được cung cấp ở định dạng XML. Tôi đã chạy tài liệu này trong Sandcastle để cho phép nó ở định dạng dễ đọc hơn. Giải nén kho lưu trữ tài liệu và tìm kiếm index.html .

Trong số nhiều tính năng khác, nó cung cấp triển khai ForEach dự kiến. Nó cho phép bạn viết mã như thế này:

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8 };

numbers.ForEach(x => Console.WriteLine(x*x));

Theo PLINQ (có sẵn từ .Net 4.0), bạn có thể thực hiện

IEnumerable<T>.AsParallel().ForAll() 

để thực hiện một vòng lặp foreach song song trên IEnumerable.

Mục đích của ForEach là gây ra tác dụng phụ. IEnumerable dành cho liệt kê lười biếng của một bộ.

Sự khác biệt về khái niệm này là khá rõ ràng khi bạn xem xét nó.

SomeEnumerable.ForEach(item=>DataStore.Synchronize(item));

Điều này sẽ không thực thi cho đến khi bạn thực hiện "đếm" hoặc "ToList ()" hoặc một cái gì đó trên đó. Nó rõ ràng không phải là những gì được thể hiện.

Bạn nên sử dụng các tiện ích mở rộng IEnumerable để thiết lập các chuỗi lặp, xác định nội dung theo các nguồn và điều kiện tương ứng của chúng. Cây biểu hiện mạnh mẽ và hiệu quả, nhưng bạn nên học cách đánh giá cao bản chất của chúng. Và không chỉ để lập trình xung quanh họ để lưu một vài ký tự ghi đè lên đánh giá lười biếng.

Nhiều người đã đề cập đến nó, nhưng tôi đã phải viết nó ra. Đây không phải là rõ ràng nhất / dễ đọc nhất?

IEnumerable<Item> items = GetItems();
foreach (var item in items) item.DoStuff();

Ngắn gọn và đơn giản (st).

Bây giờ chúng ta có tùy chọn ...

        ParallelOptions parallelOptions = new ParallelOptions();
        parallelOptions.MaxDegreeOfParallelism = 4;
#if DEBUG
        parallelOptions.MaxDegreeOfParallelism = 1;
#endif
        Parallel.ForEach(bookIdList, parallelOptions, bookID => UpdateStockCount(bookID));

Tất nhiên, điều này mở ra một lon giun chỉ hoàn toàn mới.

ps (Xin lỗi về các phông chữ, đó là những gì hệ thống quyết định)

Như nhiều câu trả lời đã chỉ ra, bạn có thể dễ dàng thêm một phương thức mở rộng như vậy. Tuy nhiên, nếu bạn không muốn làm điều đó, mặc dù tôi không biết bất cứ điều gì như thế này trong BCL, vẫn có một tùy chọn trong Systemkhông gian tên, nếu bạn đã có tham chiếu đến Tiện ích mở rộng phản ứng (và nếu bạn không , bạn nên có):

using System.Reactive.Linq;

items.ToObservable().Subscribe(i => i.DoStuff());

Mặc dù tên phương thức hơi khác một chút, nhưng kết quả cuối cùng chính xác là thứ bạn đang tìm kiếm.

ForEach cũng có thể bị xích , chỉ cần đưa trở lại phi công sau khi hành động. vẫn thông thạo

Employees.ForEach(e=>e.Act_A)
         .ForEach(e=>e.Act_B)
         .ForEach(e=>e.Act_C);

Orders  //just for demo
    .ForEach(o=> o.EmailBuyer() )
    .ForEach(o=> o.ProcessBilling() )
    .ForEach(o=> o.ProcessShipping());


//conditional
Employees
    .ForEach(e=> {  if(e.Salary<1000) e.Raise(0.10);})
    .ForEach(e=> {  if(e.Age   >70  ) e.Retire();});

Một phiên bản Eager thực hiện.

public static IEnumerable<T> ForEach<T>(this IEnumerable<T> enu, Action<T> action)
{
    foreach (T item in enu) action(item);
    return enu; // make action Chainable/Fluent
}

Chỉnh sửa: một phiên bản Lazy đang sử dụng lợi nhuận, như thế này .

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

Phiên bản Lazy CẦN phải được vật chất hóa, ví dụ như ToList (), nếu không, không có gì xảy ra. xem bên dưới những bình luận tuyệt vời từ ToolmakerSteve.

IQueryable<Product> query = Products.Where(...);
query.ForEachLazy(t => t.Price = t.Price + 1.00)
    .ToList(); //without this line, below SubmitChanges() does nothing.
SubmitChanges();

Tôi giữ cả ForEach () và ForEachLazy () trong thư viện của mình.

Sự tiếp cận "chức năng" này bị rò rỉ thời gian lớn. Không có gì ở cấp độ ngôn ngữ ngăn ngừa tác dụng phụ. Miễn là bạn có thể làm cho nó gọi lambda / ủy nhiệm của bạn cho mọi phần tử trong vùng chứa - bạn sẽ nhận được hành vi "ForEach".

Ở đây, ví dụ, một cách để hợp nhất srcDipedia vào DestDixi (nếu khóa đã tồn tại - ghi đè)

Đây là một hack và không nên được sử dụng trong bất kỳ mã sản xuất nào.

var b = srcDictionary.Select(
                             x=>
                                {
                                  destDictionary[x.Key] = x.Value;
                                  return true;
                                }
                             ).Count();

Lấy cảm hứng từ Jon Skeet, tôi đã mở rộng giải pháp của mình bằng cách sau:

Phương pháp mở rộng:

public static void Execute<TSource, TKey>(this IEnumerable<TSource> source, Action<TKey> applyBehavior, Func<TSource, TKey> keySelector)
{
    foreach (var item in source)
    {
        var target = keySelector(item);
        applyBehavior(target);
    }
}

Khách hàng:

var jobs = new List<Job>() 
    { 
        new Job { Id = "XAML Developer" }, 
        new Job { Id = "Assassin" }, 
        new Job { Id = "Narco Trafficker" }
    };

jobs.Execute(ApplyFilter, j => j.Id);

. . .

    public void ApplyFilter(string filterId)
    {
        Debug.WriteLine(filterId);
    }

MoreLinq có IEnumerable<T>.ForEachvà rất nhiều tiện ích mở rộng hữu ích khác. Có lẽ không đáng để lấy sự phụ thuộc chỉ choForEach , nhưng có rất nhiều thứ hữu ích trong đó.

https://www.nuget.org/packages/morelinq/

https://github.com/morelinq/MoreLINEQ

Tôi không đồng ý với quan điểm rằng các phương pháp mở rộng liên kết sẽ không có tác dụng phụ (không chỉ vì chúng không có, bất kỳ đại biểu nào cũng có thể thực hiện các tác dụng phụ).

Hãy xem xét những điều sau đây:

   public class Element {}

   public Enum ProcessType
   {
      This = 0, That = 1, SomethingElse = 2
   }

   public class Class1
   {
      private Dictionary<ProcessType, Action<Element>> actions = 
         new Dictionary<ProcessType,Action<Element>>();

      public Class1()
      {
         actions.Add( ProcessType.This, DoThis );
         actions.Add( ProcessType.That, DoThat );
         actions.Add( ProcessType.SomethingElse, DoSomethingElse );
      }

      // Element actions:

      // This example defines 3 distict actions
      // that can be applied to individual elements,
      // But for the sake of the argument, make
      // no assumption about how many distict
      // actions there may, and that there could
      // possibly be many more.

      public void DoThis( Element element )
      {
         // Do something to element
      }

      public void DoThat( Element element )
      {
         // Do something to element
      }

      public void DoSomethingElse( Element element )
      {
         // Do something to element
      }

      public void Apply( ProcessType processType, IEnumerable<Element> elements )
      {
         Action<Element> action = null;
         if( ! actions.TryGetValue( processType, out action ) )
            throw new ArgumentException("processType");
         foreach( element in elements ) 
            action(element);
      }
   }

Những gì ví dụ cho thấy thực sự chỉ là một loại ràng buộc muộn cho phép người ta gọi một trong nhiều hành động có thể có tác dụng phụ trên chuỗi các phần tử, mà không phải viết một cấu trúc chuyển đổi lớn để giải mã giá trị xác định hành động và dịch nó vào phương thức tương ứng của nó.

Để thông thạo người ta có thể sử dụng một mẹo như vậy:

GetItems()
    .Select(i => new Action(i.DoStuf)))
    .Aggregate((a, b) => a + b)
    .Invoke();

Đối với VB.NET, bạn nên sử dụng:

listVariable.ForEach(Sub(i) i.Property = "Value")

Một ForEachví dụ khác

public static IList<AddressEntry> MapToDomain(IList<AddressModel> addresses)
{
    var workingAddresses = new List<AddressEntry>();

    addresses.Select(a => a).ToList().ForEach(a => workingAddresses.Add(AddressModelMapper.MapToDomain(a)));

    return workingAddresses;
}