Como classes, construtores e propriedades funcionam?

Question

Accepted Answer

**Classes** são a base do modelo orientado a objetos do C# — blueprints para objetos, com **construtores** (inicializam objetos) e **propriedades** (acesso controlado a dados). A sintaxe de propriedades do C# é uma característica distintiva e elegante.

## Uma classe com construtor e propriedades

```csharp
public class Person
{
    // auto-implemented PROPERTY — encapsulated access with get/set
    public string Name { get; set; }
    public int Age { get; private set; }      // settable only within the class
    public string Email { get; init; }          // set only during initialization (C# 9)

// CONSTRUCTOR
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

public string Greet() => $"Hi, I'm {Name}";   // a method
}

var person = new Person("Ann", 30);    // create an instance
person.Name = "Bob";                     // set a property
Console.WriteLine(person.Greet());
```

## Propriedades — encapsulamento feito elegante

```csharp
// auto-property (the common case) — compiler generates the backing field
public string Name { get; set; }

// property with custom logic
private decimal _balance;
public decimal Balance
{
    get => _balance;
    set => _balance = value >= 0 ? value : throw new ArgumentException();   // validation
}

// expression-bodied / computed property
public string FullName => $"{First} {Last}";   // read-only, computed
```

**Propriedades** parecem campos, mas na verdade são métodos (`get`/`set`) — fornecendo encapsulamento (acesso controlado, validação, valores computados) com sintaxe limpa. Auto-propriedades (`{ get; set; }`) lidam com o caso comum sem necessidade de código boilerplate.

## Inicializadores de objeto e recursos modernos

```csharp
var p = new Person("Ann", 30) { Email = "a@x.com" };   // object initializer

// primary constructor (C# 12) — concise constructor parameters
public class Point(int x, int y)
{
    public int X { get; } = x;
}
```

## Por que isso importa

Classes, construtores e propriedades são a base do C# orientado a objetos — praticamente todo código C# é organizado em classes, então compreendê-los é essencial para qualquer desenvolvimento em C#.

Saber como definir classes com construtores (inicializando objetos) e métodos é fundamental, mas as **propriedades** do C# são uma característica particularmente importante e distintiva que vale a pena entender bem.

Propriedades fornecem **encapsulamento** elegantemente — parecem campos, mas na verdade são métodos `get`/`set`, permitindo acesso controlado, validação, valores computados e modificadores de acesso (como `private set` ou `init`-only) mantendo uma sintaxe limpa. **Auto-propriedades** (`{ get; set; }`) lidam com o caso comum sem nenhum boilerplate, tornando o encapsulamento sem esforço (diferentemente de linguagens onde você escreve métodos getter/setter explícitos).

Compreender propriedades (auto-propriedades, lógica customizada, computadas/somente leitura, `init`-only para imutabilidade), construtores, inicializadores de objeto e conveniências modernas (construtores primários) é conhecimento essencial e do dia a dia para escrever classes C# bem encapsuladas.

Já que classes são como você modela dados e comportamento em toda a aplicação C#, e já que propriedades são a forma idiomática e elegante do C# lidar com encapsulamento (uma característica de linguagem distintiva usada constantemente), dominar essas — especialmente o sistema de propriedades — é material fundamental e imprescindível para o desenvolvimento eficaz e orientado a objetos em C#.