Les collections doivent implémenter l'interface générique

Article
08/21/2008

Mise à jour : novembre 2007

TypeName	CollectionsShouldImplementGenericInterface
CheckId	CA1010
Catégorie	Microsoft.CSharp
Modification avec rupture	Modification sans rupture

Cause

Un type visible de l'extérieur implémente l'interface System.Collections.IEnumerable, mais n'implémente pas l'interface System.Collections.Generic.IEnumerable<T>, et l'assembly conteneur cible .NET Framework 2.0. Cette règle ignore les types qui implémentent System.Collections.IDictionary.

Description de la règle

Pour étendre la facilité d'utilisation d'une collection, implémentez l'une des interfaces de collection génériques. La collection peut être ensuite utilisée pour remplir des types de collection génériques tels que :

Comment corriger les violations

Pour corriger une violation de cette règle, implémentez l'une des interfaces de collection génériques suivantes :

Quand supprimer les avertissements

Il est possible de supprimer sans risque un avertissement de cette règle ; toutefois, l'utilisation de la collection sera plus limitée.

Exemple de violation

Description

L'exemple suivant présente une classe (type référence) qui dérive de la classe non générique CollectionBase, qui viole cette règle.

Code

using System;
using System.Collections;

namespace Samples
{
    public class Book
    {
        public Book()
        {
        }
    }

    public class BookCollection : CollectionBase
    {
        public BookCollection()
        {
        }

        public void Add(Book value)
        {
            InnerList.Add(value);
        }

        public void Remove(Book value)
        {
            InnerList.Remove(value);
        }

        public void Insert(int index, Book value)
        {
            InnerList.Insert(index, value);
        }

        public Book this[int index]
        {
            get { return (Book)InnerList[index]; }
            set { InnerList[index] = value; }
        }

        public bool Contains(Book value)
        {
            return InnerList.Contains(value);
        }

        public int IndexOf(Book value)
        {
            return InnerList.IndexOf(value);
        }

        public void CopyTo(Book[] array, int arrayIndex)
        {
            InnerList.CopyTo(array, arrayIndex);
        }
    }
}

Commentaires

Pour résoudre une violation de cette violation, vous devez implémenter les interfaces génériques ou modifier la classe de base en un type qui implémente déjà les interfaces génériques et les interfaces non génériques, telles que la classe Collection<T>.

Résoudre par modification de classe de base

Description

L'exemple suivant résout la violation en modifiant la classe de base non générique CollectionBase de la collection en classe générique Collection<T> (Collection(Of T) dans Visual Basic).

Code

using System;
using System.Collections.ObjectModel; 

namespace Samples
{    
    public class Book        
    {               
        public Book()                
        {                
        }        
    }    

    public class BookCollection : Collection<Book>    
    {        
        public BookCollection()        
        {        
        }    
    }
}

Commentaires

Modifier la classe de base d'une classe déjà finale est considéré par les consommateurs existants comme une modification avec rupture.

Résoudre par implémentation d'interface

Description

L'exemple suivant résout la violation en implémentant ces interfaces génériques : IEnumerable<T>, ICollection<T> et IList<T> (IEnumerable(Of T), ICollection(Of T) et IList(Of T) dans Visual Basic).

Code

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

namespace Samples
{
    public class Book
    {
        public Book()
        {
        }
    }

    public class BookCollection : CollectionBase, IList<Book>
    {
        public BookCollection()
        {
        }

        int IList<Book>.IndexOf(Book item)
        {
            return this.List.IndexOf(item);
        }

        void IList<Book>.Insert(int location, Book item)
        {
        }

        Book IList<Book>.this[int index]
        {
            get { return (Book) this.List[index]; }
            set { }
        }

        void ICollection<Book>.Add(Book item)
        {
        }

        bool ICollection<Book>.Contains(Book item)
        {
            return true;
        }

        void ICollection<Book>.CopyTo(Book[] array, int arrayIndex)
        {
        }

        bool ICollection<Book>.IsReadOnly
        {
            get { return false; }
        }

        bool ICollection<Book>.Remove(Book item)
        {
            if (InnerList.Contains(item))
            {
                InnerList.Remove(item);
                return true;
            }
            return false;
        }

        IEnumerator<Book> IEnumerable<Book>.GetEnumerator()
        {
            return new BookCollectionEnumerator(InnerList.GetEnumerator());
        }

        private class BookCollectionEnumerator : IEnumerator<Book>
        {
            private IEnumerator _Enumerator;

            public BookCollectionEnumerator(IEnumerator enumerator)
            {
                _Enumerator = enumerator;
            }

            public Book Current
            {
                get { return (Book)_Enumerator.Current; }
            }

            object IEnumerator.Current
            {
                get { return _Enumerator.Current; }
            }

            public bool MoveNext()
            {
                return _Enumerator.MoveNext();
            }

            public void Reset()
            {
                _Enumerator.Reset();
            }

            public void Dispose()
            {
            }
        }
    }
}