Paano mo mahahanap ang pattern ng disenyo na kailangan mo? Mga pattern ng disenyo. Mga Pattern ng OOP sa Metapora

Bago simulan ang artikulo, nais kong mag-alok ng isang ulat ng aking kaibigan na si Denis Porplenko sa mga pattern ng disenyo sa programming:

Gusto kong ipaalala sa iyo na ang mga pattern ng disenyo ay lumitaw bilang isang solusyon sa mga madalas na lumalabas na mga problema ng parehong uri, sa katunayan, sa disenyo. Ngunit natanggap nila ang kanilang pangunahing pag-unlad sa pagbuo ng software. At ipagpapatuloy ko ang kwento sa konteksto ng pag-unlad software.

Ang paksa ng mga pattern ay napakalawak na maaaring hatiin sa mga uri tulad ng mga pattern ng programming, mga pattern ng arkitektura ng system, at mga pattern ng pag-iimbak ng data. Ito ang mga pinakasikat na pattern, may iba pa. Ilista ko silang lahat sa ibaba.

Maraming mga kumpanya ang gumagamit ng mga pattern sa kanilang pagsasanay. Ang paggamit ng mga pattern ay may mga kalamangan at kahinaan nito.
Mga Benepisyo ng Paggamit ng Mga Pattern ng Disenyo:
— ang pangunahing bentahe ng paggamit ng mga pattern kaysa sa libreng disenyo ay ang pattern ay nagbibigay ng pangalan sa problema at tumutukoy sa mga paraan upang malutas ang maraming problema sa pamamagitan ng isang handa na hanay ng mga abstraction
— pinapadali ang komunikasyon sa pagitan ng mga developer ng system
— ang paggamit ng mga pattern ng disenyo ay katulad ng paggamit ng mga ready-made code library
— tamang paggamit Tinutulungan ng mga template ang mga developer na matukoy ang nais na vector ng pag-unlad at maiwasan ang maraming problema na maaaring lumitaw sa panahon ng proseso ng pagbuo.

Mga Problema na Dulot ng mga Pattern ng Disenyo:
— sa aking opinyon, ang pinakamahalagang problema sa paggamit ng mga template ay ang pagkawala ng flexibility sa disenyo at pag-unlad ng system
— ang paggamit ng mga template ay nagpapalubha sa system
— bulag na pagsunod sa isang tiyak na pattern at paggamit nito sa lahat ng dako ay maaaring magbunga ng isang grupo ng mga problema sa arkitektura at lohikal

Mga Pangunahing Pattern ng Programming

Pangunahin

Template ng delegasyon Pattern ng delegasyon - Ang isang bagay ay panlabas na nagpapahayag ng ilang pag-uugali, ngunit sa katotohanan ay nagtatalaga ng responsibilidad para sa pagsasagawa ng pag-uugali na iyon sa isang nauugnay na bagay.
Sample functional na disenyo Functional na disenyo - Tinitiyak na ang bawat module ng isang computer program ay may isang responsibilidad lamang at ginagawa ito nang may kaunting side effect sa ibang bahagi ng program.
Hindi nababagong Interface(Immutable interface) - Paglikha ng isang hindi nababagong bagay.
Interface - Pangkalahatang pamamaraan para sa pagbubuo mga programa sa kompyuter para mas madaling maintindihan.
Interface marker(Marker interface) - Ang pagkakaroon o kawalan ng isang pagpapatupad ng marker interface ay ginagamit bilang isang katangian (bilang isang marka ng isang object entity). Ang mga modernong programming language ay maaaring gumamit ng mga katangian o anotasyon sa halip.
Lalagyan ng mga katangian(Property container) - Binibigyang-daan kang magdagdag ng mga karagdagang property para sa isang klase sa isang container (sa loob ng klase), sa halip na palawigin ang klase gamit ang mga bagong property.
Pattern ng kaganapan(Channel ng kaganapan) - Pinapalawak ang pattern na I-publish/Mag-subscribe upang lumikha ng isang sentralisadong channel para sa mga kaganapan. Gumagamit ng proxy object para mag-subscribe at proxy object para mag-publish ng event sa isang channel. Ang kinatawan ay umiiral nang hiwalay sa aktwal na publisher o subscriber. Ang isang subscriber ay maaaring makatanggap ng mga nai-publish na kaganapan mula sa higit sa isang entity, kahit na ito ay nakarehistro lamang sa isang channel.

Mga generative pattern

Ang mga pattern ng paglikha ay mga pattern ng disenyo na abstract ang proseso ng instantiation. Ginagawa nilang posible na gawing independyente ang system sa paraan ng paggawa, pagbubuo at pagpapakita ng mga bagay. Ang isang template na nag-iinstantiate ng mga klase ay gumagamit ng inheritance para baguhin ang instantiated na klase, at ang isang template na nag-i-instantiate ng mga object ay nagde-delegate ng instantiation sa isa pang object.
Abstract na pabrika(Abstract factory) - Isang klase na nagbibigay ng interface para sa paglikha ng mga bahagi ng system.
Tagabuo(Builder) - Isang klase na nagbibigay ng interface para sa paglikha ng isang kumplikadong bagay.
Paraan ng pabrika(Pamamaraan ng pabrika) - Tinutukoy ang isang interface para sa paglikha ng isang bagay, ngunit iniiwan ito sa mga subclass upang magpasya kung aling klase ang i-instantiate.
Tamad na pagsisimula(Lazy initialization) — Isang bagay na pinasimulan sa unang tawag dito.
Singles pool(Multiton) - Tinitiyak na pinangalanan ng isang klase ang mga object instance at nagbibigay ng pandaigdigang access point sa kanila.
Object pool(Object pool) - Isang klase na kumakatawan sa isang interface para sa pagtatrabaho sa isang set ng mga nasimulan at handa nang gamitin na mga bagay.
Prototype(Prototype) — Tinutukoy ang interface para sa paglikha ng isang bagay sa pamamagitan ng pag-clone ng isa pang bagay sa halip na likhain ito sa pamamagitan ng isang constructor.
Ang pagkuha ng mapagkukunan ay pagsisimula(Resource acquisition is initialization (RAII)) - Ang pagkuha ng isang partikular na resource ay pinagsama sa initialization, at ang pagpapalabas nito ay sinamahan ng pagkasira ng isang bagay.
Loner(Singleton) - Isang klase na maaaring magkaroon lamang ng isang instance.

Mga pattern ng istruktura

