النموذج الأولي (Prototype).

النموذج الأولي نمط تصميم إنشائي يتيح نسخ الكائنات الموجودة دون ربط الكود بفئاتها.

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

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

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

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

يتشابه تنفيذ طريقة clone كثيرًا في جميع الفئات. تُنشئ الطريقة كائنًا من الفئة الحالية وتنقل إليه جميع قيم حقول الكائن القديم. يمكنك حتى نسخ الحقول الخاصة لأن معظم لغات البرمجة تتيح للكائنات الوصول إلى الحقول الخاصة لكائنات أخرى تنتمي إلى نفس الفئة.

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

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

في هذا المثال، يتيح لك نمط النموذج الأولي (Prototype) إنتاج نسخ طبق الأصل من الكائنات الهندسية دون ربط الكود بفئاتها.

تتبع جميع فئات الأشكال الواجهة نفسها، التي توفّر أسلوباً للاستنساخ. ويمكن للفئة الفرعية استدعاء أسلوب الاستنساخ في الفئة الأم قبل نسخ قيم حقولها الخاصة إلى الكائن الناتج.

// النموذج الأولي الأساسي.
abstract class Shape is
    field X: int
    field Y: int
    field color: string

    // مُنشئ عادي.
    constructor Shape() is
        // ...

    // مُنشئ النموذج الأولي. يُهيَّأ كائن جديد
    // بقيم من الكائن الموجود.
    constructor Shape(source: Shape) is
        this()
        this.X = source.X
        this.Y = source.Y
        this.color = source.color

    // تُعيد عملية الاستنساخ إحدى الفئات الفرعية من Shape.
    abstract method clone():Shape


// النموذج الأولي المحدد. تُنشئ طريقة الاستنساخ كائنًا جديدًا
// دفعةً واحدة عن طريق استدعاء مُنشئ الفئة الحالية و
// تمرير الكائن الحالي كمعامل للمُنشئ.
// إجراء جميع عمليات النسخ الفعلية في المُنشئ يساعد على
// الحفاظ على تناسق النتيجة: لن يُعيد المُنشئ
// نتيجة حتى يُبنى الكائن الجديد بالكامل؛ وبالتالي لا يوجد كائن
// يمكنه الإشارة إلى نسخة مبنية جزئيًا.
class Rectangle extends Shape is
    field width: int
    field height: int

    constructor Rectangle(source: Rectangle) is
        // استدعاء المُنشئ الأصلي ضروري لنسخ الحقول الخاصة
        // المُعرَّفة في الفئة الأصلية.
        super(source)
        this.width = source.width
        this.height = source.height

    method clone():Shape is
        return new Rectangle(this)


class Circle extends Shape is
    field radius: int

    constructor Circle(source: Circle) is
        super(source)
        this.radius = source.radius

    method clone():Shape is
        return new Circle(this)


// في مكان ما في كود العميل.
class Application is
    field shapes: array of Shape

    constructor Application() is
        Circle circle = new Circle()
        circle.X = 10
        circle.Y = 10
        circle.radius = 20
        shapes.add(circle)

        Circle anotherCircle = circle.clone()
        shapes.add(anotherCircle)
        // يحتوي المتغير `anotherCircle` على نسخة طبق الأصل
        // من كائن `circle`.

        Rectangle rectangle = new Rectangle()
        rectangle.width = 10
        rectangle.height = 20
        shapes.add(rectangle)

    method businessLogic() is
        // النموذج الأولي رائع لأنه يتيح لك إنتاج نسخة من
        // كائن دون معرفة أي شيء عن نوعه.
        Array shapesCopy = new Array of Shapes.

        // على سبيل المثال، لا نعرف العناصر الدقيقة في مصفوفة
        // الأشكال. كل ما نعرفه أنها جميعها
        // أشكال. لكن بفضل تعدد الأشكال، عند استدعاء طريقة
        // `clone` على شكل ما يتحقق البرنامج من فئته الحقيقية
        // ويشغّل طريقة الاستنساخ المناسبة المُعرَّفة
        // في تلك الفئة. لهذا السبب نحصل على نسخ صحيحة
        // بدلاً من مجموعة من كائنات Shape البسيطة.
        foreach (s in shapes) do
            shapesCopy.add(s.clone())

        // تحتوي مصفوفة `shapesCopy` على نسخ طبق الأصل من
        // عناصر مصفوفة `shape`.

