Dynamics AX 2012 တွင် Instantiate လုပ်ရန် မည်သည့် Subclass ကိုရှာဖွေရန် SysExtension Framework ကိုအသုံးပြုခြင်း

ထုတ်ဝေသည်- ၂၀၂၅၊ ဖေဖော်ဝါရီ ၁၆ UTC ၀၀:၃၀:၁၁
နောက်ဆုံး မွမ်းမံပြင်ဆင်သည်- ၂၀၂၆၊ ဇန်နဝါရီ ၁၂ UTC ၀၈:၄၃:၅၀

ဤဆောင်းပါးသည် Dynamics AX 2012 နှင့် Dynamics 365 for Operations တွင် လူသိနည်းသော SysExtension framework ကို အသုံးပြု၍ attribute decorations များအပေါ်အခြေခံ၍ sub class များကို မည်သို့ instantiate လုပ်ရမည်ကို ရှင်းပြထားပြီး၊ processing class hierarchy ၏ အလွယ်တကူ တိုးချဲ့နိုင်သော ဒီဇိုင်းကို ခွင့်ပြုသည်။

ဤစာမျက်နှာကို လူများတတ်နိုင်သမျှ ဝင်ရောက်ကြည့်ရှုနိုင်စေရန်အတွက် ဤစာမျက်နှာကို အင်္ဂလိပ်မှ စက်ဖြင့် ဘာသာပြန်ထားခြင်းဖြစ်ပါသည်။ ကံမကောင်းစွာဖြင့်၊ စက်ဘာသာပြန်ခြင်းသည် ပြီးပြည့်စုံသောနည်းပညာမဟုတ်သေးသောကြောင့် အမှားအယွင်းများဖြစ်ပေါ်လာနိုင်သည်။ သင်နှစ်သက်ပါက မူရင်းအင်္ဂလိပ်ဗားရှင်းကို ဤနေရာတွင် ကြည့်ရှုနိုင်ပါသည်။

Using the SysExtension Framework to Find Out Which Subclass to Instantiate in Dynamics AX 2012

ဤပို့စ်ရှိ အချက်အလက်များသည် Dynamics AX 2012 R3 ကို အခြေခံထားပါသည်။ အခြားဗားရှင်းများအတွက် မှန်ကန်နိုင်သည် သို့မဟုတ် မမှန်ကန်နိုင်ပါ။ (အပ်ဒိတ်- ဤဆောင်းပါးရှိ အချက်အလက်များသည် Dynamics 365 for Operations အတွက်လည်း မှန်ကန်ကြောင်း ကျွန်ုပ် အတည်ပြုနိုင်ပါသည်)

Dynamics AX မှာ processing class တွေကို implement လုပ်တဲ့အခါ subclass တစ်ခုချင်းစီဟာ enum value နဲ့ ကိုက်ညီတဲ့ ဒါမှမဟုတ် တခြား data coupling တွေပါဝင်တဲ့ class hierarchy တစ်ခု ဖန်တီးရတာနဲ့ မကြာခဏ ကြုံတွေ့ရလေ့ရှိပါတယ်။ classic design ကတော့ super class မှာ construct method တစ်ခု ရှိဖို့ဖြစ်ပြီး input ပေါ်မူတည်ပြီး ဘယ် class ကို instantiate လုပ်ရမလဲဆိုတာကို ဆုံးဖြတ်ပေးတဲ့ switch တစ်ခု ရှိပါတယ်။

ဒါက အခြေခံအားဖြင့် ကောင်းကောင်းအလုပ်လုပ်ပါတယ်၊ ဒါပေမယ့် input အမျိုးမျိုး (enum ထဲက element အများအပြား ဒါမှမဟုတ် input က တန်ဖိုးအမျိုးမျိုးပေါင်းစပ်ထားတာ) ရှိရင် ထိန်းသိမ်းရတာ ငြီးငွေ့စရာကောင်းပြီး အမှားအယွင်းများနိုင်ပါတယ်။ ဒီဇိုင်းမှာ အမြဲတမ်း အားနည်းချက်တစ်ခုရှိပါတယ်။ subclass အသစ်တစ်ခုထည့်ရင် ဒါမှမဟုတ် ဘယ် input ကိုအခြေခံပြီး ဘယ် subclass ကိုသုံးသင့်လဲဆိုတာ ပြောင်းလဲရင် construct method ကို ပြုပြင်ဖို့ လိုအပ်ပါလိမ့်မယ်။

