Share via

CA1800: No convertir innecesariamente

  • Artículo
Elemento Valor
RuleId CA1800
Category Microsoft.Performance
Cambio importante Poco problemático

Causa

Un método realiza conversiones duplicadas en uno de sus argumentos o variables locales.

Para realizar un análisis completo mediante esta regla, el ensamblado probado debe compilarse mediante la información de depuración y el archivo de base de datos de programa (.pdb) asociado debe estar disponible.

Nota

Esta regla está en desuso. Para más información, consulte Reglas en desuso.

Descripción de la regla

Las conversiones duplicadas reducen el rendimiento, sobre todo cuando se realizan en instrucciones de iteración compactas. Para las operaciones de conversión duplicadas explícitas, almacene el resultado de la conversión en una variable local y use la variable local en lugar de las operaciones de conversión duplicadas.

Si el operador de C# is se usa para probar si la conversión se realiza correctamente antes de que tenga lugar la conversión real, considere la posibilidad de probar mejor el resultado del operador as. Este proporciona la misma funcionalidad sin la operación de conversión implícita que realiza el operador is. O bien, en C# 7.0 y versiones posteriores, use el operador is con coincidencia de patrones para comprobar la conversión de tipos y convertir la expresión en una variable de ese tipo en un paso.

Cómo corregir infracciones

Para corregir una infracción de esta regla, modifique la implementación del método para minimizar el número de operaciones de conversión.

Cuándo suprimir las advertencias

Es seguro suprimir una advertencia de esta regla, u omitir la regla por completo, si no le preocupa el rendimiento.

Ejemplos

En el ejemplo siguiente se muestra un método que infringe la regla mediante el operador de C# is. Un segundo método satisface la regla al sustituir el operador is por una prueba contra el resultado del operador as, lo que disminuye el número de operaciones de conversión por iteración de dos a una. Un tercer método también satisface la regla al usar is con la coincidencia de patrones para crear una variable del tipo deseado si la conversión de tipos se realiza correctamente.

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.
            }
         }
      }
   }
}

En el ejemplo siguiente se muestra un método, start_Click, con varias conversiones explícitas duplicadas, que infringe la regla y un método, reset_Click, que satisface la regla al almacenar la conversión en una variable local.

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

Vea también