唯一元素List UniqueList

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;
using  System.Reflection.Emit;
using  NUnit.Framework;

namespace  SASTest
{

     #region  唯一列表
     // 添加元素保证唯一
     // 修改元素保证唯一
     public   class  UniqueList < T >  : IList < T >
         where  T : UniqueList < T > .UniqueItem
    {
        List < T >  list  =   new  List < T > ();

         public   int  Count
        {
             get
            {
                 return  list.Count;
            }
        }

         public   int  Add(T item)
        {
             if  ( ! Contains(item,  false ))
            {
                list.Add(item);
                item.CheckerEvent  +=   new  CallUniqueCheck(Item_CheckerEvent);
            }
             else
            {
                 throw   new  NotUniqueException();
            }
             return  list.Count  -   1 ;
        }

         public  T  this [ int  index]
        {
             get
            {
                 return  list[index];
            }
             set
            {
                 if  (value  ==   null )
                     throw   new  NullReferenceException();

                T tmp  =  list[index]; // 备份原来的对象
                list[index]  =  value; // 修改集合中的元素

                 if  (Contains(value,  true )) // 修改结束判断是否有重复
                {
                    list[index]  =  tmp; // 如果有重复，恢复集合
                     throw   new  NotUniqueException(); // 抛出异常
                }

                 if  ( ! object .ReferenceEquals(tmp, value)) // 如果没有重复并且替换后的元素和原来的元素不是同一个对象，要为该元素添加属性修改检查事件
                    value.CheckerEvent  +=   new  CallUniqueCheck(Item_CheckerEvent);

            }
        }

         private   void  Item_CheckerEvent(T item, Action < T >  action)
        {
            T tmp  =  (T)Activator.CreateInstance( typeof (T));
            Copy(item, tmp); // 备份原来的属性值到临时对象上
            action(item);
             if  (Contains(item,  true ))
            {
                Copy(tmp, item); // 如果失败，将备份的信息恢复
                 throw   new  NotUniqueException();
            }
        }

         private   bool  Contains(T item,  bool  edit) // 检查修改后的集合是否有重复 , 对于添加元素，在添加前检查是否已经有一个同样的。如果是修改， 则先修改再看修改后是否有两个相同的元素。
        {                                        // 修改后检查，如果发现有重复，一定要恢复原来的集合
             bool  result  =   false ;
             if  (item  ==   null )
                 throw   new  NullReferenceException();

             int  count  =   0 ;
             foreach  (T ui  in  list)
            {
                 if  (ui.Equals(item))
                {
                    count ++ ;
                }
            }
             if  (count  <=   0 )
                result  =   false ;
             else   if  (count  >   0 )
            {
                result  =   true ;
                 if  (edit  &&  count  ==   1 )
                    result  =   false ;

            }
             return  result;
        }

         private   static   void  Copy(T source, T target) // 辅助方法，拷备属性
        {
            Type t  =   typeof (T);

             foreach  (var item  in  t.GetProperties())
            {
                 try
                {
                    item.SetValue(target, item.GetValue(source,  null ),  null );
                }
                 catch  (Exception)
                {
                }
            }
        }

         public   delegate   void  CallUniqueCheck(T item, Action < T >  action);

         public   abstract   class  UniqueItem
        {
             internal   event  UniqueList < T > .CallUniqueCheck CheckerEvent;

             public   void  TryPropertyChange(Action < T >  action)
            {
                 if  (CheckerEvent  !=   null )
                {
                    CheckerEvent((T) this , action);
                }
                 else // 如果是为空表明现在这个对象还没有添加到集合中
                {
                    action((T) this ); // 直接修改属性
                }
            }

        }

         #region  IList<T> 成员

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

         public   void  Insert( int  index, T item)
        {
             if  ( ! Contains(item,  false ))
            {
                list.Insert(index, item);
                item.CheckerEvent  +=   new  CallUniqueCheck(Item_CheckerEvent);
            }
             else
            {
                 throw   new  NotUniqueException();
            }
        }

         public   void  RemoveAt( int  index)
        {
            list.RemoveAt(index);
        }

         #endregion

         #region  ICollection<T> 成员

         void  ICollection < T > .Add(T item)
        {
             this .Add(item);
        }

         public   void  Clear()
        {
             this .list.Clear();
        }

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

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

         public   bool  IsReadOnly
        {
             get
            {
                 return   false ;
            }
        }

         public   bool  Remove(T item)
        {
             return  list.Remove(item);
        }

         #endregion

         #region  IEnumerable<T> 成员

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

         #endregion

         #region  IEnumerable 成员

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
             return  list.GetEnumerator();
        }

