ExtList.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;

namespace DirectOutput.General.Generic
{
    public class ExtList<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, ICollection, IList
    {
        private List<T> _InternalList = new List<T>();


        public int IndexOf(T Item)
        {
            
            return _InternalList.IndexOf(Item);
        }

        public void CopyTo(T[] Array, int ArrayIndex)
        {
            _InternalList.CopyTo(Array, ArrayIndex);
        }


        public bool IsReadOnly
        {
            get { return false; }
        }


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


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

        public void Add(T NewListItem)
        {
            if (BeforeInsert != null)
            {
                BeforeInsert(this, new InsertEventArgs<T>(-1, NewListItem));
            }
            _InternalList.Add(NewListItem);
            if (AfterInsert != null)
            {
                AfterInsert(this, new InsertEventArgs<T>(_InternalList.IndexOf(NewListItem), NewListItem));
            }
        }


        public void AddRange(IEnumerable<T> Collection)
        {
            foreach (T Item in Collection)
            {
                Add(Item);
            }
        }


        public ExtList<T> Clone()
        {
            ExtList<T> L = new ExtList<T>();
            foreach (T Item in this)
            {
                L.Add(Item);
            }
            return L;
        }



        public void Insert(int Index, T Item)
        {
            if (BeforeInsert != null)
            {
                BeforeInsert(this, new InsertEventArgs<T>(Index, Item));
            }

            _InternalList.Insert(Index, Item);

            if (AfterInsert != null)
            {
                AfterInsert(this, new InsertEventArgs<T>(Index, Item));
            }


        }



        public void Clear()
        {
            if (BeforeClear != null)
            {
                BeforeClear(this, new EventArgs());
            }
            _InternalList.Clear();
            if (AfterClear != null)
            {
                AfterClear(this, new EventArgs());
            }
        }



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



        public bool Remove(T ItemToRemove)
        {
            bool ItemRemoved = false;
            if (_InternalList.Contains(ItemToRemove))
            {
                int Index = _InternalList.IndexOf(ItemToRemove);
                if (BeforeRemove != null)
                {
                    BeforeRemove(this, new RemoveEventArgs<T>(Index, ItemToRemove));
                }

                _InternalList.Remove(ItemToRemove);
                ItemRemoved = true;
                if (AfterRemove != null)
                {
                    AfterRemove(this, new RemoveEventArgs<T>(Index, ItemToRemove));
                }
            }
            return ItemRemoved;
        }


        public void RemoveAt(int Index)
        {
            T ItemToRemove = this[Index];
            if (BeforeRemove != null)
            {
                BeforeRemove(this, new RemoveEventArgs<T>(Index, ItemToRemove));
            }

            _InternalList.RemoveAt(Index);

            if (AfterRemove != null)
            {
                AfterRemove(this, new RemoveEventArgs<T>(Index, ItemToRemove));
            }

        }



        public bool Contains(T ItemToCheck)
        {
            return _InternalList.Contains(ItemToCheck);
        }



        public T this[int Index]
        {

            get { return _InternalList[Index]; }
            set
            {
                T OldItem = _InternalList[Index];
                if (BeforeSet != null)
                {
                    BeforeSet(this, new SetEventArgs<T>(Index, OldItem, value));
                }

                _InternalList[Index] = value;
                if (AfterSet != null)
                {
                    AfterSet(this, new SetEventArgs<T>(Index, OldItem, value));
                }
            }
        }


        public void Sort()
        {
            _InternalList.Sort();
        }


        public void Sort(IComparer<T> Comparer)
        {
            _InternalList.Sort(Comparer);
        }
        public void Sort(Comparison<T> Comparison)
        {
            _InternalList.Sort(Comparison);
        }



        public T[] ToArray()
        {
            return _InternalList.ToArray();
        }


        #region Events
        #region Clear Events


        public event EventHandler<EventArgs> BeforeClear;



        public event EventHandler<EventArgs> AfterClear;


        #endregion
        #region Insert Events

        public event EventHandler<InsertEventArgs<T>> BeforeInsert;

        public event EventHandler<InsertEventArgs<T>> AfterInsert;


        #endregion
        #region Remove Events

        public event EventHandler<RemoveEventArgs<T>> BeforeRemove;


        public event EventHandler<RemoveEventArgs<T>> AfterRemove;

        #endregion
        #region Set Events


        public event EventHandler<SetEventArgs<T>> BeforeSet;


        public event EventHandler<SetEventArgs<T>> AfterSet;



        #endregion

        #endregion


        public ExtList()
        {

        }

        public ExtList(IEnumerable<T> EnumerableList)
        {
            AddRange(EnumerableList);
        }



        #region ICollection Member

        public void CopyTo(Array array, int index)
        {
            ((ICollection)_InternalList).CopyTo(array, index);
        }

        public bool IsSynchronized
        {
            get { return ((ICollection)_InternalList).IsSynchronized; }
        }

        public object SyncRoot
        {
            get { return ((ICollection)_InternalList).SyncRoot; }
        }

        #endregion

        #region IList Member


        public int Add(object value)
        {
            if(value.GetType() != typeof(T)) {
                throw new ArgumentException(" Value is of a wrong type.");
            }
            Add((T)value);
            return _InternalList.Count - 1;
        }


        public bool Contains(object value)
        {
            if (value.GetType() != typeof(T))
            {
                throw new ArgumentException(" Value is of a wrong type.");
            }
            return _InternalList.Contains((T)value);
        }

        public int IndexOf(object value)
        {
            if (value.GetType() != typeof(T))
            {
                throw new ArgumentException(" Value is of a wrong type.");
            }
            return _InternalList.IndexOf((T)value);
        }

        public void Insert(int index, object value)
        {
            if (value.GetType() != typeof(T))
            {
                throw new ArgumentException(" Value is of a wrong type.");
            }
            Insert(index, (T)value);
        }

        public bool IsFixedSize
        {
            get { return ((IList)_InternalList).IsFixedSize; }
        }

        public void Remove(object value)
        {
            if (value.GetType() != typeof(T))
            {
                throw new ArgumentException(" Value is of a wrong type.");
            }
            Remove((T)value);
        }

        object IList.this[int index]
        {
            get
            {
                return _InternalList[index];
            }
            set
            {
                this[index] = (T)value;
            }
        }

        #endregion
    }

}