W konstruktorze możemy umieścić nadmiarową logikę biznesową, która będzie odpowiadała na przykład za walidację danych. Ponieważ możemy posiadać wiele konstruktorów istnieje możliwość łączenia ich za pomocą słowa kluczowego this.
Dodajmy do naszej klasy z poprzedniego wpisu nową zmienna, która będzie nam przechowywać nazwę naszego prostopadłościanu:

class Cuboid {
        private double height;
        private double width;
        private double length;
        private string name;
        public double GetHeight() {
            return height;
        }
       
        public double GetWidth() {
            return width;
        }
        public double GetLength() {
            return length;
        }
        public string GetName() {
            return name;
        }
}

Następnie dodajmy metodę, która będzie nam sprawdzać czy wprowadzana wartość jest ujemna, w przypadku gdy tak się stanie pomnoży nam ją przez -1 dzięki czemu uzyskamy wartość dodatnią i nie będzie można wprowadzić ujemnej długości, szerokości czy wysokości dla naszego prostopadłościanu:

private double CheckValue(double value) {
            if (value < 0)
                value = value * (-1);
            return value;
        } 

Dodajmy nowy konstruktor domyślny, który będzie na początku naszego łańcucha, wartości liczbowe będą równe 1, do zmiennej nazwa przypiszemy: „Prototyp A”

  public Cuboid() {
            height = 1;
            width = 1;
            length = 1;
            name = "Prototyp A";
           } 

Wynik stworzenie prostopadłościanu z tego konstruktora:

lancuch1

Rys. Stan obiektu utworzonego za pomocą konstruktora domyślnego

Napiszmy konstruktory, które będą implementowały naszą logikę biznesową:

public Cuboid(double Height, string Name) {
            height = CheckValue(Height);
            name = Name;
        }

Wynik stworzenie prostopadłościanu z tego konstruktora:

Cuboid przykladowy = new Cuboid(10, "Prototyp B");

lancuch2Rys. Wyświetlenie stanu obiektu

Jak widzimy kompilator przypisał nam dla długości i szerokości 0, czyli wartości domyślne. Jeżeli chcemy użyć naszych wartości z konstruktora domyślnego, wystarczy użyć słowa kluczowego this w następujący sposób:

public Cuboid(double Height, string Name) : this()  {
            height = CheckValue(Height);
            name = Name;
        }

Wynik stworzenie prostopadłościanu z tego konstruktora:

Cuboid przykladowy = new Cuboid(10, "Prototyp B");

lancuch3Rys. Wyświetlenie stanu obiektu

Jak widzimy kompilator przypisał wartości dla długości i szerokości z konstruktora domyślnego.

Napiszmy resztę konstruktorów:

public Cuboid(double height, double Width, string Name) : this()   {
            height = CheckValue(height);
            width = CheckValue(Width);
            name = Name;
        }

Wynik stworzenie prostopadłościanu z tego konstruktora:

Cuboid przykladowy = new Cuboid(10,20, "Prototyp C");

lancuch4

Rys. Wyświetlenie stanu obiektu

Na koniec zostało nam napisanie konstruktora, który będzie przyjmował wszystkie parametry, w tym przypadku nie potrzebujemy odnosić się do konstruktora domyślnego:

public Cuboid(double height, double Width, double Length, string Name) {
            height = CheckValue(height);
            width = CheckValue(Width);
            length = CheckValue(Length);
            name = Name;
        }

Wynik: stworzenie prostopadłościanu z tego konstruktora:

Cuboid przykladowy = new Cuboid(10, 20, 15, "Prototyp D");

lancuch5