Ang mga template ng istruktura ay tumutukoy sa iba't ibang mga kumplikadong istruktura, na nagbabago sa interface ng mga umiiral na bagay o sa pagpapatupad nito, na ginagawang mas madali ang pagbuo at pag-optimize ng programa.
Adapter(Adapter / Wrapper) - Isang bagay na nagbibigay ng pakikipag-ugnayan sa pagitan ng dalawang iba pang mga bagay, ang isa ay gumagamit, at ang isa ay nagbibigay, ng isang interface na hindi tugma sa una.
tulay(Bridge) - Isang istraktura na nagbibigay-daan sa iyong baguhin ang interface ng pag-access at ang interface ng pagpapatupad ng klase nang nakapag-iisa.
Linker(Composite) - Isang bagay na pinagsasama ang mga bagay na katulad nito.
Dekorador o Tagabalot(Decorator) o (Wrapper) - Isang klase na nagpapalawak ng functionality ng isa pang klase nang hindi gumagamit ng inheritance.
Facade(Facade) - Isang bagay na nag-abstract ng trabaho sa ilang mga klase, pinagsasama ang mga ito sa isang solong kabuuan.
Isang punto ng pagpasok(Front controller) - Nagbibigay pinag-isang interface para sa mga interface sa subsystem. Tinutukoy ng Front Controller ang isang mataas na antas na interface na ginagawang mas madaling gamitin ang subsystem.
Oportunista(Flyweight) - Ito ay isang bagay na kumakatawan sa sarili nito bilang isang natatanging instance sa iba't ibang lugar programa, ngunit sa katunayan ay hindi isa.
Deputy(Proxy) - Isang bagay na nagsisilbing tagapamagitan sa pagitan ng dalawang iba pang mga bagay, at nagpapatupad/naghihigpit sa pag-access sa bagay na na-access sa pamamagitan nito.

Mga pattern ng pag-uugali

Tinutukoy ng mga pattern ng pag-uugali ang pakikipag-ugnayan sa pagitan ng mga bagay, kaya nadaragdagan ang flexibility nito.
Kadena ng Pananagutan(Chain of responsibility) - Idinisenyo upang ayusin sa isang sistema ng mga antas ng responsibilidad.
Koponan(Utos) - Kumakatawan sa isang aksyon. Ang command object ay naglalaman ng mismong aksyon at mga parameter nito.
Interpreter(Interpreter) - Lutasin ang isang problema na madalas mangyari, ngunit maaaring magbago.
Tagapag-ulit(Iterator) - Kumakatawan sa isang bagay na nagbibigay-daan sa iyong makakuha ng sunud-sunod na access sa mga elemento ng isang pinagsama-samang bagay nang hindi gumagamit ng mga paglalarawan ng bawat isa sa mga bagay na bahagi ng pagsasama-sama.
Tagapamagitan(Mediator) - Nagbibigay ng pakikipag-ugnayan sa pagitan ng maraming bagay, habang bumubuo maluwag na pagkakabit at pag-aalis ng pangangailangan para sa mga bagay na tahasang sumangguni sa isa't isa.
Tagapangalaga(Memento) - Binibigyang-daan kang makuha at i-save ang mga panloob na estado ng isang bagay nang hindi nasira ang encapsulation upang maibalik mo ito sa ibang pagkakataon sa mga estadong ito.
Null object(Null object) - Pinipigilan ang mga null pointer sa pamamagitan ng pagbibigay ng "default" na bagay.
Tagamasid(Observer) - Tinutukoy ang isa-sa-maraming dependency sa pagitan ng mga bagay upang kapag nagbago ang estado ng isang bagay, lahat ng umaasa dito ay aabisuhan tungkol sa kaganapang ito.
lingkod(Servant) - Ginagamit upang magbigay ng karaniwang functionality sa isang pangkat ng mga klase.
Pagtutukoy(Specification) - Nagsisilbing link ng lohika ng negosyo.
Estado(Estado) - Ginagamit sa mga kaso kung saan, sa panahon ng pagpapatupad ng programa, dapat baguhin ng isang bagay ang pag-uugali nito depende sa estado nito.
Diskarte(Diskarte) - Idinisenyo upang tukuyin ang isang pamilya ng mga algorithm, i-encapsulate ang bawat isa sa kanila at tiyakin ang kanilang pagpapalit.
Paraan ng template(Pamamaraan ng template) - Tinutukoy ang batayan ng algorithm at pinapayagan ang mga inapo na tukuyin muli ang ilang hakbang ng algorithm nang hindi binabago ang istraktura nito sa kabuuan.
Bisita(Bisita) - Inilalarawan ang isang operasyon na ginagawa sa mga bagay ng ibang klase. Kapag binago mo ang klase ng Bisita, hindi na kailangang baguhin ang mga naihatid na klase.
Simpleng Patakaran— Alam kong may ganoong pattern, ngunit hindi ko pa nakikita kung ano ang ibig sabihin nito. Kung mayroon kang anumang impormasyon, i-post ito sa mga komento.
Tagapakinig(Event listener) - katulad
Isang beses na bisita(Single-serving na bisita) - Ino-optimize ang pagpapatupad ng pattern ng bisita, na sinisimulan, ginamit nang isang beses, at pagkatapos ay tinanggal.
Hierarchical na bisita(Hierarchical na bisita) - Nagbibigay ng paraan upang madaanan ang lahat ng vertices ng isang hierarchical na istraktura ng data (halimbawa, isang puno).

Parallel Programming Patterns

