CA1038: Gli enumeratori devono essere fortemente tipizzati

Articolo
06/08/2015

TypeName	EnumeratorsShouldBeStronglyTyped
CheckId	CA1038
Category	Microsoft.Design
Breaking Change	Breaking

Causa

Un tipo pubblico o protetto implementa IEnumerator, ma non fornisce una versione fortemente tipizzata della proprietà IEnumerator.Current.I tipi derivati dai tipi riportati di seguito non sono interessati da questa regola:

Descrizione della regola

Questa regola richiede che le implementazioni di IEnumerator forniscano anche una versione fortemente tipizzata della proprietà Current in modo che agli utenti non venga richiesto di eseguire il cast del valore restituito nel tipo sicuro quando utilizzano la funzionalità fornita dall'interfaccia.Questa regola presuppone che il tipo che implementa IEnumerator contenga una raccolta di istanze di un tipo più sicuro di Object.

Come correggere le violazioni

Per correggere una violazione di questa regola, implementare in modo esplicito la proprietà dell'interfaccia (dichiararla come IEnumerator.Current).Aggiungere una versione fortemente tipizzata pubblica della proprietà, dichiarata come Current, e fare in modo che restituisca un oggetto fortemente tipizzato.

Esclusione di avvisi

Escludere un avviso da questa regola quando si implementa un enumeratore basato su oggetti da utilizzare con una raccolta basata su oggetti, quale una struttura ad albero binaria.I tipi che estendono la nuova raccolta definiranno l'enumeratore fortemente tipizzato ed esporranno la proprietà fortemente tipizzata.

Esempio

Nell'esempio riportato di seguito viene illustrato il modo corretto per implementare un tipo IEnumerator fortemente tipizzato.

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