ما هو الفرق بين نمط تصميم منشئ ونمط تصميم المصنع؟

https://stackoverflow.com/questions/757743

09-09-2019
|

سؤال

أيهما أكثر فائدة ولماذا؟

كيف يمكنني تمثيل نتائجي كشركة بيانية إذا أردت اختبار هذه الأنماط ومقارنتها؟

المحلول

مع أنماط التصميم، لا يوجد عادة حل "أكثر فائدة" يعمل لجميع الحالات. ذلك يعتمد على ما تحتاج إلى تنفيذه.

من ويكيبيديا:

يركز Builder على بناء كائن معقد خطوة بخطوة. يؤكد مصنع التجريدي على عائلة من كائنات المنتجات (إما بسيطة أو معقدة). إرجاع Builder المنتج كخطوة أخيرة، ولكن بقدر ما يتعلق الأمر بمصنع مجردة، يتم إرجاع المنتج على الفور.

باني غالبا ما يبني مركبا.

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

في بعض الأحيان تكون أنماط الإبداع مكملة: يمكن ل Builder استخدام أحد الأنماط الأخرى لتنفيذ المكونات التي يتم بناؤها. يمكن أن يستخدم مصنع التجريدي والباني والنموذج الأولي المفروم في تطبيقاتهم.

Wikipedia دخول نمط تصميم المصنع:http://en.wikipedia.org/wiki/factory_method_pattern.

Wikipedia دخول نمط تصميم منشئ:http://en.wikipedia.org/wiki/builder_pattern.

نصائح أخرى

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

نمط البناء, من ناحية أخرى، هو في جوهر كائن التفاف حول جميع المعلمات المحتملة التي قد ترغب في تمريرها إلى استدعاء منشئ. يتيح لك ذلك استخدام طرق STERTER لإنشاء قائمة المعلمات ببطء. طريقة إضافية واحدة على فئة Builder هي طريقة بناء ()، والتي تمر ببساطة كائن Builder في المنشئ المطلوب، وإرجاع النتيجة.

في لغات ثابتة مثل Java، يصبح هذا أكثر أهمية عندما يكون لديك أكثر من حفنة من المعلمات (المحتمل) من (اختياري)، لأنها تتجنب شرط الحصول على منشئين تلسكوبي لجميع المجموعات المحتملة من المعلمات. كما يتيح لك Builder استخدام أساليب STERTER لتحديد الحقول للقراءة فقط أو الخاصة التي لا يمكن تعديلها مباشرة بعد استدعاء المنشئ.

مثال المصنع الأساسي

// Factory
static class FruitFactory {
    static Fruit create(name, color, firmness) {
        // Additional logic
        return new Fruit(name, color, firmness);
    }
}

// Usage
Fruit fruit = FruitFactory.create("apple", "red", "crunchy");

منشئ أساسي مثال

// Builder
class FruitBuilder {
    String name, color, firmness;
    FruitBuilder setName(name)         { this.name     = name;     return this; }
    FruitBuilder setColor(color)       { this.color    = color;    return this; }
    FruitBuilder setFirmness(firmness) { this.firmness = firmness; return this; }
    Fruit build() {
        return new Fruit(this); // Pass in the builder
    }
}

// Usage
Fruit fruit = new FruitBuilder()
        .setName("apple")
        .setColor("red")
        .setFirmness("crunchy")
        .build();

قد يستحق مقارنة عينات التعليمات البرمجية من هذين صفحات ويكيبيديا:

http://en.wikipedia.org/wiki/factory_method_pattern.
http://en.wikipedia.org/wiki/builder_pattern.

يمكن أن ينظر إلى نمط المصنع كإصدار مبسط من نمط البناء.

في ال مصنع نمط، المصنع هو المسؤول عن إنشاء فرعية مختلفة من كائن اعتمادا على الاحتياجات.

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

في ال باني النمط، يتم إنشاء أنواع فرعية مختلفة أيضا بواسطة طريقة منشئ، ولكن قد يختلف تكوين الكائنات داخل نفس الفئة الفرعية.

