Lặp lại hai Danh sách hoặc Mảng với một câu lệnh ForEach trong C #

Điều này chỉ dành cho kiến ​​thức chung:

Nếu tôi có hai, hãy nói, Liệt kê và tôi muốn lặp lại cả hai với cùng một vòng lặp foreach, chúng ta có thể làm điều đó không?

Biên tập

Chỉ cần làm rõ, tôi muốn làm điều này:

List<String> listA = new List<string> { "string", "string" };
List<String> listB = new List<string> { "string", "string" };

for(int i = 0; i < listA.Count; i++)
    listB[i] = listA[i];

Nhưng với một foreach =)

Đây được gọi là thao tác Zip và sẽ được hỗ trợ trong .NET 4.

Với điều đó, bạn sẽ có thể viết một cái gì đó như:

var numbers = new [] { 1, 2, 3, 4 };
var words = new [] { "one", "two", "three", "four" };

var numbersAndWords = numbers.Zip(words, (n, w) => new { Number = n, Word = w });
foreach(var nw in numbersAndWords)
{
    Console.WriteLine(nw.Number + nw.Word);
}

Thay thế cho loại ẩn danh với các trường được đặt tên, bạn cũng có thể lưu vào dấu ngoặc nhọn bằng cách sử dụng Tuple và trình trợ giúp Tuple.Create tĩnh của nó:

foreach (var nw in numbers.Zip(words, Tuple.Create)) 
{
    Console.WriteLine(nw.Item1 + nw.Item2);
}

Nếu bạn không muốn đợi .NET 4.0, bạn có thể thực hiện Zipphương thức của riêng mình . Sau đây hoạt động với .NET 2.0. Bạn có thể điều chỉnh việc thực hiện tùy thuộc vào cách bạn muốn xử lý trường hợp hai liệt kê (hoặc danh sách) có độ dài khác nhau; cái này tiếp tục đến cuối bảng liệt kê dài hơn, trả về các giá trị mặc định cho các mục bị thiếu từ bảng liệt kê ngắn hơn.

static IEnumerable<KeyValuePair<T, U>> Zip<T, U>(IEnumerable<T> first, IEnumerable<U> second)
{
    IEnumerator<T> firstEnumerator = first.GetEnumerator();
    IEnumerator<U> secondEnumerator = second.GetEnumerator();

    while (firstEnumerator.MoveNext())
    {
        if (secondEnumerator.MoveNext())
        {
            yield return new KeyValuePair<T, U>(firstEnumerator.Current, secondEnumerator.Current);
        }
        else
        {
            yield return new KeyValuePair<T, U>(firstEnumerator.Current, default(U));
        }
    }
    while (secondEnumerator.MoveNext())
    {
        yield return new KeyValuePair<T, U>(default(T), secondEnumerator.Current);
    }
}

static void Test()
{
    IList<string> names = new string[] { "one", "two", "three" };
    IList<int> ids = new int[] { 1, 2, 3, 4 };

    foreach (KeyValuePair<string, int> keyValuePair in ParallelEnumerate(names, ids))
    {
        Console.WriteLine(keyValuePair.Key ?? "<null>" + " - " + keyValuePair.Value.ToString());
    }
}

Bạn có thể sử dụng Union hoặc Concat, cái trước loại bỏ trùng lặp, cái sau không

foreach (var item in List1.Union(List1))
{
   //TODO: Real code goes here
}

foreach (var item in List1.Concat(List1))
{
   //TODO: Real code goes here
}