Ginagamit upang mas mahusay na magsulat ng mga multi-threaded na programa, at nagbibigay ng mga handa na solusyon sa mga problema sa pag-synchronize.
Aktibong bagay(Active Object) - Nagsisilbing paghiwalayin ang thread ng execution ng isang method mula sa thread kung saan ito tinawag. Gumagamit ng mga template asynchronous na tawag pamamaraan at scheduler.
Dodger(Balking) - Nagsisilbi upang magsagawa ng isang aksyon sa isang bagay lamang kapag ito ay nasa tamang estado.
Pagbubuklod ng ari-arian(Nagbubuklod na mga katangian) - Pinagsasama ang maramihang mga tagamasid upang matiyak ang pag-synchronize ng mga katangian sa iba't ibang mga bagay
Pagmemensahe(Messaging design pattern (MDP)) - Nagbibigay-daan sa mga bahagi at application na magpalitan ng impormasyon (mga mensahe).
I-double check ang lock(Double-checked locking) - Idinisenyo upang bawasan ang overhead na nauugnay sa pagkuha ng lock.
Asynchronous na mga kaganapan(Asynchronous na nakabatay sa kaganapan) — Tugunan ang mga problema na may Asynchronous pattern na lumabas sa mga program na may maraming mga thread.
Protektadong Suspensyon(Guarded suspension) - Ginagamit upang harangan ang pagpapatupad ng isang aksyon sa isang bagay kapag ito ay nasa tamang estado.
Half-sync(Half-Sync/Half-Async) - wala pang data tungkol sa pattern na ito.
Mga pinuno(Mga pinuno/tagasunod) - wala pang data tungkol sa pattern na ito.
Lock(Lock) - Ang isang thread ay nagla-lock ng isang mapagkukunan upang maiwasan ang ibang mga thread mula sa pag-access o pagbabago nito.
Subaybayan(Monitor object) — Isang bagay na inilaan para sa ligtas na paggamit higit sa isang thread.
Reactor - Idinisenyo para sa sabay-sabay na paghahatid ng mga kahilingan sa serbisyo mula sa isa o higit pang mga mapagkukunan.
Read-write locking(Read write lock) - Nagbibigay-daan sa maramihang mga thread na sabay-sabay na magbasa ng impormasyon mula sa isang nakabahaging storage, ngunit pinapayagan lamang ang isang thread na baguhin ito sa isang pagkakataon.
Tagapag-iskedyul(Scheduler) - Nagbibigay ng mekanismo para sa pagpapatupad ng mga patakaran sa pag-iiskedyul nang hindi umaasa sa anumang partikular na patakaran.
Thread pool(Thread pool) - Nagbibigay ng pool ng mga thread para sa pagproseso ng mga trabaho, kadalasang ipinapakita sa anyo ng isang pila.
Espesyal na imbakan ng stream(Thread-specific storage) - Nagsisilbing magbigay ng iba't ibang global variable para sa iba't ibang thread.
Single thread execution(Single thread execution) - Pinipigilan ang concurrent method invocation, at sa gayon ay ipinagbabawal ang parallel execution ng paraang ito.
Pattern ng kooperatiba(Cooperative pattern) - Nagbibigay ng mekanismo para sa ligtas na paghinto ng mga thread ng execution, gamit ang isang karaniwang flag upang hudyat ang pagwawakas ng mga thread.

Mga Pattern ng Arkitektura ng System

Model-View-Controller(MVC) - Model-View-Controller.
Model-View-Presenter
Model-View-View na Modelo
Presentation-Abstraction-Control
Mga hubad na bagay
Hierarchical Model–View–Controller

Mga template ng negosyo

Active Record - isang paraan upang ma-access ang data mga database ng relasyon data sa object-oriented programming.
Delegado ng Negosyo
Composite Entity
Composite View
DAO (Data Access Object) Bagay sa Pag-access ng Data
View ng Dispatcher
Front Controller
Pagharang sa Filter
Pagpapatala
Activator ng Serbisyo
Tagahanap ng Serbisyo
Serbisyo sa Manggagawa
Facade ng Session/Facade ng Session
Transfer Object Assembler
Ilipat ang Bagay
Tagapangasiwa ng Listahan ng Halaga
Tingnan ang Helper
Yunit ng Trabaho

Iba pang mga uri ng mga template

Mayroon ding ilang iba pang mga template na magagamit ngayon.
Imbakan(Repository)
Carrier Rider Mapper ilarawan ang pagbibigay ng access sa nakaimbak na impormasyon.
Mga Template ng Analitikal ilarawan ang pangunahing diskarte para sa pagbuo ng mga kinakailangan ng software (pagsusuri ng mga kinakailangan) bago magsimula ang proseso ng pagbuo ng software
Mga template ng komunikasyon ilarawan ang proseso ng komunikasyon sa pagitan ng mga indibidwal na kalahok/empleyado ng isang organisasyon
Mga Template ng Organisasyon ilarawan ang hierarchy ng organisasyon ng enterprise/firm
Mga antipattern(Anti-Design-Patterns) inilalarawan kung ano ang hindi dapat gawin kapag bumubuo ng mga programa, nagpapakita karaniwang mga pagkakamali sa disenyo at pagpapatupad

Kung naisip mo na kung ano ang mga pattern ng disenyo, maligayang pagdating. Sa artikulong ito sasabihin ko sa iyo kung ano ang mga ito, bakit kailangan ang mga ito, kung paano gamitin ang mga ito, at magbigay ng mga halimbawa ng pinakakaraniwang mga template sa PHP.

Ano ang mga pattern ng disenyo?

Ang mga pattern ng disenyo ay napatunayan, handa nang gamitin na mga solusyon sa mga madalas na nakakaharap na problema. pang-araw-araw na programming mga gawain. Ito ay hindi isang klase o isang library na maaaring konektado sa isang proyekto, ito ay isang bagay na higit pa. Ang isang pattern ng disenyo na angkop para sa gawain ay ipinatupad sa bawat partikular na kaso. Bilang karagdagan, ito ay independiyente sa programming language. Ang isang magandang pattern ay madaling ipatupad sa karamihan, kung hindi lahat ng mga wika, depende sa pagpapahayag ng wika. Dapat tandaan, gayunpaman, na ang gayong pattern, kung inilapat nang hindi tama o sa maling problema, ay maaaring magdulot ng maraming problema. Gayunpaman, ang isang wastong inilapat na template ay makakatulong na malutas ang problema nang madali at simple.

Mayroong tatlong uri ng mga template:

  • istruktura;
  • pagbuo;
  • pag-uugali.

Structural Tinutukoy ng mga template ang mga ugnayan sa pagitan ng mga klase at mga bagay, na nagpapahintulot sa kanila na magtulungan.

Generative ang mga template ay nagbibigay ng mga mekanismo ng pagsisimula, na nagbibigay-daan sa iyong lumikha ng mga bagay sa isang maginhawang paraan.

Pag-uugali ginagamit ang mga template upang pasimplehin ang mga pakikipag-ugnayan sa pagitan ng mga entity.

Bakit kailangan ang mga pattern ng disenyo?

Ang pattern ng disenyo, sa kaibuturan nito, ay isang maalalahaning solusyon sa isang partikular na problema. Kung nahaharap ka sa isang kilalang problema, bakit hindi gamitin handa na solusyon, napatunayan ng karanasan?

Halimbawa

Isipin natin na kailangan mong pagsamahin ang dalawang klase na magagawa iba't ibang operasyon depende sa sitwasyon. Ang mga klase na ito ay labis na ginagamit ng umiiral na sistema, na ginagawang imposibleng alisin ang isa sa mga ito at idagdag ang paggana nito sa pangalawa. Bilang karagdagan, ang pagpapalit ng code ay mangangailangan ng maingat na pagsubok, dahil ang naturang refactoring ay humahantong sa mga hindi maiiwasang pagkakamali. Sa halip, maaari mong ipatupad ang mga pattern ng Strategy at Adapter at gamitin ang mga ito upang malutas ang problema.

