C# 已更改项目的列表

我需要在c#中创建一个包含三个列表的列表。一个包含新添加的项目，另一个包含已更新的项目，另一个包含已删除的项目。 我创建了一个从ObservaleCollection继承的类，其中T是INotifyPropertyChanged，它有我提到的三个列表。一切正常，但我有个问题。我希望这个列表被发送到一个WCF服务，所以它被序列化反序列化，这就是我的问题。序列化后，每个项目都包含在新项目列表中

有解决办法吗？框架或nugget包中是否有实现此案例的集合。 非常感谢

更新1 目前我已经写了两篇文章试图找到我的目标，但它们都有相同的问题。通过WCF发送对象时，每个项目都包含在addedItem列表中。这似乎是一个序列化问题，但我还没有找到任何解决方案

这是我写的课程

这是新的

[CollectionDataContract]
        public class ListWithStates<T> : IList<T>, ICollection<T>, IReadOnlyList<T>, IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable 
            where T: INotifyPropertyChanged
        {
            [DataMember]
            public List<T> addedItems { get; set; }
            [DataMember]
            public List<T> updatedItems { get; set; }
            [DataMember]
            public List<T> removedItems { get; set; }
            [DataMember]
            public List<T> items { get; set; }

            #region Constructor

            public ListWithStates() : this(new List<T>()) { }

            public ListWithStates(IEnumerable<T> collection)
            {
                this.items = new List<T>(collection);

                InitStateLists();
                CreateEvents();
            }

            private void InitStateLists()
            {
                this.addedItems = new List<T>();
                this.updatedItems = new List<T>();
                this.removedItems = new List<T>();
            }

            private void CreateEvents()
            {
                foreach(T item in this.items)
                    item.PropertyChanged += Item_PropertyChanged;
            }

            #endregion


            #region Propiedades

            public int Count
            {
                get
                {
                    return this.items.Count;
                }
            }

            public bool IsReadOnly
            {
                get
                {
                    return false;
                }
            }

            public T this[int index]
            {
                get
                {
                    return this.items[index];
                }

                set
                {
                    RemoveItemFromStateLists(this[index]);
                    this[index] = value;
                    AddItemToStateLists(value);
                }
            }

            #endregion


            #region Implementación de interfaces

            public int IndexOf(T item)
            {
                return this.items.IndexOf(item);
            }

            public void Insert(int index, T item)
            {
                RemoveItemFromStateLists(this.items[index]);
                this.items.Insert(index, item);
                AddItemToStateLists(item);
            }

            public void RemoveAt(int index)
            {
                RemoveItemFromStateLists(this.items[index]);
                this.items.RemoveAt(index);
            }

            public void Add(T item)
            {
                this.items.Add(item);
                AddItemToStateLists(item);
            }

            public void Clear()
            {
                foreach (T item in this.items)
                    RemoveItemFromStateLists(item);

                this.items.Clear();
            }

            public bool Contains(T item)
            {
                return this.items.Contains(item);
            }

            public void CopyTo(T[] array, int arrayIndex)
            {
                this.items.CopyTo(array, arrayIndex);
            }

            public bool Remove(T item)
            {
                RemoveItemFromStateLists(item);
                return this.items.Remove(item);
            }

            public IEnumerator<T> GetEnumerator()
            {
                return this.items.GetEnumerator();
            }

            IEnumerator IEnumerable.GetEnumerator()
            {
                return this.items.GetEnumerator();
            }

            #endregion


            #region Métodos

            private void AddItemToStateLists(T item)
            {
                if (this.addedItems.Contains(item))
                    return;

                this.addedItems.Add(item);
                item.PropertyChanged += Item_PropertyChanged;
            }

            private void UpdateItemFromStateLists(T item)
            {
                if (this.addedItems.Contains(item))
                    return;
                if (this.updatedItems.Contains(item))
                    return;

                this.updatedItems.Add(item);
            }

            private void RemoveItemFromStateLists(T item)
            {
                item.PropertyChanged -= Item_PropertyChanged;

                if (this.addedItems.Contains(item))
                {
                    this.addedItems.Remove(item);
                    return;
                }

                if (this.updatedItems.Contains(item))
                {
                    this.updatedItems.Remove(item);
                    return;
                }

                if (!this.removedItems.Contains(item))
                    this.removedItems.Add(item);
            }

            private void Item_PropertyChanged(object sender, PropertyChangedEventArgs e)
            {
                if (!(sender is T))
                    return;

                UpdateItemFromStateLists((T)sender);
            }

            #endregion
        }

