CA1010: Coleções devem implementar a interface genérica

TypeName

CollectionsShouldImplementGenericInterface

CheckId

CA1010

<strong>Categoria</strong>

Microsoft.design

Alteração significativa

Não-separável

Causa

Um tipo visível externamente implementa o System.Collections.IEnumerable interface mas não implementa o System.Collections.Generic.IEnumerable<T> interface e os destinos de assembly contendo .NET Framework 2.0. Esta regra ignora os tipos que implementam System.Collections.IDictionary.

Descrição da regra

Para ampliar a usabilidade de uma coleção, implemente uma das interfaces de coleção genérica. Em seguida, a coleção pode ser usada para preencher os tipos de coleção genérica como, por exemplo, o seguinte:

Como corrigir violações

Para corrigir uma violação desta regra, implemente uma das seguintes interfaces de coleção genérica:

Quando suprimir avisos

É seguro eliminar um aviso esta regra; No entanto, a coleção terá um uso mais limitado.

Violação de exemplo

Descrição

O exemplo a seguir mostra uma classe (tipo de referência) que deriva da não genérica CollectionBase classe, que viola essa regra.

Código

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);
        }
    }
}

Comentários

Para corrigir uma violação dessa violação, você deve implementar as interfaces genéricas ou alterar a classe base para um tipo que já implementa duas interfaces genéricas e não genéricas, como o Collection<T> classe.

Corrigir por alteração de classe Base

Descrição

O exemplo a seguir corrige a violação, alterando a classe base da coleção de não-genéricas CollectionBase classe para a classe genérica Collection<T> (Collection(Of T) na Visual Basic) classe.

Código

using System;
using System.Collections.ObjectModel; 

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

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

Comentários

Alterar a classe base de uma classe já lançada é considerada uma alteração significativa aos consumidores existentes.

Corrigir pela implementação da Interface

Descrição

O exemplo a seguir corrige a violação ao implementar essas interfaces genéricas: IEnumerable<T>, ICollection<T>, and IList<T> (IEnumerable(Of T), ICollection(Of T), and IList(Of T) in Visual Basic).

Código

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()
            {
            }
        }
    }
}

Regras relacionadas

CA1005: Evitar o excesso parâmetros em tipos genéricos

CA1000: Não é declarar membros estáticos em tipos genéricos

CA1002: Não expõem listas genéricas

CA1006: Não se aninham tipos genéricos em assinaturas de membro

CA1004: Métodos genéricos devem fornecer o parâmetro de tipo

CA1003: Usar instâncias do manipulador de evento genérico

CA1007: Use genéricos onde for apropriado

Consulte também

Referência

Generics (C# Programming Guide)