C# 我相信你在这里射击是为了什么。如果这么简单的话，我会自杀的。我将把它添加到我的代码中并查看！星期一早上还太早；）是的，我现在就是这样做的，和你一样，我觉得它不是很干净，可能更容易完成。你的应用程序花了多少时间复制值？会有重复的值吗？e、 g.{1,5,5,

---

我相信你在这里射击是为了什么。

如果这么简单的话，我会自杀的。我将把它添加到我的代码中并查看！星期一早上还太早；）是的，我现在就是这样做的，和你一样，我觉得它不是很干净，可能更容易完成。你的应用程序花了多少时间复制值？会有重复的值吗？e、 g.{1,5,5,7,11}顺便说一句，如果您正在使用NHibernate并处理非重复实体，您可能希望使用Iesi.Collections.ISet，而不是IList。ISet强制要求没有重复项。@瑞克-不，我不想要重复的值。@Kyralessa-是的，这就是我写这个问题的确切原因-一切都回到了nhibernate。我将一个父对象及其子对象作为JSON传递给我的codebehind。因为它是序列化的，而子对象上没有“parent”属性，所以我需要在.NET中手动分配它：（因此，这个？事实上，我问这个问题是因为NHibernate的持久性问题…而不是ints，我有表示数据库记录的实体。我应该将我的标题改写为最少的代码量，而不是“高效”，因为我认为这可能会让一些人感到厌烦。Yeppers，这正是我需要的。我需要的是“未更改”答案保持不变。所以我今天学到了两件事，oldList=newList将它们合并在一起，非常可爱。然而，这个答案正是我所需要的，并且比我最初的解决方案少了很多代码！感谢这是一个O（n*n）复杂的方法（考虑到Contains调用是O（n））请注意，在与上述算法合并后，

OriginalList

中的项目顺序不一定与

NewList

中的顺序匹配。顺便说一句，使用Except会使其更短，但如果使用引用类型，则必须创建并传递自定义IEqualityComparer。这是更多的代码。假设我是我们正在初始化引用类型…我使用了一个具有guid ParentId的对象，而不是INT，然后是一些其他字段。然后如何比较每个对象的ParentId属性？最简单的方法是重写Equals。以上两行都将使用重写。（我已经测试过了，这就是为什么我没有使用Exception；它没有使用Equals覆盖。）如果你不能覆盖Equals，你可以创建一个IEqualityComparer并将它作为第二个参数传递给Contains。感谢你提供的代码示例，我将在我的项目tonite中试用它（因为事实上我使用的是引用类型，但我不想把我的问题搞得一团糟，我想“保持简单”。谢谢！

IList<int> originalList = new List<int>();
originalList.add(1);
originalList.add(5);
originalList.add(10);

IList<int> newList = new List<int>();
newList.add(1);
newList.add(5);
newList.add(7);  
newList.add(11);

{ 1, 5, 7, 11 }

originalList = newList;

originalList = new List<int>(newList);

List<int> firstList = new List<int>() {1, 2, 3, 4, 5};
List<int> secondList = new List<int>() {1, 3, 5, 7, 9};

List<int> newList = new List<int>();

foreach (int i in firstList)
{
  newList.Add(i);
}

foreach (int i in secondList)
{
  if (!newList.Contains(i))
  {
    newList.Add(i);
  }
}

for(int i = originalList.length-1; i >=0; --i)
{
     if (!newList.Contains(originalList[i])
            originalList.RemoveAt(i);
}

foreach(int n in newList)
{
     if (!originaList.Contains(n))
           originalList.Add(n);
}

originalList = new List<int>(
                      from x in newList
                      join y in originalList on x equals y into z
                      from y in z.DefaultIfEmpty()
                      select x);

public class IEnumerableDiff<T>
{
    private delegate bool Compare(T x, T y);

    private List<T> _inXAndY;
    private List<T> _inXNotY;
    private List<T> _InYNotX;

    /// <summary>
    /// Compare two IEnumerables.
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <param name="compareKeys">True to compare objects by their keys using Data.GetObjectKey(); false to use object.Equals comparison.</param>
    public IEnumerableDiff(IEnumerable<T> x, IEnumerable<T> y, bool compareKeys)
    {
        _inXAndY = new List<T>();
        _inXNotY = new List<T>();
        _InYNotX = new List<T>();
        Compare comparer = null;
        bool hit = false;

        if (compareKeys)
        {
            comparer = CompareKeyEquality;
        }
        else
        {
            comparer = CompareObjectEquality;
        }


        foreach (T xItem in x)
        {
            hit = false;
            foreach (T yItem in y)
            {
                if (comparer(xItem, yItem))
                {
                    _inXAndY.Add(xItem);
                    hit = true;
                    break;
                }
            }
            if (!hit)
            {
                _inXNotY.Add(xItem);
            }
        }

        foreach (T yItem in y)
        {
            hit = false;
            foreach (T xItem in x)
            {
                if (comparer(yItem, xItem))
                {
                    hit = true;
                    break;
                }
            }
            if (!hit)
            {
                _InYNotX.Add(yItem);
            }
        }
    }

    /// <summary>
    /// Adds and removes items from the x (current) list so that the contents match the y (new) list.
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <param name="compareKeys"></param>
    public static void SyncXList(IList<T> x, IList<T> y, bool compareKeys)
    {
        var diff = new IEnumerableDiff<T>(x, y, compareKeys);
        foreach (T item in diff.InXNotY)
        {
            x.Remove(item);
        }
        foreach (T item in diff.InYNotX)
        {
            x.Add(item);
        }
    }

    public IList<T> InXAndY
    {
        get { return _inXAndY; }
    }

    public IList<T> InXNotY
    {
        get { return _inXNotY; }
    }

    public IList<T> InYNotX
    {
        get { return _InYNotX; }
    }

    public bool ContainSameItems
    {
        get { return _inXNotY.Count == 0 && _InYNotX.Count == 0; }
    }

    private bool CompareObjectEquality(T x, T y)
    {
        return x.Equals(y);
    }

    private bool CompareKeyEquality(T x, T y)
    {
        object xKey = Data.GetObjectKey(x);
        object yKey = Data.GetObjectKey(y);
        return xKey.Equals(yKey);
    }

}

originalList.RemoveAll(x => !newList.Contains(x));
originalList.AddRange(newList.Where(x => !originalList.Contains(x)));

class EqualThingTester : IEqualityComparer<Thing>
{
    public bool Equals(Thing x, Thing y)
    {
        return x.ParentID.Equals(y.ParentID);
    }

    public int GetHashCode(Thing obj)
    {
        return obj.ParentID.GetHashCode();
    }
}

originalList.RemoveAll(x => !newList.Contains(x, new EqualThingTester()));
originalList.AddRange(newList.Where(x => !originalList.Contains(x, new EqualThingTester())));

originalList.RemoveAll(x => !newList.Contains(x, new EqualThingTester()));
originalList.AddRange(newList.Except(originalList, new EqualThingTester()));

var List3 = List1.Intersect(List2);