CA1038 : Les énumérateurs doivent être fortement typés
TypeName |
EnumeratorsShouldBeStronglyTyped |
CheckId |
CA1038 |
Catégorie |
Microsoft.CSharp |
Modification avec rupture |
Oui |
Cause
Un type public ou protégé implémente System.Collections.IEnumerator mais ne fournit pas de version fortement typée de la propriété IEnumerator.Current. Les types dérivés des types suivants ne sont pas soumis à cette règle :
Description de la règle
Cette règle requiert que les implémentations IEnumerator fournissent également une version fortement typée de la propriété Current afin que les utilisateurs ne soient pas tenus d'effectuer un cast de la valeur de retour en type fort lorsqu'ils utilisent les fonctionnalités fournies par l'interface. Cette règle considère que le type qui implémente IEnumerator contient une collection d'instances d'un type plus fort que Object.
Comment corriger les violations
Pour corriger une violation de cette règle, implémentez la propriété d'interface explicitement (déclarez-la en tant que IEnumerator.Current). Ajoutez une version publique fortement typée de la propriété, déclarée en tant que Current, et faites en sorte qu'elle retourne un objet fortement typé.
Quand supprimer les avertissements
Supprimez un avertissement de cette règle lors de l'implémentation d'un énumérateur fondé sur des objets à utiliser avec une collection fondée sur des objets, notamment un arbre binaire. Les types qui étendent la nouvelle collection définissent l'énumérateur fortement typé et exposent la propriété fortement typée.
Exemple
L'exemple suivant montre la manière correcte d'implémenter un type IEnumerator fortement typé.
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);
}
}
}
Règles connexes
CA1035 : Les implémentations ICollection possèdent des membres fortement typés
CA1039 : Les listes sont fortement typées
Voir aussi
Référence
System.Collections.IEnumerator
System.Collections.CollectionBase