CA1024: Use as propriedades onde for apropriado

Causa

Um método público ou protegido tem um nome que começa com Get, sem parâmetros e retorna um valor que não é uma matriz.

Descrição da regra

Na maioria dos casos, propriedades representam os dados e métodos de realizar ações. As propriedades são acessadas como os campos, o que os torna mais fácil de usar. Um método é um bom candidato para se tornar uma propriedade, se houver uma das seguintes condições:

• Não requer argumentos e retorna as informações de estado de um objeto.

• Aceita um único argumento para definir a parte do estado de um objeto.

Propriedades devem se comportar como se eles são campos; Se o método não é possível, ele não deve ser alterado para uma propriedade. Métodos são melhores do que as 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. Acessar um campo não retorna uma versão convertida dos dados que ele armazena.

• O método Get tem um efeito de lado observável. Recuperando o valor de um campo não produz efeitos colaterais.

• A ordem de execução é importante. Definindo o valor de um campo não depende da ocorrência de outras operações.

• Chamando o método duas vezes em sucessão cria resultados diferentes.

• O método é estático, mas retorna um objeto que pode ser alterado pelo chamador. Recuperando o valor de um campo não permite que o chamador alterar os dados 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 avisos

Suprimir um aviso da regra, se o método de atender a pelo menos um dos critérios listados anteriormente.

Controlando a expansão de propriedade no depurador

Um motivo que os programadores evitar o uso de uma propriedade é porque eles não desejam que o depurador para expandir automaticamente. Por exemplo, a propriedade pode envolver a alocação de um objeto grande ou chamar um P/Invoke, mas ele realmente não pode ter efeitos colaterais observáveis.

Você pode impedir o depurador expansão automática propriedades aplicando System.Diagnostics.DebuggerBrowsableAttribute. O exemplo a seguir mostra esse atributo sendo aplicado a uma propriedade de 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árias que deve não porque não se comportarem como os 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();
      }
   }
}