이것은 일반적인 지식을 위해서만 :
두 개가있는 경우 List 라고 가정 하고 동일한 foreach 루프로 둘 다 반복하고 싶습니다.
편집하다
명확히하기 위해이 작업을 수행하고 싶었습니다.
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과 정적 Tuple을 사용하여 중괄호를 절약 할 수도 있습니다.
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);
}
}
}
답변
C # 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}");
}
답변
아니요, for 루프를 사용해야합니다.
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를 반환합니다.
그것이 당신이 원하는 것이지만 거의 그렇지 않다면 더 자세히 설명하면 도움이 될 것입니다.