Use propriedades onde for apropriado

TypeName	UsePropertiesWhereAppropriate
CheckId	CA1024
Category (Categoria)	Microsoft.Design
Quebrando alterar	Quebrando

Causa

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

Descrição da regra

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

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

• Aceita um único argumento para conjunto alguma parte do estado de um objeto.

Propriedades devem se comportar sistema autônomo se fossem campos; se o método não for possível, ele não ser alterado para uma propriedade.Métodos são preferível a propriedades nas seguintes situações:

• O método executa uma operação demorada.O método é perceivably mais lento do que o time necessário para conjunto ou obter o valor do campo.

• O método executará uma conversão.Acessar um campo não retorna uma versão convertida de dados que ele armazena.

• O método Get tem um efeito colateral observável.Recuperar o valor do campo não produzem qualquer efeitos colaterais.

• A ordem de execução é importante.Definir o valor de um campo não depende de outras operações que ocorreu.

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

• O método for estático, mas retorna um objeto que pode ser alterado pelo chamador.Recuperar o valor do 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 dessa regra, altere o método a uma propriedade.

Quando suprimir avisos

Elimina um aviso essa 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 para programadores evitar o uso de uma propriedade é o fato de 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 talvez não tenha realmente efeitos colaterais observáveis.

Você pode impedir que o depurador expansão automática propriedades aplicando System.Diagnostics.DebuggerBrowsableAttribute. O exemplo a seguir mostra esse atributo seja aplicado a uma propriedade da ocorrê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 
{ 
    publicclass TestClass 
    { 
        // [...] 

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

        }
    }
}

Exemplo

O exemplo a seguir contém diversos métodos que deve ser convertido em Propriedades e vários 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();
      }
   }
}