Лучший алгоритм для синхронизации двух IList в C# 2.0

Для запуска я избавился бы от изменяемой структуры. Изменяемые типы значения являются существенно плохой вещью. (Как общедоступные поля, IMO.)

Вероятно, стоит создать Словарь, таким образом, можно легко сравнить содержание двух списков. После того как у Вас есть тот простой способ проверить на присутствие/отсутствие, остальные должны быть простыми.

Чтобы быть честными, хотя, это походит, Вы в основном хотите, чтобы L2 был полной копией L1... очищают L2 и просто называют AddRange? Или точка то, что Вы также хотите принять другие меры при изменении L2?

В дополнение к комментарию Jon Skeet делают Вашу структуру Учетной записи классом и переопределяют Равняние () и GetHashCode () метод для получения хорошей проверки равенства.

Если Ваши два списка отсортированы, то можно просто идти через них в тандеме. Это - O (m+n) операция. Следующий код мог помочь:

class Program
{
    static void Main()
    {
        List<string> left = new List<string> { "Alice", "Charles", "Derek" };
        List<string> right = new List<string> { "Bob", "Charles", "Ernie" };

        EnumerableExtensions.CompareSortedCollections(left, right, StringComparer.CurrentCultureIgnoreCase,
            s => Console.WriteLine("Left: " + s), s => Console.WriteLine("Right: " + s), (x,y) => Console.WriteLine("Both: " + x + y));
    }
}

static class EnumerableExtensions
{
    public static void CompareSortedCollections<T>(IEnumerable<T> source, IEnumerable<T> destination, IComparer<T> comparer, Action<T> onLeftOnly, Action<T> onRightOnly, Action<T, T> onBoth)
    {
        EnumerableIterator<T> sourceIterator = new EnumerableIterator<T>(source);
        EnumerableIterator<T> destinationIterator = new EnumerableIterator<T>(destination);

        while (sourceIterator.HasCurrent && destinationIterator.HasCurrent)
        {
            // While LHS < RHS, the items in LHS aren't in RHS
            while (sourceIterator.HasCurrent && (comparer.Compare(sourceIterator.Current, destinationIterator.Current) < 0))
            {
                onLeftOnly(sourceIterator.Current);
                sourceIterator.MoveNext();
            }

            // While RHS < LHS, the items in RHS aren't in LHS
            while (sourceIterator.HasCurrent && destinationIterator.HasCurrent && (comparer.Compare(sourceIterator.Current, destinationIterator.Current) > 0))
            {
                onRightOnly(destinationIterator.Current);
                destinationIterator.MoveNext();
            }

            // While LHS==RHS, the items are in both
            while (sourceIterator.HasCurrent && destinationIterator.HasCurrent && (comparer.Compare(sourceIterator.Current, destinationIterator.Current) == 0))
            {
                onBoth(sourceIterator.Current, destinationIterator.Current);
                sourceIterator.MoveNext();
                destinationIterator.MoveNext();
            }
        }

        // Mop up.
        while (sourceIterator.HasCurrent)
        {
            onLeftOnly(sourceIterator.Current);
            sourceIterator.MoveNext();
        }

        while (destinationIterator.HasCurrent)
        {
            onRightOnly(destinationIterator.Current);
            destinationIterator.MoveNext();
        }
    }
}

internal class EnumerableIterator<T>
{
    private readonly IEnumerator<T> _enumerator;

    public EnumerableIterator(IEnumerable<T> enumerable)
    {
        _enumerator = enumerable.GetEnumerator();
        MoveNext();
    }

    public bool HasCurrent { get; private set; }

    public T Current
    {
        get { return _enumerator.Current; }
    }

    public void MoveNext()
    {
        HasCurrent = _enumerator.MoveNext();
    }
}

Необходимо будет быть осторожны относительно изменения наборов при итерации по ним, все же.

Если они не отсортированы, то сравнение каждого элемента в одном с каждым элементом в другом является O (млн), которые становятся болезненными действительно быстро.

Если можно перенести для копирования значений ключа с каждого набора в Словарь или подобный (т.е. набор с приемлемой производительностью при выяснении "X существует?"), затем Вы могли придумать что-то разумное.

L2 = L1.clone ()?

... но я предположил бы, что Вы забыли упоминать что-то.

Я знаю, что это старый пост, но вам стоит почитать AutoMapper. Он будет делать именно то, что вы хотите, очень гибким и настраиваемым способом.

AutoMapper