لمواصلة مثال السيارة قد يكون لديك createCar طريقة البناء التي تخلق Hondaكائن بدقة مع محرك اسطوانة 4، أو Hondaكائن ثلاثي مع 6 اسطوانات. نمط البناء يسمح لهذه الحبيبية الدقيقة.

مخططات كل من نمط باني و ال طريقة مصنع نمط تتوفر على ويكيبيديا.

يصف نمط تصميم Builder كائن يعرف كيفية صياغة كائن آخر من نوع معين على عدة خطوات. إنه يحمل الحالة اللازمة للبند المستهدف عند كل خطوة متوسطة. فكر ما يمر Stringbuilder لإنتاج سلسلة نهائية.

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

بناء كائن معقد خطوة بخطوة: منشئ نمط
يتم إنشاء كائن بسيط باستخدام طريقة واحدة: نمط طريقة المصنع
إنشاء كائن باستخدام طريقة مصنع متعددة: نمط مصنع مجردة

كلاهما أنماط الخلق، لإنشاء كائن.

1) نمط المصنع - افترض، لديك فئة فائقة واحدة و عدد الفصول الفرعية. يعتمد الكائن يعتمد على المعلمة / القيمة التي يتم تمريرها.

2) نمط منشئ - لإنشاء كائن معقد.

Ex: Make a Loan Object. Loan could be house loan, car loan ,
    education loan ..etc. Each loan will have different interest rate, amount ,  
    duration ...etc. Finally a complex object created through step by step process.

نمط منشئ ونمط المصنع، يبدو كلاهما مشابه جدا للعيون العارية لأن كلاهما يخلق كائنات لك.

ولكن عليك أن تبدو أقرب

هذا المثال الحياة الواقعية سيجعل الفرق بين اثنين أكثر واضحة.

لنفترض أنك ذهبت إلى مطعم للوجبات السريعة وأمرت طعام.

1) ما الطعام؟

بيتزا

2) ما هي الطبقة؟

Capsicum، الطماطم، دجاج شواء، لا أناناس

يتم إجراء أنواع مختلفة من الأطعمة من قبل نمط المصنع ولكن المتغيرات المختلفة (النكهات) من الطعام معين مصنوعة من قبل منشئ نمط.

أنواع مختلفة من الأطعمة

بيتزا، برجر، المعكرونة

متغيرات البيتزا

الجبن الوحيد والجبن + الطماطم + كابسيكوم والجبن + الطماطم وغيرها.

نموذج الكود

يمكنك رؤية تنفيذ نموذج التعليمات البرمجية لكلا الأنماط هنا
نمط باني
نمط المصنع

أولا بعض الأشياء العامة لمتابعة حجتي:

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

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

الإجابة على السؤال:

من خلال طرح الفرق بين أنماطين يجب أن تسأل نفسك ما النمط يجعل النظام الخاص بك بطريقة أكثر مرونة. كل نمط له هدف خاص به لتنظيم التبعيات بين الفصول الدراسية في نظامك.

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

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

نمط البناء:GOF: "افصل بناء كائن معقد من تمثيلها حتى تتمكن عملية البناء نفسها من إنشاء تمثيلات مختلفة".

ماذا يعني هذا:تقوم بتغليف عملية البناء في فصل آخر، يسمى المدير (GOF). يحتوي هذا المدير على خوارزمية إنشاء مثيلات جديدة للمنتج (مثل إنشاء منتج معقد من أجزاء أخرى). لإنشاء الأجزاء المتكاملة من المنتج بأكمله، يستخدم المخرج منشئا. من خلال تبادل Builder في المدير، يمكنك استخدام خوارزمية نفسها لإنشاء المنتج، ولكن تغيير تمثيل أجزاء واحدة (وبالتالي تمثيل المنتج). لتوسيع أو تعديل نظامك في تمثيل المنتج، كل ما عليك فعله هو تطبيق فئة منشئ جديدة.

