0Pricing
C# Academy · Aula

Capturando parâmetros em membros

Use os parâmetros do construtor primário em todo o tipo.

Capturando parâmetros em membros é 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.

Usando parâmetros em membros

O poder dos construtores primários vem do uso dos parâmetros dentro de membros: métodos, propriedades e inicializadores de campos. O compilador organiza o armazenamento conforme necessário.

using System;

class Multiplier(int factor) {
    public int Apply(int n) => n * factor;
}

Console.WriteLine(new Multiplier(3).Apply(5)); // 15

Captura versus somente inicializador

Se um parâmetro for usado apenas em um inicializador de campo ou propriedade, não será necessário armazenamento adicional. Se for usado em um método, o compilador o captura em um campo oculto.

using System;

class A(int x) {
    public int Stored = x;     // initializer only
}
class B(int x) {
    public int Get() => x;     // captured into a field
}

Console.WriteLine(new A(7).Stored); // 7
Console.WriteLine(new B(9).Get());  // 9

Parâmetros são mutáveis

Os parâmetros de construtores primários comportam-se como parâmetros comuns: são mutáveis dentro da instância, a menos que sejam tratados como somente leitura. Alterar um deles modifica o campo capturado.

using System;

class Toggle(bool on) {
    public void Flip() => on = !on;
    public bool State => on;
}

var t = new Toggle(false);
t.Flip();
Console.WriteLine(t.State); // True

Expondo como propriedades somente leitura

Um padrão comum é expor um parâmetro por meio de uma propriedade somente leitura, oferecendo uma interface pública limpa e mantendo o parâmetro interno.

using System;

class User(string email) {
    public string Email { get; } = email;
}

Console.WriteLine(new User("a@b.com").Email); // a@b.com

Propriedades calculadas a partir de parâmetros

Os parâmetros se integram naturalmente a propriedades calculadas com corpo de expressão.

using System;

class Money(decimal amount, string currency) {
    public string Display => amount.ToString("0.00") + " " + currency;
}

Console.WriteLine(new Money(9.5m, "USD").Display); // 9.50 USD

Parâmetros em vários métodos

O mesmo parâmetro capturado pode ser compartilhado por vários métodos, funcionando como um campo privado inicializado durante a construção.

using System;

class Range2(int lo, int hi) {
    public bool Contains(int n) => n >= lo && n <= hi;
    public int Clamp(int n) => Math.Max(lo, Math.Min(hi, n));
}

var r = new Range2(0, 10);
Console.WriteLine(r.Contains(5)); // True
Console.WriteLine(r.Clamp(15));   // 10

Capturando tipos de referência

Os parâmetros de tipos de referência capturados permitem armazenar dependências injetadas e chamá-las de qualquer método.

using System;
using System.Collections.Generic;

class Repo(List<string> store) {
    public void Add(string item) => store.Add(item);
    public int Count => store.Count;
}

var list = new List<string>();
var repo = new Repo(list);
repo.Add("x");
Console.WriteLine(repo.Count); // 1

Evitando armazenamento duplicado acidental

Se você atribuir um parâmetro a um campo e também usar o parâmetro em métodos, poderá acabar armazenando o valor duas vezes. Prefira uma única abordagem para manter a clareza.

using System;

class Clean(int x) {
    // expose once via property, reference property in methods
    public int Value { get; } = x;
    public int Doubled() => Value * 2;
}

Console.WriteLine(new Clean(4).Doubled()); // 8

Parâmetros em expressões lambda

Os parâmetros podem ser capturados por expressões lambda definidas dentro da classe, assim como os campos.

using System;
using System.Collections.Generic;
using System.Linq;

class Filter(int threshold) {
    public IEnumerable<int> KeepAbove(IEnumerable<int> xs) =>
        xs.Where(n => n > threshold);
}

var f = new Filter(3);
Console.WriteLine(string.Join(",", f.KeepAbove(new[]{1,2,3,4,5}))); // 4,5

Tempo de vida do escopo

Um parâmetro capturado vive enquanto o objeto existir. Ele funciona efetivamente como estado da instância; portanto, não presuma que seja redefinido entre chamadas de métodos.

using System;

class Accumulator(int seed) {
    private int total = seed;
    public int Add(int n) { total += n; return total; }
}

var a = new Accumulator(100);
Console.WriteLine(a.Add(1)); // 101
Console.WriteLine(a.Add(1)); // 102

Combinando tudo

Este serviço captura duas dependências e as utiliza em vários métodos, mostrando a estrutura típica de um caso real.

using System;

class PriceService(decimal taxRate, string currency) {
    public decimal WithTax(decimal net) => net * (1 + taxRate);
    public string Format(decimal v) => v.ToString("0.00") + " " + currency;
}

var s = new PriceService(0.2m, "EUR");
Console.WriteLine(s.Format(s.WithTax(100m))); // 120.00 EUR

Verificação rápida

Confirme como os parâmetros de construtores primários são armazenados.

Recapitulação

Você aprendeu como os parâmetros de construtores primários são usados em membros.

  • Quando usados em métodos, os parâmetros são capturados em campos ocultos.
  • Quando usados apenas em inicializadores, nenhum armazenamento adicional é necessário.
  • Exponha-os por meio de propriedades somente de leitura para obter uma interface limpa.
  • Eles se comportam como estado da instância durante o tempo de vida do objeto.

Perguntas Frequentes

A aula “Capturando parâmetros em membros” é grátis?

Sim — o texto completo de “Capturando parâmetros em membros” é 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 “Capturando parâmetros em membros”?

Use os parâmetros do construtor primário em todo o tipo. 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 “Capturando parâmetros em membros”?

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

  1. Construtores primários em classes
  2. Capturando parâmetros em membros
  3. Construtores primários com structs
  4. Combinando com propriedades e tipos base
← Voltar para C# Academy