Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês
É recomendável usar o Visual Studio 2017

Não chame propriedades que clonagem valores de loops

TypeName

DoNotCallPropertiesThatCloneValuesInLoops

CheckId

CA1817

Category (Categoria)

Microsoft.Performance

Quebrando alterar

NonBreaking

Um método chama o acessador get de uma propriedade dentro de uma instrução de iteração, como for ou while loop, e o acessador retorna um objeto clonado.

Um objeto clonado é um novo objeto criado com um valor idêntico de um objeto existente.Um objeto clonado é recuperado de um chamar para o método ICloneable.Clone, que cria um Novo instância do seu tipo declarativo com um valor idêntico de atual instância.

Essa regra avisa sobre uma propriedade acessada dentro de uma instrução de iteração quando a propriedade retorna um objeto clonado.Neste maiúscminúsc, múltiplo são criados objetos idênticos.Se isso não for a intenção, acessar a propriedade fora de instrução de iteração.Caso contrário, Múltiplo objetos desnecessários são criados e posteriormente, esses objetos devem ser coletado pelo Garbage Collector.Isso diminui o desempenho, especialmente em instruções de iteração compacto.

Para corrigir uma violação dessa regra, atribuir a propriedade a uma variável local fora de instrução de iteração e use a variável local dentro de instrução de iteração.

Excluir um aviso desta regra se a intenção é criar os valores clonados dentro de instrução de iteração.Também é seguro excluir um aviso dessa regra, ou ignorar a regra inteiramente, se o desempenho não for uma preocupação.

O exemplo a seguir mostra duas violações dessa regra, uma das quais devem ser excluídos e um método, BetterPerformingMethod, que satisfaça a regra usando uma variável local para armazenar o valor clonado.

using System;
using System.Collections;

namespace PerformanceLibrary
{
   public class PropertyThatClones
   {
      ArrayList someList = new ArrayList();

      public ArrayList List
      {
         get
         {
            return (ArrayList)someList.Clone();
         }
      }

      public void ModifyList(object anything)
      {
         someList.Add(anything);
      }
   }

   public class UseProperty
   {
      PropertyThatClones cloner;
      ArrayList[] arrayOfLists;

      public UseProperty()
      {
         cloner = new PropertyThatClones();
         cloner.ModifyList("thirteen");
         arrayOfLists = new ArrayList[10];
      }

      // The following method violates the rule.
      public void UnderperformingMethod()
      {
         for(int i = 0; i < 10; i++)
         {
            Console.WriteLine(cloner.List);
         }
      }

      // The following method satisfies the rule.
      public void BetterPerformingMethod()
      {
         ArrayList localList = cloner.List;

         for(int i = 0; i < 10; i++)
         {
            Console.WriteLine(localList);
         }
      }

      // The following method violates the rule but the 
      // violation should be excluded because the array 
      // of identical ArrayList instances is intended.
      public void BuildArrayOfArrayLists()
      {
         for(int i = 0; i < arrayOfLists.Length; i++)
         {
            arrayOfLists[i] = cloner.List;
         }
      }
   }
}


Mostrar: