CA1038 : Les énumérateurs doivent être fortement typésCA1038: Enumerators should be strongly typed

TypeNameTypeName EnumeratorsShouldBeStronglyTypedEnumeratorsShouldBeStronglyTyped
CheckIdCheckId CA1038CA1038
CategoryCategory Microsoft.DesignMicrosoft.Design
Modification avec ruptureBreaking Change RuptureBreaking

CauseCause

Un type public ou protégé implémente System.Collections.IEnumerator mais ne fournit ne pas une version fortement typée de la System.Collections.IEnumerator.Current propriété.A public or protected type implements System.Collections.IEnumerator but does not provide a strongly typed version of the System.Collections.IEnumerator.Current property. Les types qui sont dérivés des types suivants sont exemptés de cette règle :Types that are derived from the following types are exempt from this rule:

Description de la règleRule description

Cette règle requiert IEnumerator implémentations fournissent également une version fortement typée de la Current propriété afin que les utilisateurs ne soient pas tenus d’effectuer un cast de la valeur de retour vers le type fort lorsqu’ils utilisent les fonctionnalités fournies par l’interface.This rule requires IEnumerator implementations to also provide a strongly typed version of the Current property so that users are not required to cast the return value to the strong type when they use the functionality that is provided by the interface. Cette règle suppose que le type qui implémente IEnumerator contient une collection d’instances d’un type plus fort que Object.This rule assumes that the type that implements IEnumerator contains a collection of instances of a type that is stronger than Object.

Comment corriger les violationsHow to fix violations

Pour corriger une violation de cette règle, implémentez la propriété d’interface explicitement (déclarez-le en tant que IEnumerator.Current).To fix a violation of this rule, implement the interface property explicitly (declare it as IEnumerator.Current). Ajouter une version publique fortement typée de la propriété déclarée comme Current, et qu’il renvoie un objet fortement typé.Add a public strongly typed version of the property, declared as Current, and have it return a strongly typed object.

Quand supprimer les avertissementsWhen to suppress warnings

Supprimer un avertissement de cette règle lorsque vous implémentez un énumérateur basée sur un objet pour une utilisation avec une collection basée sur un objet, comme un arbre binaire.Suppress a warning from this rule when you implement an object-based enumerator for use with an object-based collection, such as a binary tree. Les types qui étendent la nouvelle collection définissent l’énumérateur fortement typé et exposent la propriété fortement typée.Types that extend the new collection will define the strongly typed enumerator and expose the strongly typed property.

ExempleExample

L’exemple suivant montre comment implémenter fortement typé IEnumerator type.The following example demonstrates the correct way to implement a strongly typed IEnumerator type.

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

CA1035 : Les implémentations ICollection ont des membres fortement typésCA1035: ICollection implementations have strongly typed members

CA1039 : Les listes sont fortement typéesCA1039: Lists are strongly typed

Voir aussiSee also