CA1035 : Les implémentations ICollection possèdent des membres fortement typésCA1035: ICollection implementations have strongly typed members

TypeNameTypeName ICollectionImplementationsHaveStronglyTypedMembersICollectionImplementationsHaveStronglyTypedMembers
CheckIdCheckId CA1035CA1035
CategoryCategory Microsoft.DesignMicrosoft.Design
Modification avec ruptureBreaking Change RuptureBreaking

CauseCause

Un type public ou protégé implémente System.Collections.ICollection mais ne fournit ne pas de méthode fortement typée pour System.Collections.ICollection.CopyTo.A public or protected type implements System.Collections.ICollection but does not provide a strongly typed method for System.Collections.ICollection.CopyTo. La version fortement typée de CopyTo doit accepter deux paramètres et ne peut pas avoir un System.Array ou un tableau de System.Object en tant que son premier paramètre.The strongly typed version of CopyTo must accept two parameters and cannot have a System.Array or an array of System.Object as its first parameter.

Description de la règleRule description

Cette règle requiert ICollection implémentations fournissent fortement des membres typés afin que les utilisateurs ne doivent pas effectuer un cast des arguments à la Object tapez lorsqu’ils utilisent les fonctionnalités fournies par l’interface.This rule requires ICollection implementations to provide strongly typed members so that users are not required to cast arguments to the Object type when they use the functionality that is provided by the interface. Cette règle suppose que le type qui implémente ICollection effectue donc à gérer une collection d’instances d’un type plus fort que Object.This rule assumes that the type that implements ICollection does so to manage a collection of instances of a type that is stronger than Object.

ICollection implémente l'interface System.Collections.IEnumerable.ICollection implements the System.Collections.IEnumerable interface. Si les objets dans la collection étendent System.ValueType, vous devez fournir un membre fortement typé pour GetEnumerator afin d’éviter la baisse de performances est provoquée par le boxing.If the objects in the collection extend System.ValueType, you must provide a strongly typed member for GetEnumerator to avoid the decrease in performance that is caused by boxing. Cela n’est pas nécessaire lorsque les objets de la collection sont un type référence.This is not required when the objects of the collection are a reference type.

Pour implémenter une version fortement typée d’un membre d’interface, implémentez explicitement les membres d’interface à l’aide de noms sous la forme InterfaceName.InterfaceMemberName, tel que CopyTo.To implement a strongly typed version of an interface member, implement the interface members explicitly by using names in the form InterfaceName.InterfaceMemberName, such as CopyTo. Les membres d’interface explicites utilisent les types de données qui sont déclarés par l’interface.The explicit interface members use the data types that are declared by the interface. Implémenter des membres fortement typés à l’aide du nom de membre d’interface, tel que CopyTo.Implement the strongly typed members by using the interface member name, such as CopyTo. Déclarer des membres fortement typés comme publics et déclarez des paramètres et retourner des valeurs à être de type fort qui est géré par la collection.Declare the strongly typed members as public, and declare parameters and return values to be of the strong type that is managed by the collection. Les types forts remplacent les types plus faibles comme Object et Array qui sont déclarés par l’interface.The strong types replace weaker types such as Object and Array that are declared by the interface.

Comment corriger les violationsHow to fix violations

Pour corriger une violation de cette règle, implémentez le membre d’interface explicitement (déclarez-le en tant que CopyTo).To fix a violation of this rule, implement the interface member explicitly (declare it as CopyTo). Ajouter le membre fortement typé public, déclaré comme CopyTo, et qu’il procède à un tableau fortement typé en tant que son premier paramètre.Add the public strongly typed member, declared as CopyTo, and have it take a strongly typed array as its first parameter.

Quand supprimer les avertissementsWhen to suppress warnings

Supprimez un avertissement de cette règle si vous implémentez une nouvelle collection basée sur un objet, comme une arborescence binaire, où des types qui étendent la nouvelle collection déterminent le type fort.Suppress a warning from this rule if you implement a new object-based collection, such as a binary tree, where types that extend the new collection determine the strong type. Ces types doivent être conforme à cette règle et exposer des membres fortement typés.These types should comply with this rule and expose strongly typed members.

ExempleExample

L’exemple suivant illustre la façon correcte d’implémenter ICollection.The following example demonstrates the correct way to implement ICollection.

using System;
using System.Collections;
namespace DesignLibrary
{
   
   public class ExceptionCollection : ICollection
   {   
      private 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.
      // Because the type underlying this collection is a reference type,
      // you do not need a strongly typed version of GetEnumerator.

      public IEnumerator GetEnumerator()
      {
         return data.GetEnumerator();
      }
   }
}

CA1038 : Les énumérateurs doivent être fortement typésCA1038: Enumerators should be strongly typed

CA1039 : Les listes sont fortement typéesCA1039: Lists are strongly typed

Voir aussiSee also