CA1038: os enumeradores devem ser fortemente tipados

Artigo
06/08/2015

TypeName	EnumeratorsShouldBeStronglyTyped
CheckId	CA1038
Categoria	Microsoft.Design
Alteração Significativa	Quebra

Causa

Um público ou um implementa protegidos IEnumerator do tipo mas não fornecem uma versão com rigidez da propriedade de IEnumerator.Current .Tipos que é derivada dos seguintes tipos é isento dessa regra:

Descrição da Regra

Essa regra requer implementações de IEnumerator fornecer também uma versão com rigidez da propriedade de Current de forma que usuários não sejam necessários para converter o valor de retorno no tipo forte quando usarem a funcionalidade fornecida pela interface.Esta regra assumirá que o tipo que implementa IEnumerator contém uma coleção de instâncias de um tipo que é mais segura que Object.

Como Corrigir Violações

Para corrigir uma violação desta regra, implemente a propriedade da interface explicitamente (a declarar como IEnumerator.Current).Adicionar uma versão com rigidez do utilitário a propriedade, declarada como Current, e mande-a retornar um objeto com rigidez.

Quando Suprimir Alertas

Suprima um aviso desta regra quando você implementa um enumerador baseado em objeto para uso com uma coleção de objetos com base, como uma árvore binária.Tipos que estende a nova coleção definirá o enumerador com rigidez e expõe a propriedade com rigidez de tipos.

Exemplo

O exemplo a seguir demonstra a forma correta da implementação de um tipo com rigidez de IEnumerator .

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