لذلك باختصار:الغرض من نمط مصنع الملخص هو تبادل مجموعة من المنتجات التي يتم استخدامها معا. الغرض من نمط Builder هو تغليف خوارزمية مجردة لإنشاء منتج لإعادة استخدامه لمختلف تمثيلات المنتج.

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

واحد فارغ فرق بين منشئ ومصنع يمكن أن يجعله ما يلي

لنفترض أن لدينا سيارة

class Car
{
  bool HasGPS;
  bool IsCityCar;
  bool IsSportsCar;
  int   Cylenders;
  int Seats;

  public:
     void Car(bool hasGPs=false,bool IsCityCar=false,bool IsSportsCar=false, int Cylender=2, int Seats=4);
 };

في الواجهة أعلاه يمكننا الحصول على السيارة بالطريقة التالية:

 int main()
 {
    BadCar = new Car(false,false,true,4,4);
  }

ولكن ماذا لو حدث بعض الاستثناء أثناء إنشاء المقاعد ؟؟ لن تحصل على الكائن على الإطلاق

افترض أن لديك تنفيذ مثل ما يلي

class Car
 {
    bool mHasGPS;
    bool mIsCityCar;
    bool mIsSportsCar;
    int mCylenders;
    int mSeats;

 public:
    void Car() : mHasGPs(false), mIsCityCar(false), mIsSportsCar(false), mCylender(2), mSeats(4) {}
    void SetGPS(bool hasGPs=false)  {mHasGPs = hasGPs;}
    void SetCity(bool CityCar)  {mIsCityCar = CityCar;}
    void SetSports(bool SportsCar)  {mIsSportsCar = SportsCar;}
    void SetCylender(int Cylender)  {mCylenders = Cylender;}    
    void SetSeats(int seat) {mSeats = seat;}    
};

 class CarBuilder 
 {
    Car* mCar;
public:
        CarBuilder():mCar(NULL) {   mCar* = new Car();  }
        ~CarBuilder()   {   if(mCar)    {   delete mCar;    }
        Car* GetCar()   {   return mCar; mCar=new Car();    }
        CarBuilder* SetSeats(int n) {   mCar->SetSeats(n); return this; }
        CarBuilder* SetCylender(int n)  {   mCar->SetCylender(n); return this;  }
        CarBuilder* SetSports(bool val) {   mCar->SetSports(val); return this;  }
        CarBuilder* SetCity(bool val)   {   mCar->SetCity(val); return this;    }
        CarBuilder* SetGPS(bool val)    {   mCar->SetGPS(val); return this; }
}

الآن يمكنك إنشاء مثل هذا

 int main()
 {
   CarBuilder* bp =new CarBuilder;
    Car* NewCar  = bp->SetSeats(4)->SetSports(4)->SetCity(ture)->SetGPS(false)->SetSports(true)->GetCar();

     bp->SetSeats(2);

     bp->SetSports(4);

     bp->SetCity(ture);

     bp->SetSports(true)

     Car* Car_II=  bp->GetCar();

  }

هنا في الحالة الثانية، حتى لو فشلت عملية واحدة، فستظل تحصل على السيارة.

قد تكون هذه السيارة لا تعمل في وقت لاحق تماما ولكن، سيكون لديك الكائن.

نظرا لأن طريقة المصنع تمنحك السيارة في مكالمة واحدة، في حين أن البناء يبني واحدا تلو الآخر.

على الرغم من ذلك، إلا أنه يعتمد على احتياجات المخصصات التي يذهب إليها.

+-------------------------------------------------------------------+---------------------------------------------------+
|                              Builder                              |                      Factory                      |
+-------------------------------------------------------------------+---------------------------------------------------+
| Return only single instance to handle complex object construction | Retrun various instances on multiple constructors |
| No interface required                                             | Interface driven                                  |
| Inner classes is involved (to avoid telescopic constructors)      | Subclasses are involved                           |
+-------------------------------------------------------------------+---------------------------------------------------+

تلسكوبات منشئ نمط

تشبيه:

مصنع: النظر في مطعم. إن إنشاء "وجبة اليوم" هو نمط المصنع، لأنك تخبر المطبخ "الحصول على وجبة لي اليوم" ويقرر المطبخ (المصنع) ما الكائن الذي يولد، بناء على المعايير الخفية.
باني: يظهر Builder إذا طلبت بيتزا مخصصة. في هذه الحالة، يخبر النادل الطاهي (باني) "أحتاج إلى بيتزا؛ أضف الجبن والبصل ولحم الخنزير المقدد إليه!" وبالتالي، فإن البناء يكشف السمات يجب أن يكون الكائن الذي تم إنشاؤه، ولكن يخفي كيفية تعيينها.

كياسة

باني و مصنع مجردة تعني لأغراض مختلفة. اعتمادا على حالة الاستخدام الصحيح، يجب عليك تحديد نمط التصميم المناسب.

باني السمات البارزه:

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

مصنع (مصنع بسيط) الميزات البارزة:

إنشاء نمط
بناء على الميراث
يقوم المصنع بإرجاع طريقة المصنع (واجهة) والتي بدورها بإرجاع كائن ملموس
يمكنك استبدال الكائنات الخرسانية الجديدة للواجهة والعميل (المتصل) لا ينبغي أن تكون على دراية بجميع التطبيقات الخرسانية
يعمل العميل دائما واجهة واجهة فقط ويمكنك إخفاء تفاصيل إنشاء كائن في طريقة المصنع.

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

إلقاء نظرة على الوظائف ذات الصلة:

حفظ منشئ في فئة منفصلة (واجهة بطلاقة)

أنماط التصميم: طريقة مصنع VS مصنع VS مجردة

يمكنك الرجوع إلى المقالات أدناه لمزيد من التفاصيل:

SourceMaking.

JournalDev.

نمط مصنع مجردة ومباني كلاهما أنماط الخلق ولكن مع نية مختلفة.

نمط مصنع مجردة تؤكد إنشاء كائن للعائلات ذات الصلة أينما:

كل عائلة هي مجموعة من الفصول المستمدة من فئة / واجهة قاعدة مشتركة.
يتم إرجاع كل كائن على الفور نتيجة مكالمة واحدة.

نمط باني يركز على بناء كائن معقد خطوة بخطوة. يقوم بتشكيك التمثيل من عملية بناء الكائن المعقد، بحيث يمكن استخدام نفس عملية البناء في تمثيلات مختلفة.

يعتبر كائن Builder تكوين الكائن المعقد.
يعرف كائن المدير بروتوكول استخدام Builder، حيث يحدد البروتوكول جميع الخطوات المنطقية المطلوبة لبناء الكائن المعقد.

البناء المعقد هو عندما يتكون الكائن الذي سيتم بناؤه من كائنات أخرى مختلفة تمثلها التجريدات.

النظر في قائمة في ماكدونالدز. تحتوي القائمة على مشروب، رئيسي وجانب. اعتمادا على أحفاد التجريدات الفردية تتكون معا، فإن القائمة التي تم إنشاؤها لديها تمثيل آخر.

مثال: كولا، كبير ماك، البطاطس المقلية
مثال: العفريت، شذرات، فرايز مجعد

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

باستخدام نمط Builder، يمكنك فصل خوارزمية إنشاء كائن معقد من المكونات المختلفة المستخدمة لإنشاءها.

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

مصنع: يستخدم لإنشاء مثيل كائن حيث تعقد هذه التبعيات الكائن بالكامل من قبل المصنع بالكامل. ل نمط مصنع مجردة, ، غالبا ما يكون هناك العديد من التطبيقات الخرسانية لنفس المصنع المجردة. يتم حقن التنفيذ الصحيح للمصنع عبر حقن التبعية.

باني: تستخدم للبناء ثابت الكائنات، عندما تكون تبعيات الكائن المراد إنشاء مثيل جزئيا مقدما وجزئيا من قبل عميل البناء.

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

هنا تعمل فئة Builder كوسيط بين الطبقات الرئيسية وطبقات نوع معين. المزيد من التجريد.

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

أعتقد أن استخدام الفرق والفرق بين أنماط المصنع والباني يمكن فهم / توضيح أسهل في فترة زمنية معينة أثناء عملك في نفس قاعدة التعليمات البرمجية وتغيير المتطلبات.

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

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

بصراحة، في إشارة إلى شيء نوع من "وجود كائن تم إنشاؤه في خطوة واحدة أو خطوات متعددة هو الفرق" لأن عامل التنوع الوحيد لم يكن كافيا بالنسبة لي لتمييزها لأنني يمكنني استخدام كلا الاتجاهين لتقريبا جميع الحالات التي واجهتها الآن دون أن تعاني من أي فائدة. لذلك هذا هو ما فكرت أخيرا في ذلك.

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

مثال: دعونا نقول أننا نخلق المتاهة

1. مصنع مجردة:

Maze* MazeGame::CreateMaze (MazeFactory& factory) {
Maze* maze = factory.MakeMaze(); /// product is available at start!!
 /* Call some methods on maze */
return maze;
}

2. باني:

Maze* MazeGame::CreateMaze (MazeBuilder& builder) {
builder.buildMaze(); /// We don't have access to maze
 /* Call some methods on builder */
return builder.GetMaze();
}

بناء نمط يؤكد على تعقيد من إنشاء كائن (حلها "خطوات")

يؤكد نمط مجردة "فقط" على "تجريد" كائنات (متعددة ولكن ذات صلة).

في الرأي الخاص بي، يستخدم نمط منشئتي عندما ترغب في إنشاء كائن من مجموعة من الكائنات الأخرى وإنشاء جزء يجب أن تكون مستقلة عن الكائن الذي تريد إنشاءه. يساعد على إخفاء إنشاء جزء من العميل لإنشاء باني وعميل مستقل. يتم استخدامه لإنشاء الكائنات المعقدة (الكائنات التي قد تتكون من خصائص معقدة)

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

IMHO

Builder هو نوع من المصنع أكثر تعقيدا.

ولكن في Builder، يمكنك إنشاء مثيلات باستخدام مصانع أخرى, ، مطلوبة لبناء كائن نهائي وصحيح.

لذلك، نتحدث عن تطور "أنماط الخلق" من خلال التعقيد يمكنك التفكير في الأمر بهذه الطريقة:

Dependency Injection Container -> Service Locator -> Builder -> Factory

مصنع باني ومختر

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

واجهة شائعة للمنتجات

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

من: http://www.oodesign.com/builder-pattern.html.

تأتي كلا النماذج لنفس ضرورة: إخفاء من بعض رمز العميل منطق البناء كائن معقد. ولكن ما الذي يجعل "مجمع" (أو، أحيانا، تعقيد) كائن؟ أساسا، بسبب التبعيات، أو بالأحرى حالة كائن مؤلف من دول جزئية أكثر. يمكنك ضخ التبعيات عن طريق المنشئ لتعيين حالة الكائن الأولي، ولكن قد يتطلب كائن الكثير منهم، وسيكون البعض في حالة أولية افتراضية (فقط لأننا يجب أن تعلمنا أن تعيين تبعية افتراضية إلى NULL ليست هي أنظف طريقة ) وبعض المواصفة الأخرى إلى الدولة التي يقودها بعض الشرط. علاوة على ذلك، هناك خصائص كائن هي نوع من "التبعيات النسيان" ولكن أيضا يمكنهم تحمل الدول الاختيارية.

هناك طريقتان معروفان للسيطرة على هذا التعقيد:

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

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

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

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

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

مرخصة بموجب: CC-BY-SA مع الإسناد

لا تنتمي إلى StackOverflow