ကံကောင်းထောက်မစွာ၊ SysExtension framework ကို အသုံးပြုခြင်းဖြင့် ပိုမိုကြော့ရှင်းသော်လည်း၊ ဝမ်းနည်းစရာကောင်းသည်မှာ လူသိနည်းသော နည်းလမ်းတစ်ခုရှိသည်။

ဒီ framework က သင့်ရဲ့ sub class တွေကို အလှဆင်ဖို့ အသုံးပြုနိုင်တဲ့ attribute တွေကို အသုံးချပြီး system က ဘယ် sub class ကို ဘာကိုကိုင်တွယ်ရမလဲဆိုတာ ဆုံးဖြတ်နိုင်အောင် လုပ်ပေးပါတယ်။ construct method တစ်ခု လိုအပ်ဦးမှာပါ။ ဒါပေမယ့် မှန်ကန်စွာလုပ်ဆောင်မယ်ဆိုရင် sub class အသစ်တွေထပ်ထည့်တဲ့အခါ ပြင်ဆင်စရာ မလိုပါဘူး။

စိတ်ကူးယဉ် ဥပမာတစ်ခုကို ကြည့်ပြီး InventTrans ဇယားကို အခြေခံပြီး တစ်ခုခုသော လုပ်ဆောင်မှုမျိုးကို လုပ်ဆောင်တဲ့ အဆင့်ဆင့်ကို အကောင်အထည်ဖော်မယ်လို့ ဆိုကြပါစို့။ ဘယ်လုပ်ဆောင်မှုကို လုပ်ဆောင်ရမလဲဆိုတာက မှတ်တမ်းတွေရဲ့ StatusReceipt နဲ့ StatusIssue ပေါ်မှာ မူတည်သလို မှတ်တမ်းတွေက SalesLine၊ PurchLine နဲ့ ဆက်စပ်မှု ရှိ၊ မရှိပေါ်မှာလည်း မူတည်ပါတယ်။ အခုဆို ပေါင်းစပ်မှု အမျိုးမျိုးကို သင်ကြည့်ရှုနေပါပြီ။

ဒါဆိုရင် လောလောဆယ်မှာ ပေါင်းစပ်မှုအနည်းငယ်ကိုသာ ကိုင်တွယ်ဖို့ လိုအပ်တယ်ဆိုတာ သင်သိပါတယ်၊ ဒါပေမယ့် အချိန်ကြာလာတာနဲ့အမျှ ပေါင်းစပ်မှုတွေကို ပိုမိုကိုင်တွယ်နိုင်ဖို့ တောင်းဆိုခံရမယ်ဆိုတာလည်း သင်သိပါတယ်လို့ ပြောရအောင်။

လောလောဆယ်တော့ SalesLine နဲ့ ဆက်စပ်နေတဲ့ ReservPhysical ဒါမှမဟုတ် ReservOrdered ဆိုတဲ့ StatusIssue နဲ့ မှတ်တမ်းတွေကိုပဲ ကိုင်တွယ်ရမှာဖြစ်ပြီး တခြားပေါင်းစပ်မှုတွေအားလုံးကိုတော့ လျစ်လျူရှုထားလို့ရပါတယ်၊ ဒါပေမယ့် နောက်မှ ကိုင်တွယ်ရမယ်ဆိုတာ သိထားတဲ့အတွက် ကုဒ်ကို အလွယ်တကူ တိုးချဲ့အသုံးပြုနိုင်အောင် ဒီဇိုင်းဆွဲထားသင့်ပါတယ်။

