0Pricing
C# Academy · Lección

Captura de parámetros en miembros

Utilice los parámetros del constructor primario en todo el tipo.

Captura de parámetros en miembros es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

Usar parámetros en miembros

La utilidad de los constructores principales procede de usar sus parámetros dentro de miembros: métodos, propiedades e inicializadores de campos. El compilador organiza el almacenamiento según sea necesario.

using System;

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

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

Captura frente a uso exclusivo en inicializadores

Si un parámetro se utiliza únicamente en un inicializador de campo o propiedad, no se necesita almacenamiento adicional. Si se utiliza en un método, el compilador lo captura en un 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

Los parámetros son mutables

Los parámetros de un constructor principal se comportan como parámetros normales: son mutables dentro de la instancia, a menos que los trate como de solo lectura. Modificar uno cambia el 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

Exponer parámetros como propiedades de solo lectura

Un patrón habitual consiste en exponer un parámetro mediante una propiedad con solo captador, ofreciendo una interfaz pública clara y manteniendo el 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

Propiedades calculadas a partir de parámetros

Los parámetros se integran de forma natural en las propiedades calculadas con cuerpo de expresión.

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 en varios métodos

El mismo parámetro capturado puede compartirse entre varios métodos y actuar como un campo privado inicializado durante la construcción.

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

Captura de tipos de referencia

Los parámetros de tipo de referencia capturados permiten almacenar dependencias inyectadas y llamarlas desde cualquier 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

Cómo evitar el almacenamiento doble accidental

Si asigna un parámetro a un campo y además utiliza el parámetro en los métodos, puede terminar almacenando el valor dos veces. Prefiera un solo enfoque para mantener la claridad.

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 en lambdas

Las lambdas definidas dentro de la clase pueden capturar parámetros, igual que los 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

Duración del ámbito

Un parámetro capturado vive tanto como el objeto. En la práctica, forma parte del estado de la instancia, así que no dé por hecho que se restablece entre llamadas a 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

Integración

Este servicio captura dos dependencias y las utiliza en varios métodos, mostrando la estructura habitual en situaciones reales.

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

Comprobación rápida

Confirme cómo se almacenan los parámetros de los constructores primarios.

Resumen

Ha aprendido cómo se utilizan los parámetros de los constructores primarios en los miembros.

  • Cuando se utilizan en métodos, los parámetros se capturan en campos ocultos.
  • Cuando se utilizan únicamente en inicializadores, no se necesita almacenamiento adicional.
  • Expóngalos mediante propiedades de solo lectura para obtener una interfaz limpia.
  • Se comportan como estado de la instancia durante toda la vida del objeto.

Preguntas frecuentes

¿La lección «Captura de parámetros en miembros» es gratis?

Sí — el texto completo de «Captura de parámetros en miembros» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Captura de parámetros en miembros»?

Utilice los parámetros del constructor primario en todo el tipo. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Captura de parámetros en miembros»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Constructores primarios en clases
  2. Captura de parámetros en miembros
  3. Constructores primarios con structs
  4. Combinación con propiedades y tipos base
← Volver a C# Academy