डायनॅमिक्स एएक्स २०१२ मध्ये कोणता उपवर्ग स्थापित करायचा हे शोधण्यासाठी सिस्टमएक्सटेंशन फ्रेमवर्क वापरणे

प्रकाशित: १६ फेब्रुवारी, २०२५ रोजी १२:२६:१८ AM UTC

हा लेख ऑपरेशन्ससाठी डायनॅमिक्स AX 2012 आणि डायनॅमिक्स 365 मधील अल्प-ज्ञात SysExtension फ्रेमवर्कचा वापर कसा करायचा याचे वर्णन करतो जेणेकरून अॅट्रिब्यूट डेकोरेशनवर आधारित सब क्लासेस इंस्टंटिएट करता येतील, ज्यामुळे प्रोसेसिंग क्लास हायरार्कीचे सहज विस्तारनीय डिझाइन करता येईल.

हे पान जास्तीत जास्त लोकांना उपलब्ध व्हावे म्हणून इंग्रजीतून मशीन भाषांतरित करण्यात आले आहे. दुर्दैवाने, मशीन भाषांतर अद्याप परिपूर्ण तंत्रज्ञान नाही, त्यामुळे चुका होऊ शकतात. तुम्हाला हवे असल्यास, तुम्ही मूळ इंग्रजी आवृत्ती येथे पाहू शकता:

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

या पोस्टमधील माहिती डायनॅमिक्स AX २०१२ R3 वर आधारित आहे. ती इतर आवृत्त्यांसाठी वैध असू शकते किंवा नसू शकते. (अपडेट: मी पुष्टी करू शकतो की या लेखातील माहिती ऑपरेशन्ससाठी डायनॅमिक्स ३६५ साठी देखील वैध आहे)

डायनॅमिक्स AX मध्ये प्रोसेसिंग क्लासेस अंमलात आणताना, तुम्हाला अनेकदा एक वर्ग पदानुक्रम तयार करावा लागतो ज्यामध्ये प्रत्येक उपवर्ग एका enum मूल्याशी जुळतो किंवा इतर काही डेटा कपलिंग असते. एक क्लासिक डिझाइन म्हणजे सुपर क्लासमध्ये एक कन्स्ट्रक्ट मेथड असणे, ज्यामध्ये एक स्विच असतो जो इनपुटच्या आधारे कोणता वर्ग स्थापित करायचा हे ठरवतो.

हे तत्वतः चांगले काम करते, परंतु जर तुमच्याकडे अनेक भिन्न संभाव्य इनपुट असतील (एनममधील अनेक घटक किंवा कदाचित इनपुट हे अनेक वेगवेगळ्या मूल्यांचे संयोजन असेल), तर ते राखणे कंटाळवाणे आणि त्रुटी-प्रवण होऊ शकते आणि डिझाइनमध्ये नेहमीच तोटा असतो की जर तुम्ही कधीही नवीन सबक्लास जोडला किंवा कोणत्या इनपुटच्या आधारावर कोणता सबक्लास वापरायचा यात बदल केला तर तुम्हाला ती कन्स्ट्रक्ट पद्धत सुधारावी लागेल.

सुदैवाने, हे करण्याचा एक खूपच सुंदर, परंतु दुर्दैवाने खूपच कमी ज्ञात मार्ग आहे, तो म्हणजे SysExtension फ्रेमवर्कचा वापर.

हे फ्रेमवर्क तुमच्या सबक्लासेस सजवण्यासाठी वापरल्या जाणाऱ्या गुणधर्मांचा फायदा घेते जेणेकरून सिस्टमला कोणत्या सबक्लासचा वापर कशासाठी करायचा हे ठरवता येईल. तुम्हाला अजूनही कन्स्ट्रक्ट मेथडची आवश्यकता असेल, परंतु जर ते योग्यरित्या केले तर नवीन सबक्लासेस जोडताना तुम्हाला त्यात कधीही बदल करावे लागणार नाहीत.

चला एक काल्पनिक उदाहरण पाहू आणि असे म्हणूया की तुम्ही एक पदानुक्रम लागू करणार आहात जो InventTrans टेबलवर आधारित काही प्रकारची प्रक्रिया करतो. कोणती प्रक्रिया करायची हे रेकॉर्डच्या StatusReceipt आणि StatusIssue वर अवलंबून असते, तसेच रेकॉर्ड SalesLine, PurchLine किंवा दोन्हीशी संबंधित आहेत की नाही यावर देखील अवलंबून असते. आधीच, तुम्ही बरेच वेगवेगळे संयोजन पाहत आहात.

