CA1038: Výčtu by měla být silný

Článek
03/04/2013

TypeName	EnumeratorsShouldBeStronglyTyped
CheckId	CA1038
Kategorie	Microsoft.Design
Narušující změna	Narušující

Příčina

Veřejný nebo chráněný typ implementuje rozhraní System.Collections.IEnumerator, ale neposkytuje verzi vlastnosti IEnumerator.Current se silnými typy.Typy odvozené z následujících typů jsou osvobozeny od tohoto pravidla:

Popis pravidla

Toto pravidlo vyžaduje, aby implementace rozhraní IEnumerator také poskytovaly verzi vlastnosti Current se silnými typy, aby uživatelé nemuseli při použití funkčnosti poskytované tímto rozhraním přetypovávat návratovou hodnotu na silný typ.Toto pravidlo předpokládá, že typ implementující rozhraní IEnumerator obsahuje kolekci instancí typu, který je silnější než typ Object.

Jak vyřešit porušení

Explicitní implementace vlastnosti rozhraní (deklarovaná jako IEnumerator.Current) vyřeší porušení tohoto pravidla.To se provede přidáním veřejné verze vlastnosti se silným typem, deklarované jako Current, která vrací objekt se silným typem.

Kdy potlačit upozornění

Toto upozornění je vhodné potlačit, pokud implementujete enumerátor založený na objektech, který je používán společně s kolekcí založené na objektech, jako například binární strom.Typy, které rozšiřují novou kolekci, budou definovat enumerátor se silnými typy a vystaví vlastnost se silným typem.

Příklad

Následující příklad ukazuje správný způsob implementace rozhraní IEnumerator se silnými typy.

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