Đây là một phương thức mở rộng tùy chỉnh IEnumerable <> có thể được sử dụng để lặp qua hai danh sách cùng một lúc.

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApplication1
{
    public static class LinqCombinedSort
    {
        public static void Test()
        {
            var a = new[] {'a', 'b', 'c', 'd', 'e', 'f'};
            var b = new[] {3, 2, 1, 6, 5, 4};

            var sorted = from ab in a.Combine(b)
                         orderby ab.Second
                         select ab.First;

            foreach(char c in sorted)
            {
                Console.WriteLine(c);
            }
        }

        public static IEnumerable<Pair<TFirst, TSecond>> Combine<TFirst, TSecond>(this IEnumerable<TFirst> s1, IEnumerable<TSecond> s2)
        {
            using (var e1 = s1.GetEnumerator())
            using (var e2 = s2.GetEnumerator())
            {
                while (e1.MoveNext() && e2.MoveNext())
                {
                    yield return new Pair<TFirst, TSecond>(e1.Current, e2.Current);
                }
            }

        }


    }
    public class Pair<TFirst, TSecond>
    {
        private readonly TFirst _first;
        private readonly TSecond _second;
        private int _hashCode;

        public Pair(TFirst first, TSecond second)
        {
            _first = first;
            _second = second;
        }

        public TFirst First
        {
            get
            {
                return _first;
            }
        }

        public TSecond Second
        {
            get
            {
                return _second;
            }
        }

        public override int GetHashCode()
        {
            if (_hashCode == 0)
            {
                _hashCode = (ReferenceEquals(_first, null) ? 213 : _first.GetHashCode())*37 +
                            (ReferenceEquals(_second, null) ? 213 : _second.GetHashCode());
            }
            return _hashCode;
        }

        public override bool Equals(object obj)
        {
            var other = obj as Pair<TFirst, TSecond>;
            if (other == null)
            {
                return false;
            }
            return Equals(_first, other._first) && Equals(_second, other._second);
        }
    }

}

Kể từ C # 7, bạn có thể sử dụng Tuples ...

int[] nums = { 1, 2, 3, 4 };
string[] words = { "one", "two", "three", "four" };

foreach (var tuple in nums.Zip(words, (x, y) => (x, y)))
{
    Console.WriteLine($"{tuple.Item1}: {tuple.Item2}");
}

// or...
foreach (var tuple in nums.Zip(words, (x, y) => (Num: x, Word: y)))
{
    Console.WriteLine($"{tuple.Num}: {tuple.Word}");
}

Không, bạn sẽ phải sử dụng một vòng lặp for cho điều đó.

for (int i = 0; i < lst1.Count; i++)
{
    //lst1[i]...
    //lst2[i]...
}

Bạn không thể làm một cái gì đó như

foreach (var objCurrent1 int lst1, var objCurrent2 in lst2)
{
    //...
}

Nếu bạn muốn một yếu tố với yếu tố tương ứng bạn có thể làm

Enumerable.Range(0, List1.Count).All(x => List1[x] == List2[x]);

Điều đó sẽ trả về true nếu mọi mục bằng với mục tương ứng trong danh sách thứ hai

Nếu đó là gần như nhưng không hoàn toàn những gì bạn muốn, nó sẽ giúp ích nếu bạn xây dựng nhiều hơn.

Phương pháp này sẽ hoạt động để thực hiện danh sách và có thể được thực hiện như một phương pháp mở rộng.

public void TestMethod()
{
    var first = new List<int> {1, 2, 3, 4, 5};
    var second = new List<string> {"One", "Two", "Three", "Four", "Five"};

    foreach(var value in this.Zip(first, second, (x, y) => new {Number = x, Text = y}))
    {
        Console.WriteLine("{0} - {1}",value.Number, value.Text);
    }
}

public IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(List<TFirst> first, List<TSecond> second, Func<TFirst, TSecond, TResult> selector)
{
    if (first.Count != second.Count)
        throw new Exception();  

    for(var i = 0; i < first.Count; i++)
    {
        yield return selector.Invoke(first[i], second[i]);
    }
}

Bạn cũng có thể chỉ cần sử dụng một biến số nguyên cục bộ nếu các danh sách có cùng độ dài:

List<classA> listA = fillListA();
List<classB> listB = fillListB();

var i = 0;
foreach(var itemA in listA)
{
    Console.WriteLine(itemA  + listB[i++]);
}

Bạn cũng có thể làm như sau:

var i = 0;
foreach (var itemA in listA)
{
  Console.WriteLine(itemA + listB[i++]);
}

Lưu ý: độ dài listAphải giống với listB.

Tôi hiểu / hy vọng rằng các danh sách có cùng độ dài: Không, đặt cược duy nhất của bạn là với một tiêu chuẩn cũ đơn giản cho vòng lặp.