Class StrategyAndAdapterExampleClass ( private $_class_one; private $_class_two; private $_context; public function __construct($context) ($this->_context = $context; ) public function operation1() ( if($this->_context == "context_for_class_one ") ( $this->_class_one->operation1_in_class_one_context(); ) else ($this->_context == "context_for_class_two") ( $this->_class_two->operation1_in_class_two_context(); ) ) )

Simple, hindi ba? Tingnan natin ang template ng Strategy.

Template na "Diskarte"

Diskarte- isang pattern ng pag-uugali na nagpapahintulot sa iyo na piliin ang pag-uugali ng isang programa sa panahon ng pagpapatupad depende sa konteksto sa pamamagitan ng pag-encapsulate ng ilang mga algorithm sa iba't ibang klase.

Sa halimbawa sa itaas, ang pagpili ng diskarte ay batay sa halaga ng $context variable sa oras na nilikha ang object. Kung ang value ay "context_for_class_one" , gagamitin ng program ang class class_one . At vice versa.

Okay, ngunit saan ito magagamit?

Isipin na ikaw ay bumubuo ng isang klase na maaaring lumikha o mag-update ng isang tala sa isang database. Sa parehong mga kaso mga parameter ng input ay magiging pareho (pangalan, address, numero ng telepono, atbp.), ngunit, depende sa sitwasyon, kailangan niyang gamitin iba't ibang function para mag-update at gumawa ng record. Maaari mong muling isulat ang if/else na kundisyon sa bawat pagkakataon, o maaari kang lumikha ng isang paraan na tatanggap sa konteksto:

User ng Klase ( public function na CreateOrUpdate($name, $address, $mobile, $userid = null) ( if(is_null($userid)) ( // wala ang user, gumawa ng record ) iba pa ( // umiiral ang record, i-update ito)))

Kadalasan, ang pattern ng Strategy ay nagsasangkot ng mga encapsulating algorithm sa mga klase, ngunit sa sa kasong ito ito ay hindi kailangan. Tandaan na hindi mo kailangang sundin ang template na salita para sa salita. Ang anumang mga pagpipilian ay katanggap-tanggap kung malulutas nila ang problema at tumutugma sa konsepto.

Template ng adaptor

Adapter- isang structural template na nagbibigay-daan sa iyong gumamit ng klase na nagpapatupad mga kinakailangang function, ngunit may hindi naaangkop na interface.

Nagbibigay-daan din ito sa iyo na baguhin ang ilang input upang maging tugma sa interface ng panloob na klase.

Paano ito gamitin?

Ang isa pang pangalan para sa isang adaptor ay "I-wrap". "Binabalot" nito ang bagong interface sa buong klase para magamit. Klasikong halimbawa: kailangan mong lumikha ng isang klase modelo ng paksa, pagkakaroon ng mga object class sa database. Sa halip na direktang i-access ang mga klase sa talahanayan at tawagan ang kanilang mga pamamaraan nang paisa-isa, maaari mong i-encapsulate ang mga tawag sa mga pamamaraang iyon sa isang paraan sa isang adaptor. Hindi lamang ito magbibigay-daan sa iyong muling gumamit ng isang hanay ng mga operasyon, ngunit ito rin ay magliligtas sa iyo mula sa patuloy na muling pagsusulat ng maraming code kung kailangan mong gawin ang parehong hanay ng mga aksyon sa ibang lugar.

Paghambingin ang dalawang halimbawa.

Nang walang adaptor
$user = bagong User(); $user->CreateOrUpdate(// mga parameter); $profile = bagong Profile(); $profile->CreateOrUpdate(// mga parameter);

Kung kailangan nating muling gamitin ang naturang code, mapipilitan tayong muling isulat ang buong bagay.

Gamit ang isang adaptor

Maaari kaming lumikha ng klase ng Account wrapper:

Class Account() ( public function NewAccount(// parameters) ($user = new User(); $user->CreateOrUpdate(// bahagi ng mga parameter); $profile = new Profile(); $profile->CreateOrUpdate( // bahagi ng mga parameter); $account_domain->NewAccount(// mga parameter);

Ngayon ay magagamit na namin ang klase ng Account sa bawat oras at bilang karagdagan maaari kaming magdagdag ng karagdagang pag-andar dito.

Template ng Paraan ng Pabrika

Pabrika- isang template ng pagbuo, na isang klase na may pamamaraan para sa paglikha ng iba't ibang mga bagay.

Ang pangunahing layunin ng pattern na ito ay upang i-encapsulate ang pamamaraan para sa paglikha ng iba't ibang mga klase sa isang solong function, na, depende sa kontekstong ipinasa dito, ay nagbabalik ng kinakailangang bagay.

Paano ito gamitin?

Ang isang pabrika ay karaniwang ginagamit upang lumikha ng iba't ibang mga variant ng isang batayang klase. Sabihin nating mayroon kang klase ng button - Button - at tatlong opsyon - ImageButton, InputButton at FlashButton. Sa isang pabrika maaari kang lumikha iba't ibang mga pagpipilian mga pindutan depende sa sitwasyon.

Una, gumawa tayo ng tatlong klase:

Abstract class Button ( protected $_html; public function getHtml() ( return $this->_html; ) ) class ImageButton extends Button ( protected $_html = "..."; // HTML code ng image button ) class InputButton extends Button ( protektado $_html = "..."; // HTML code para sa isang regular na button ( ); ) klase FlashButton extends Button ( protektado $_html = "..."; // HTML code ng Flash button )

Ngayon ay maaari naming isulat ang aming pabrika:

Class ButtonFactory ( public static function createButton($type) ($baseClass = "Button"; $targetClass = ucfirst($type).$baseClass; if (class_exists ($targetClass) && is_subclass_of($targetClass, $baseClass)) ( return new $targetClass; ) else ( throw new Exception("Ang uri ng button na "$type" ay hindi kinikilala."); ) )

at gamitin ito:

$buttons = array("imahe","input","flash"); foreach($buttons bilang $b) ( echo ButtonFactory::createButton($b)->getHtml() )

Ang output ay dapat na HTML na may lahat ng uri ng mga pindutan. Sa ganitong paraan, natukoy namin kung anong uri ng button ang gusto namin at muling gamitin ang code.

Template ng dekorador

Dekorador ay isang structural pattern na nagbibigay-daan sa iyong magdagdag ng bagong pag-uugali sa isang bagay sa panahon ng pagpapatupad ng programa, depende sa sitwasyon.

Ang layunin ay palawigin ang pag-uugali ng isang partikular na bagay nang hindi kinakailangang baguhin ang pag-uugali ng batayang klase. Papayagan ka nitong gumamit ng maraming dekorador nang sabay-sabay. Ang pattern na ito ay isang alternatibo sa mana. Hindi tulad ng mana, ang isang dekorador ay nagdaragdag ng pag-uugali sa panahon ng pagpapatupad ng programa.

Upang ipatupad ang dekorador kailangan namin:

  1. Magmana ng klase ng dekorador mula sa base one.
  2. Magdagdag ng field na may link sa batayang klase sa dekorador.
  3. Magpasa ng reference sa bagay na ipapalamuti sa tagabuo ng dekorador.
  4. I-redirect ang mga pamamaraan mula sa dekorador patungo sa bagay na pinalamutian.
  5. I-override ang mga paraan sa dekorador na gusto mong baguhin ang ugali.

Paano ito gamitin?

Sabihin nating mayroon tayong isang bagay na kailangang magkaroon ng isang tiyak na pag-uugali sa isang partikular na sitwasyon. Halimbawa, mayroon kaming HTML na link upang mag-log out sa iyong account, na dapat ipakita sa ibang paraan depende sa kung anong pahina tayo. Ito ang mismong kaso kapag tutulungan tayo ng mga dekorador.

Una, magpasya tayo kung anong "tanaw" ang kailangan natin:

  • Kung tayo ay nasa pangunahing pahina at naka-log in, ang link ay dapat nasa h2 tag.
  • Kung kami ay nasa ibang page at naka-log in, dapat na may salungguhit ang link.
  • Kung kami ay naka-log in, ang link ay dapat na nasa malakas na tag.

Ngayon ay maaari nating isulat ang mga dekorador mismo:

Class HtmlLinks ( // pamamaraan para sa pagtatrabaho sa anumang HTML link) class LogoutLink ay nagpapalawak ng HtmlLinks ( protektado $_html; pampublikong function __construct() ($this->_html = "Logout"; ) public function setHtml($html) ($this - >_html = $html; ) public function render() ( echo $this->_html; ) ) class LogoutLinkH2Decorator extends HtmlLinks ( protected $_logout_link; public function __construct ($ logout_link) ($this->_logout_link = $logout_link; $ this ->setHtml("" . $this->_html . "") public function __call($name, $args) ($this->_logout_link->$name($args); ) ) class LogoutLinkUnderlineDecorator extends HtmlLinks ( protected $ _logout_link; pampublikong function __construct($logout_link) ($this->_logout_link = $logout_link; $this->setHtml("" . $this->_html . ""); ) public function __call($name, $ args) ( $this->_logout_link->$name($args); ) ) class LogoutLinkStrongDecorator extends HtmlLinks ( protected $_logout_link; public function __construct($logout_link) ($this->_logout_link = $logout_link;

$this->setHtml("" . $this->_html . "");

) pampublikong function __call($name, $args) ($this->_logout_link->$name($args); ) )

Ngayon ay maaari nating gamitin ang mga ito tulad nito:

$logout_link = bagong LogoutLink(); if($is_logged_in) ($logout_link = bagong LogoutLinkStrongDecorator($logout_link); ) if($in_home_page) ($logout_link = bagong LogoutLinkH2Decorator($logout_link); ) iba pa ($logout_link = bagong LogoutLinkUnderlineDecorator($logout_link-); ) $logout_link-) >render();

Pansinin kung paano mo magagamit ang maramihang mga dekorador sa parehong bagay. Ginagamit nilang lahat ang function na __call upang tawagan ang orihinal na paraan. Kung mag-log in kami sa aming account at pumunta sa home page, ang resulta ay magiging ganito:

Loner Mag-logout

Template na "Single"

Paano ito gamitin?

- isang pagbuo ng pattern na nagbibigay-daan sa iyong tiyakin na sa panahon ng pagpapatupad ng programa ay isang pagkakataon lamang ng isang klase na may pandaigdigang pag-access ang nilikha.

Class Session ( private static $instance; public static function getInstance() ( if(is_null(self::$instance)) ( self::$instance = new self(); ) return self::$instance; ) private function __construct () ( ) pribadong pag-andar __clone() ( ) // iba pang mga pamamaraan ng session... ... ... ) // kumuha ng isang halimbawa ng session $session = Session::getInstance();

Ngayon ay maaari na nating ma-access ang session mula sa iba't ibang bahagi ng code, kahit na mula sa ibang mga klase. Palaging ibabalik ng paraan ng getInstance ang parehong session.

Konklusyon

Sa artikulong ito, tiningnan lang namin ang mga pinakakaraniwang pattern sa marami. Kung gusto mong matuto nang higit pa tungkol sa mga pattern ng disenyo, makakahanap ka ng maraming impormasyon sa Wikipedia. Para sa higit pa kumpletong impormasyon tingnan ang sikat na aklat na "Object Oriented Design Techniques" ng Gang of Four.

At panghuli: kapag ginagamit ito o ang template na iyon, tiyaking malulutas mo ang problema ang tamang paraan. Tulad ng nabanggit, kung ginamit nang hindi tama, maaaring maging sanhi ng mga pattern ng disenyo mas maraming problema kaysa magdesisyon. Ngunit kung gagawin nang tama, ang kanilang mga benepisyo ay hindi matataya.

Huling na-update: 10/31/2015

Ano ang mga pattern ng disenyo? Ang isang pattern ay kumakatawan sa isang tiyak na paraan ng pagbuo code ng programa upang malutas ang mga karaniwang problema sa disenyo. Sa kasong ito, ipinapalagay na mayroong isang tiyak na hanay ng mga pangkalahatang pormal na problema na nangyayari nang madalas, at ang mga pattern ay nagbibigay ng isang hanay ng mga prinsipyo para sa paglutas ng mga problemang ito.

Bagaman ang ideya ng mga pattern bilang isang paraan ng paglalarawan ng mga solusyon sa mga karaniwang problema sa disenyo ay lumitaw nang matagal na ang nakalipas, ang kanilang katanyagan ay nagsimulang lumago higit sa lahat dahil sa sikat na gawain apat na may-akda na sina Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides, na tinawag na "Mga Pattern ng Disenyo: Mga Elemento ng Reusable Object-Oriented Software" (sa Russian na kilala bilang "Object-Oriented Design Techniques. Design Patterns") at na-publish sa 1994. At ang pangkat ng mga may-akda mismo ay madalas na tinatawag na "Gang of Four" o Gang of Four, o GoF para sa maikling salita. Ang aklat na ito ay mahalagang unang malakihang pagtatangka upang ilarawan ang mga karaniwang pamamaraan ng disenyo ng programa. At sa paglipas ng panahon, ang paggamit ng mga pattern ay nagsimulang ituring na mahusay na kasanayan sa programming.

Ano ang ibinibigay sa atin ng paggamit ng mga pattern? Kapag nagsusulat ng mga programa, maaari nating gawing pormal ang problema sa anyo ng mga klase at bagay at ang mga ugnayan sa pagitan ng mga ito. At ilapat ang isa sa mga umiiral na pattern upang malutas ito. Bilang resulta, hindi natin kailangang mag-imbento ng anuman. Mayroon na kaming yari na template, at kailangan lang namin itong ilapat sa isang partikular na programa.

Bukod dito, ang mga pattern, bilang panuntunan, ay hindi nakasalalay sa programming language. Magiging katulad ang kanilang mga prinsipyo ng aplikasyon sa C#, Jave, at iba pang mga wika. Bagama't sa loob ng gabay na ito ay pag-uusapan natin ang tungkol sa mga pattern sa konteksto ng wikang C#.

Ang pag-iisip sa mga pattern ay nagpapadali din sa pagbuo ng mga programa sa mga grupo. Ang pag-alam sa pattern ng disenyo na ginamit at ang mga pangunahing prinsipyo nito ay magpapadali para sa isa pang programmer na maunawaan at magamit ang pagpapatupad nito.

Kasabay nito, hindi ka dapat gumamit ng mga pattern para sa kapakanan ng mga pattern mismo. Magandang programa nagsasangkot ng paggamit ng mga pattern. Gayunpaman, ang mga pattern ay hindi palaging pinapasimple at pinapabuti ang programa. Ang kanilang hindi makatarungang paggamit ay maaaring humantong sa komplikasyon ng code ng programa at pagbaba sa kalidad nito. Ang pattern ay dapat na makatwiran at sa isang mahusay na paraan paglutas ng problema.

Mayroong maraming iba't ibang mga pattern na lumulutas iba't ibang problema at gumanap iba't ibang gawain. Ngunit ayon sa kanilang aksyon, maaari silang pagsamahin sa isang bilang ng mga grupo. Tingnan natin ang ilang grupo ng mga pattern. Ang pag-uuri ng mga pangunahing pattern ay batay sa layunin o mga gawain na ginagawa ng isang partikular na pattern.

Mga Generative Pattern

Ang mga generative pattern ay mga pattern na abstract ang proseso ng instantiation o, sa madaling salita, ang proseso ng pagbuo ng mga klase at bagay. Kabilang sa mga ito ang mga sumusunod na namumukod-tangi:

    Tagabuo

    Prototype

    Singleton

Isa pang pangkat ng mga pattern - mga pattern ng istruktura- sinusuri kung paano bumubuo ang mga klase at bagay ng mas malalaking istruktura - mga klase at bagay na mas kumplikado sa kalikasan. Kasama sa mga template na ito ang:

    Adapter

    tulay

    Composite

    Dekorador

    Facade

    Flyweight

    Deputy (Proxy)

Ang ikatlong pangkat ng mga pattern ay tinatawag na pag-uugali - tinutukoy nila ang mga algorithm at pakikipag-ugnayan sa pagitan ng mga klase at bagay, iyon ay, ang kanilang pag-uugali. Kabilang sa mga naturang template ay ang mga sumusunod:

    Utos

    Interpreter

    Tagapag-ulit

    Tagapamagitan

    Tagapangalaga (Memento)

    Tagamasid

    Estado

    Diskarte

    Paraan ng template

    Bisita

Mayroong iba pang mga klasipikasyon ng mga pattern depende sa kung ang pattern ay kabilang sa mga klase o mga bagay.

Inilalarawan ng mga pattern ng klase ang mga ugnayan sa pagitan ng mga klase sa pamamagitan ng mana. Ang mga ugnayan sa pagitan ng mga klase ay tinutukoy sa oras ng pag-compile. Kasama sa mga pattern na ito ang:

    Paraan ng Pabrika

    Interpreter

    Paraan ng Template

    Adapter

Isa pang bahagi ng mga pattern - mga pattern ng bagay ilarawan ang mga ugnayan sa pagitan ng mga bagay. Ang mga ugnayang ito ay nangyayari sa runtime at samakatuwid ay mas nababaluktot. Kasama sa mga pattern ng bagay ang sumusunod:

    Abstract na Pabrika

    Tagabuo

    Prototype

    Singleton

    tulay

    Composite

    Dekorador

    Facade

    Flyweight

    Deputy (Proxy)

    Kadena ng pananagutan

    Utos

    Tagapag-ulit

    Tagapamagitan

    Tagapangalaga (Memento)

    Tagamasid

    Estado

    Diskarte

    Bisita

At ito ay ilan lamang sa mga pangunahing pattern. Sa pangkalahatan, marami pang iba't ibang pattern ng disenyo. Ang ilan sa mga ito ay nagsisimula pa lamang gamitin, ang iba ay kasalukuyang sikat, at ang ilan ay hindi gaanong karaniwan kaysa dati.

At sa manwal na ito Titingnan natin ang pinakapangunahing at karaniwang mga pattern at prinsipyo ng kanilang paggamit kaugnay ng C# na wika.

Paano pumili ng tamang pattern?

Una sa lahat, kapag nilulutas ang isang problema, kailangan mong tukuyin ang lahat ng mga entity na ginamit at ang mga koneksyon sa pagitan nila at i-abstract ang mga ito mula sa partikular na sitwasyon. Pagkatapos ay kailangan mong makita kung ang abstract na anyo ng paglutas ng problema ay umaangkop sa isang tiyak na pattern. Halimbawa, ang kakanyahan ng problemang nilulutas ay maaaring ang paglikha ng mga bagong bagay. Sa kasong ito, maaaring sulit na tingnan ang mga generative pattern. Bukod dito, ito ay mas mahusay na hindi agad kumuha ng isang tiyak na pattern - ang una na tila kinakailangan, ngunit upang tumingin sa ilang mga kaugnay na mga pattern mula sa parehong grupo na malutas ang parehong problema.

Kasabay nito, mahalagang maunawaan ang kahulugan at layunin ng pattern, upang malinaw na kinakatawan ang abstract na organisasyon nito at ang mga posibleng kongkretong pagpapatupad nito. Ang isang pattern ay maaaring magkaroon ng iba't ibang mga pagpapatupad, at kung mas madalas mong makaharap ang mga pagpapatupad na ito, mas mauunawaan mo ang kahulugan ng pattern. Ngunit hindi ka dapat gumamit ng pattern kung hindi mo ito naiintindihan, kahit na sa unang tingin ay nakakatulong ito sa iyong lutasin ang problema.

At sa huli, dapat tayong sumunod sa prinsipyo ng KISS (Keep It Simple, Stupid) - panatilihing simple at malinaw ang code ng programa hangga't maaari. Pagkatapos ng lahat, ang punto ng mga pattern ay hindi upang gawing kumplikado ang code ng programa, ngunit sa halip na gawing simple ito.

Sa kanilang core, ang mga pattern ay regular na mga template disenyo. Hiniram sa mga ordinaryong arkitekto (sa mga nakikitungo sa mga gusali). Ang punto ay simple. Sa gawain ng isang arkitekto, may mga gawain na maaaring maginhawang malutas sa isa o higit pang mga napatunayang paraan.

Sa pamamagitan ng pagkakatulad, ang disenyo ng software ay may sariling mga isyu sa arkitektura, tulad ng paghahati ng isang application sa mga bahagi/modules, pag-aayos ng mga dependency sa pagitan ng mga ito, pamamahagi ng mga responsibilidad sa pagganap, atbp. Tulad ng matalinong nabanggit ng mga may-akda ng libro mula sa gang ng apat na ito (Ang "Gang of Four"), sa aming industriya posible ring makilala ang isang tiyak na bilang ng mga karaniwang template, na sinubukan sa pagsasanay, upang hindi makatapak sa rake na nalampasan na ng iba.

Ang kakanyahan ng pag-unawa sa mga pattern ay upang maunawaan sa kung anong mga sitwasyon ang tama na gumamit ng isang partikular na pattern ng disenyo at ilapat ito nang tama. Mahalagang maunawaan na ang formula na "mas maraming pattern ang mailalagay ko sa aking aplikasyon, mas mabuti" ay hindi tama. Dapat itong gamitin nang matalino at kung saan lamang sila talagang kailangan. Bilang karagdagan, ang mga pattern ay nagiging hindi na ginagamit at nagiging mga anti-pattern habang umuunlad ang teknolohiya (na sa aming larangan ay ginagawa ito nang higit pa sa mabilis). At, siyempre, may mga karaniwang tinatanggap na mga template at mayroong mga matagumpay na ginagamit sa makitid na mga bilog.
Dito rin, kailangan mong maunawaan na hindi ito isang uri ng dogma - tulad ng 10 sagradong mga pattern ng disenyo :)

Upang maunawaan kung saan kailangan ang mga ito, kailangan mo ng karanasan. Iyon ay (ako ay personal na kumbinsido) na lamang ng isang lubhang limitadong bilang ng mga tao ay maaaring matuto mula sa mga pagkakamali ng iba. Ang iba ay kailangang malaman ito sa kanilang sarili :)

Ibibigay ko ang mga sumusunod na tip para sa pag-aaral ng mga pattern:

1) Magbasa ng ilang libro para maunawaan kung anong uri ng hayop ito at kung ano ang kinakain nito. Maaari kang kumuha ng isa sa mga variation ng GoF book o ilang derivatives para sa iyong development stack - kilalanin ang mga pangunahing sikat na template. Kaagad pagkatapos nito, ipinapayo kong basahin ang aklat na "The Bitter Taste of Java" (Bruce Tate) - tungkol ito sa mga anti-pattern. Ito ay upang maunawaan reverse side kanilang paggamit. Nagustuhan ko ito at sa tingin ko ito ang nagligtas sa akin mula sa maraming problema. Ang nasa halimbawa ng Java ay hindi mahalaga. Ito ay tungkol sa tungkol sa mga template, kaya magiging madali para sa mga kinatawan ng iba pang mga stack (na kasama ako) na maunawaan pa rin.

2) Subukang mapagtanto kung nakatagpo ka na ng isang bagay sa iyong trabaho na madaling maging isa sa mga pattern. Kung saan posible na mailapat nang tama ang konsepto, at kung saan nagkaroon lamang ng mga problema dahil dito.

3) Sa mga bagong proyekto, panatilihin ang kaalaman na nakuha mula sa mga template sa iyong ulo - bigla itong darating sa madaling gamiting.

Sa huli, alam mo man ang mga pattern o hindi, kasama ng karanasan ang pag-unawa kung aling arkitektura ang magiging tama at alin ang hindi. Paano ito gagawing maginhawa at paano hindi. At hindi mahalaga kung anong mga pattern ang tawag mo dito.

I would even advise approaching the development of IT architectural wisdom from the other side - from the side of non-functional requirements or so-called "-ilities" - marami sa kanila. Narito ang 7 piraso na inilarawan. Sa pangkalahatan, mayroong dose-dosenang mga ito.

Sa iba pa - tulad ng pagpapanatili ( simpleng suporta code), scalability, extensibility, availability, atbp. Kung, kapag nagdidisenyo ng iyong aplikasyon, iniisip mo ang tungkol sa mga "ility" na ito at subukang ibigay ang mga ito sa lawak na kinakailangan para sa proyekto, kung gayon, bilang panuntunan, ang iyong aplikasyon ay magkakaroon ng mahusay na arkitektura. Kasabay nito, ang mga pattern ng disenyo ay lilitaw dito nang maikli sa kanilang sarili.

Dahil ang ideya ng paggamit ng mga template ay isang pagtatangka ng mga nakaranasang software engineer na magbigay ng isang dosenang handa na mga recipe sa mga hindi gaanong karanasan, upang hanggang sa matutunan nila kung paano magluto ng "masarap na sinigang", hindi sila nagluluto ng isang bagay na ganap na hindi nakakain. :) Matutong "magluto", umunawa -ilites :) at lahat ay magiging maayos