သင့်ရဲ့ အဆင့်အတန်းဟာ အခုအချိန်မှာ ဒီလိုပုံစံမျိုး ဖြစ်နိုင်ပါတယ်။

ကျွန်ုပ်၏ပရိုဆက်ဆာကျွန်ုပ်၏ပရိုဆက်ဆာ_အရောင်းကျွန်ုပ်၏ပရိုဆက်ဆာ_အရောင်း_အရန်မှာယူထားသောကျွန်ုပ်၏ပရိုဆက်ဆာ_အရောင်း_အရန်ရုပ်ပိုင်းဆိုင်ရာ

အခုဆိုရင် ModuleInventPurchSales နဲ့ StatusIssue enum ကိုအခြေခံပြီး subclass တစ်ခုကို instantiate လုပ်တဲ့ method တစ်ခုကို super class မှာ အလွယ်တကူ implement လုပ်လို့ရပါပြီ။ ဒါပေမယ့် sub class တစ်ခုထည့်တိုင်း super class ကို modify လုပ်ဖို့လိုအပ်မှာဖြစ်ပြီး အဲဒါက object-oriented programming မှာ inheritance ရဲ့ idea တော့မဟုတ်ပါဘူး။ batch job အသစ်ထည့်တိုင်း RunBaseBatch ဒါမှမဟုတ် SysOperationServiceBase ကို modify လုပ်စရာမလိုပါဘူး။

ယင်းအစား၊ သင်သည် SysExtension framework ကို အသုံးပြုနိုင်ပါသည်။ ထိုသို့ပြုလုပ်ရန် SysAttribute ကို extend လုပ်ရန် လိုအပ်သည့် အခြား class တစ်ခုကို ထည့်သွင်းရန် လိုအပ်မည်ဖြစ်သည်။ ဤ class ကို သင်၏ processing class များကို အလှဆင်နိုင်သည့် attribute အဖြစ် အသုံးပြုမည်ဖြစ်သည်။

ဒီ class ဟာ SysOperation implementation အတွက် data contract class တစ်ခု ဖန်တီးပုံနဲ့ အလွန်ဆင်တူပါတယ်၊ ဘာလို့လဲဆိုတော့ အဲဒီတန်ဖိုးတွေကို ရယူပြီး သတ်မှတ်ဖို့အတွက် data member အချို့နဲ့ parm method တွေ ပါဝင်လို့ပါ။

ကျွန်ုပ်တို့၏ကိစ္စတွင်၊ ClassDeclaration သည် ဤကဲ့သို့ပုံစံရှိနိုင်သည်။

class MyProcessorSystemAttribute extends SysAttribute
{
    ModuleInventPurchSales  module;
    StatusIssue             statusIssue;
    StatusReceipt           statusReceipt
}

data member အားလုံးကို instantiate လုပ်ဖို့ new() method တစ်ခု လုပ်ဖို့လိုပါတယ်။ default value တွေထဲက တစ်ချို့ ဒါမှမဟုတ် အားလုံးကို ပေးချင်ရင် ပေးလို့ရပါတယ်။ ဒါပေမယ့် ကျွန်တော်ကတော့ အဲဒီလို မလုပ်ရသေးပါဘူး။

public void new(ModuleInventPurchSales  _module,
                StatusIssue             _statusIssue,
                StatusReceipt           _statusReceipt)
{
    ;

    super();

    module          = _module;
    statusIssue     = _statusIssue;
    statusReceipt   = _statusReceipt;
}

data member တစ်ခုချင်းစီအတွက် parm method ကိုလည်း implement လုပ်သင့်ပါတယ်၊ ဒါပေမယ့် ဘယ်လိုလုပ်ရမလဲဆိုတာ သင်သိမယ်လို့ ကျွန်တော်သေချာလို့ ဒီမှာ ကျွန်တော်ချန်လှပ်ထားပါတယ် - မဟုတ်ရင် လေ့ကျင့်ခန်းတစ်ခုအနေနဲ့ ယူဆကြည့်ရအောင် ;-)