[CollectionDataContract]
带有状态的公共类列表：IList、ICollection、IReadOnlyList、IReadOnlyCollection、IEnumerable、IEnumerable
其中T:INotifyPropertyChanged
{
[数据成员]
公共列表加法器{get；set；}
[数据成员]
公共列表updateItems{get；set；}
[数据成员]
公共列表removedItems{get；set；}
[数据成员]
公共列表项{get；set；}
#区域构造函数
public ListWithStates（）：此（新列表（））{}
带有状态的公共列表（IEnumerable集合）
{
this.items=新列表（集合）；
InitStateLists（）；
CreateEvents（）；
}
私有void InitStateLists（）
{
this.addedItems=新列表（）；
this.updateItems=新列表（）；
this.removedItems=新列表（）；
}
私有void CreateEvents（）
{
foreach（此.items中的T项）
item.PropertyChanged+=item_PropertyChanged；
}
#端区
#邻近区
公共整数计数
{
得到
{
返回此.items.Count；
}
}
公共图书馆是只读的
{
得到
{
返回false；
}
}
公共T此[int索引]
{
得到
{
返回此.items[索引]；
}
设置
{
从StateList（此[索引]）中删除项目；
此[索引]=值；
AddItemToStateList（值）；
}
}
#端区
#区域接口实现
公共整数索引（T项）
{
返回此.items.IndexOf（item）；
}
公共空白插入（整数索引，T项）
{
从StateList（this.items[索引]）中删除项目；
本.项目.插入（索引，项目）；
补充报表（项目）；
}
公共无效删除（整数索引）
{
从StateList（this.items[索引]）中删除项目；
此.items.RemoveAt（索引）；
}
公共作废新增（T项）
{
此.items.Add（item）；
补充报表（项目）；
}
公共空间清除（）
{
foreach（此.items中的T项）
从状态列表（项目）中删除项目；
this.items.Clear（）；
}
公共布尔包含（T项）
{
返回此.items.Contains（项目）；
}
public void CopyTo（T[]数组，int arrayIndex）
{
this.items.CopyTo（数组，arrayIndex）；
}
公共布尔删除（T项）
{
从状态列表（项目）中删除项目；
返回此。项目。删除（项目）；
}
公共IEnumerator GetEnumerator（）
{
返回此.items.GetEnumerator（）；
}
IEnumerator IEnumerable.GetEnumerator（）
{
返回此.items.GetEnumerator（）；
}
#端区
#梅托多地区
私有无效AddItemToStateList（T项）
{
如果（本附录包含（项目））
返回；
本.增编.增编（项目）；
item.PropertyChanged+=item_PropertyChanged；
}
私有void updateItemFromStateList（T项）
{
如果（本附录包含（项目））
返回；
if（this.updateItems.Contains（项））
返回；
this.updateItems.Add（项）；
}
私有void RemoveItemFromStateList（T项）
{
item.PropertyChanged-=item_PropertyChanged；
如果（本附录包含（项目））
{
本.增补.删除（项目）；
返回；
}
if（this.updateItems.Contains（项））
{
this.updateItems.Remove（项）；
返回；
}
如果（！this.removedItems.Contains（item））
此.removedItems.Add（项目）；
}
私有无效项\u PropertyChanged（对象发送方，PropertyChangedEventArgs e）
{
如果（！（发送方为T））
返回；
updateItemFromStateList（（T）发送方）；
[CollectionDataContract]
    public class ObservableCollectionWithStates<T> : ObservableCollection<T> where T : INotifyPropertyChanged
    {
        [DataMember]
        public List<T> addedItems { get; set; }
        [DataMember]
        public List<T> updatedItems { get; set; }
        [DataMember]
        public List<T> removedItems { get; set; }

        #region Constructor

        public ObservableCollectionWithStates() : base()
        {
            InitStateLists();
            CreateEvents();
        }

        public ObservableCollectionWithStates(List<T> list) : base(list)
        {
            InitStateLists();
            CreateEvents();
        }

        public ObservableCollectionWithStates(IEnumerable<T> collection) : base(collection)
        {
            InitStateLists();
            CreateEvents();
        }

        private void InitStateLists()
        {
            this.addedItems = new List<T>();
            this.updatedItems = new List<T>();
            this.removedItems = new List<T>();
        }

        private void CreateEvents()
        {
            foreach (T item in this)
                item.PropertyChanged += Item_PropertyChanged;
        }

        #endregion


        #region Métodos sobreescritos

        protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
        {
            if (e.OldItems != null)
            {
                foreach(T item in e.OldItems)
                    item.PropertyChanged -= Item_PropertyChanged;
            }

            if (e.NewItems != null)
            {
                foreach (T item in e.NewItems)
                    item.PropertyChanged += Item_PropertyChanged;
            }

            UpdateStateLists(e.Action, e.OldItems, e.NewItems);
            base.OnCollectionChanged(e);
        }

        private void UpdateStateLists(NotifyCollectionChangedAction action, IList oldItems, IList newItems)
        {
            if (action == NotifyCollectionChangedAction.Add)
            {
                foreach (var item in newItems)
                    AddItemToStateLists((T)item);
            }
            else if (action == NotifyCollectionChangedAction.Remove)
            {
                foreach (var item in oldItems)
                    RemoveItemFromStateLists((T)item);
            }
            else if (action == NotifyCollectionChangedAction.Replace)
            {
                foreach (var item in newItems)
                    AddItemToStateLists((T)item);

                foreach (var item in oldItems)
                    RemoveItemFromStateLists((T)item);
            }
            else if (action == NotifyCollectionChangedAction.Reset)
            {
                foreach (var item in oldItems)
                    RemoveItemFromStateLists((T)item);
            }
        }

        #endregion


        #region Métodos propios

        private void AddItemToStateLists(T item)
        {
            if (this.addedItems.Contains(item))
                return;

            this.addedItems.Add(item);
        }

        private void UpdateItemFromStateLists(T item)
        {
            if (this.addedItems.Contains(item))
                return;
            if (this.updatedItems.Contains(item))
                return;

            this.updatedItems.Add(item);
        }

        private void RemoveItemFromStateLists(T item)
        {
            if (this.addedItems.Contains(item))
            {
                this.addedItems.Remove(item);
                return;
            }

            if (this.updatedItems.Contains(item))
            {
                this.updatedItems.Remove(item);
                return;
            }

            if (!this.removedItems.Contains(item))
                this.removedItems.Add(item);
        }

        private void Item_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (!(sender is T))
                return;

            UpdateItemFromStateLists((T)sender);
        }

        #endregion
    }

class Items
{
    private List<string> NewItems { get; set; }
    private List<string> UpdatedItems { get; set; }
    private List<string> RemovedItems { get; set; }
}

        List<Items> ListOfItems = new List<Items>();