CA1024: usar propriedades quando apropriado

Artigo
06/08/2015

TypeName	UsePropertiesWhereAppropriate
CheckId	CA1024
Categoria	Microsoft.Design
Alteração Significativa	Quebra

Causa

Um público ou um método protegido têm um nome que começa com Get, não usa nenhum parâmetro, e retornam um valor que não é uma matriz.

Descrição da Regra

Na maioria dos casos, as propriedades representam dados e os métodos executam ações.As propriedades são acessadas como campos, que os torna mais fácil usar.Um método é uma boa candidata a se tornar uma propriedade se uma destas condições estiver presente:

Não usa nenhum argumento e retorna informações do estado de um objeto.
Aceita um único argumento para definir qualquer parte do estado de um objeto.

As propriedades devem se comportar como se fossem campos; se o método não pode, não deve ser alterado para uma propriedade.Os métodos são melhor do que propriedades nas seguintes situações:

O método executa uma operação demorada.O método é perceivably mais lento do que o tempo necessário para definir ou obter o valor de um campo.
O método executa uma conversão.Acessando um campo não retorna uma versão convertida de dados que armazenam.
O método obter tem um efeito colateral observável.Recuperando o valor de um campo não gerencia nenhum efeito colateral.
A ordem de execução é importante.Defina o valor de um campo não confie na ocorrência de outras operações.
Chame o método duas vezes cria sucessivamente resultados diferentes.
O método é estática mas retorna um objeto que pode ser modificado pelo chamador.Recuperar o valor de um campo não permite que o chamador modificar os dados que são armazenados pelo campo.
O método retorna uma matriz.

Como Corrigir Violações

Para corrigir uma violação desta regra, altere o método a uma propriedade.

Quando Suprimir Alertas

Suprima um aviso dessa regra se o método localiza pelo menos um dos critérios listados anteriormente.

Expansão de controle da propriedade no depurador

Os desenvolvedores de uma razão para usar uma propriedade é porque não desejam que o depurador automática para a expanda.Por exemplo, a propriedade pode envolver atribuir um objeto grande ou chame um P/Invoke, mas não pode realmente ter nenhum efeito colateral perceptíveis.

Você pode evitar o depurador propriedades automática expandindo aplicando DebuggerBrowsableAttribute.O exemplo a seguir mostra esse atributo que está sendo aplicado a uma propriedade da instância.

Imports System 
Imports System.Diagnostics 

Namespace Microsoft.Samples 

    Public Class TestClass 

        ' [...] 

        <DebuggerBrowsable(DebuggerBrowsableState.Never)> _ 
        Public ReadOnly Property LargeObject() As LargeObject 
            Get 
                ' Allocate large object 
                ' [...] 
            End Get 
        End Property 

    End Class 

End Namespace

using System; 
using System.Diagnostics; 

namespace Microsoft.Samples 
{ 
    public class TestClass 
    { 
        // [...] 

        [DebuggerBrowsable(DebuggerBrowsableState.Never)] 
        public LargeObject LargeObject 
        { 
            get 
            { 
                // Allocate large object 
                // [...] 

        }
    }
}

Exemplo

O exemplo a seguir contém vários métodos que devem ser convertidos em propriedades, e vários que não devem porque não se comportam como campos.

using System;
using System.Globalization;
using System.Collections;
namespace DesignLibrary
{
   // Illustrates the behavior of rule:  
   //  UsePropertiesWhereAppropriate. 

   public class Appointment
   {
      static long nextAppointmentID;
      static double[] discountScale = {5.0, 10.0, 33.0};
      string customerName;
      long customerID;
      DateTime when;

      // Static constructor. 
      static Appointment()
      {
         // Initializes the static variable for Next appointment ID.
      }

      // This method will violate the rule, but should not be a property. 
      // This method has an observable side effect.  
      // Calling the method twice in succession creates different results. 
      public static long GetNextAvailableID()
      {
         nextAppointmentID++;
         return nextAppointmentID - 1;
      }

      // This method will violate the rule, but should not be a property. 
      // This method performs a time-consuming operation.  
      // This method returns an array. 

      public Appointment[] GetCustomerHistory()
      {
         // Connect to a database to get the customer's appointment history. 
         return LoadHistoryFromDB(customerID);
      }

      // This method will violate the rule, but should not be a property. 
      // This method is static but returns a mutable object. 
      public static double[] GetDiscountScaleForUpdate()
      {
         return discountScale;
      }

      // This method will violate the rule, but should not be a property. 
      // This method performs a conversion. 
      public string GetWeekDayString()
      {
         return DateTimeFormatInfo.CurrentInfo.GetDayName(when.DayOfWeek);
      }

      // These methods will violate the rule, and should be properties. 
      // They each set or return a piece of the current object's state. 

      public DayOfWeek GetWeekDay ()
      {
         return when.DayOfWeek;
      }

      public void  SetCustomerName (string customerName)
      {
         this.customerName = customerName;
      }
      public string GetCustomerName ()
      {
         return customerName;
      }

     public void SetCustomerID (long customerID)
      {
         this.customerID = customerID;
      }

      public long GetCustomerID ()
      {
         return customerID;
      }

      public void SetScheduleTime (DateTime when)
      {
         this.when = when;
      }

      public DateTime GetScheduleTime ()
      {
         return when;
      }

      // Time-consuming method that is called by GetCustomerHistory.
      Appointment[] LoadHistoryFromDB(long customerID)
      {
         ArrayList records = new ArrayList();
         // Load from database. 
         return (Appointment[])records.ToArray();
      }
   }
}

Partilhar via