C# Academy · Aula

Combinando com propriedades e tipos base

Encaminhe parâmetros para tipos base e propriedades.

Aula 4 de 413 etapas

Combinando com propriedades e tipos base é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 4 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.

Combinando construtores primários com herança

Uma classe derivada com um construtor primário pode encaminhar seus parâmetros para uma classe base usando a sintaxe : Base(args) no cabeçalho.

using System;

class Animal(string name) {
    public string Name => name;
}

class Dog(string name) : Animal(name) {
    public string Speak() => Name + " says Woof";
}

Console.WriteLine(new Dog("Rex").Speak()); // Rex says Woof

Encaminhando um subconjunto de parâmetros

A classe derivada pode receber mais parâmetros que a classe base e passar apenas os relevantes para ela.

using System;

class Shape(string color) {
    public string Color => color;
}

class Box(string color, int size) : Shape(color) {
    public int Size => size;
}

var b = new Box("red", 5);
Console.WriteLine(b.Color + " " + b.Size); // red 5

Transformando argumentos para a classe base

Você pode calcular os argumentos do construtor da classe base a partir dos parâmetros da classe derivada diretamente no cabeçalho.

using System;

class Label(string text) {
    public string Text => text;
}

class UpperLabel(string text) : Label(text.ToUpper()) {
}

Console.WriteLine(new UpperLabel("hi").Text); // HI

Adicionando propriedades ao mesmo tempo

Um construtor primário e propriedades explícitas podem coexistir. Inicialize as propriedades a partir dos parâmetros na declaração.

using System;

class Product(string name, decimal price) {
    public string Name { get; } = name;
    public decimal Price { get; set; } = price;
}

var p = new Product("Book", 12m);
p.Price = 10m;
Console.WriteLine(p.Name + " " + p.Price); // Book 10

Parâmetros da classe base e uso na classe derivada

Mesmo depois de encaminhar um parâmetro para a classe base, um parâmetro do construtor primário da classe derivada ainda pode ser usado no corpo dessa classe.

using System;

class Base(int id) {
    public int Id => id;
}

class Item(int id, string label) : Base(id) {
    public string Describe() => "#" + id + ": " + label;
}

Console.WriteLine(new Item(7, "Widget").Describe()); // #7: Widget

Registros e construtores primários

Os registros usam construtores primários para gerar automaticamente propriedades públicas somente de inicialização. Um registro posicional é o caso mais conciso.

using System;

record Person(string First, string Last) {
    public string Full => First + " " + Last;
}

Console.WriteLine(new Person("Ada", "Lovelace").Full); // Ada Lovelace

Herança de registros

Os registros derivados encaminham os valores posicionalmente para um registro base, gerando o conjunto combinado de propriedades.

using System;

record Vehicle(string Make);
record Car(string Make, int Doors) : Vehicle(Make);

var c = new Car("Toyota", 4);
Console.WriteLine(c.Make + " " + c.Doors); // Toyota 4

Validação antes da chamada à classe base

Se você precisar de validação, faça-a em um inicializador de propriedade usando uma expressão de lançamento; a chamada à classe base ainda será executada primeiro.

using System;

class Base(string tag) { public string Tag => tag; }

class Node(string tag) : Base(tag) {
    public string Tag2 { get; } =
        tag.Length > 0 ? tag : throw new ArgumentException("empty");
}

Console.WriteLine(new Node("a").Tag); // a

Combinando parâmetros capturados e propriedades

Você pode manter alguns parâmetros como estado privado capturado e expor outros como propriedades, ajustando a interface pública conforme necessário.

using System;

class Order(int id, decimal total) {
    public decimal Total { get; } = total; // public
    public string Reference() => "ORD-" + id;   // id stays private
}

var o = new Order(42, 99m);
Console.WriteLine(o.Reference() + " " + o.Total); // ORD-42 99

Valores padrão de propriedades

As propriedades que não estão vinculadas a parâmetros ainda podem receber inicializadores padrão, combinando livremente com os parâmetros do construtor primário.

using System;

class Session(string user) {
    public string User { get; } = user;
    public bool Active { get; set; } = true;
}

var s = new Session("kai");
Console.WriteLine(s.User + " " + s.Active); // kai True

Combinando tudo

Uma classe derivada que encaminha valores para uma classe base, adiciona uma propriedade e expõe um membro calculado.

using System;

class Employee(string name) {
    public string Name => name;
}

class Manager(string name, int teamSize) : Employee(name) {
    public int TeamSize { get; } = teamSize;
    public string Title => Name + " (manages " + TeamSize + ")";
}

Console.WriteLine(new Manager("Sam", 5).Title); // Sam (manages 5)

Verificação rápida

Confirme como os construtores primários encaminham valores para classes base.

Responda na aula interativa

Recapitulação

Você aprendeu a combinar construtores primários com propriedades e classes base.

class D(...) : Base(args) encaminha valores para a classe base.
Os argumentos da classe base podem ser calculados diretamente.
As propriedades podem ser inicializadas a partir dos parâmetros na declaração.
Os registros geram propriedades públicas somente de inicialização a partir de parâmetros posicionais.

Grátis para começar

Aprenda C# com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 93
Aulas: 346

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Combinando com propriedades e tipos base” é grátis?

Sim — o texto completo de “Combinando com propriedades e tipos base” é 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 “Combinando com propriedades e tipos base”?

Encaminhe parâmetros para tipos base e propriedades. 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 4 de 4.

Quanto tempo leva a aula “Combinando com propriedades e tipos base”?

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

Construtores primários em classes
Capturando parâmetros em membros
Construtores primários com structs
Combinando com propriedades e tipos base

← Voltar para C# Academy