Les énumérateurs doivent être fortement typés

Article
08/21/2008

Mise à jour : novembre 2007

TypeName	EnumeratorsShouldBeStronglyTyped
CheckId	CA1038
Catégorie	Microsoft.CSharp
Modification avec rupture	Oui

Cause

Un type public ou protégé implémente System.Collections.IEnumerator mais ne fournit pas de version fortement typée de la propriété IEnumerator.Current. Les types dérivés des types suivants ne sont pas soumis à cette règle :

Description de la règle

Cette règle requiert que les implémentations IEnumerator fournissent également une version fortement typée de la propriété Current afin que les utilisateurs ne soient pas tenus d'effectuer un cast de la valeur de retour en type fort lorsqu'ils utilisent les fonctionnalités fournies par l'interface. Cette règle considère que le type qui implémente IEnumerator contient une collection d'instances d'un type plus fort que Object.

Comment corriger les violations

Pour corriger une violation de cette règle, implémentez la propriété d'interface explicitement (déclarez-la en tant que IEnumerator.Current). Ajoutez une version publique fortement typée de la propriété, déclarée en tant que Current, et faites en sorte qu'elle retourne un objet fortement typé.

Quand supprimer les avertissements

Supprimez un avertissement de cette règle lors de l'implémentation d'un énumérateur fondé sur des objets à utiliser avec une collection fondée sur des objets, notamment un arbre binaire. Les types qui étendent la nouvelle collection définissent l'énumérateur fortement typé et exposent la propriété fortement typée.

Exemple

L'exemple suivant montre la manière correcte d'implémenter un type IEnumerator fortement typé.

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