المُنشئ Constructor في C#: الافتراضي وذو المعاملات والتسلسل بـ this() وbase()

المُنشئ (constructor) هو الشيفرة التي تعمل حين تنشئ كائنًا بـ new. يحمل اسم الصنف نفسه، ولا نوع إرجاع له، ومهمته وضع الكائن الجديد في حالة صالحة قبل أن يستخدمه أحد.

using System;

class Product
{
    public string Name;
    public decimal Price;

    public Product(string name, decimal price)
    {
        if (price < 0) throw new ArgumentOutOfRangeException(nameof(price));
        Name = name;
        Price = price;
    }
}

class Program
{
    static void Main()
    {
        var mug = new Product("Mug", 8.50m);
        Console.WriteLine($"{mug.Name}: {mug.Price}");

        try
        {
            var broken = new Product("Lamp", -3m);
        }
        catch (ArgumentOutOfRangeException e)
        {
            Console.WriteLine($"Rejected: {e.ParamName}");
        }
    }
}

المخرجات:

Mug: 8.50
Rejected: price

لأن المُنشئ يرفض السعر السالب، لا يمكن أن يوجد Product بسعر سالب. هذا الضمان هو السبب الرئيسي لكتابة المُنشئات بدل ضبط الحقول من الخارج.

المُنشئ الافتراضي، ومتى يختفي

إن لم يصرّح الصنف بأي مُنشئ، يقدّم المترجم مُنشئًا عامًا بلا معاملات لا يفعل شيئًا سوى تشغيل مهيّئات الحقول. ولهذا تعمل new BankAccount() على صنف ليس فيه إلا حقول.

وبمجرد أن تصرّح بأي مُنشئ، لا يعود ذلك الضمني يُولَّد:

class Product
{
    public string Name;
    public Product(string name) { Name = name; }
}

var p = new Product();   // error CS7036: There is no argument given that corresponds to the required parameter 'name'

هذا يفاجئ الناس حين تحتاج أداة تسلسل أو ORM أو قيد new() عام إلى مُنشئ بلا معاملات. إن أردت الاثنين فصرّح بالذي بلا معاملات بنفسك:

public Product() { }                       // or
public Product() : this("Unnamed") { }     // delegate to the other one (next section)

يمكن أن يكون المُنشئ public أو internal أو protected أو private. ويحدد وصوله من يستطيع إنشاء كائنات به.

التحميل الزائد والتسلسل بـ this(...)

يمكن أن يكون للصنف عدة مُنشئات بقوائم معاملات مختلفة. لتجنّب نسخ الإسنادات نفسها في كل واحد سلسلها: تستدعي : this(...) مُنشئًا آخر من الصنف نفسه قبل تنفيذ الجسم الحالي.

using System;

class Pizza
{
    public string Size;
    public string Crust;
    public int Toppings;

    public Pizza(string size, string crust, int toppings)
    {
        Size = size;
        Crust = crust;
        Toppings = toppings;
        Console.WriteLine($"  full constructor: {size}, {crust}, {toppings}");
    }

    public Pizza(string size) : this(size, "classic", 0)
    {
        Console.WriteLine("  size-only constructor body");
    }

    public Pizza() : this("medium")
    {
        Console.WriteLine("  parameterless constructor body");
    }
}

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

المخرجات:

new Pizza():
  full constructor: medium, classic, 0
  size-only constructor body
  parameterless constructor body
Result: medium classic with 0 toppings

تشغّل السلسلة المُنشئ الأكمل أولًا وتعود إلى الذي استدعيته. أبقِ العمل الحقيقي (التحقق والإسنادات) في مُنشئ واحد ودع الآخرين يقدّمون القيم الافتراضية فقط.

المعاملات الاختيارية بديل: تعطي public Pizza(string size = "medium", string crust = "classic", int toppings = 0) مُنشئًا واحدًا يغطي الاستدعاءات الثلاثة. لكن التسلسل يظل الأنسب حين تحتاج المُنشئات الأقصر إلى حساب شيء، أو حين يجب ألا يتطلب تغيير قيمة افتراضية إعادة ترجمة المستدعين (قيم المعاملات الاختيارية الافتراضية تُنسخ في الشيفرة المستدعية وقت الترجمة).

