C # bir ForEach deyimi ile iki Liste veya Diziler yineleme

Bu sadece genel bilgi için:

İki tane varsa, diyelim, Liste , ve her ikisini de aynı foreach döngüsüyle yinelemek istiyorum, bunu yapabilir miyiz?

Düzenle

Sadece açıklığa kavuşturmak için bunu yapmak istedim:

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

Ama bir foreach =) ile

Bu Zip işlemi olarak bilinir ve .NET 4'te desteklenir.

Bununla, şöyle bir şey yazabilirsiniz:

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

Adlandırılmış alanlara sahip anonim türe alternatif olarak, bir Tuple ve statik Tuple kullanarak parantezlere de kaydedebilirsiniz.

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

.NET 4.0'ı beklemek istemiyorsanız, kendi Zipyönteminizi uygulayabilirsiniz . Aşağıdaki .NET 2.0 ile çalışır. İki numaralandırmanın (veya listenin) farklı uzunluklara sahip olduğu durumu nasıl ele almak istediğinize bağlı olarak uygulamayı ayarlayabilirsiniz; bu daha uzun numaralandırmanın sonuna kadar devam eder ve daha kısa numaralandırmadan eksik öğeler için varsayılan değerleri döndürür.

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

Union veya Concat kullanabilirsiniz, birincisi kopyaları kaldırır, daha sonra

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

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

İşte aynı anda iki liste arasında geçiş yapmak için kullanılabilecek özel bir IEnumerable <> genişletme yöntemi.

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

}

C # 7'den beri, Tuples'ı kullanabilirsiniz ...

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

Hayır, bunun için bir for-loop kullanmanız gerekir.

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

Gibi bir şey yapamazsın

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

Eğer karşılık gelen bir eleman istiyorsanız

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

Her öğe ikinci listedeki ilgili öğeye eşitse bu doğru olur

Neredeyse ama tam olarak istediğiniz şey değilse, daha fazla ayrıntı vermeniz yardımcı olacaktır.

Bu yöntem bir liste uygulaması için kullanılabilir ve bir uzantı yöntemi olarak uygulanabilir.

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

Listeler aynı uzunlukta ise yerel bir tamsayı değişkeni de kullanabilirsiniz:

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

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

Ayrıca aşağıdakileri de yapabilirsiniz:

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

Not: uzunluğu ile listAaynı olmalıdır listB.

Listelerin aynı uzunlukta olduğunu anlıyorum / umuyorum: Hayır, tek bahsiniz döngü için eski bir standartla gidiyor.