CA1800 : N'effectuez pas de cast inutilementCA1800: Do not cast unnecessarily

TypeNameTypeName DoNotCastUnnecessarilyDoNotCastUnnecessarily
CheckIdCheckId CA1800CA1800
CategoryCategory Microsoft.PerformanceMicrosoft.Performance
Modification avec ruptureBreaking Change Sans ruptureNon-breaking

CauseCause

Une méthode effectue des casts en double sur un de ses arguments ou les variables locales.A method performs duplicate casts on one of its arguments or local variables.

Pour l’analyse complète par cette règle, l’assembly testé doit être construit à l’aide des informations de débogage et le fichier de base de données (.pdb) du programme associé doit être disponible.For complete analysis by this rule, the tested assembly must be built by using debugging information, and the associated program database (.pdb) file must be available.

Description de la règleRule description

Les casts en doublon font baisser les performances, surtout lorsque les casts sont exécutés au sein d'instructions d'itération compactes.Duplicate casts decrease performance, especially when the casts are performed in compact iteration statements. Pour les opérations de casts en doublon explicites, stocker le résultat du cast dans une variable locale et utilisez la variable locale au lieu des opérations de cast en double.For explicit duplicate cast operations, store the result of the cast in a local variable and use the local variable instead of the duplicate cast operations.

Si C# is opérateur est utilisé pour déterminer si le cast va réussir avant l’exécution proprement dite, envisagez de tester le résultat de la as opérateur à la place.If the C# is operator is used to test whether the cast will succeed before the actual cast is performed, consider testing the result of the as operator instead. Cela fournit les mêmes fonctionnalités sans l’opération de cast implicite est effectuée par le is opérateur.This provides the same functionality without the implicit cast operation that is performed by the is operator. Ou, dans c# 7.0 et versions ultérieures, utilisez le is opérateur avec critères spéciaux de vérifier la conversion de type et de convertir l’expression à une variable de ce type en une seule étape.Or, in C# 7.0 and later, use the is operator with pattern matching to check the type conversion and cast the expression to a variable of that type in one step.

Comment corriger les violationsHow to fix violations

Pour corriger une violation de cette règle, modifiez l’implémentation de méthode pour réduire le nombre d’opérations de cast.To fix a violation of this rule, modify the method implementation to minimize the number of cast operations.

Quand supprimer les avertissementsWhen to suppress warnings

Il est recommandé de supprimer un avertissement de cette règle, ou à ignorer la règle, si les performances ne sont pas un problème.It is safe to suppress a warning from this rule, or to ignore the rule completely, if performance is not a concern.

ExemplesExamples

L’exemple suivant montre une méthode qui viole la règle à l’aide de C# is opérateur.The following example shows a method that violates the rule by using the C# is operator. Une deuxième méthode satisfait la règle en remplaçant le is opérateur avec un test par rapport au résultat de la as opérateur, ce qui réduit le nombre d’opérations de cast par itération de deux à un.A second method satisfies the rule by replacing the is operator with a test against the result of the as operator, which decreases the number of cast operations per iteration from two to one. Une troisième méthode satisfait également à la règle à l’aide de is avec critères spéciaux pour créer une variable du type souhaité si la conversion de type réussirait.A third method also satisfies the rule by using is with pattern matching to create a variable of the desired type if the type conversion would succeed.

using System;
using System.Collections;
using System.Windows.Forms;

namespace PerformanceLibrary
{
   public sealed class SomeClass
   {
      private SomeClass() {}

      // This method violates the rule.
      public static void UnderPerforming(ArrayList list)
      {
         foreach(object obj in list) 
         {
            // The 'is' statement performs a cast operation.
            if(obj is Control) 
            {
               // The 'as' statement performs a duplicate cast operation.
               Control aControl = obj as Control;
               // Use aControl.
            }

         }
      }

      // This method satisfies the rule.
      public static void BetterPerforming(ArrayList list)
      {
         foreach(object obj in list) 
         {
            Control aControl = obj as Control;
            if(aControl != null) 
            {
               // Use aControl.
            }
         }
      }
   }
}

L’exemple suivant montre une méthode, start_Click, qui a plusieurs conversions explicites en double, ce qui viole la règle et une méthode, reset_Click, ce qui satisfait la règle en stockant le cast dans une variable locale.The following example shows a method, start_Click, that has multiple duplicate explicit casts, which violates the rule, and a method, reset_Click, which satisfies the rule by storing the cast in a local variable.

Imports System
Imports System.Drawing
Imports System.Windows.Forms

Namespace PerformanceLibrary

   Public Class SomeForm : Inherits Form

      Dim start, reset As Button

      Sub New()

         start = New Button()
         reset = New Button()
         AddHandler start.Click, AddressOf start_Click
         AddHandler reset.Click, AddressOf reset_Click
         Controls.Add(start)
         Controls.Add(reset)

      End Sub

      ' This method violates the rule.
      Private Sub start_Click(sender As Object, e As EventArgs)
      
         Dim controlSize As Size = DirectCast(sender, Control).Size
         Dim rightToLeftValue As RightToLeft = _ 
            DirectCast(sender, Control).RightToLeft
         Dim parent As Control = DirectCast(sender, Control)

      End Sub

      ' This method satisfies the rule.
      Private Sub reset_Click(sender As Object, e As EventArgs)
      
         Dim someControl As Control = DirectCast(sender, Control)
         Dim controlSize As Size = someControl.Size
         Dim rightToLeftValue As RightToLeft = someControl.RightToLeft
         Dim parent As Control = someControl

      End Sub

   End Class

End Namespace
using System;
using System.Drawing;
using System.Windows.Forms;

namespace PerformanceLibrary
{
   public class SomeForm : Form
   {
      Button start, reset;

      public SomeForm()
      {
         start = new Button();
         reset = new Button();
         start.Click += new EventHandler(start_Click);
         reset.Click += new EventHandler(reset_Click);
         Controls.Add(start);
         Controls.Add(reset);
      }

      // This method violates the rule.
      void start_Click(object sender, EventArgs e)
      {
         Size controlSize = ((Control)sender).Size;
         RightToLeft rightToLeftValue = ((Control)sender).RightToLeft;
         Control parent = (Control)sender;
      }

      // This method satisfies the rule.
      void reset_Click(object sender, EventArgs e)
      {
         Control someControl = (Control)sender;
         Size controlSize = someControl.Size;
         RightToLeft rightToLeftValue = someControl.RightToLeft;
         Control parent = someControl;
      }
   }
}

Voir aussiSee also