         #endregion
    }



     public   class  NotUniqueException : ApplicationException
    {
         public  NotUniqueException()
            :  base ( " 元素重复 " )
        {

        }
         public  NotUniqueException( string  message)
            :  base (message)
        {

        }
    }

     #endregion

     #region  测试代码
    [TestFixture]
     public   class  Tester
    {
        [Test]
        [ExpectedException( " SASTest.NotUniqueException " )]
         public   void  AddTest() // 添加相同元素 
        {

            UniqueList < MyPoint >  list  =   new  UniqueList < MyPoint > ();

            list.Add( new  MyPoint { X  =   1 , Y  =   1  });
            list.Add( new  MyPoint { X  =   1 , Y  =   2  });
            list.Add( new  MyPoint { X  =   2 , Y  =   1  });
            list.Add( new  MyPoint { X  =   1 , Y  =   1  });


            Assert.AreEqual( 3 , list.Count); // 冲突时添不进相同元素
        }

        [Test]
        [ExpectedException( " SASTest.NotUniqueException " )]
         public   void  UpdatePropertyTest() // 修改元素属性，使元素重复
        {
            UniqueList < MyPoint >  list  =   new  UniqueList < MyPoint > ();
            list.Add( new  MyPoint { X  =   1 , Y  =   1  });
            list.Add( new  MyPoint { X  =   1 , Y  =   2  });
            list.Add( new  MyPoint { X  =   2 , Y  =   1  });

            list[ 0 ].X  =   2 ;

            Assert.AreEqual( 1 , list[ 0 ].X); // 冲突时修改不了

            list[ 0 ].X  =   10 ;
            Assert.AreEqual( 10 , list[ 0 ].X); // 不冲突时可以修改
        }

        [Test]
        [ExpectedException( " SASTest.NotUniqueException " )]
         public   void  UpdateTest() // 修改集合元素，使元素重复
        {
            UniqueList < MyPoint >  list  =   new  UniqueList < MyPoint > ();
            list.Add( new  MyPoint { X  =   1 , Y  =   1  });
            list.Add( new  MyPoint { X  =   1 , Y  =   2  });
            list.Add( new  MyPoint { X  =   2 , Y  =   1  });

            list[ 0 ]  =   new  MyPoint { X  =   1 , Y  =   2  };

            Assert.AreEqual( 2 , list[ 0 ].Y);

            list[ 0 ]  =   new  MyPoint { X  =   10 , Y  =   10  };

            Assert.AreEqual( 10 , list[ 0 ].X);
            Assert.AreEqual( 10 , list[ 0 ].Y);
        }

    }

     public   class  MyPoint : UniqueList < MyPoint > .UniqueItem
    {
         private   int  _x;

         public   int  X
        {
             get  {  return  _x; }
             set
            {
                TryPropertyChange(p  =>  p._x  =  value);
            }
        }

         private   int  _y;

         public   int  Y
        {
             get  {  return  _y; }
             set
            {
                TryPropertyChange(p  =>  p._y  =  value);
            }
        }

         public   override   bool  Equals( object  obj)
        {
             if  (obj  ==   null )
                 throw   new  NullReferenceException();
            MyPoint point  =  obj  as  MyPoint;
             return   this .X.Equals(point.X)  &&   this .Y.Equals(point.Y);
        }
    }

     #endregion
}