استدعاء مُنشئ الصنف الأساس بـ base(...)

الصنف المشتق لا يرث المُنشئات. يجب على كل مُنشئ في الصنف المشتق أن يشغّل مُنشئًا من الصنف الأساس أولًا. إن لم تكتب شيئًا يُدرج المترجم استدعاءً لمُنشئ الأساس الذي بلا معاملات؛ وإن لم يكن للأساس واحد فعليك اختيار واحد بـ : base(...).

ترتيب تنفيذ كل شيء يستحق أن تراه مرة:

using System;

class Vehicle
{
    string log = Note("Vehicle field initializer");
    public string Plate;

    public Vehicle(string plate)
    {
        Console.WriteLine("Vehicle constructor body");
        Plate = plate;
    }

    protected static string Note(string text)
    {
        Console.WriteLine(text);
        return text;
    }
}

class Truck : Vehicle
{
    string log2 = Note("Truck field initializer");
    public int Axles;

    public Truck(string plate, int axles) : base(plate)
    {
        Console.WriteLine("Truck constructor body");
        Axles = axles;
    }
}

class Program
{
    static void Main()
    {
        var t = new Truck("KL-204", 3);
        Console.WriteLine($"{t.Plate}, {t.Axles} axles");
    }
}

المخرجات:

Truck field initializer
Vehicle field initializer
Vehicle constructor body
Truck constructor body
KL-204, 3 axles

تعمل مهيّئات الحقول أولًا، الصنف المشتق قبل الصنف الأساس، ثم تعمل أجسام المُنشئات من الأساس نزولًا. فحين يُنفَّذ جسم Truck تكون Plate مضبوطة أصلًا. الفخ الوحيد في هذا الترتيب: إن استدعى مُنشئ الأساس دالة virtual يتجاوزها Truck، يُنفَّذ التجاوز قبل جسم مُنشئ Truck، ويرى Axles ما زالت 0. تجنّب استدعاء الدوال الافتراضية من المُنشئات.

المُنشئات الساكنة

يهيّئ المُنشئ الساكن النوع لا الكائن. لا معاملات له ولا معدّل وصول، ويستدعيه وقت التشغيل مرة واحدة بالضبط، قبيل أول استخدام للنوع.

using System;
using System.Collections.Generic;

class TaxTable
{
    public static readonly Dictionary<string, decimal> Rates;

    static TaxTable()
    {
        Console.WriteLine("Loading tax table (runs once)");
        Rates = new Dictionary<string, decimal>
        {
            ["PT"] = 0.23m,
            ["DE"] = 0.19m,
        };
    }

    public static decimal WithTax(string country, decimal net) => net * (1 + Rates[country]);
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Program started");
        Console.WriteLine(TaxTable.WithTax("PT", 100m));
        Console.WriteLine(TaxTable.WithTax("DE", 100m));
    }
}

المخرجات:

Program started
Loading tax table (runs once)
123.00
119.00

يجعل وقت التشغيل المُنشئ الساكن آمنًا مع الخيوط: حتى لو لمست عدة خيوط النوع في الوقت نفسه يعمل مرة واحدة. وإن رمى استثناءً فكل استخدام لاحق للنوع يرمي TypeInitializationException طوال عمر العملية، فأبقه بسيطًا وخاليًا من عمليات الإدخال والإخراج التي قد تفشل.

المُنشئ مقابل مهيّئ الكائن

مهيّئ الكائن، new Pizza("large") { Toppings = 3 }، ليس مُنشئًا ثانيًا. يحوّله المترجم إلى "شغّل المُنشئ، ثم أسند هذه الأعضاء". استخدم كلًّا فيما يجيده:

• معاملات المُنشئ للقيم التي لا يكون الكائن صالحًا دونها. يجب على كل مستدعٍ تمريرها، ويستطيع المُنشئ فحصها.
• المهيّئ للإعدادات الاختيارية ذات القيم الافتراضية المعقولة.

var order = new Order(customerId: 42) { Note = "Leave at the door", GiftWrap = true };