Arkitektura

Disenyo ng computer program

Kwento

Benepisyo

Ang pangunahing pakinabang ng bawat isa hiwalay na template ay na ito ay naglalarawan ng solusyon sa isang buong klase ng abstract na mga problema. Gayundin, ang katotohanan na ang bawat pattern ay may sariling pangalan ay nagpapadali sa pagtalakay ng abstract data structures (ADTs) sa mga developer, dahil maaari silang sumangguni sa mga kilalang pattern. Kaya, dahil sa mga template, terminolohiya, mga pangalan ng mga module at mga elemento ng proyekto ay pinag-isa.

Ang isang wastong nabalangkas na pattern ng disenyo ay nagbibigay-daan, sa sandaling natagpuan ang isang matagumpay na solusyon, na magamit nang paulit-ulit.

Hindi tulad ng mga idyoma, ang mga pattern ay independyente sa programming language na ginamit.

Pagpuna

Minsan pinapanatili ng mga template ang isang masalimuot at hindi epektibong sistema ng mga konsepto na binuo ng isang makitid na grupo. Kapag ang bilang ng mga pattern ay tumaas nang lampas sa kritikal na kumplikado, nagsisimulang balewalain ng mga performer ang mga pattern at ang buong sistemang nauugnay sa kanila.

Kadalasang pinapalitan ng mga template ang kakulangan o kakulangan ng dokumentasyon sa isang komplikadong kapaligiran ng software.

