EXTENSION DES LISTES GÉNÉRIQUES (DESIGN PATTERN "DECORATEUR")

/// <summary>
    /// Classe permettant de stocker une liste d'objets dont le type est de type T.
    /// Cette liste peut lever des évènements lors d'un ajout ou lors d'une suppression.
    /// Cette liste peut aussi lever des exception lorsque :
    /// - On tente d'ajouter un objet null à la liste,
    /// - On tente de retirer un objet null de la liste,
    /// - On tente d'ajouter un même objet plusieurs fois à la liste,
    /// - On tente de supprimer un objet de la liste alors que celui-ci n'existe pas.
    /// </summary>
    /// <typeparam name="T">Type de l'objet stocké dans la liste.</typeparam>
    [Serializable]
    public class EvtList <T> : IList<T>, IEnumerable, IEnumerable<T> // where T : VotreTypeObjetFari
    {
    	#region Privates

        /// <summary>
        /// Permet de stocker les éléments de la liste.
        /// </summary>
        private IList<T> InternalList = null;

        #endregion

        #region Events

        /// <summary>
        /// Survient lors de l'ajout d'un élément à la liste.
        /// </summary>
        public event EventHandler onAddInternal;

        /// <summary>
        /// Survient lors de l'ajout d'un élément à la liste.
        /// </summary>
        [field: NonSerialized]
        public event EventHandler onAdd;

        /// <summary>
        /// Survient lors de la suppression d'un élément de la liste.
        /// </summary>
        internal event EventHandler onRemoveInternal;

        /// <summary>
        /// Survient lors de la suppression d'un élément de la liste.
        /// </summary>
        [field: NonSerialized]
        public event EventHandler onRemove;

        /// <summary>
        /// Permet de lancer tous les évènements associés à l'ajout d'un élément à la liste.
        /// </summary>
        /// <param name="itemAdded">L'objet ajouté.</param>
        protected void LaunchAddEvents(T itemAdded) {
            try {
        		// Construction de l'objet AddEventArgs permettant de communiquer quel objet
                // a été ajouté à la liste.
                EvtListAddEventArgs args = new EvtListAddEventArgs(itemAdded);

                // Lancement des évènements onAddInternal puis onAdd.
                if (onAddInternal != null) onAddInternal(this, args);
                if (onAdd != null) onAdd(this, args);

        	} catch (Exception ex) {
                throw ex;
            }
        }

        /// <summary>
        /// Permet de lancer tous les évènements associés à la suppression d'un élément à la liste.
        /// </summary>
        /// <param name="itemRemoved">L'objet supprimé.</param>
        protected void LaunchRemoveEvents(T itemRemoved) {
            try {
                // Construction de l'objet AddEventArgs permettant de communiquer quel objet
                // a été supprimé à la liste.
                EvtListRemoveEventArgs args = new EvtListRemoveEventArgs(itemRemoved);

                // Lancement des évènements onAddInternal puis onAdd.
                if (onRemoveInternal != null) onRemoveInternal(this, args);
                if (onRemove != null) onRemove(this, args);

        	} catch (Exception ex) {
                throw ex;
        	}
        }

        #endregion

        #region Constructors
        public EvtList(){
        	InternalList = new List<T>();
        }
        
        public EvtList(IList<T> list){
        	InternalList = list;
        }
    	#endregion
    	
        #region IList<T> Members

        /// <summary>
        /// Permet de récupérer l'index d'un élément de la liste.
        /// </summary>
        /// <param name="item">L'élément recherché.</param>
        /// <returns>L'index de l'élément recherché.</returns>
        public int IndexOf(T item) {
            return InternalList.IndexOf(item);
        }

        /// <summary>
        /// Permet d'insérer un élément dans la liste, à un index précis.
        /// </summary>
        /// <param name="index">L'index ou l'objet doit être ajouté.</param>
        /// <param name="item">L'élément à ajouter.</param>
        public void Insert(int index, T item) {
            try{
        		lock(InternalList){
        		
	                // Si l'élément qui est ajouté est null ou déjà dans la liste, on lève une exception.
	                if (item == null) throw new ObjectAddedToEvtListNullError();
	                if (InternalList.Contains(item)) throw new ObjectAllreadyInEvtListError();
	
	                InternalList.Insert(index, item); // Insertion de l'élément dans la liste.
	                LaunchAddEvents(item); // Lancement des évènements qui doivent survenir lors de l'ajout d'un élément de la liste.
        		}
        	} catch (Exception ex) {
        		throw ex;
        	}
        }
        
        /// <summary>
        /// Permet de savoir si la liste est en lecture seule ou non.
        /// </summary>
        public bool IsReadOnly
        {
            get { return false; }
        }

        /// <summary>
        /// Permet de supprimer un élément de la liste à l'emplacement spécifié.
        /// </summary>
        /// <param name="index">L'index de l'élément à supprimer.</param>
        public void RemoveAt(int index) {
            try{
                T RemovedObject = InternalList[index]; // Stockage de l'élément supprimé pour l'envoyer aux gestionnaires d'évènements.
                InternalList.RemoveAt(index); // Suppression de l'élément dans la liste.
                LaunchRemoveEvents(RemovedObject); // Lancement des évènements qui doivent survenir lors de la suppression d'un élément de la liste.
            
        	} catch (Exception ex) {
        		throw ex;
        	}
        }

        /// <summary>
        /// Accesseur indexé. Permet d'accéder ou de modifier l'un des éléments de la liste à partir
        /// d'un index.
        /// </summary>
        /// <param name="index">L'index recherché.</param>
        /// <returns>L'élémént recherché.</returns>
        public T this[int index] {
            get { return InternalList[index]; }
            
            set {
                try{
                    //if (InternalList[index] != value) {
                        LaunchRemoveEvents(InternalList[index]);
                        InternalList[index] = value;
                        LaunchAddEvents(InternalList[index]);
                    //}
                } catch (Exception ex) {
            		throw ex;
            	}
            }
        }

        #endregion

        #region ICollection<T> Members

        /// <summary>
        /// Permet d'ajouter un élément à la liste.
        /// </summary>
        /// <param name="item"></param>
        public void Add(T item) {
            try {
                //Thread.BeginCriticalRegion(); // Début d'une région de thread critique.
                lock(InternalList){
                	// Si l'élément qui est ajouté est null ou déjà dans la liste, on lève une exception.
	                if (item == null) throw new ObjectAddedToEvtListNullError();
	                if (InternalList.Contains(item)) throw new ObjectAllreadyInEvtListError();
	
	                InternalList.Add(item); // Insertion de l'élément dans la liste.
	                LaunchAddEvents(item); // Lancement des évènements qui doivent survenir lors de l'ajout d'un élément de la liste.
                }
            } catch (Exception ex) {
            	throw ex;
            }
        }

        /// <summary>
        /// Permet de vider la liste de tous ses éléments.
        /// </summary>
        public void Clear() {
            while (Count > 0) Remove(this[0]);
        }

        /// <summary>
        /// Permet de savoir si l'élément spécifié appartient à la liste.
        /// </summary>
        /// <param name="item">L'élément recherché.</param>
        /// <returns>True si l'élément appartient à la liste, false sinon.</returns>
        public bool Contains(T item) {
            return InternalList.Contains(item);
        }

        /// <summary>
        /// Permet de copier les éléments de la liste dans un tableau.
        /// </summary>
        /// <param name="array">Le tableau dans lequel copier les éléments.</param>
        /// <param name="arrayIndex">L'index de l'élément à partir duquel doit commencer la copie.</param>
        public void CopyTo(T[] array, int arrayIndex) {
            InternalList.CopyTo(array, arrayIndex);
        }

        /// <summary>
        /// Permet de récupérer le nombre d'éléments de la liste.
        /// </summary>
        public int Count {
            get { return InternalList.Count; }
        }

        /// <summary>
        /// Permet de supprimer un élément de la liste.
        /// </summary>
        /// <param name="item">L'élément à supprimer.</param>
        public bool Remove(T item) {
            try {
        		lock(InternalList){
	        		// Si l'élément qui est ajouté est null ou déjà dans la liste, on lève une exception.
	                if (item == null) throw new ObjectRemovedToEvtListNullError();
	                if (!InternalList.Contains(item)) throw new ObjectRemovedFromHLD_ListObjectsDoesNotExistsError();
	
	                InternalList.Remove(item); // Suppression de l'élément dans la liste.
	                LaunchRemoveEvents(item); // Lancement des évènements qui doivent survenir lors de la suppression d'un élément de la liste.
        		}
        	}catch (Exception ex) {
        		throw ex;
        	}
            return true;
        }

        #endregion

        #region IEnumerable<T> Members

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

        #endregion

        #region IEnumerable Members

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

        #endregion
    }

Télécharger le zip

02 octobre 2007 11:15:46 :

MAJ sur la description du côté thread-safe de cette liste (suite à la question de Yxion)

02 octobre 2007 15:03:12 :

Remplacement des Thread.BeginCriticalRegion par des lock.