အခုဆိုရင် သင့်ရဲ့ attribute class ကို သင့်ရဲ့ processing class တစ်ခုချင်းစီကို အလှဆင်ဖို့ အသုံးပြုနိုင်ပါပြီ။ ဥပမာအားဖြင့်၊ class declaration တွေက ဒီလိုပုံစံဖြစ်နိုင်ပါတယ်။

[MyProcessorSystemAttribute(ModuleInventPurchSales::Sales,
                            StatusIssue::None,
                            StatusReceipt::None)]
class MyProcessor_Sales extends MyProcessor
{
}

[MyProcessorSystemAttribute(ModuleInventPurchSales::Sales,
                            StatusIssue::ReservOrdered,
                            StatusReceipt::None)]
class MyProcessor_Sales_ReservOrdered extends MyProcessor_Sales
{
}

[MyProcessorSystemAttribute(ModuleInventPurchSales::Sales,
                            StatusIssue::ReservPhysical,
                            StatusReceipt::None)]
class MyProcessor_Sales_ReservPhysical extends MyProcessor_Sales
{
}

မင်းရဲ့ class တွေကို မင်းကြိုက်တဲ့ပုံစံနဲ့ နာမည်ပေးလို့ရတယ်၊ ဒီမှာ အရေးကြီးတဲ့အပိုင်းက မင်းရဲ့ class တွေကို သူတို့လုပ်တဲ့ processing အမျိုးအစားနဲ့ ကိုက်ညီတဲ့ attribute တွေနဲ့ အလှဆင်ဖို့ပဲ။ (ဒါပေမယ့် Dynamics AX မှာ class hierarchy တွေအတွက် naming convention တွေရှိပြီး ဖြစ်နိုင်ရင် အဲဒါတွေကို လိုက်နာတာ အမြဲတမ်းကောင်းတဲ့ အကြံပါ)။

အခုဆိုရင် class တစ်ခုချင်းစီက ဘယ်လို processing လုပ်လဲဆိုတာကို သိရှိနိုင်ဖို့ class တွေကို အလှဆင်ပြီးသွားပြီဆိုရင် SysExtension framework ကို အသုံးပြုပြီး sub class တွေရဲ့ object တွေကို လိုအပ်သလို instantiate လုပ်နိုင်ပါတယ်။

သင့်ရဲ့ super class (MyProcessor) မှာ၊ သင်ဟာ ဒီလို construct method တစ်ခုကို ထည့်နိုင်ပါတယ်။

public static MyProcessor construct(ModuleInventPurchSales _module,
StatusIssue _statusIssue,
StatusReceipt _statusReceipt)
{
    MyProcessor                 ret;
    MyProcessorSystemAttribute  attribute;
    ;

    attribute = new MyProcessorSystemAttribute( _module,
                                                _statusIssue,
                                                _statusReceipt);

    ret = SysExtensionAppClassFactory::getClassFromSysAttribute(classStr(MyProcessor), attribute);

    if (!ret)
    {
        //  no class found
        //  here you could throw an error, instantiate a default
        //  processor instead, or just do nothing, up to you
    }

    return ret;
}

အရမ်းစိတ်ဝင်စားစရာကောင်းတဲ့အပိုင်း - ပြီးတော့ ဒီပို့စ်တစ်ခုလုံးရဲ့ object (စကားလုံးအသုံးအနှုန်းကို ခွင့်လွှတ်ပါ) - ကတော့ SysExtensionAppClassFactory class ထဲက getClassFromSysAttribute() method ပါ။ ဒီ method က hierarchy ရဲ့ super class ရဲ့နာမည်ကို လက်ခံပါတယ် (ဒီ super class က hierarchy ရဲ့ထိပ်မှာရှိဖို့မလိုပါဘူး။ ဒီ class ကိုတိုးချဲ့ထားတဲ့ class တွေသာ အရည်အချင်းပြည့်မီမယ်လို့ ဆိုလိုပါတယ်) နဲ့ attribute object တစ်ခုပါ။

