Enumeradores devem ser fortemente tipados

Artigo
08/25/2010

TypeName	EnumeratorsShouldBeStronglyTyped
CheckId	CA1038
Category (Categoria)	Microsoft.Design
Quebrando alterar	Quebrando

Causa

Um tipo público ou protegido implementa System.Collections.IEnumerator mas não fornece uma versão com rigidez de tipos de IEnumerator.Current propriedade. Tipos derivados de tipos a seguir estão isentos desta regra:

Descrição da regra

Esta regra requer IEnumerator implementações a também fornecer uma versão com rigidez de tipos de Current propriedade para que os usuários não precisem converter o valor retornado para o tipo de alta segurança quando eles usam a funcionalidade fornecida pela interface. Esta regra pressupõe que o tipo que implementa IEnumerator contém uma coleção de instâncias de um tipo é mais forte que Object.

Como corrigir violações

Para corrigir uma violação dessa regra, implementar a propriedade de interface explicitamente (declará-lo sistema autônomo IEnumerator.Current). Adicionar que um público fortemente tipadas versão da propriedade declarada sistema autônomo Current, e ainda retornar um objeto com rigidez de tipos.

Quando suprimir avisos

Suprimir um aviso da regra quando você implementa um enumerador para uso com uma coleção com base em objeto, sistema autônomo uma árvore binária baseada em objeto.Tipos que se estendem a nova coleção serão definir enumerador com rigidez de tipos e expõe a propriedade com rigidez de tipos.

Exemplo

O exemplo a seguir demonstra a maneira correta de implementar um com rigidez de tiposIEnumerator Digite.

using System;
using System.Collections;
namespace DesignLibrary
{
   // The ExceptionEnumerator class implements a strongly typed enumerator 
   // for the ExceptionCollection type.

   public class ExceptionEnumerator: IEnumerator
   {
      private IEnumerator myCollectionEnumerator;

      private ExceptionEnumerator () {}

      public ExceptionEnumerator(ExceptionCollection collection)
      {
         myCollectionEnumerator = collection.data.GetEnumerator();
      }

      // Implement the IEnumerator interface member explicitly.
      object IEnumerator.Current
      {
         get 
         {
            return myCollectionEnumerator.Current;
         }
      }

      // Implement the strongly typed member.
      public Exception Current
      {
         get 
         {
            return (Exception) myCollectionEnumerator.Current;
         }
      }

      // Implement the remaining IEnumerator members.
      public bool MoveNext ()
      {
         return myCollectionEnumerator.MoveNext();
      }

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

   public class ExceptionCollection : ICollection
   {   
      internal ArrayList data;

      ExceptionCollection()
      {
         data = new ArrayList();
      }

      // Provide the explicit interface member for ICollection.
      void ICollection.CopyTo(Array array, int index)
      {
         data.CopyTo(array, index);
      }

      // Provide the strongly typed member for ICollection.
      public void CopyTo(Exception[] array, int index)
      {
         ((ICollection)this).CopyTo(array, index);
      }

      // Implement the rest of the ICollection members.
      public int Count
      {
        get 
        {
           return data.Count;
        }
      }

      public object SyncRoot
      {
         get 
        {
           return this; 
        }
      }

      public bool IsSynchronized
      {
         get 
         {
            return false; 
         }
      }

      // The IEnumerable interface is implemented by ICollection.
      IEnumerator IEnumerable.GetEnumerator()
      {
         return new ExceptionEnumerator(this);
      }

      public ExceptionEnumerator GetEnumerator()
      {
         return new ExceptionEnumerator(this);
      }
   }
}