منذ C# 11 يجب ضبط الخاصية المعلّمة بـ required في المهيّئ، وهذا يمنح صياغة المهيّئ بعض ضمانات المُنشئ. وهذا مشروح في صفحة الخصائص.

المُنشئات الخاصة

المُنشئ private يعني أن الصنف نفسه وحده يستطيع إنشاء مثيلات. نمطان يستخدمانه: دالة مصنع ساكنة، يتحكم فيها الصنف بالإنشاء ويستطيع إعادة كائن مخزّن مؤقتًا أو null، والمفرد (singleton):

using System;

class Temperature
{
    public decimal Celsius { get; }

    private Temperature(decimal celsius) { Celsius = celsius; }

    public static Temperature FromCelsius(decimal c) => new Temperature(c);
    public static Temperature FromFahrenheit(decimal f) => new Temperature((f - 32) * 5 / 9);
}

class Program
{
    static void Main()
    {
        var a = Temperature.FromCelsius(21m);
        var b = Temperature.FromFahrenheit(212m);
        Console.WriteLine(a.Celsius);
        Console.WriteLine(b.Celsius);
        // var c = new Temperature(5m); // error CS0122: inaccessible due to its protection level
    }
}

المخرجات:

21
100

خطأ المترجم لـ new Temperature(5m) خارج الصنف هو CS0122، وهو نفسه الذي تنتجه معدّلات الوصول لأي عضو خاص. تحلّ دوال المصنع المسمّاة قيدًا حقيقيًا: لا يمكن لمُنشئين أن يأخذا كلاهما decimal واحدًا، لكن FromCelsius وFromFahrenheit تستطيعان. أما الصنف الذي ليس فيه إلا أعضاء ساكنة (صنف أدوات) فيجب التصريح به static بدل إخفاء مُنشئه.

المُنشئات بجسم تعبيري

المُنشئ الذي جسمه عبارة واحدة يمكنه استخدام =>:

public Product(string name) => Name = name;

ومع الصفوف يمكنك حتى إسناد عدة حقول في سطر واحد: public Point(int x, int y) => (X, Y) = (x, y);.

المُنشئات الأساسية (C# 12)

تتيح C# 12 لصنف أو بنية التصريح بمعاملات مُنشئها على النوع نفسه. وتكون المعاملات في النطاق في كل عضو:

public class Customer(string name, int id)
{
    public string Name { get; } = name;          // copy into a property
    public string Label => $"#{id} {Name}";      // or read a parameter directly

    public Customer(string name) : this(name, 0) { }   // other constructors must chain to it
}

فرقان عن السجلات يفاجئان الناس. معاملات المُنشئ الأساسي في الصنف لا تصبح خصائص عامة؛ تكشفها بنفسك. والمعامل المستخدم داخل عضو يُلتقط في حقل مخفي يبقى قابلًا للتغيير، فتُترجم name = "x"; داخل دالة. المُنشئات الأساسية في بيئتها الطبيعية مع حقن الاعتماديات، حيث المعاملات خدمات لا يفعل الصنف سوى استدعائها:

public class OrderService(IOrderRepository repo, ILogger<OrderService> log)
{
    public Order Get(int id) => repo.Find(id);
}

أخطاء شائعة

• فقدان المُنشئ الذي بلا معاملات. إضافة مُنشئ بمعاملات تزيل الضمني (CS7036 عند كل new X()).
• نسيان : base(...) حين لا يملك الصنف الأساس مُنشئًا بلا معاملات. لا يستطيع المترجم إدراج الاستدعاء الضمني ويبلّغ بأنه لا وسيط للمعامل الإلزامي لمُنشئ الأساس.
• استدعاء دوال افتراضية في مُنشئ. يُنفَّذ التجاوز قبل جسم المُنشئ المشتق.
• عمل ثقيل في مُنشئ. استدعاءات الشبكة أو قراءة الملفات أو أي شيء بطيء تجعل الكائنات مكلفة والاستثناءات صعبة المعالجة. استخدم دالة مصنع ساكنة، أو دالة تهيئة غير متزامنة، لذلك العمل.
• كتابة نوع إرجاع. public void Product() دالة عادية اسمها Product، ويرفضها المترجم لأن العضو لا يمكن أن يحمل اسم النوع المحيط به (CS0542).