May isang opinyon na ang bulag na aplikasyon ng mga template mula sa reference na libro, nang hindi nauunawaan ang mga dahilan at mga kinakailangan para sa pagkilala sa bawat indibidwal na template, ay nagpapabagal sa propesyonal na paglago ng isang programmer, dahil pinapalitan nito ang malikhaing gawain sa isang mekanikal na pagpapalit ng mga template. Ang mga taong sumusunod sa opinyon na ito ay naniniwala na dapat kang maging pamilyar sa mga listahan ng mga template kapag ikaw ay "lumaki" sa kanila nang propesyonal - at hindi mas maaga. Magandang criterion ang kinakailangang antas ng propesyonalismo - pagkilala sa mga template nang nakapag-iisa, batay sa sariling karanasan. Kasabay nito, siyempre, ang pamilyar sa teorya na nauugnay sa mga pattern ay kapaki-pakinabang sa anumang antas ng propesyonalismo at nagtuturo sa pagbuo ng isang programmer sa tamang direksyon. Tanging ang paggamit ng mga template "ayon sa sangguniang libro" ay kaduda-dudang.

Maaaring mag-promote ang mga template ng hindi magandang istilo ng pagbuo ng application at kadalasang bulag na inilalapat.

Upang malampasan ang mga pagkukulang na ito, ginagamit ang refactoring.

