-Choose the one you want to use. Enjoy!
Wednesday, April 29, 2015
Let's use pure Myanmar Unicode in Windows 8
-In Windows 8.1, pure Myanmar Unicode font has been already included on the system. -You don't have to install any extra font or "Keyboard" to use. -First, make sure that there is "Myanmar Text" by open "MS Word" and see the font drop down.
-Now, Let's make ready for Keyboard/Input of Myanmar. -Type "Control Panel" in the Windows 8.1 search box. (Note: Click the "Windows" icon and just type the word you want to search.)
-Click the Control Panel to Open. -In the "Clock, Language and Region" group, click "Add a language" link.
-Type "Myanmar" or "Burmese" in the search language box.
-Click the font name and just click "Add". -Now, u will see in the list as:
Done. -Now, you are ready to type/use pure "Myanmar" unicode. -To change the input method(keyboard), just press "Windows" key and "Space Bar"
-Choose the one you want to use. Enjoy!
-Choose the one you want to use. Enjoy!
Thursday, April 2, 2015
ဆော့ဖ်ဝဲ ဗိသုကာဒီဇိုင်းပုံစံများ (Software Architectural Design Patterns)
Design Pattern ရဲ့ သမိုင်းကြောင်းအကျဉ်း
• ၁၉၇၇-၇၉ မှာ ဗိသုကာပညာရှင် ခရစ်စ်တိုဖာ အလက်စ်ဇန်းဒါး Christopher Wolfgang Alexander (born in October 4th, 1936 in Vienna, Austria) က၊ အဆောက်အဦး နဲ မို့ရွာတည်ဆောက်မှုဆိုင်ရာ ဒီဇိုင်းပုံစံ နဲ ပတ်သက်တဲ့ အတွေးအခေါ် အယူအဆ တစ်ရပ်ကို “A Pattern Language: Towns, Buildings, Construction” ဆိုတဲ့ စာတမ်းမှာ တင်ပြခဲ့တယ်။
• အဲဒီအတွေးအခေါ် အယူအဆ သဘောတရားတွေကို အခြေခံပြီး အမေရိကန် ေဆာ့ဖ်၀ဲအင်ဂျင်နီယာတွေဖြစ်တဲ့ Kent Beck နဲ Ward Cunningham တို က၊ object oriented programming ရးသားတဲ့ နရာမှာ ‘pattern’ တွ အသုံးချကြည့်တဲ့နည်းလမ်းတွေကို စမ်းသပ်ခဲ့ပြီး၊ “Using Pattern Languages for Object-Oriented Programs” ဆို တဲ့ စာတမ်းတစ်စောင်ကို ၁၉၈၇ မှာ ACM(Association for Computing Machinery) ကဦးစီးကျင်းပတဲ့၊ OOPSLA (Object Oriented Programming, Systems, Languages and Applications) ကွန်ဖရင့် မှာ တင်သွင်းခဲ့ပါတယ်။
• ၁၉၈၀ နှာင်းပိုင်းနဲ ၁၉၉၀ အစောပိုင်း ကာလတွေမှာ ဆာ့ဖ်၀ဲအင်ဂျင်နီယာတွေ နဲ ဆာ့ဖ်၀ဲဗိသုကာတွေက ဆာ့ဖ်၀ဲ ရးသား တည်ဆောက်ရာမှာ သုံးတဲ့ ဗိသုကာပုံစံတွေ ကို ခွဲခြားစိစစ်ပြီး ၎င်းတို ကိုသုံးစွဲတဲ့ နရာမှာ တွ ကြုံရတဲ့ ပဿနာ တွနဲ ပတ်သက်လို အသေးစိပ် စတင် လ့လာခဲ့ကြတယ်။
• ၁၉၉၅ ခုနှစ်မှာတော့၊ ဒီကနေ ခတ် ဆာ့ဖ်၀ဲအင်ဂျင်နီယာပညာရပ်နယ်ပယ်ရဲ့ ဂန္ထ၀င်စာအုပ် “Design Pattern : Elements of Reusable Object-Oriented Software” ကို Erich Gamma, Richard Helm, Ralph Johnson နဲ John Vlissides တို က ရးသားထုတေ်၀ခဲ့တယ်။ အဲဒီပုဂ္ဂိုလ် လးရောက်ကို ဆာ့ဖ်၀ဲဒီဇိုင်းလောကမှာ လးဦးဂိုဏ်း (Gang of Four - GoF) လို ခါ်ကြတယ်။
• ၁၉၉၇ မှာ Joseph Yoder နဲ Jeffrey Baraclow က၊ security pattern တွနဲ ပတ်သက်တဲ့ “Architectural Patterns for Enabling Application Security” ဆိုတဲ့ စာတမ်းတစ်စောင်ကို ထုတေ်၀ခဲ့တယ်။
Design Pattern ဆိုတာ ဘာလဲ
ခရစ်စ်တိုဖာ အလက်စ်ဇန်းဒါး က Pattern ဆိုတာကို ဟာဒီလိုရှင်းပြပါတယ်။
“ပုံစံတိုင်း ပုံစံတိုင်းဟာ ပင်ပပတ်၀န်းကျင်မှာ ထပ်တလဲလဲ တွ ကြုံနေကျ ပဿနာကို ဖါ်ပြတယ်။ ပီးရင် အဲဒီပြဿနာရဲ့ တကယ့်ရင်းမြစ်အဖြေ ကို ဖါ်ပြတယ်။
အဲလိုနည်းနဲ ခင်ဗျားဟာ ဆင်တူအလုပ်တစ်ခုကို ဘယ်တော့မှ နှစ်ခါပြန်လုပ်စရာမလိုပဲ အဲဒီဖြေရှင်းနည်းကိုပဲ အကြိမ်ကြိမ် အထပ်ထပ် ပန်သုံးစွဲနိုင်တယ်”။
သူပြောတာကတော့ အဆောက်အဦးနဲ မို ရွာတည်ဆောက်ရေးကို ရည်ညွှန်းတာဖြစ်ပေမယ့်၊ အဲဒီစကားဟာ object oriented design pattern တွအတွက်လည်း လုံး၀မှန်ကန်တဲ့ စကားဖြစ်ပါတယ်။ နယ်ပယ်ခြင်းမတူပေမယ့် တကယ့်အနှစ်သာရကတော့ ပဿနာနဲ အဖြေ ဘယ်လို ဆက်စပ် ဖွဲ စည်း တည်ဆောက်ထားသလဲဆိုတာပါပဲ။ သူရည်ညွှန်းတဲ့ အဖြေဆိုတာ နံရံတွေ တံခါးပေါက်တွေ ဖစ်ပြီး၊ ကျွန်တော်တို ရဲ့ အဖြေဆိုတာကတော့၊ object တွ interface တွပေါ့။
ယေဘုယျအားဖြင့် pattern တစ်ခုမှာ အဓိက အစိပ်အပိုင်း ၄-ပိုင်း ပါ၀င်ပါတယ်။
၁. pattern ရဲ့ အမည်
၂. ဒီ pattern ဖစ်လာစေတဲ့ အရင်းခံ ပဿနာ
၃. အဲဒီပြဿနာအတွက် ဖရှင်းပုံ
၄. ဒီ pattern ကို သုံး လို ဖစ်လာတဲ့ အကျိုးဆက်တွေ
Software Design Pattern ဆိုတာ
class တွရဲ့ ဖွဲ စည်းတည်ဆောက်ပုံ နဲ object တွ အချင်းချင်း အပြန်အလှန် ဆက်သွယ်ပုံကို ဖါ်ပြထားတဲ့
ဆာ့ဖ်၀ဲလုပ်ငန်းခွင်ရဲ့ အရင် အတွေ အကြုံတွေအပေါ် အခြေခံပြီး၊ ယဘုယျ ပဿနာ နဲ ဖစ်နိုင်တဲ့ အဖြေကို ပုံစံတကျ ဖါ်ပြထားတဲ့
လက်တွေ ပင်ပလောကရဲ့ ဆာ့ဖ်၀ဲရေးသားထုတ်လုပ်မှု လုပ်ငန်းခွင်တွေမှာ၊ ထပ်တလဲလဲ တွ ကြုံနေရတဲ့ ဆာ့ဖ်၀ဲနဲ ပတ်သက်တဲ့ ဒီဇိုင်းပိုင်းဆိုင်ရာ ပဿနာတွေရဲ့ အဖြေ အဖြစ်၊ သင့်လျော်သလို ပန်လည်သုံးစွဲနိုင်တဲ့ ဆာ့ဖ်၀ဲဗိသုကာဒီဇိုင်းပုံစံ” ဖစ်ပါတယ်။
အတိုချုပ်ပြောရရင်တော့ “design pattern ဆိုတာ ဆာ့ဖ်၀ဲရေးသားထုတ်လုပ် တဲ့အခါ၊ ယဘုယျ ကြုံတွေ နကျ object-oriented design ပဿနာတွေကို ဘယ်လို ဖရှင်းမလဲ ဆိုတာ ပုံစံတကျဖေါ်ပြထားတဲ့ ဆာ့ဖ်၀ဲတည်ဆောက်မှုဆိုင်ရာ ဗိသုကာဒီဇိုင်းပုံစံ” ဖစ်ပါတယ်။
အခြေခံ Design Pattern ဘယ်နှစ်မျိုးရှိသလဲ
လေးဦးဂိုဏ်း ဖါ်ထုတ်တင်ပြခဲ့တဲ့ ဒီဇိုင်းပုံစံတွေဟာ ဒီကနေ ဆာ့ဖ်၀ဲလောကမှာရှိတဲ့ ဒီဇိုင်းပုံစံတွေအားလုံးရဲ့ အခြေခံပါ။ သူတို တင်ပြခဲ့တဲ့ Design Pattern စုစုပေါင်း ၂၃ မျိုးရှိပြီး အဲဒီ ၂၃ မျိုးကို အဓိကအုပ်စုကြီးသုံးစုအဖြစ် ခွဲခြားထားပါတယ်။ အဲဒါတွေကတော့
i. object တွကို ဘယ်လို စတင်ဖန်တီးတည်ဆောက် (instantiate) မလဲဆိုတာကို အဓိကထား ဖါ်ပြတဲ့ Creational Design Pattern
ii. class တွ object တွကို ဘယ်လို ဘယ်ပုံ ဖွဲ စည်းတည်ဆောက် ထားသလဲဆိုတာကို အဓိကထားဖေါ်ပြတဲ့ Structural Design Pattern နဲ
iii. Object တွ class တွရဲ့ အပြုအမူ လုပ်ကိုင်ဆောင်ရွက်ပုံ (ဘာတွေကို ဘယ်လိုလုပ်ကြသလဲဆိုတာ) ကို အဓိကထားဖေါ်ပြတဲ့ Behavioral Design Pattern
ဆိုပြီး ဖစ်ပါတယ်။
အောက်ပါဇယားမှာ GoF ရဲ့ ဒီဇိုင်းပုံစံ ၂၃ မျိုးကို အုပ်စု ၃-စု ခွဲပြီး ၊ အတိုချုပ် ရှင်းလင်းချက်နဲ တကွ ဖါ်ပြထားပါတယ်။
Creational Patterns
စဉ် အမည် အတိုချုပ် အဓိပ္ပါယ်
၁ Abstract Factory ဆက်နွယ်ပတ်သက်မှုရှိနေတဲ့ class တွအတွက် object ဆာက်တဲ့ ပုံစံ။
၂ Builder Object တည်ဆောက်တဲ့ နရာနဲ ကိုယ်စားပြုတဲ့ နရာ သပ်သပ်စီ ခွဲထားတဲ့ ပုံစံ။
၃ Factory Method အမွေယူထားတဲ့ class ပါင်းများစွာအတွက် object ဆာက်တဲ့ ပုံစံ။
၄ Prototype လုံး၀ ပီးပြည့်စုံတဲ့အဆင့်အထိ တည်ဆောက်ပြီးသား object တစ်ခုကို၊ ထပ်တူညီပွားယူတဲ့ ပုံစံ။
၅ Singleton class တစ်ခုအတွက် object တစ်ခုတိတိ ကိုပဲ တည်ဆောက်ခွင့်ပေးတဲ့ ပုံစံ။
Structural Patterns
စဉ် အမည် အတိုချုပ် အဓိပ္ပါယ်
6 Adapter မတူညီတဲ့ class တွအတွက်၊ သူတို အားလုံးနဲ ကိုက်ညီမယ့် interface တွ တည်ဆောက်တဲ့ ပုံစံ။
7 Bridge အသုံးပြုမယ့် object ရဲ့ interface နဲ ၊ အဲဒီ object ကိုယ်စားပြုတဲ့ class ကို သပ်သပ်စီ ခွဲထားတဲ့ ပုံစံ။
8 Composite သီးသန် တစ်ခုတည်းဖြစ်တဲ့ object တွနဲ ၊ တစ်ခုနဲ တစ်ခု တွဲဖက်ပူးပေါင်း နတဲ့ object တွရဲ့ tree structure ကို ဖါ်ပြတဲ့ ပုံစံ။
9 Decorator Object တစ်ခုရဲ့ ဆာင်ရွက်ရမယ့် လုပ်ငန်းတာ၀န်တွေကို၊ run time မှာ ထပ်ထည့်တဲ့ ပုံစံ။
10 Facade စနစ်ခွဲ (sub system) တစ်ခုလုံးကို class တစ်ခုတည်းက ကိုယ်စားပြုတဲ့ ပုံစံ။
11 Flyweight Object တွကို ထိထိရောက်ရောက် မျှေ၀သုံးစွဲနိုင်ဖို ချိန်ညှိထားတဲ့ပုံစံ။
12 Proxy Object တစ်ခုကို တခြား object တစ်ခုနဲ ကိုယ်စားပြု သုံးစွဲတဲ့ ပုံစံ။
Behavioral Patterns
စဉ် အမည် အတိုချုပ် အဓိပ္ပါယ်
13 Chain of Responsibilities တွဲစပ်နေတဲ့ object တွ အချင်းချင်းကြားမှာ လုပ်ငန်းတာ၀န်တွေကို လက်ဆင့်ကမ်းဖြန် ၀ လုပ်ဆောင်စေတဲ့ပုံစံ။
14 Command command request ကို object ထဲမှာ ဖုံးအုပ် ထည့်သွင်း တည်ဆောက်ထားတဲ့ပုံစံ။
15 Interpreter ပရိုဂရမ်ထဲမှာ ဘာသာစကားဆိုင်ရာ အစိပ်အပိုင်းကို ထည့်သွင်းတည်ဆောက်ထားတဲ့ပုံစံ။
16 Iterator အစုအေ၀းထဲမှာပါတဲ့ element တခုချင်းစီကို အစီအစဉ်အလိုက် ဆွဲယူအသုံးပြုတဲ့ပုံစံ။
17 Mediator class တွအချင်းချင်း ရိုးရှင်းတဲ့ ဆက်သွယ်မှုပုံစံကို သတ်မှတ်တဲ့ပုံစံ။
18 Memento လိုအပ်ရင် မူလအခြေအနေကို ပန်ရနိုင်အောင် object ရဲ့ အတွင်းပိုင်းအခြေအနေကို ရယူသိမ်းဆည်းထားတဲ့ပုံစံ။
19 Observer class တခုမှာ အပြောင်းအလဲတခုဖြစ်တိုင်း တခြား class တွကို တပြိုင်တည်း အသိပေး အကြောင်းကြားတဲ့ ပုံစံ။
20 State object တခုရဲ့ အခြေအနေပြောင်းရင် အပြုအမူကိုပါ ပာင်းစေတဲ့ ပုံစံ။
21 Strategy ပဿနာဖြေရှင်းပုံ algorithm ကို class ရဲ့ အတွင်းထဲမှာ ဖုံးအုပ် ထည့်သွင်း တည်ဆောက်ထားတဲ့ ပုံစံ။
22 Template Method ပဿနာဖြေရှင်းပုံ အသေးစိပ်အဆင့်တွေကို sub-class တွဆီ လွှဲပြောင်းပေးထားတဲ့ ပုံစံ။
23 Visitor class ကို ဘာမှ မပြောင်းစေပဲနဲ လုပ်ဆောင်ချက်အသစ်ကို သတ်မှတ်တဲ့ပုံစံ။
တိကျသေချာတဲ့ ဖွဲ စည်းမှု ပုံသဏ္ဍန် ပါ်လွင်ဖို နဲ ၊ အနက်အဓိပ္ပါယ်ကို ရှင်းလင်းစွာနားလည်သဘောပေါက်နိုင်ဖို ၊ Design Pattern တွကိုဖေါ်ထုတ်တင်ပြရာမှာ၊ အာက်ပါ အချက်တွေ ပါ၀င်သင့်တယ်လို GoF က ဆိုပါတယ်။
1. Intent (အကျဉ်းချုပ် ရှင်းလင်းချက်)
2. Motivation (နောက်ခံပြဿနာနဲ ဖရှင်းပုံ)
3. Applicability (လက်တွေ အသုံးချနိုင်မှု အနေအထား)
4. Structure (ဖွဲ စည်းတည်ဆောက်ပုံ)
5. Participants (ပါ၀င်တဲ့ class, object, interface တွ)
6. Collaborations (class တွ object တွ အချင်းချင်း ပူးပေါင်းလုပ်ဆောင်ပုံ)
7. Consequences (အကျိုးဆက်)
8. Implementation (အကောင်အထည်ဖေါ်ဆောင်ရွက်မှုပုံစံ)
9. Sample Code (နမူနာ ကုဒ်)
10. Known Uses (ပြင်ပလောက ရဲ့ သုံးစွဲမှုများ)
11. Related Patterns (ဆက်စပ်ပုံစံများ)
ဆိုပြီးဖြစ်ပါတယ်။
ကဲ ဒီတော့ ပထမဆုံး အနေနဲ Creational patterns အုပ်စုထဲက အတော်အတန် ရိုးရှင်းလွယ်ကူတဲ့ Factory Design Pattern အကြောင်းကို ကျွန်တော်တို စတင်လေ့လာကြည့်ကြပါစို ။ တကယ်တော့ မိတ်ဆွေတို သိတဲ့အတိုင်း အထက်မှာတင်ပြခဲ့သလိုပဲ creational design pattern ဆိုတာ “ဆော့ဖ်၀ဲစနစ်တခုအတွင်းမှာ၊ ကိုယ်လိုအပ်တဲ့ အခြေအနေနဲ သင့်တော်မယ့် လိုက်လျောညီထွေဖြစ်မယ့် object ကို ဘယ်လို တည်ဆောက်မလဲ ဆိုတဲ့ object တည်ဆောက်တဲ့ နည်းစနစ်တွေနဲ ပတ်သက်ပြီး အထူးပြုလေ့လာတဲ့ ဒီဇိုင်းပုံစံ” တခုပါ။ “ဒီ object ဆာက်တာများ ဘာဆန်းလို ဒီလို တကူးတက တသီးတသန် ကြီး လုပ်နေရတာတုန်း” လို မိတ်ဆွေတို ထင်ကောင်းထင်ပါလိမ့်မယ်။ တကယ်တော့ ဒီဇိုင်းပိုင်းဆိုင်ရာပြဿနာတွေနဲ ဒီဇိုင်းရှုပ်ထွေးမှုကိုဖြစ်စေတာ အဲဒီ object တည်ဆောက်တဲ့ အခြေခံပုံစံတွေ ကိုယ်တိုင်ပါပဲ။ ဒါကြောင့် object တည်ဆောက်ပုံကို ထိန်းချုပ်တဲ့ ဒီ creational design pattern တွကို software complexity ကို လျာ့ချနိုင်ဖို နဲ ဆာ့ဖ်၀ဲဒီဇိုင်းပိုင်းဆိုင်ရာပြဿနာတွေ ဖရှင်းနိုင်ဖို အသုံးချနိုင်ပါတယ်။
Factory Design Pattern
Object တည်ဆောက်နိုင်ဖို အတွက် interface တစ်ခုကို ဖန်တီးပေးထားပါတယ်။ ဒါပေမယ့် ဘယ် object ကို ဆာက်မလဲဆိုတာတော့ sub-class, child-class တွကို ရွးချယ် ဆုံးဖြတ်ခွင့် ပးထားပါတယ်။ ဒီ factory method ကို virtual constructor လို လဲ လူသိများပါတယ်။ ဘာလို လဲဆိုတော့ ဒီ pattern ဟာ constructor ကို အစားထိုးဖို အတွက်သုံးတာဖြစ်လို ပါ။ ပီးတော့လည်း ဒီ ဒီဇိုင်းပုံစံဟာ object တွကို create လုပ်ရာမှာ design time မှာထက် run time ရာက်မှ instantiate လုပ်ခွင့်ပေးထားတဲ့အတွက်၊ class ရဲ့ object creation ကို ကြိုတင်ပြီး ပုံသေ သတ်မှတ်ထားတာမျိုးမဟုတ်ပဲ၊ လိုအပ်တော့မှ လိုအပ်သလို ထိန်းချုပ်တည်ဆောက်တာမျိုးဖြစ်ပါတယ်။
using System;
usingSystem.Collections.Generic;
namespaceInfoTherapy.DesignPattern.Factory
{
public interface IEmployee
{
doubleSalary { get; }
}
public class ProjectManager: IEmployee
{
public double Salary
{
get{ return 100.00; }
}
}
public class Developer : IEmployee
{
public double Salary
{
get { return 75.00; }
}
}
public class DBA : IEmployee
{
public double Salary
{
get{ return 70.00; }
}
}
public class EmployeeFactory
{
public enum EmployeeType
{
ProjectManager,
Developer,
DBA
}
public static IEmployeegetEmployee(EmployeeType empType)
{
IEmployeeemployee = null;
switch(empType)
{
case EmployeeType.ProjectManager:
employee = new ProjectManager();
break;
caseEmployeeType.Developer:
employee = new Developer();
break;
caseEmployeeType.DBA:
employee = new DBA();
break;
default:
thrownew ArgumentException(string.Format(
"An employee of type {0} cannot be found",
Enum.GetName(typeof(EmployeeType), empType)));
}
returnemployee;
}
}
class FactoryDPDemo
{
static void Main(string[] args)
{
Dictionary<EmployeeFactory.EmployeeType, IEmployee> employees =
newDictionary<EmployeeFactory.EmployeeType, IEmployee>();
//let's create a new employee for each available employee type.
//Each item is insatantiated without the client needing to know
//what type of object is being created.
//this is handled by the factory method
foreach(EmployeeFactory.EmployeeTypeeType in
Enum.GetValues(typeof(EmployeeFactory.EmployeeType)))
{
employees.Add(eType, EmployeeFactory.getEmployee(eType));
}
//now let's iterate through our dictionary and
//diplay the base salary for each factory object
foreach(EmployeeFactory.EmployeeTypetype in employees.Keys)
Console.WriteLine(string.Format(
"The basic salary for {0} is {1:C} per hour.",
type, employees[type].Salary));
Console.ReadKey();
}
}
}
ဆက်လက်တင်ပြပါမည်။
ရွှင်လန်းချမ်းမြေ့ပါစေ။
infoTherapy-2015
• ၁၉၇၇-၇၉ မှာ ဗိသုကာပညာရှင် ခရစ်စ်တိုဖာ အလက်စ်ဇန်းဒါး Christopher Wolfgang Alexander (born in October 4th, 1936 in Vienna, Austria) က၊ အဆောက်အဦး နဲ မို့ရွာတည်ဆောက်မှုဆိုင်ရာ ဒီဇိုင်းပုံစံ နဲ ပတ်သက်တဲ့ အတွေးအခေါ် အယူအဆ တစ်ရပ်ကို “A Pattern Language: Towns, Buildings, Construction” ဆိုတဲ့ စာတမ်းမှာ တင်ပြခဲ့တယ်။
• အဲဒီအတွေးအခေါ် အယူအဆ သဘောတရားတွေကို အခြေခံပြီး အမေရိကန် ေဆာ့ဖ်၀ဲအင်ဂျင်နီယာတွေဖြစ်တဲ့ Kent Beck နဲ Ward Cunningham တို က၊ object oriented programming ရးသားတဲ့ နရာမှာ ‘pattern’ တွ အသုံးချကြည့်တဲ့နည်းလမ်းတွေကို စမ်းသပ်ခဲ့ပြီး၊ “Using Pattern Languages for Object-Oriented Programs” ဆို တဲ့ စာတမ်းတစ်စောင်ကို ၁၉၈၇ မှာ ACM(Association for Computing Machinery) ကဦးစီးကျင်းပတဲ့၊ OOPSLA (Object Oriented Programming, Systems, Languages and Applications) ကွန်ဖရင့် မှာ တင်သွင်းခဲ့ပါတယ်။
• ၁၉၈၀ နှာင်းပိုင်းနဲ ၁၉၉၀ အစောပိုင်း ကာလတွေမှာ ဆာ့ဖ်၀ဲအင်ဂျင်နီယာတွေ နဲ ဆာ့ဖ်၀ဲဗိသုကာတွေက ဆာ့ဖ်၀ဲ ရးသား တည်ဆောက်ရာမှာ သုံးတဲ့ ဗိသုကာပုံစံတွေ ကို ခွဲခြားစိစစ်ပြီး ၎င်းတို ကိုသုံးစွဲတဲ့ နရာမှာ တွ ကြုံရတဲ့ ပဿနာ တွနဲ ပတ်သက်လို အသေးစိပ် စတင် လ့လာခဲ့ကြတယ်။
• ၁၉၉၅ ခုနှစ်မှာတော့၊ ဒီကနေ ခတ် ဆာ့ဖ်၀ဲအင်ဂျင်နီယာပညာရပ်နယ်ပယ်ရဲ့ ဂန္ထ၀င်စာအုပ် “Design Pattern : Elements of Reusable Object-Oriented Software” ကို Erich Gamma, Richard Helm, Ralph Johnson နဲ John Vlissides တို က ရးသားထုတေ်၀ခဲ့တယ်။ အဲဒီပုဂ္ဂိုလ် လးရောက်ကို ဆာ့ဖ်၀ဲဒီဇိုင်းလောကမှာ လးဦးဂိုဏ်း (Gang of Four - GoF) လို ခါ်ကြတယ်။
• ၁၉၉၇ မှာ Joseph Yoder နဲ Jeffrey Baraclow က၊ security pattern တွနဲ ပတ်သက်တဲ့ “Architectural Patterns for Enabling Application Security” ဆိုတဲ့ စာတမ်းတစ်စောင်ကို ထုတေ်၀ခဲ့တယ်။
Design Pattern ဆိုတာ ဘာလဲ
ခရစ်စ်တိုဖာ အလက်စ်ဇန်းဒါး က Pattern ဆိုတာကို ဟာဒီလိုရှင်းပြပါတယ်။
“ပုံစံတိုင်း ပုံစံတိုင်းဟာ ပင်ပပတ်၀န်းကျင်မှာ ထပ်တလဲလဲ တွ ကြုံနေကျ ပဿနာကို ဖါ်ပြတယ်။ ပီးရင် အဲဒီပြဿနာရဲ့ တကယ့်ရင်းမြစ်အဖြေ ကို ဖါ်ပြတယ်။
အဲလိုနည်းနဲ ခင်ဗျားဟာ ဆင်တူအလုပ်တစ်ခုကို ဘယ်တော့မှ နှစ်ခါပြန်လုပ်စရာမလိုပဲ အဲဒီဖြေရှင်းနည်းကိုပဲ အကြိမ်ကြိမ် အထပ်ထပ် ပန်သုံးစွဲနိုင်တယ်”။
သူပြောတာကတော့ အဆောက်အဦးနဲ မို ရွာတည်ဆောက်ရေးကို ရည်ညွှန်းတာဖြစ်ပေမယ့်၊ အဲဒီစကားဟာ object oriented design pattern တွအတွက်လည်း လုံး၀မှန်ကန်တဲ့ စကားဖြစ်ပါတယ်။ နယ်ပယ်ခြင်းမတူပေမယ့် တကယ့်အနှစ်သာရကတော့ ပဿနာနဲ အဖြေ ဘယ်လို ဆက်စပ် ဖွဲ စည်း တည်ဆောက်ထားသလဲဆိုတာပါပဲ။ သူရည်ညွှန်းတဲ့ အဖြေဆိုတာ နံရံတွေ တံခါးပေါက်တွေ ဖစ်ပြီး၊ ကျွန်တော်တို ရဲ့ အဖြေဆိုတာကတော့၊ object တွ interface တွပေါ့။
ယေဘုယျအားဖြင့် pattern တစ်ခုမှာ အဓိက အစိပ်အပိုင်း ၄-ပိုင်း ပါ၀င်ပါတယ်။
၁. pattern ရဲ့ အမည်
၂. ဒီ pattern ဖစ်လာစေတဲ့ အရင်းခံ ပဿနာ
၃. အဲဒီပြဿနာအတွက် ဖရှင်းပုံ
၄. ဒီ pattern ကို သုံး လို ဖစ်လာတဲ့ အကျိုးဆက်တွေ
Software Design Pattern ဆိုတာ
class တွရဲ့ ဖွဲ စည်းတည်ဆောက်ပုံ နဲ object တွ အချင်းချင်း အပြန်အလှန် ဆက်သွယ်ပုံကို ဖါ်ပြထားတဲ့
ဆာ့ဖ်၀ဲလုပ်ငန်းခွင်ရဲ့ အရင် အတွေ အကြုံတွေအပေါ် အခြေခံပြီး၊ ယဘုယျ ပဿနာ နဲ ဖစ်နိုင်တဲ့ အဖြေကို ပုံစံတကျ ဖါ်ပြထားတဲ့
လက်တွေ ပင်ပလောကရဲ့ ဆာ့ဖ်၀ဲရေးသားထုတ်လုပ်မှု လုပ်ငန်းခွင်တွေမှာ၊ ထပ်တလဲလဲ တွ ကြုံနေရတဲ့ ဆာ့ဖ်၀ဲနဲ ပတ်သက်တဲ့ ဒီဇိုင်းပိုင်းဆိုင်ရာ ပဿနာတွေရဲ့ အဖြေ အဖြစ်၊ သင့်လျော်သလို ပန်လည်သုံးစွဲနိုင်တဲ့ ဆာ့ဖ်၀ဲဗိသုကာဒီဇိုင်းပုံစံ” ဖစ်ပါတယ်။
အတိုချုပ်ပြောရရင်တော့ “design pattern ဆိုတာ ဆာ့ဖ်၀ဲရေးသားထုတ်လုပ် တဲ့အခါ၊ ယဘုယျ ကြုံတွေ နကျ object-oriented design ပဿနာတွေကို ဘယ်လို ဖရှင်းမလဲ ဆိုတာ ပုံစံတကျဖေါ်ပြထားတဲ့ ဆာ့ဖ်၀ဲတည်ဆောက်မှုဆိုင်ရာ ဗိသုကာဒီဇိုင်းပုံစံ” ဖစ်ပါတယ်။
အခြေခံ Design Pattern ဘယ်နှစ်မျိုးရှိသလဲ
လေးဦးဂိုဏ်း ဖါ်ထုတ်တင်ပြခဲ့တဲ့ ဒီဇိုင်းပုံစံတွေဟာ ဒီကနေ ဆာ့ဖ်၀ဲလောကမှာရှိတဲ့ ဒီဇိုင်းပုံစံတွေအားလုံးရဲ့ အခြေခံပါ။ သူတို တင်ပြခဲ့တဲ့ Design Pattern စုစုပေါင်း ၂၃ မျိုးရှိပြီး အဲဒီ ၂၃ မျိုးကို အဓိကအုပ်စုကြီးသုံးစုအဖြစ် ခွဲခြားထားပါတယ်။ အဲဒါတွေကတော့
i. object တွကို ဘယ်လို စတင်ဖန်တီးတည်ဆောက် (instantiate) မလဲဆိုတာကို အဓိကထား ဖါ်ပြတဲ့ Creational Design Pattern
ii. class တွ object တွကို ဘယ်လို ဘယ်ပုံ ဖွဲ စည်းတည်ဆောက် ထားသလဲဆိုတာကို အဓိကထားဖေါ်ပြတဲ့ Structural Design Pattern နဲ
iii. Object တွ class တွရဲ့ အပြုအမူ လုပ်ကိုင်ဆောင်ရွက်ပုံ (ဘာတွေကို ဘယ်လိုလုပ်ကြသလဲဆိုတာ) ကို အဓိကထားဖေါ်ပြတဲ့ Behavioral Design Pattern
ဆိုပြီး ဖစ်ပါတယ်။
အောက်ပါဇယားမှာ GoF ရဲ့ ဒီဇိုင်းပုံစံ ၂၃ မျိုးကို အုပ်စု ၃-စု ခွဲပြီး ၊ အတိုချုပ် ရှင်းလင်းချက်နဲ တကွ ဖါ်ပြထားပါတယ်။
Creational Patterns
စဉ် အမည် အတိုချုပ် အဓိပ္ပါယ်
၁ Abstract Factory ဆက်နွယ်ပတ်သက်မှုရှိနေတဲ့ class တွအတွက် object ဆာက်တဲ့ ပုံစံ။
၂ Builder Object တည်ဆောက်တဲ့ နရာနဲ ကိုယ်စားပြုတဲ့ နရာ သပ်သပ်စီ ခွဲထားတဲ့ ပုံစံ။
၃ Factory Method အမွေယူထားတဲ့ class ပါင်းများစွာအတွက် object ဆာက်တဲ့ ပုံစံ။
၄ Prototype လုံး၀ ပီးပြည့်စုံတဲ့အဆင့်အထိ တည်ဆောက်ပြီးသား object တစ်ခုကို၊ ထပ်တူညီပွားယူတဲ့ ပုံစံ။
၅ Singleton class တစ်ခုအတွက် object တစ်ခုတိတိ ကိုပဲ တည်ဆောက်ခွင့်ပေးတဲ့ ပုံစံ။
Structural Patterns
စဉ် အမည် အတိုချုပ် အဓိပ္ပါယ်
6 Adapter မတူညီတဲ့ class တွအတွက်၊ သူတို အားလုံးနဲ ကိုက်ညီမယ့် interface တွ တည်ဆောက်တဲ့ ပုံစံ။
7 Bridge အသုံးပြုမယ့် object ရဲ့ interface နဲ ၊ အဲဒီ object ကိုယ်စားပြုတဲ့ class ကို သပ်သပ်စီ ခွဲထားတဲ့ ပုံစံ။
8 Composite သီးသန် တစ်ခုတည်းဖြစ်တဲ့ object တွနဲ ၊ တစ်ခုနဲ တစ်ခု တွဲဖက်ပူးပေါင်း နတဲ့ object တွရဲ့ tree structure ကို ဖါ်ပြတဲ့ ပုံစံ။
9 Decorator Object တစ်ခုရဲ့ ဆာင်ရွက်ရမယ့် လုပ်ငန်းတာ၀န်တွေကို၊ run time မှာ ထပ်ထည့်တဲ့ ပုံစံ။
10 Facade စနစ်ခွဲ (sub system) တစ်ခုလုံးကို class တစ်ခုတည်းက ကိုယ်စားပြုတဲ့ ပုံစံ။
11 Flyweight Object တွကို ထိထိရောက်ရောက် မျှေ၀သုံးစွဲနိုင်ဖို ချိန်ညှိထားတဲ့ပုံစံ။
12 Proxy Object တစ်ခုကို တခြား object တစ်ခုနဲ ကိုယ်စားပြု သုံးစွဲတဲ့ ပုံစံ။
Behavioral Patterns
စဉ် အမည် အတိုချုပ် အဓိပ္ပါယ်
13 Chain of Responsibilities တွဲစပ်နေတဲ့ object တွ အချင်းချင်းကြားမှာ လုပ်ငန်းတာ၀န်တွေကို လက်ဆင့်ကမ်းဖြန် ၀ လုပ်ဆောင်စေတဲ့ပုံစံ။
14 Command command request ကို object ထဲမှာ ဖုံးအုပ် ထည့်သွင်း တည်ဆောက်ထားတဲ့ပုံစံ။
15 Interpreter ပရိုဂရမ်ထဲမှာ ဘာသာစကားဆိုင်ရာ အစိပ်အပိုင်းကို ထည့်သွင်းတည်ဆောက်ထားတဲ့ပုံစံ။
16 Iterator အစုအေ၀းထဲမှာပါတဲ့ element တခုချင်းစီကို အစီအစဉ်အလိုက် ဆွဲယူအသုံးပြုတဲ့ပုံစံ။
17 Mediator class တွအချင်းချင်း ရိုးရှင်းတဲ့ ဆက်သွယ်မှုပုံစံကို သတ်မှတ်တဲ့ပုံစံ။
18 Memento လိုအပ်ရင် မူလအခြေအနေကို ပန်ရနိုင်အောင် object ရဲ့ အတွင်းပိုင်းအခြေအနေကို ရယူသိမ်းဆည်းထားတဲ့ပုံစံ။
19 Observer class တခုမှာ အပြောင်းအလဲတခုဖြစ်တိုင်း တခြား class တွကို တပြိုင်တည်း အသိပေး အကြောင်းကြားတဲ့ ပုံစံ။
20 State object တခုရဲ့ အခြေအနေပြောင်းရင် အပြုအမူကိုပါ ပာင်းစေတဲ့ ပုံစံ။
21 Strategy ပဿနာဖြေရှင်းပုံ algorithm ကို class ရဲ့ အတွင်းထဲမှာ ဖုံးအုပ် ထည့်သွင်း တည်ဆောက်ထားတဲ့ ပုံစံ။
22 Template Method ပဿနာဖြေရှင်းပုံ အသေးစိပ်အဆင့်တွေကို sub-class တွဆီ လွှဲပြောင်းပေးထားတဲ့ ပုံစံ။
23 Visitor class ကို ဘာမှ မပြောင်းစေပဲနဲ လုပ်ဆောင်ချက်အသစ်ကို သတ်မှတ်တဲ့ပုံစံ။
တိကျသေချာတဲ့ ဖွဲ စည်းမှု ပုံသဏ္ဍန် ပါ်လွင်ဖို နဲ ၊ အနက်အဓိပ္ပါယ်ကို ရှင်းလင်းစွာနားလည်သဘောပေါက်နိုင်ဖို ၊ Design Pattern တွကိုဖေါ်ထုတ်တင်ပြရာမှာ၊ အာက်ပါ အချက်တွေ ပါ၀င်သင့်တယ်လို GoF က ဆိုပါတယ်။
1. Intent (အကျဉ်းချုပ် ရှင်းလင်းချက်)
2. Motivation (နောက်ခံပြဿနာနဲ ဖရှင်းပုံ)
3. Applicability (လက်တွေ အသုံးချနိုင်မှု အနေအထား)
4. Structure (ဖွဲ စည်းတည်ဆောက်ပုံ)
5. Participants (ပါ၀င်တဲ့ class, object, interface တွ)
6. Collaborations (class တွ object တွ အချင်းချင်း ပူးပေါင်းလုပ်ဆောင်ပုံ)
7. Consequences (အကျိုးဆက်)
8. Implementation (အကောင်အထည်ဖေါ်ဆောင်ရွက်မှုပုံစံ)
9. Sample Code (နမူနာ ကုဒ်)
10. Known Uses (ပြင်ပလောက ရဲ့ သုံးစွဲမှုများ)
11. Related Patterns (ဆက်စပ်ပုံစံများ)
ဆိုပြီးဖြစ်ပါတယ်။
ကဲ ဒီတော့ ပထမဆုံး အနေနဲ Creational patterns အုပ်စုထဲက အတော်အတန် ရိုးရှင်းလွယ်ကူတဲ့ Factory Design Pattern အကြောင်းကို ကျွန်တော်တို စတင်လေ့လာကြည့်ကြပါစို ။ တကယ်တော့ မိတ်ဆွေတို သိတဲ့အတိုင်း အထက်မှာတင်ပြခဲ့သလိုပဲ creational design pattern ဆိုတာ “ဆော့ဖ်၀ဲစနစ်တခုအတွင်းမှာ၊ ကိုယ်လိုအပ်တဲ့ အခြေအနေနဲ သင့်တော်မယ့် လိုက်လျောညီထွေဖြစ်မယ့် object ကို ဘယ်လို တည်ဆောက်မလဲ ဆိုတဲ့ object တည်ဆောက်တဲ့ နည်းစနစ်တွေနဲ ပတ်သက်ပြီး အထူးပြုလေ့လာတဲ့ ဒီဇိုင်းပုံစံ” တခုပါ။ “ဒီ object ဆာက်တာများ ဘာဆန်းလို ဒီလို တကူးတက တသီးတသန် ကြီး လုပ်နေရတာတုန်း” လို မိတ်ဆွေတို ထင်ကောင်းထင်ပါလိမ့်မယ်။ တကယ်တော့ ဒီဇိုင်းပိုင်းဆိုင်ရာပြဿနာတွေနဲ ဒီဇိုင်းရှုပ်ထွေးမှုကိုဖြစ်စေတာ အဲဒီ object တည်ဆောက်တဲ့ အခြေခံပုံစံတွေ ကိုယ်တိုင်ပါပဲ။ ဒါကြောင့် object တည်ဆောက်ပုံကို ထိန်းချုပ်တဲ့ ဒီ creational design pattern တွကို software complexity ကို လျာ့ချနိုင်ဖို နဲ ဆာ့ဖ်၀ဲဒီဇိုင်းပိုင်းဆိုင်ရာပြဿနာတွေ ဖရှင်းနိုင်ဖို အသုံးချနိုင်ပါတယ်။
Factory Design Pattern
Object တည်ဆောက်နိုင်ဖို အတွက် interface တစ်ခုကို ဖန်တီးပေးထားပါတယ်။ ဒါပေမယ့် ဘယ် object ကို ဆာက်မလဲဆိုတာတော့ sub-class, child-class တွကို ရွးချယ် ဆုံးဖြတ်ခွင့် ပးထားပါတယ်။ ဒီ factory method ကို virtual constructor လို လဲ လူသိများပါတယ်။ ဘာလို လဲဆိုတော့ ဒီ pattern ဟာ constructor ကို အစားထိုးဖို အတွက်သုံးတာဖြစ်လို ပါ။ ပီးတော့လည်း ဒီ ဒီဇိုင်းပုံစံဟာ object တွကို create လုပ်ရာမှာ design time မှာထက် run time ရာက်မှ instantiate လုပ်ခွင့်ပေးထားတဲ့အတွက်၊ class ရဲ့ object creation ကို ကြိုတင်ပြီး ပုံသေ သတ်မှတ်ထားတာမျိုးမဟုတ်ပဲ၊ လိုအပ်တော့မှ လိုအပ်သလို ထိန်းချုပ်တည်ဆောက်တာမျိုးဖြစ်ပါတယ်။
using System;
usingSystem.Collections.Generic;
namespaceInfoTherapy.DesignPattern.Factory
{
public interface IEmployee
{
doubleSalary { get; }
}
public class ProjectManager: IEmployee
{
public double Salary
{
get{ return 100.00; }
}
}
public class Developer : IEmployee
{
public double Salary
{
get { return 75.00; }
}
}
public class DBA : IEmployee
{
public double Salary
{
get{ return 70.00; }
}
}
public class EmployeeFactory
{
public enum EmployeeType
{
ProjectManager,
Developer,
DBA
}
public static IEmployeegetEmployee(EmployeeType empType)
{
IEmployeeemployee = null;
switch(empType)
{
case EmployeeType.ProjectManager:
employee = new ProjectManager();
break;
caseEmployeeType.Developer:
employee = new Developer();
break;
caseEmployeeType.DBA:
employee = new DBA();
break;
default:
thrownew ArgumentException(string.Format(
"An employee of type {0} cannot be found",
Enum.GetName(typeof(EmployeeType), empType)));
}
returnemployee;
}
}
class FactoryDPDemo
{
static void Main(string[] args)
{
Dictionary<EmployeeFactory.EmployeeType, IEmployee> employees =
newDictionary<EmployeeFactory.EmployeeType, IEmployee>();
//let's create a new employee for each available employee type.
//Each item is insatantiated without the client needing to know
//what type of object is being created.
//this is handled by the factory method
foreach(EmployeeFactory.EmployeeTypeeType in
Enum.GetValues(typeof(EmployeeFactory.EmployeeType)))
{
employees.Add(eType, EmployeeFactory.getEmployee(eType));
}
//now let's iterate through our dictionary and
//diplay the base salary for each factory object
foreach(EmployeeFactory.EmployeeTypetype in employees.Keys)
Console.WriteLine(string.Format(
"The basic salary for {0} is {1:C} per hour.",
type, employees[type].Salary));
Console.ReadKey();
}
}
}
ဆက်လက်တင်ပြပါမည်။
ရွှင်လန်းချမ်းမြေ့ပါစေ။
infoTherapy-2015