Как присоединиться к двум спискам в c # [duplicate]

JaredPar имеет библиотеку с множеством полезных вещей, включая Zip, который позволит вам делать то, что вы хотите сделать.

MSDN имеет следующий пример пользовательских последовательностей . И Уэлбог прав; если у вас нет указателя на базовые данные, у вас нет гарантии, что операция сделает то, что вы ожидаете.

Непроверенный, но должен работать:

IEnumerable<KeyValuePair<T, U>> Zip<T, U>(IEnumerable<T> t, IEnumerable<U> u) {
    IEnumerator<T> et = t.GetEnumerator();
    IEnumerator<U> eu = u.GetEnumerator();

    for (;;) {
        bool bt = et.MoveNext();
        bool bu = eu.MoveNext();
        if (bt != bu)
            throw new ArgumentException("Different number of elements in t and u");
        if (!bt)
            break;
        yield return new KeyValuePair<T, U>(et.Current, eu.Current);
    }
}

Посмотрите на nextension :

В настоящее время реализованные методы

IEnumerable

• ForEach Выполняет указанное действие на каждом элементе IEnumerable.
• Элементы группы кластеров в лотах одинакового размера.
• Scan Создает список, применяя делегат к парам элементов в IEnumerable.
• AtLeast Проверяет, что в IEnumerable есть хотя бы определенное количество элементов.
• Проверки AtMost В IEnumerable есть не более определенного количества элементов.
• Zip Создает список путем объединения двух других списков в один.
• Цикл Создает список, повторяя другой список.

Вы можете использовать методы Zip в MoreLINQ .

Как обновление для любого, кто сталкивается с этим вопросом, .NET 4.0 поддерживает это как ex из MS:

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

var numbersAndWords = numbers.Zip(words, (first, second) => first + " " + second);

Другая реализация из проекта функционально-dotnet Алексея Романова:

/// <summary>
/// Takes two sequences and returns a sequence of corresponding pairs. 
/// If one sequence is short, excess elements of the longer sequence are discarded.
/// </summary>
/// <typeparam name="T1">The type of the 1.</typeparam>
/// <typeparam name="T2">The type of the 2.</typeparam>
/// <param name="sequence1">The first sequence.</param>
/// <param name="sequence2">The second sequence.</param>
/// <returns></returns>
public static IEnumerable<Tuple<T1, T2>> Zip<T1, T2>(
    this IEnumerable<T1> sequence1, IEnumerable<T2> sequence2) {
    using (
        IEnumerator<T1> enumerator1 = sequence1.GetEnumerator())
    using (
        IEnumerator<T2> enumerator2 = sequence2.GetEnumerator()) {
        while (enumerator1.MoveNext() && enumerator2.MoveNext()) {
            yield return
                Pair.New(enumerator1.Current, enumerator2.Current);
        }
    }
    //
    //zip :: [a] -> [b] -> [(a,b)]
    //zip (a:as) (b:bs) = (a,b) : zip as bs
    //zip _      _      = []
}

Замените Pair.New новым KeyValuePair<T1, T2> (и возвращаемым типом) хорошо идти.

Я бы использовал что-то вдоль линий -

IEnumerable<KeyValuePair<T,U>> Merge<T,U>(IEnumerable<T> keyCollection, IEnumerable<U> valueCollection)
{
    var keys = keyCollection.GetEnumerator();
    var values = valueCollection.GetEnumerator();
    try
    { 
        keys.Reset();
        values.Reset();

        while (keys.MoveNext() && values.MoveNext())
        {
            yield return new KeyValuePair<T,U>(keys.Current,values.Current);
        }
    }
    finally
    {
        keys.Dispose();
        values.Dispose();
    }
}

Это должно работать правильно и правильно очищать после этого.

Подумайте о том, что вы более подробно задаете здесь:

Вы хотите объединить два IEnumerables, в которых «индексы элементов, соединенных вместе в KeyValuePair, одинаковы», но вы " не имеют счетчика или индекса для элементов, которые я объединяю ».

Нет никакой гарантии, что ваши IEnumerables даже отсортированы или несортированы. Нет никакой корреляции между двумя вашими объектами IEnumerable, так как вы можете их скоррелировать?