CA1038: Wyliczenia powinny być silnie typizowane

Artykuł
06/08/2015

TypeName	EnumeratorsShouldBeStronglyTyped
CheckId	CA1038
Kategoria	Microsoft.Design
Zmiana kluczowa	Kluczowa

Przyczyna

Publiczny lub chroniony typ implementuje IEnumerator , ale nie dostarcza silnie typowanej wersji właściwości IEnumerator.Current.Typy pochodne następujących typów są zwolnione od tej reguły:

Opis reguły

Ta reguła wymaga implementacji IEnumerator, aby zapewnić również silnie typowaną wersję właściwości Current, dzięki czemu użytkownicy nie są zmuszeni do rzutowania wartości zwróconej na typ silny, podczas używania funkcjonalności dostarczonych przez interfejs.Zasada ta zakłada, że typ, który implementuje IEnumerator zawiera kolekcję wystąpień typu, który jest silniejszy niż Object.

Jak naprawić naruszenia

Aby naprawić naruszenie tej zasady, należy zaimplementować właściwości interfejsu jawnie (zadeklarować go jako IEnumerator.Current).Należy dodać publiczną wersję silnie typowanej właściwości zadeklarowanej jako Current i zwrócić silnie typowany obiekt.

Kiedy pominąć ostrzeżenia

Podczas implementowania obiektów modułu wyliczającego do użycia z kolekcją obiektów, taką jak drzewo binarne, należy pominąć ostrzeżenie od tej reguły.Typy rozszerzające nowe kolekcje będą definiować silnie typowany moduł wyliczający i uwidacznia silnie typowaną właściwość.

Przykład

Poniższy przykład demonstruje poprawny sposób zaimplementowania silnie typowanego typu 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);
      }
   }
}