Это просто для общих знаний:
Если у меня есть два, скажем, Список, и я хочу итерации с одним и тем же циклом foreach, можем ли мы это сделать?
Edit
Чтобы уточнить, я хотел сделать это:
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];
Но с foreach =)
Это называется Zip и будет поддерживаться в .NET 4.
С этим вы сможете написать что-то вроде:
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);
}
В качестве альтернативы анонимному типу с именованными полями вы также можете сохранять на фигурных скобках с помощью кортежа и его статического помощника Tuple.Create:
foreach (var nw in numbers.Zip(words, Tuple.Create))
{
Console.WriteLine(nw.Item1 + nw.Item2);
}
Если вы не хотите ждать .NET 4.0, вы можете реализовать свой собственный метод Zip. Следующее работает с .NET 2.0. Вы можете настроить реализацию в зависимости от того, как вы хотите обрабатывать случай, когда две перечисления (или списки) имеют разную длину: это продолжается до конца более длинного перечисления, возвращая значения по умолчанию для отсутствующих элементов из более короткого перечисления.
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 или Concat, первый удаляет дубликаты, а позже
foreach (var item in List1.Union(List1))
{
//TODO: Real code goes here
}
foreach (var item in List1.Concat(List1))
{
//TODO: Real code goes here
}
Здесь используется настраиваемый метод расширения IEnumerable < > , который можно использовать для циклического преобразования двух списков одновременно.
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);
}
}
}
Вы также можете просто использовать переменную локального целого, если списки имеют одинаковую длину:
List<classA> listA = fillListA();
List<classB> listB = fillListB();
var i = 0;
foreach(var itemA in listA)
{
Console.WriteLine(itemA + listB[i++]);
}
Нет, вам нужно будет использовать for-loop для этого.
for (int i = 0; i < lst1.Count; i++)
{
//lst1[i]...
//lst2[i]...
}
Вы не можете сделать что-то вроде
foreach (var objCurrent1 int lst1, var objCurrent2 in lst2)
{
//...
}
Если вам нужен один элемент с соответствующим, который вы могли бы сделать
Enumerable.Range(0, List1.Count).All(x => List1[x] == List2[x]);
Это вернет true, если каждый элемент равен соответствующему во втором списке
Если это почти, но не совсем то, что вы хотите, это поможет, если вы разработаете больше.
Этот метод будет работать для реализации списка и может быть реализован как метод расширения.
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]);
}
}
С С# 7 вы можете использовать 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}");
}
Я понимаю/надеюсь, что списки имеют одинаковую длину: Нет, ваша единственная ставка идет с простым старым стандартом для цикла.