Udostępnij za pośrednictwem

CA1038: Wyliczenia powinny być silnie typizowane

  • Artykuł
Pozycja Wartość
Ruleid CA1038
Kategoria Microsoft.Design
Zmiana powodująca niezgodność Kluczowa

Przyczyna

Typ publiczny lub chroniony implementuje System.Collections.IEnumerator , ale nie zapewnia silnie typizowanej System.Collections.IEnumerator.Current wersji właściwości. Typy pochodzące z następujących typów są wykluczone z tej reguły:

Uwaga

Ta reguła została przestarzała. Aby uzyskać więcej informacji, zobacz Przestarzałe reguły.

Opis reguły

Ta reguła wymaga IEnumerator implementacji w celu zapewnienia silnie typizowanej Current wersji właściwości, aby użytkownicy nie byli zobowiązani do rzutowania wartości zwracanej na silny typ, gdy korzystają z funkcji udostępnianych przez interfejs. Ta reguła zakłada, że typ implementujący IEnumerator zawiera kolekcję wystąpień typu, który jest silniejszy niż Object.

Jak naprawić naruszenia

Aby naprawić naruszenie tej reguły, zaimplementuj jawnie właściwość interfejsu (zadeklaruj ją jako IEnumerator.Current). Dodaj publicznie silnie typizowana wersja właściwości, zadeklarowana jako Current, i zwraca silnie typizowanego obiektu.

Kiedy pomijać ostrzeżenia

Pomiń ostrzeżenie z tej reguły podczas implementowania modułu wyliczającego opartego na obiektach do użycia z kolekcją opartą na obiektach, taką jak drzewo binarne. Typy rozszerzające nową kolekcję będą definiować silnie typizowane moduły wyliczające i uwidaczniać silnie typizowana właściwość.

Przykład

W poniższym przykładzie pokazano prawidłowy sposób implementowania silnie typizowanego IEnumerator typu.

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: Implementacje interfejsu ICollection mają silnie typizowane składowe

CA1039: Listy są silnie typizowane

Zobacz też