Propriedades completas com campos de suporte
Adicione lógica aos métodos de acesso de leitura e escrita.
Propriedades completas com campos de suporte é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.
Além das propriedades automáticas
Quando o senhor precisa de lógica dentro de get ou set, escreve uma propriedade completa com um campo de suporte explícito. O campo armazena os dados; os acessadores controlam o acesso.
using System;
class Temperature
{
private double _celsius;
public double Celsius
{
get { return _celsius; }
set { _celsius = value; }
}
}
class Program
{
static void Main()
{
var t = new Temperature();
t.Celsius = 21.5;
Console.WriteLine(t.Celsius);
}
}A convenção dos campos de suporte
Por convenção, um campo de suporte é private e recebe um nome iniciado por sublinhado, como _name. A propriedade pública o expõe.
using System;
class Person
{
private string _name;
public string Name
{
get { return _name; }
set { _name = value; }
}
}
class Program
{
static void Main()
{
var p = new Person();
p.Name = "Grace";
Console.WriteLine(p.Name);
}
}A palavra-chave value
Dentro de um acessador set, o parâmetro implícito value contém a atribuição recebida. O senhor decide o que fazer com ela.
using System;
class Box
{
private int _size;
public int Size
{
get { return _size; }
set { _size = value * 2; }
}
}
class Program
{
static void Main()
{
var box = new Box();
box.Size = 10;
Console.WriteLine("Stored size: " + box.Size);
}
}Validação no acessador de escrita
Um uso comum de uma propriedade completa é validar a entrada antes de armazená-la, lançando uma exceção se o valor for inválido.
using System;
class Account
{
private decimal _balance;
public decimal Balance
{
get { return _balance; }
set
{
if (value < 0)
throw new ArgumentException("Balance cannot be negative");
_balance = value;
}
}
}
class Program
{
static void Main()
{
var a = new Account();
a.Balance = 500m;
Console.WriteLine("Balance: " + a.Balance);
}
}Propriedades calculadas (somente para leitura)
Uma propriedade que possui apenas get pode calcular seu valor a partir de outros campos. Não há campo de suporte porque nada é armazenado.
using System;
class Rectangle
{
private double _width;
private double _height;
public Rectangle(double w, double h)
{
_width = w;
_height = h;
}
public double Area
{
get { return _width * _height; }
}
}
class Program
{
static void Main()
{
var r = new Rectangle(4, 5);
Console.WriteLine("Area: " + r.Area);
}
}Efeitos colaterais nos acessadores de escrita
Um acessador de escrita pode fazer mais do que armazenar: pode normalizar a entrada, atualizar o estado relacionado ou registrar alterações.
using System;
class User
{
private string _email;
public string Email
{
get { return _email; }
set { _email = value.Trim().ToLower(); }
}
}
class Program
{
static void Main()
{
var u = new User();
u.Email = " Hello@Example.COM ";
Console.WriteLine("Normalized: " + u.Email);
}
}Cálculo adiado em um acessador de leitura
Um acessador de leitura pode armazenar em cache um resultado dispendioso em um campo de suporte na primeira vez que ele for solicitado.
using System;
class Report
{
private string _cached;
public string Content
{
get
{
if (_cached == null)
_cached = "Generated at runtime";
return _cached;
}
}
}
class Program
{
static void Main()
{
var r = new Report();
Console.WriteLine(r.Content);
Console.WriteLine(r.Content);
}
}Protegendo contra estados inválidos
Combine um campo de suporte com lógica para manter um objeto sempre válido. Neste caso, o acessador de escrita limita o valor a um intervalo.
using System;
class Volume
{
private int _level;
public int Level
{
get { return _level; }
set
{
if (value < 0) _level = 0;
else if (value > 100) _level = 100;
else _level = value;
}
}
}
class Program
{
static void Main()
{
var v = new Volume();
v.Level = 150;
Console.WriteLine("Clamped: " + v.Level);
}
}Combinando valores armazenados e calculados
Uma classe frequentemente combina propriedades armazenadas (com campos de suporte) e propriedades calculadas somente para leitura, derivadas delas.
using System;
class Employee
{
private string _first;
private string _last;
public string First { get { return _first; } set { _first = value; } }
public string Last { get { return _last; } set { _last = value; } }
public string FullName { get { return _first + " " + _last; } }
}
class Program
{
static void Main()
{
var e = new Employee { First = "Marie", Last = "Curie" };
Console.WriteLine(e.FullName);
}
}Emitindo notificações de alterações
Os acessadores de escrita são o local natural para notificar quando os dados mudam, um padrão muito utilizado em estruturas de interface do usuário.
using System;
class Model
{
private int _count;
public int Count
{
get { return _count; }
set
{
if (_count != value)
{
_count = value;
Console.WriteLine("Count changed to " + _count);
}
}
}
}
class Program
{
static void Main()
{
var m = new Model();
m.Count = 1;
m.Count = 1;
m.Count = 2;
}
}Reunindo tudo
As propriedades completas permitem que uma classe imponha invariantes e exponha dados derivados, tudo por trás de uma interface limpa semelhante à de um campo.
using System;
class Thermostat
{
private double _target;
public double Target
{
get { return _target; }
set { _target = value < 10 ? 10 : value; }
}
public string Status { get { return _target >= 22 ? "Warm" : "Cool"; } }
}
class Program
{
static void Main()
{
var th = new Thermostat();
th.Target = 5;
Console.WriteLine(th.Target + " -> " + th.Status);
th.Target = 24;
Console.WriteLine(th.Target + " -> " + th.Status);
}
}Verificação rápida
Teste sua compreensão sobre propriedades completas.
Recapitulação
Uma propriedade completa combina um campo de suporte privado com acessadores get/set explícitos, permitindo adicionar validação, normalização, armazenamento em cache ou notificações de alterações. As propriedades calculadas somente para leitura possuem apenas um acessador de leitura e nenhum campo de suporte. A palavra-chave value transporta a atribuição recebida em um acessador de escrita.
using System;
class Demo
{
private int _n;
public int N
{
get { return _n; }
set { _n = value < 0 ? 0 : value; }
}
public int Doubled { get { return _n * 2; } }
}
class Program
{
static void Main()
{
var d = new Demo();
d.N = -5;
Console.WriteLine(d.N + ", " + d.Doubled);
}
}Perguntas Frequentes
A aula “Propriedades completas com campos de suporte” é grátis?
Sim — o texto completo de “Propriedades completas com campos de suporte” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.
O que vou aprender em “Propriedades completas com campos de suporte”?
Adicione lógica aos métodos de acesso de leitura e escrita. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar C# Academy?
Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Propriedades completas com campos de suporte”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de C# Academy?
Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Propriedades implementadas automaticamente
- Propriedades completas com campos de suporte
- Membros com corpo de expressão
- Indexadores