0Pricing
C# Academy · Lezione

Concatenamento dei costruttori con this

Riutilizzi l'inizializzazione tra i costruttori.

Concatenamento dei costruttori con this è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 4 lezioni in totale.

Perché concatenare i costruttori?

Quando più costruttori condividono la logica di configurazione, può concatenarli in modo che uno chiami l'altro. In questo modo evita di duplicare il codice e mantiene l'inizializzazione in un unico punto.

using System;

class Box
{
    public int Width;
    public int Height;

    public Box(int width, int height)
    {
        Width = width;
        Height = height;
    }

    public Box() : this(1, 1) { }
}

class Program
{
    static void Main()
    {
        var def = new Box();
        Console.WriteLine(def.Width + "x" + def.Height);
    }
}

La sintassi : this(...)

Il concatenamento usa : this(args) dopo la firma del costruttore. Il costruttore di destinazione viene eseguito per primo, quindi viene eseguito il corpo del costruttore corrente.

using System;

class Person
{
    public string Name;
    public int Age;

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
        Console.WriteLine("Full constructor ran");
    }

    public Person(string name) : this(name, 0)
    {
        Console.WriteLine("Name-only constructor ran");
    }
}

class Program
{
    static void Main()
    {
        var p = new Person("Sam");
        Console.WriteLine(p.Name + ", " + p.Age);
    }
}

Ordine di esecuzione

Il costruttore concatenato viene eseguito prima del corpo del costruttore chiamante. Questo garantisce che l'inizializzazione di base avvenga per prima.

using System;

class Step
{
    public Step(int n)
    {
        Console.WriteLine("Init with " + n);
    }

    public Step() : this(0)
    {
        Console.WriteLine("Then default body");
    }
}

class Program
{
    static void Main()
    {
        var s = new Step();
    }
}

Un'unica fonte di verità

Convogli tutti i costruttori in un costruttore "principale" che contiene la logica effettiva. Gli altri si limitano a fornire valori predefiniti e a concatenarsi a esso.

using System;

class Connection
{
    public string Host;
    public int Port;

    public Connection(string host, int port)
    {
        Host = host;
        Port = port;
    }

    public Connection(string host) : this(host, 8080) { }
    public Connection() : this("localhost", 8080) { }
}

class Program
{
    static void Main()
    {
        var c = new Connection("example.com");
        Console.WriteLine(c.Host + ":" + c.Port);
    }
}

Concatenamento con valori predefiniti

Il concatenamento è un modo chiaro per esprimere valori predefiniti stratificati: ogni costruttore più breve completa un valore predefinito aggiuntivo e delega il lavoro.

using System;

class Coffee
{
    public string Size;
    public bool Milk;
    public int Sugar;

    public Coffee(string size, bool milk, int sugar)
    {
        Size = size;
        Milk = milk;
        Sugar = sugar;
    }

    public Coffee(string size, bool milk) : this(size, milk, 0) { }
    public Coffee(string size) : this(size, false) { }
}

class Program
{
    static void Main()
    {
        var c = new Coffee("large");
        Console.WriteLine(c.Size + ", milk=" + c.Milk + ", sugar=" + c.Sugar);
    }
}

Validazione nella destinazione

Poiché ogni costruttore passa per quello principale, la validazione scritta al suo interno protegge tutti i percorsi di creazione.

using System;

class Rect
{
    public int W;
    public int H;

    public Rect(int w, int h)
    {
        if (w <= 0 || h <= 0)
            throw new ArgumentException("Dimensions must be positive");
        W = w;
        H = h;
    }

    public Rect(int side) : this(side, side) { }
}

class Program
{
    static void Main()
    {
        var square = new Rect(5);
        Console.WriteLine(square.W + "x" + square.H);
    }
}

Concatenamento e parametri predefiniti

I parametri predefiniti possono sostituire molti sovraccarichi, ma il concatenamento è più chiaro quando ogni costruttore richiede una logica leggermente diversa nel proprio corpo.

using System;

class Logger
{
    public string Prefix;
    public bool Verbose;