ထို့နောက် သတ်မှတ်ထားသော super class ကို တိုးချဲ့ပြီး သက်ဆိုင်ရာ attribute ဖြင့် အလှဆင်ထားသော class တစ်ခု၏ object ကို ပြန်ပေးသည်။

construct method မှာ validation ဒါမှမဟုတ် logic ကို သင်ကြိုက်သလောက် ထပ်ထည့်လို့ရပေမယ့် အရေးကြီးတဲ့အချက်ကတော့ ဒီ method ကို တစ်ခါ implement လုပ်ပြီးသွားရင် နောက်တစ်ခါ modify လုပ်စရာမလိုတော့ပါဘူး။ sub class တွေကို hierarchy မှာ ထည့်နိုင်ပြီး သူတို့ကို သင့်တော်စွာ အလှဆင်ထားသရွေ့ construct method က ရေးတုန်းက မရှိခဲ့ပေမယ့် ရှာတွေ့ပါလိမ့်မယ်။

စွမ်းဆောင်ရည်ကော။ ရိုးရိုးသားသားပြောရရင် benchmark လုပ်ကြည့်တာမျိုးတော့ မလုပ်ဖူးပေမယ့် ကျွန်တော့်အမြင်အရတော့ ဒါက classic switch statement design ထက် ပိုဆိုးတဲ့ စွမ်းဆောင်ရည်ရှိတယ်လို့ ထင်ပါတယ်။ ဒါပေမယ့် Dynamics AX ရဲ့ performance issue အများစုဟာ database access ကြောင့်ဖြစ်တာကို ထည့်သွင်းစဉ်းစားရင် ကျွန်တော် သိပ်စိတ်ပူမှာ မဟုတ်ပါဘူး။

ဟုတ်ပါတယ်၊ object ထောင်ပေါင်းများစွာကို မြန်မြန်ဖန်တီးဖို့ လိုအပ်မယ့် တစ်ခုခုကို အကောင်အထည်ဖော်နေတယ်ဆိုရင် နောက်ထပ်စုံစမ်းစစ်ဆေးချင်မှာပေါ့၊ ဒါပေမယ့် object တစ်ခုတည်းကို အချိန်အကြာကြီး processing လုပ်ဖို့ instantiate လုပ်တဲ့ classic case တွေမှာတော့ ဒါက အရေးပါမယ်လို့ ကျွန်တော်မထင်ပါဘူး။ ဒါ့အပြင်၊ ကျွန်တော့်ရဲ့ troubleshooting tip (နောက်စာပိုဒ်) ကို ထည့်သွင်းစဉ်းစားရင် SysExtension framework ဟာ caching ပေါ်မှာ မှီခိုနေရပုံရပြီး လည်ပတ်နေတဲ့ system မှာ စွမ်းဆောင်ရည်ကို သိသာထင်ရှားစွာ ထိခိုက်မယ်လို့ ကျွန်တော်မထင်ပါဘူး။

ပြဿနာရှာဖွေခြင်း- construct method သည် သင့် sub class များကို မှန်ကန်စွာ အလှဆင်ထားကြောင်း သေချာသော်လည်း ရှာမတွေ့ပါက၊ ၎င်းသည် caching ပြဿနာတစ်ခု ဖြစ်နိုင်သည်။ client နှင့် server နှစ်ခုလုံးရှိ cache များကို ရှင်းလင်းကြည့်ပါ။ AOS ကို အမှန်တကယ် restart လုပ်ရန် မလိုအပ်သော်လည်း နောက်ဆုံးနည်းလမ်း ဖြစ်နိုင်သည်။

နောက်ထပ်စာဖတ်ခြင်း။

ဤပို့စ်ကို သင်နှစ်သက်ပါက၊ ဤအကြံပြုချက်များကို သင်လည်း နှစ်သက်နိုင်ပါသည်-