Część kodu w każdym konstruktorze zawiera powtórzenia, aby wyeliminować ten problem zmieńmy hierarchie tworzenia konstruktorów i ich łączenia w łańcuch. W przykładzie powyżej zaczęliśmy od konstruktora domyślnego a następnie tworzyliśmy konstruktory z parametrami, które za pomocą słowa kluczowego this przypisywały brakujące wartości z konstruktora domyślnego, dzięki czemu wyeliminowaliśmy kilka powtórzeń.
Możemy wyeliminować wszystkie powtórzenia i skrócić kod zaczynając nasz łańcuch konstruktorów od konstruktora który zawiera największą ilość parametrów a następnie stworzymy, te z ich mniejszą ilością kończąc na konstruktorze domyślnym:
Konstruktor zawierający wszystkie parametry:

 public Cuboid(double Height, double Width, double Length, string Name) {
            height = CheckValue(Height);
            width = CheckValue(Width);
            length = CheckValue(Length);
            name = Name;
        }

Napiszmy resztę naszych konstruktorów:

public Cuboid(double Height, string Name) : this(Height, 1, 1, Name) { }
public Cuboid(double Height, double Width, string Name) : this(Height, Width, 1, Name) { }

Następnie napiszmy konstruktor domyślny z wykorzystaniem słowa kluczowego this:

public Cuboid() : this(1, 1, 1, "Prototyp domyślny") { }

Kod całej klasy po zmianie łańcucha konstruktorów:

class Cuboid {
        private double height;
        private double width;
        private double length;
        private string name;
        public double GetHeight() {
            return height;
        }
       
        public double GetWidth() {
            return width;
        }
        public double GetLength() {
            return length;
        }
        public string GetName() {
            return name;
        }
        
        public Cuboid() {
            height = 1;
            width = 1;
            length = 1;
            name = "Prototyp A";
           }
       
        public Cuboid(double Height, double Width, double Length, string Name) {
            height = CheckValue(Height);
            width = CheckValue(Width);
            length = CheckValue(Length);
            name = Name;
        }
        
        public Cuboid(double Height, string Name) : this(Height, 1, 1, Name) { }
        public Cuboid(double Height, double Width, string Name) : this(Height, Width, 1, Name) { }
public Cuboid() : this(1, 1, 1, "Prototyp domyślny") { }


        private double CheckValue(double value) {
            if (value < 0)
                value = value * (-1);
            return value;
        }
         }

Wtedy gdy wywołany konstruktor prześle parametry do konstruktora głównego przerywa wywoływanie instrukcji kodu. Gdy konstruktor główny wykona swoje zadania, kompilator powraca do konstruktora, który rozpoczął wywołanie i kończy wykonywać jego kod. Aby zaobserwować ten przepływ dodajmy do konstruktorów metodę wyświetlającą na ekran komunikat:

public Cuboid(double Height, double Width, double Length, string Name) {
            height = CheckValue(Height);
            width = CheckValue(Width);
            length = CheckValue(Length);
            name = Name;
            Console.WriteLine("Wywołał się konstruktor z największą ilością parametrów");
        }
   public Cuboid(double Height, string Name) : this(Height, 1, 1, Name) {
            Console.WriteLine("Wywołał się konstruktor z przypisaniem wysokości i nazwy");
        }

Kod klienta:

static void Main() {
            
            Cuboid przykladowy = new Cuboid(10, "Prototyp D");
            Console.WriteLine("Nazwa: " + przykladowy.GetName());
            Console.WriteLine("Długość wynosi: " + przykladowy.GetLength());
            Console.WriteLine("Szerokość wynosi: " + przykladowy.GetWidth());
            Console.WriteLine("Wysokość wynosi: " + przykladowy.GetHeight());

            Console.ReadKey();
        
        }

Oto wynik po skompilowaniu:

lancuch6

Rys. Wyświetlenie stanu obiektu

Podsumowanie:
Używanie łączenia konstruktorów w łańcuch nie jest oczywiście obowiązkowe, ale dzięki tej czynności uzyskujemy łatwiejszy do zarządzania i bardziej zwięzły kod klasy. Możemy też uprościć zadania programistyczne, ponieważ całą odpowiedzialność przerzucamy na jeden konstruktor a pozostałe przekazują do niego tylko wartości.