**نمط واجهة المبنى** (بالإنجليزية: **facade pattern**)‏ (يلفظ (فساد) *façade أيضاً*) هو نمط تصميم برامج شائع الاستخدام في البرمجة كائنية التوجه. تشبه الواجهة في العمارة، الواجهة هي كائن يعمل كواجهة أمامية تخفي كودًا أساسيًا أو بنيويًا أكثر تعقيدًا. يمكن للواجهة:

* تحسين إمكانية قراءة مكتبة البرامج وإمكانية استخدامها من خلال إخفاء التفاعل مع المكونات الأكثر تعقيدًا وراء واجهة برمجة تطبيقات واحدة (وغالبًا ما تكون مبسطة)
* توفير واجهة خاصة بالسياق لمزيد من الوظائف العامة (كاملة مع التحقق من صحة المدخلات الخاصة بالسياق)
* بمثابة نقطة انطلاق لمُعدِّل أوسع للأنظمة المتآلفة أو المترابطة بإحكام لصالح كود أكثر ترابطاً.

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

نظرة عامة
---------

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

ما هي المشاكل التي يمكن أن يحلها نمط تصميم الواجهة؟

* لتسهيل استخدام نظام فرعي معقد، يجب توفير واجهة بسيطة لمجموعة من الواجهات في النظام الفرعي.
* يجب تقليل التبعيات على نظام فرعي.

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

ما الحل الذي يصفه نمط تصميم الواجهة؟

تعريف كائن واجهة `Facade` من أجل ذلك.

* ينفذ واجهة بسيطة من حيث (بتفويض) الواجهات في النظام الفرعي
* قد تؤدي وظائف إضافية قبل/ بعد إعادة توجيه الطلب.

يتيح هذا العمل من خلال كائن واجهة `Facade` لتقليل التبعيات على نظام فرعي. انظر أيضًا صنف UML ومخطط التسلسل أدناه.

الاستخدام
---------

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

| نمط | نوايا |
| --- | --- |
| نمط المحوّل | يحول واجهة إلى أخرى بحيث تتطابق مع ما يتوقعه العميل |
| عامل الديكور | يضيف المسؤولية إلى الواجهة ديناميكيًا من خلال التفاف الكود الأصلي |
| واجهة المبنى | يوفر واجهة مبسطة |

عادة ما يتم استخدام نمط الواجهة عندما

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

بناء
----

### مخطط الصنفUML ومخطط التسلسل

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

### مخطط الصنف UML

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

مثال
----

هذا مثال تجريدي لكيفية تفاعل العميل ("you") مع واجهة ("computer") لنظام معقد (أجزاء الكمبيوتر الداخلية، مثل وحدة المعالجة المركزية والأجهزة).

### ++C

```
#include <memory>
 
class CPU {
 public:
 void Freeze();
 void Jump(long position);
 void Execute();
};

class HardDrive {
 public:
 char\* Read(long lba, int size);
};

class Memory {
 public:
 void Load(long position, char\* data);
};

// Facade:
class ComputerFacade {
 public:
 void Start() {
 cpu\_->Freeze();
 memory\_->Load(kBootAddress, hard\_drive\_->Read(kBootSector, kSectorSize));
 cpu\_->Jump(kBootAddress);
 cpu\_->Execute();
 }

 private:
 std::unique\_ptr<CPU> cpu\_ = std::make\_unique<CPU>();
 std::unique\_ptr<Memory> memory\_ = std::make\_unique<Memory>();
 std::unique\_ptr<HardDrive> hard\_drive\_ = std::make\_unique<HardDrive>();
};

int main() {
 ComputerFacade computer;
 computer.Start();
}

```

### #C

#### التنفيذ

```
namespace DesignPattern.Facade
{
 class SubsystemA
 {
 public string OperationA1()
 {
 return "Subsystem A, Method A1\n";
 }
 public string OperationA2()
 {
 return "Subsystem A, Method A2\n";
 }
 }
 
 class SubsystemB
 {
 public string OperationB1()
 {
 return "Subsystem B, Method B1\n";
 }

 public string OperationB2()
 {
 return "Subsystem B, Method B2\n";
 }
 }

 class SubsystemC
 {
 public string OperationC1()
 {
 return "Subsystem C, Method C1\n";
 }

 public string OperationC2()
 {
 return "Subsystem C, Method C2\n";
 }
 }

 public class Facade
 {
 private readonly SubsystemA a = new SubsystemA();
 private readonly SubsystemB b = new SubsystemB();
 private readonly SubsystemC c = new SubsystemC();
 public void Operation1()
 {
 Console.WriteLine("Operation 1\n" +
 a.OperationA1() +
 b.OperationB1() +
 c.OperationC1());
 }
 public void Operation2()
 {
 Console.WriteLine("Operation 2\n" +
 a.OperationA2() +
 b.OperationB2() +
 c.OperationC2());
 }
 }
}

```