समजा, तुम्हाला माहिती आहे की सध्या तुम्हाला फक्त काही मोजक्याच संयोजनांची आवश्यकता आहे, परंतु तुम्हाला हे देखील माहित आहे की कालांतराने तुम्हाला अधिकाधिक संयोजने हाताळण्यास सक्षम होण्यास सांगितले जाईल.

चला ते तुलनेने सोपे ठेवूया आणि असे म्हणूया की सध्या तुम्हाला फक्त ReservPhysical किंवा ReservOrdered च्या StatusIssue सह SalesLine शी संबंधित रेकॉर्ड हाताळायचे आहेत, इतर सर्व संयोजने सध्या दुर्लक्षित केली जाऊ शकतात, परंतु तुम्हाला माहिती आहे की तुम्हाला नंतर ते हाताळावे लागतील, तुम्हाला तुमचा कोड अशा प्रकारे डिझाइन करायचा आहे की तो सहजपणे विस्तारता येईल.

तुमची पदानुक्रम सध्या अशी दिसू शकते:

माझाप्रोसेसर
- माझाप्रोसेसर_विक्री
  - माझेप्रोसेसर_विक्री_राखीवऑर्डर केलेले
  - माझाप्रोसेसर_विक्री_संरक्षितभौतिक

आता, तुम्ही सुपर क्लासमध्ये सहजपणे एक पद्धत अंमलात आणू शकता जी ModuleInventPurchSales आणि StatusIssue enum वर आधारित सबक्लास इंस्टंटिएट करते. परंतु त्यानंतर तुम्हाला प्रत्येक वेळी सबक्लास जोडताना सुपर क्लासमध्ये बदल करावे लागतील आणि ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंगमध्ये ती खरोखर इनहेरिटन्सची कल्पना नाही. शेवटी, प्रत्येक वेळी नवीन बॅच जॉब जोडताना तुम्हाला RunBaseBatch किंवा SysOperationServiceBase मध्ये बदल करण्याची आवश्यकता नाही.

त्याऐवजी, तुम्ही SysExtension फ्रेमवर्क वापरू शकता. त्यासाठी तुम्हाला दुसरा क्लास जोडावा लागेल, ज्याला SysAttribute वाढवणे आवश्यक आहे. हा क्लास तुमच्या प्रोसेसिंग क्लासेसना सजवण्यासाठी अॅट्रिब्यूट म्हणून वापरला जाईल.

हा वर्ग SysOperation अंमलबजावणीसाठी डेटा कॉन्ट्रॅक्ट क्लास कसा बनवायचा यासारखाच आहे, कारण त्यात काही डेटा सदस्य आणि त्या मूल्ये मिळविण्यासाठी आणि सेट करण्यासाठी parm पद्धती असतील.

आमच्या बाबतीत, ClassDeclaration असे काहीतरी दिसू शकते:

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

सर्व डेटा सदस्यांना इन्स्टंटिएट करण्यासाठी तुम्हाला एक new() पद्धत बनवावी लागेल. तुम्हाला हवे असल्यास तुम्ही त्यापैकी काही किंवा सर्व डीफॉल्ट व्हॅल्यू देऊ शकता, परंतु मी ते केलेले नाही.

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

    super();

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

आणि तुम्ही प्रत्येक डेटा सदस्यासाठी एक parm पद्धत देखील लागू केली पाहिजे, परंतु मी ती येथे वगळली आहे कारण मला खात्री आहे की तुम्हाला ते कसे करायचे हे माहित आहे - अन्यथा, चला ते एक व्यायाम समजूया ;-)

आता तुम्ही तुमच्या प्रत्येक प्रोसेसिंग क्लासला सजवण्यासाठी तुमच्या अॅट्रिब्यूट क्लासचा वापर करू शकता. उदाहरणार्थ, क्लास डिक्लेरेशन असे दिसू शकतात:

