Enumeratoren sollten eine starke Typisierung aufweisen

Artikel
08/20/2008

Aktualisiert: November 2007

TypeName	EnumeratorsShouldBeStronglyTyped
CheckId	CA1038
Kategorie	Microsoft.Design
Unterbrechende Änderung	Breaking

Ursache

Ein öffentlicher oder geschützter Typ implementiert System.Collections.IEnumerator, gibt jedoch keine stark typisierte Version der IEnumerator.Current-Eigenschaft an. Typen, die von den folgenden Typen abgeleitet sind, sind von dieser Regel ausgenommen:

Regelbeschreibung

Nach dieser Regel müssen IEnumerator-Implementierungen für die Current-Eigenschaft auch eine Version mit starker Typisierung angeben, damit die Benutzer den Rückgabewert nicht in den starken Typ umwandeln müssen, wenn sie die durch die Schnittstelle zur Verfügung gestellten Funktionen verwenden. Diese Regel setzt voraus, dass der Typ, der IEnumerator implementiert, eine Auflistung von Instanzen eines Typs enthält, der stärker ist als Object.

Behandlung von Verstößen

Um einen Verstoß gegen diese Regel zu beheben, implementieren Sie die Schnittstelleneigenschaft explizit (deklarieren Sie sie als IEnumerator.Current). Fügen Sie eine öffentliche stark typisierte Version der Eigenschaft hinzu, die als Current deklariert ist, und lassen Sie diese ein stark typisiertes Objekt zurückgeben.

Wann Warnungen unterdrückt werden sollten

Unterdrücken Sie eine Warnung dieser Regel, wenn Sie einen objektbasierten Enumerator implementieren, der zur Verwendung mit einer objektbasierten Auflistung, z. B. einer binären Struktur, vorgesehen ist. Typen, die die neue Auflistung erweitern, definieren den stark typisierten Enumerator und stellen die Eigenschaft mit starker Typisierung zur Verfügung.

Beispiel

Im folgenden Beispiel wird das richtige Verfahren zur Implementierung eines IEnumerator-Typs mit starker Typisierung dargestellt.

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