#### عينة من الكود

```
namespace DesignPattern.Facade.Sample
{ 
 // The 'Subsystem ClassA' class
 class CarModel
 {
 public void SetModel()
 {
 Console.WriteLine(" CarModel - SetModel");
 }
 }

 /// <summary>
 /// The 'Subsystem ClassB' class
 /// </summary>
 class CarEngine
 {
 public void SetEngine()
 {
 Console.WriteLine(" CarEngine - SetEngine");
 }
 }

 // The 'Subsystem ClassC' class
 class CarBody
 {
 public void SetBody()
 {
 Console.WriteLine(" CarBody - SetBody");
 }
 }

 // The 'Subsystem ClassD' class
 class CarAccessories
 {
 public void SetAccessories()
 {
 Console.WriteLine(" CarAccessories - SetAccessories");
 }
 }

 // The 'Facade' class
 public class CarFacade
 {
 private readonly CarAccessories accessories;
 private readonly CarBody body;
 private readonly CarEngine engine;
 private readonly CarModel model;

 public CarFacade()
 {
 accessories = new CarAccessories();
 body = new CarBody();
 engine = new CarEngine();
 model = new CarModel();
 }

 public void CreateCompleteCar()
 {
 Console.WriteLine("\*\*\*\*\*\*\*\* Creating a Car \*\*\*\*\*\*\*\*\*\*");
 model.SetModel();
 engine.SetEngine();
 body.SetBody();
 accessories.SetAccessories();

 Console.WriteLine("\*\*\*\*\*\*\*\* Car creation is completed. \*\*\*\*\*\*\*\*\*\*");
 }
 }

 // Facade pattern demo
 class Program
 {
 static void Main(string[] args)
 {
 var facade = new CarFacade();

 facade.CreateCompleteCar();

 Console.ReadKey();
 }
 }
}

```

### جافا

```
/\* Comp

class CPU {
 public void freeze() { ... }
 public void jump(long position) { ... }
 public void execute() { ... }
}

class HardDrive {
 public byte[] read(long lba, int size) { ... }
}

class Memory {
 public void load(long position, byte[] data) { ... }
}

/\* Facade \*/

class ComputerFacade {
 private final CPU processor;
 private final Memory ram;
 private final HardDrive hd;

 public ComputerFacade() {
 this.processor = new CPU();
 this.ram = new Memory();
 this.hd = new HardDrive();
 }

 public void start() {
 processor.freeze();
 ram.load(BOOT\_ADDRESS, hd.read(BOOT\_SECTOR, SECTOR\_SIZE));
 processor.jump(BOOT\_ADDRESS);
 processor.execute();
 }
}

/\* Client \*/

class You {
 public static void main(String[] args) {
 ComputerFacade computer = new ComputerFacade();
 computer.start();
 }
}

```

### روبي

```
# Complex Parts
class CPU
 def freeze; end
 def jump(position); end
 def execute; end
end
 
class Memory
 def load(position, data); end
end

class HardDrive
 def read(lba, size); end
end

# Facade
class ComputerFacade

 def initialize
 @processor = CPU.new
 @ram = Memory.new
 @hd = HardDrive.new
 end

 def start
 @processor.freeze
 @ram.load(BOOT\_ADDRESS, @hd.read(BOOT\_SECTOR, SECTOR\_SIZE))
 @processor.jump(BOOT\_ADDRESS)
 @processor.execute
 end
end

# Client
computer\_facade = ComputerFacade.new
computer\_facade.start

```

### PHP