[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
{
}

अर्थात, तुम्ही तुमच्या वर्गांना तुम्हाला हवे तसे नाव देऊ शकता, येथे महत्त्वाचा भाग असा आहे की तुम्ही तुमचे वर्ग अशा गुणधर्मांनी सजवा जे ते कोणत्या प्रकारच्या प्रक्रियेशी जुळतात. (परंतु लक्षात ठेवा की डायनॅमिक्स AX मध्ये वर्ग पदानुक्रमांसाठी नामकरण पद्धती आहेत आणि शक्य असल्यास त्यांचे पालन करणे नेहमीच चांगली कल्पना असते).

आता तुम्ही तुमचे वर्ग सजवले आहेत जेणेकरून ते कोणत्या प्रकारची प्रक्रिया करतात हे ओळखता येईल, तुम्ही SysExtension फ्रेमवर्कचा फायदा घेऊन आवश्यकतेनुसार उपवर्गांच्या ऑब्जेक्ट्सची स्थापना करू शकता.

तुमच्या सुपर क्लासमध्ये (मायप्रोसेसर), तुम्ही अशी रचना पद्धत जोडू शकता:

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;
}

या संपूर्ण पोस्टचा खरोखरच मनोरंजक भाग - आणि खरोखरच ऑब्जेक्ट (शब्दाला माफ करा) - म्हणजे SysExtensionAppClassFactory क्लासमधील getClassFromSysAttribute() पद्धत. ही पद्धत असे करते की ती पदानुक्रमाच्या सुपर क्लासचे नाव स्वीकारते (आणि हा सुपर क्लास पदानुक्रमाच्या शीर्षस्थानी असण्याची आवश्यकता नाही; याचा अर्थ असा की फक्त या वर्गाचा विस्तार करणारे वर्ग पात्र असतील) आणि एक विशेषता ऑब्जेक्ट.

त्यानंतर ते एका वर्गाचे ऑब्जेक्ट परत करते जे निर्दिष्ट सुपर वर्ग वाढवते आणि संबंधित गुणधर्माने सजवलेले असते.

तुम्ही कन्स्ट्रक्ट मेथडमध्ये तुम्हाला हवे तितके अधिक व्हॅलिडेशन किंवा लॉजिक जोडू शकता, परंतु येथे महत्त्वाचा मुद्दा असा आहे की एकदा अंमलात आणल्यानंतर, तुम्हाला ही पद्धत पुन्हा कधीही बदलण्याची गरज नाही. तुम्ही पदानुक्रमात उपवर्ग जोडू शकता आणि जोपर्यंत तुम्ही त्यांना योग्यरित्या सजवण्याची खात्री कराल, तोपर्यंत कन्स्ट्रक्ट मेथड त्यांना शोधून काढेल जरी ते लिहिले गेले तेव्हा ते अस्तित्वात नव्हते.

कामगिरीबद्दल काय? मी प्रामाणिकपणे ते बेंचमार्क करण्याचा प्रयत्न केलेला नाही, परंतु माझ्या अंतःकरणाला असे वाटते की हे कदाचित क्लासिक स्विच स्टेटमेंट डिझाइनपेक्षा वाईट कामगिरी करते. तथापि, डायनॅमिक्स AX मधील बहुतेक कामगिरी समस्या डेटाबेस प्रवेशामुळे उद्भवतात हे लक्षात घेता, मी त्याबद्दल जास्त काळजी करणार नाही.

अर्थात, जर तुम्ही असे काही अंमलात आणत असाल ज्यासाठी हजारो ऑब्जेक्ट्स लवकर तयार करावे लागतील, तर तुम्हाला अधिक तपास करावा लागेल, परंतु ज्या क्लासिक प्रकरणांमध्ये तुम्ही फक्त एकाच ऑब्जेक्टला काही लांब प्रक्रिया करण्यासाठी इन्स्टंट करता, मला शंका आहे की ते काही फरक पडेल. तसेच, माझ्या समस्यानिवारण टिप (पुढील परिच्छेद) लक्षात घेता, असे दिसते की SysExtension फ्रेमवर्क कॅशिंगवर अवलंबून आहे, म्हणून चालू असलेल्या सिस्टममध्ये मला शंका आहे की त्याचे कार्यप्रदर्शन लक्षणीयरीत्या प्रभावित झाले आहे. समस्यानिवारण: जर कन्स्ट्रक्ट पद्धतीला तुमचे सबक्लासेस योग्यरित्या सजवले आहेत याची खात्री असूनही ते सापडले नाहीत, तर ती कॅशिंग समस्या असू शकते. क्लायंट आणि सर्व्हर दोन्हीवर कॅशे साफ करण्याचा प्रयत्न करा. प्रत्यक्षात AOS रीस्टार्ट करणे आवश्यक नसावे, परंतु ते शेवटचा उपाय असू शकते.