Pangunahing Uri ng Mga Pattern ng Disenyo

Mga pangunahing template (Pangunahin)

  • Interface ng marker
  • Lalagyan ng Ari-arian

Mga Pattern ng Generative na Disenyo

  • Paraan ng Pabrika, Virtual Constructor
  • Mga hindi kilalang subroutine na bagay

Mga template ng istruktura

  • Proxy/Kapalit, Kahalili
  • Lalagyan
  • Extensibility
  • Mga tubo at mga filter
  • Pribadong data ng klase

Mga pattern ng pag-uugali

Parallel Programming Patterns (Concurrency)

  • Aktibong Bagay
  • Balking
  • Binabantayan ang suspensyon
  • Half-Sync/Half-Async
  • Mga pinuno/tagasunod
  • Subaybayan ang Bagay
  • Reaktor
  • Basahin ang write lock
  • Tagapag-iskedyul
  • Thread pool
  • Imbakan na Partikular sa Thread
  • Pagpapatupad ng Single Thread

MVC

  • Enterprise

    Unsorted

    • Lalagyan ng Ari-arian
    • Channel ng Kaganapan
    • Imbakan/Imbakan

    Iba pang mga uri ng mga template

    Mayroon ding ilang iba pang mga template ngayon:

    • Carrier Rider Mapper, na nagbibigay ng access sa nakaimbak na impormasyon
    • Inilalarawan ng mga template ng analytical ang pangunahing diskarte para sa pagbuo ng mga kinakailangan ng software (pagsusuri ng kinakailangan) bago magsimula ang proseso ng pagbuo ng software
    • inilalarawan ng mga template ng komunikasyon ang proseso ng komunikasyon sa pagitan ng mga indibidwal na kalahok/empleyado ng isang organisasyon
    • mga template ng organisasyon, ilarawan ang hierarchy ng organisasyon ng isang enterprise/firm
    • Ang mga Anti-Design-Pattern ay naglalarawan kung ano ang hindi dapat gawin kapag bumubuo ng mga programa, na nagpapakita ng mga katangiang error sa disenyo at pagpapatupad.

    Tingnan din

    • Pangkalahatang programming

      • Mga link

      • Olga Dubina Pagsusuri ng Mga Pattern ng Disenyo. - Pagsusuri ng ilan sa mga pinakamahalagang monograph sa mga pattern ng disenyo mga sistema ng impormasyon. Hinango noong Setyembre 5, 2006.
      • Portland Pattern Repository - listahan ng mga pattern ng disenyo sa wiki engine
      • aklat ni mgrand - isang site na may paglalarawan ng isang malaking bilang ng mga pattern ng disenyo
      • Mga Pattern ng Pagbibitiw - mga paglabag sa disenyong hindi nakatuon sa proyekto (isang parody ng mga pattern)
      • Ang Kultura ng Pagpapadala ng Eclipse Erich Gamma

      Panitikan

      • E. Gamma, R. Helm, R. Johnson, J. Vlissides Mga diskarte sa disenyo na nakatuon sa object. Mga Pattern ng Disenyo = Mga Pattern ng Disenyo: Mga Elemento ng Reusable Object-Oriented Software. - St. Petersburg: "Peter", 2007. - P. 366. - ISBN 978-5-469-01136-1 (din ISBN 5-272-00355-1)
      • Craig Larman Application ng UML 2.0 at mga pattern ng disenyo = Paglalapat ng UML at Mga Pattern: Isang Panimula sa Pagsusuri na Nakatuon sa Bagay at Disenyo at Pag-uulit na Pag-unlad. - M.: "Williams", 2006. - P. 736. - ISBN 0-13-148906-2
      • Martin Fowler Arkitektura ng enterprise mga aplikasyon ng software= Mga Pattern ng Enterprise Application Architecture (Addison-Wesley Signature Series). - M.: "Williams", 2007. - P. 544. - ISBN 0-321-12742-0
      • Joshua Kerievsky Refactoring sa Mga Pattern (Addison-Wesley Signature Series). - M.: "Williams", 2006. - P. 400. - ISBN 0-321-21335-1
      • Scott W. Ambler, Pramodkumar J. Sadalaj Mga Refactoring Database: Evolutionary Database Design (Addison-Wesley Signature Series). - M.: "Williams", 2007. - P. 368. - ISBN 0-321-29353-3

      Wikimedia Foundation.

  • 2010.
  • Patterson, James

Patterson, Percival



Julia