```
/\*\* 
 \* The complicated, underlying logic.
 \*/
class CPU
{
  public function freeze() {/\* ... \*/}
  public function jump($position) {/\* ... \*/}
  public function execute() {/\* ... \*/}
}

class Memory
{
  public function load($position, $data) {/\* ... \*/}
}

class HardDrive
{
  public function read($lba, $size) {/\* ... \*/}
}

/\*\*
 \* The facade that users would be interacting with.
 \*/
class ComputerFacade
{
  protected CPU $cpu;
  protected Memory $memory;
  protected HardDrive $hd;

  public function \_\_construct()
  {
    $this->cpu = new CPU;
    $this->memory = new Memory;
    $this->hd = new HardDrive;
  }

  public function start() : void
  {
    $this->cpu->freeze();
    $this->memory->load(BOOT\_ADDRESS, $this->hd->read(BOOT\_SECTOR, SECTOR\_SIZE));
    $this->cpu->jump(BOOT\_ADDRESS);
    $this->cpu->execute();
  }
}

/\*\*
 \* How a user could start the computer.
 \*/
$computer = new ComputerFacade;
$computer->start();

```

### بايثون

```
"""
Facade pattern example.
"""
 
# Complex computer parts
class CPU(object):
 """
 Simple CPU representation.
 """
  def freeze(self) -> None:
    print("Freezing processor.")

  def jump(self, position) -> None:
    print("Jumping to:", position)

  def execute(self) -> None:
    print("Executing.")

class Memory(object):
 """
 Simple memory representation.
 """
  def load(self, position, data):
    print("Loading from {0} data: '{1}'.".format(position, data))

class SolidStateDrive(object):
 """
 Simple solid state drive representation.
 """
  def read(self, lba, size):
    return "Some data from sector {0} with size {1}".format(lba, size)

class ComputerFacade(object):
 """
 Represents a facade for various computer parts.
 """
  def \_\_init\_\_(self) -> None:
    self.cpu = CPU()
    self.memory = Memory()
    self.ssd = SolidStateDrive()

  def start(self) -> None:
    self.cpu.freeze()
    self.memory.load("0x00", self.ssd.read("100", "1024"))
    self.cpu.jump("0x00")
    self.cpu.execute()

computer\_facade = ComputerFacade()
computer\_facade.start()

```
 Output: 

```
Freezing processor.
Loading from 0x00 data: 'Some data from sector 100 with size 1024'.
Jumping to: 0x00
Executing.

```

### بوويرشيل PowerShell

```
"""
Facade pattern example.
"""
  
class CPU {
  
  freeze() {
    "$this freezing" | Out-Host
  }

  jump($position) {
    "$this jump to $position" | Out-Host
  }

  execute() {
    "$this execute" | Out-Host
  }
}

class Memory {
  load($position, $data) {
    "$this load $position $data" | Out-Host    
  }
}

class HardDrive {
  [object] read($lba, $size) {    
    "$this read $lba $size" | Out-Host    
    
    return "(some data)"
  }
}

# Façade
class Computer {
  hidden [CPU]$cpu 
  hidden [Memory]$memory
  hidden [HardDrive]$hardDrive

  Computer() {
    $this.cpu = New-Object CPU
    $this.memory = New-Object Memory
    $this.hardDrive = New-Object HardDrive
  }

  StartComputer() {
    $this.cpu.freeze()
    $this.memory.load(0, $this.hardDrive.read(0, 1024))
    $this.cpu.jump(10)
    $this.cpu.execute()
  }
}

$façade = [Computer]::new()

$façade.StartComputer()

```
 Output: 

```
CPU freezing
HardDrive read 0 1024
Memory load 0 (some data)
CPU jump to 10
CPU execute

```

انظر أيضا
---------

* التغليف (برمجة الكمبيوتر)

المراجع
-------

1. ↑  Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides (1994). *Design Patterns: Elements of Reusable Object-Oriented Software*. Addison Wesley. ص. 185ff. ISBN:0-201-63361-2. مؤرشف من الأصل في 2020-06-12.`{{استشهاد بكتاب}}`: صيانة CS1: أسماء متعددة: قائمة المؤلفين (link)
2. ↑  "The Facade design pattern - Problem, Solution, and Applicability". *w3sDesign.com*. مؤرشف من الأصل في 2020-06-12. اطلع عليه بتاريخ 2017-08-12.
3. ↑  Freeman، Eric؛ Freeman، Elisabeth؛ Sierra، Kathy؛ Bates، Bert (2004). Hendrickson، Mike؛ Loukides، Mike (المحررون). *Head First Design Patterns*. O'Reilly. ج. 1. ص. 243, 252, 258, 260. ISBN:978-0-596-00712-6. مؤرشف من الأصل (paperback) في 2020-05-29. اطلع عليه بتاريخ 2012-07-02.
4. ↑  "The Facade design pattern - Structure and Collaboration". *w3sDesign.com*. مؤرشف من الأصل في 2020-06-12. اطلع عليه بتاريخ 2017-08-12.