1. أنشئ واجهة النموذج الأولي وأعلن عن طريقة clone فيها. أو فقط أضف الطريقة إلى جميع فئات تدرج هرمي موجود للفئات إذا كان لديك واحد.

2. يجب أن تُعرِّف فئة النموذج الأولي المُنشئ البديل الذي يقبل كائنًا من تلك الفئة كمعامل. يجب أن ينسخ المُنشئ قيم جميع الحقول المُعرَّفة في الفئة من الكائن المُمرَّر إلى النسخة المُنشأة حديثًا. إذا كنت تُعدِّل فئة فرعية، يجب أن تستدعي المُنشئ الأصلي للسماح للفئة الأعلى بمعالجة استنساخ حقولها الخاصة.

   إذا كانت لغة البرمجة لا تدعم تحميل الدوال الزائد (method overloading)، لن تتمكن من إنشاء مُنشئ "نموذج أولي" منفصل. وبالتالي ستُنفَّذ عملية نسخ بيانات الكائن إلى النسخة المستنسخة المنشأة حديثًا داخل طريقة clone. ومع ذلك، وجود هذا الكود في مُنشئ عادي أكثر أمانًا لأن الكائن الناتج يُعاد مُهيَّأ بالكامل مباشرةً بعد استدعاء عامل new.

3. تتكون طريقة الاستنساخ عادةً من سطر واحد فقط: تشغيل عامل new مع نسخة النموذج الأولي من المُنشئ. لاحظ أن كل فئة يجب أن تُجاوز طريقة الاستنساخ صراحةً وتستخدم اسم فئتها الخاص مع عامل new. وإلا قد تُنتج طريقة الاستنساخ كائنًا من الفئة الأصلية.

4. اختياريًا، أنشئ سجل نماذج أولية مركزيًا لتخزين كتالوج من النماذج الأولية المستخدمة بشكل متكرر.

   يمكنك تنفيذ السجل كفئة مصنع جديدة أو وضعه في فئة النموذج الأولي الأساسية مع طريقة ثابتة لجلب النموذج الأولي. يجب أن تبحث هذه الطريقة عن نموذج أولي بناءً على معايير البحث التي يمررها كود العميل إلى الطريقة. يمكن أن تكون المعايير إما علامة نصية بسيطة أو مجموعة معقدة من معاملات البحث. بعد العثور على النموذج الأولي المناسب، يجب على السجل استنساخه وإرجاع النسخة إلى العميل.

   أخيرًا، استبدل الاستدعاءات المباشرة لمُنشئات الفئات الفرعية باستدعاءات لطريقة المصنع في سجل النماذج الأولية.

• تبدأ العديد من التصميمات باستخدام Factory Method (أقل تعقيداً وأكثر قابلية للتخصيص عبر الفئات الفرعية) وتتطور نحو Abstract Factory، أو Prototype، أو Builder (أكثر مرونة، ولكن أكثر تعقيداً).

• غالباً ما تعتمد فئات Abstract Factory على مجموعة من Factory Methods، ولكن يمكنك أيضاً استخدام Prototype لتركيب الدوال على هذه الفئات.

• يمكن أن يساعد Prototype عندما تحتاج إلى حفظ نسخ من Commands في السجل.

• التصميمات التي تستخدم Composite وDecorator بشكل مكثف يمكنها في كثير من الأحيان الاستفادة من استخدام Prototype. يتيح لك تطبيق النمط استنساخ هياكل معقدة بدلاً من إعادة بنائها من الصفر.

• لا يعتمد Prototype على الوراثة لذلك لا يعاني من عيوبها. من ناحية أخرى، يتطلب Prototype تهيئة معقدة للكائن المستنسخ. يعتمد Factory Method على الوراثة لكنه لا يتطلب خطوة تهيئة.

• أحياناً يمكن أن يكون Prototype بديلاً أبسط لـ Memento. يعمل هذا إذا كان الكائن الذي تريد تخزين حالته في السجل بسيطًا نسبيًا ولا يحتوي على روابط لموارد خارجية، أو كانت الروابط سهلة الإعادة.

• يمكن تنفيذ كل من Abstract Factories وBuilders وPrototypes كـ Singletons.