    public Logger(string prefix, bool verbose)
    {
        Prefix = prefix;
        Verbose = verbose;
    }

    public Logger(string prefix) : this(prefix, false)
    {
        Console.WriteLine("Created quiet logger");
    }
}

class Program
{
    static void Main()
    {
        var log = new Logger("APP");
        Console.WriteLine(log.Prefix + " verbose=" + log.Verbose);
    }
}

I corpi vuoti sono comuni

Un costruttore che usa il concatenamento ha spesso un corpo { } vuoto, perché tutto il lavoro viene svolto dal costruttore di destinazione.

using System;

class Vector
{
    public double X, Y, Z;

    public Vector(double x, double y, double z)
    {
        X = x; Y = y; Z = z;
    }

    public Vector(double v) : this(v, v, v) { }
}

class Program
{
    static void Main()
    {
        var v = new Vector(2);
        Console.WriteLine(v.X + "," + v.Y + "," + v.Z);
    }
}

Evitare i cicli

I costruttori non devono concatenarsi in un ciclo (A chiama B, B chiama A). Il compilatore rifiuta le catene circolari : this(...).

using System;

class Safe
{
    public int A, B;

    public Safe(int a, int b)
    {
        A = a;
        B = b;
    }

    public Safe(int a) : this(a, 0) { }   // chains one direction only
}

class Program
{
    static void Main()
    {
        var s = new Safe(7);
        Console.WriteLine(s.A + ", " + s.B);
    }
}

Combinazione con this.field

Può concatenare i costruttori e usare comunque this. nel corpo per qualsiasi configurazione aggiuntiva da eseguire dopo la restituzione del costruttore di destinazione.

using System;

class Account
{
    public string Owner;
    public decimal Balance;
    public bool Active;

    public Account(string owner, decimal balance)
    {
        this.Owner = owner;
        this.Balance = balance;
    }

    public Account(string owner) : this(owner, 0m)
    {
        this.Active = true;
    }
}

class Program
{
    static void Main()
    {
        var a = new Account("Rin");
        Console.WriteLine(a.Owner + " active=" + a.Active);
    }
}

Mettere tutto insieme

Il concatenamento mantiene una classe DRY: un costruttore esegue la validazione e assegna i valori; gli altri forniscono semplici scorciatoie.

using System;

class Pizza
{
    public string Size;
    public int Toppings;

    public Pizza(string size, int toppings)
    {
        if (toppings < 0) throw new ArgumentException("toppings");
        Size = size;
        Toppings = toppings;
    }

    public Pizza(string size) : this(size, 0) { }
    public Pizza() : this("medium") { }
}

class Program
{
    static void Main()
    {
        var p = new Pizza();
        Console.WriteLine(p.Size + " with " + p.Toppings + " toppings");
    }
}

Verifica rapida

Metta alla prova la Sua comprensione del concatenamento dei costruttori.

Riepilogo

Il concatenamento dei costruttori usa : this(args) per chiamare un altro costruttore della stessa classe. Il costruttore di destinazione viene eseguito per primo, quindi viene eseguito il corpo corrente. Faccia passare ogni costruttore attraverso un unico costruttore principale per centralizzare la validazione ed evitare configurazioni duplicate. Le catene circolari non sono consentite.

using System;

class Demo
{
    public int X, Y;
    public Demo(int x, int y) { X = x; Y = y; }
    public Demo(int both) : this(both, both) { }
}

class Program
{
    static void Main()
    {
        var d = new Demo(4);
        Console.WriteLine(d.X + "," + d.Y);
    }
}

Domande Frequenti

La lezione «Concatenamento dei costruttori con this» è gratuita?

Sì — il testo completo di «Concatenamento dei costruttori con this» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 4 lezioni in totale.

Cosa imparerò in «Concatenamento dei costruttori con this»?

Riutilizzi l'inizializzazione tra i costruttori. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C# Academy?

Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Concatenamento dei costruttori con this»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C# Academy?

Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Definizione dei costruttori
  2. Concatenamento dei costruttori con this
  3. Inizializzatori di oggetti e raccolte
  4. Costruttori statici
← Torna a C# Academy