روابط خارجية
------------

* وصف من مستودع نقش بورتلاند

* أيقونة بوابةبوابة برمجة الحاسوب
* أيقونة بوابةبوابة علم الحاسوب

|  |
| --- |
| **نمط واجهة المبنى** في المشاريع الشقيقة: |
|  | 
* صور وملفات صوتية من كومنز.
 |


| * ع
* ن
* ت
 أنماط تصميم البرمجيات (برمجة) |
| --- |
| إنشائي (Creational) | 
* Abstract factory
* نمط تصميم الباني
* حقن التبعية
* نمط طريقة المصنع
* Lazy initialization
* Multiton
* Object pool
* Prototype
* اكتساب الموارد تهيئة
* النمط المفرد

 |
| هيكلي (Structural) | 
* نمط المحول
* نموذج التصميم جسر
* نموذج التصميم المجمع
* نموذج التصميم ديكور
* Delegation
* نمط واجهة المبنى
* نموذج التصميم وزن الذبابة
* Front controller
* Marker interface
* Module
* نمط الوكيل
* Twin

 |
| سلوكي (Behavioral) | 
* Blackboard
* Chain of responsibility
* Command
* Interpreter
* نمط المكرر
* Mediator
* Memento
* Null object
* المراقب (نموذج تصميم)
* Servant
* Specification
* State
* نموذج الإستراتيجية
* Template method
* Visitor

 |
| وظيفي (Functional) | 
* مونويد
* Functor
* Applicative
* Monad
* Comonad
* Free monad
* HOF
* Currying
* Function composition
* Closure
* المولد

 |
| متزامن (Concurrency) | 
* Active object
* Actor
* Balking
* حاجز (حوسبة)
* Binding properties
* Coroutine
* Compute kernel
* Double-checked locking
* Event-based asynchronous
* ليف
* Futex
* Futures and promises
* Guarded suspension
* Immutable object
* Join
* Lock
* صيغة التراسل
* Monitor
* Nuclear
* Proactor
* Reactor
* Read write lock
* Scheduler
* STM
* Thread pool
* Thread-local storage

 |
| معماري (Architectural) | 
* \* ADR
* نمط التسجيل النشط
* نمط الوسيط
* نموذج الخادم والعميل
* هندسة البرمجيات بالمكونات
* DAO
* كائن نقل البيانات
* تصميم موجه بالمجال
* ECB
* ECS
* EDA
* Front controller
* Identity map
* Interceptor
* Implicit invocation
* عكس التحكم
* Model 2
* MOM
* Microservices
* MVA
* نمط وعرض ومتحكم
* MVP
* MVVM
* Monolithic
* عمارة متعددة الطبقات
* Naked objects
* ORB
* ند لند
* Publish–subscribe
* PAC
* رست
* بنية خدمية
* نمط محدد موقع الخدمة
* SN
* SBA
* Specification

 |
| توزيع سحابي (Cloud Distributed) | 
* Ambassador
* Anti-Corruption Layer
* Bulkhead
* Cache-Aside
* Circuit Breaker
* CQRS
* Compensating Transaction
* Competing Consumers
* Compute Resource Consolidation
* Event Sourcing
* External Configuration Store
* Federated Identity
* Gatekeeper
* فهرس قاعدة بيانات
* Leader Election
* نموذج الهيكلة والتجميع
* Materialized View
* Pipes
* Filters
* Priority Queue
* Publisher-Subscriber
* Queue-Based Load Leveling
* Retry
* Scheduler Agent Supervisor
* Sharding
* Sidecar
* Strangler
* Throttling
* Valet Key

 |
| أخرى | 
* Business delegate
* Composite entity
* Intercepting filter
* Lazy loading
* Mangler
* غرض مقلد
* Type tunnel
* Method chaining

 |
| كتب | 
* *خطط التصميم*
* *Enterprise Integration Patterns*
* *Code Complete*
* *POSA*

 |
| أشخاص | 
* كريستوفر الكسندر
* إريك جاما
* رالف جونسن
* John Vlissides
* Grady Booch
* كينت بيك
* وورد كانينغهام
* مارتن فاولر
* روبرت سيسيل مارتن
* Jim Coplien
* دوغلاس س. شميت
* Linda Rising

 |
| مجتمعات (Communities) | 
* The Hillside Group
* The Portland Pattern Repository

 |