ડાયનેમિક્સ એએક્સ 2012 માં કયા પેટા વર્ગને પ્રારંભ કરવો તે શોધવા માટે SysExtension ફ્રેમવર્કનો ઉપયોગ કરીને

પ્રકાશિત: 16 ફેબ્રુઆરી, 2025 એ 12:28:18 AM UTC વાગ્યે

આ લેખ વર્ણવે છે કે કેવી રીતે ડાયનેમિક્સ એએક્સ 2012 અને ડાયનેમિક્સ 365માં બહુ ઓછા જાણીતા SysExtension ફ્રેમવર્કનો ઉપયોગ કરવો જેથી એટ્રિબ્યુટ ડેકોરેશનના આધારે પેટા વર્ગોને ત્વરિત કરી શકાય, જે પ્રોસેસિંગ ક્લાસ શ્રેણીના વંશવેલાની સરળતાથી બહાર કાઢી શકાય તેવી ડિઝાઇનને મંજૂરી આપે છે.

આ પૃષ્ઠ શક્ય તેટલા વધુ લોકો સુધી સુલભ બને તે માટે અંગ્રેજીમાંથી મશીન અનુવાદ કરવામાં આવ્યો હતો. કમનસીબે, મશીન અનુવાદ હજુ સુધી સંપૂર્ણ તકનીક નથી, તેથી ભૂલો થઈ શકે છે. જો તમે ઇચ્છો, તો તમે મૂળ અંગ્રેજી સંસ્કરણ અહીં જોઈ શકો છો:

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

આ પોસ્ટમાંની માહિતી ડાયનેમિક્સ એએક્સ ૨૦૧૨ આર ૩ પર આધારિત છે. તે અન્ય સંસ્કરણો માટે માન્ય હોઈ શકે છે અથવા ન પણ હોઈ શકે. (અપડેટ: હું પુષ્ટિ કરી શકું છું કે આ લેખની માહિતી કામગીરી માટે ડાયનેમિક્સ 365 માટે પણ માન્ય છે)

ડાયનેમિક્સ એએક્સ (AX) માં પ્રોસેસિંગ વર્ગોનો અમલ કરતી વખતે, તમને ઘણી વખત વર્ગ વંશવેલો બનાવવાનો સામનો કરવો પડે છે જેમાં દરેક પેટાવર્ગ ગણતરી મૂલ્યને અનુરૂપ હોય છે અથવા અન્ય કોઈ ડેટા કપલિંગ ધરાવે છે. ક્લાસિક ડિઝાઇન પછી સુપર ક્લાસમાં કન્સ્ટ્રક્ટ મેથડ ધરાવે છે, જેમાં એક સ્વીચ હોય છે જે ઇનપુટના આધારે કયા ક્લાસને ઇન્સ્ટિમેટ કરવું તે નક્કી કરે છે.

આ સૈદ્ધાંતિક રીતે સારી રીતે કાર્ય કરે છે, પરંતુ જો તમારી પાસે ઘણા જુદા જુદા સંભવિત ઇનપુટ્સ હોય (ગણતરીમાં ઘણા તત્વો અથવા કદાચ ઇનપુટ ઘણા જુદા જુદા મૂલ્યોનું સંયોજન છે), તો તે કંટાળાજનક અને જાળવણી માટે ભૂલ-સંભવિત બની શકે છે અને ડિઝાઇનમાં હંમેશા ગેરલાભ છે કે જો તમે ક્યારેય નવો પેટાવર્ગ ઉમેરો છો અથવા કયા ઇનપુટના આધારે પેટાવર્ગનો ઉપયોગ કરવો જોઇએ તેમાં ફેરફાર કરવા માટે તમારે જણાવેલ બાંધકામ પદ્ધતિને સુધારવાની જરૂર પડશે.

સદ્ભાગ્યે, ત્યાં ઘણું બધું ભવ્ય છે, પરંતુ કમનસીબે આ કરવાની રીત પણ ઘણી ઓછી જાણીતી છે, એટલે કે સિઝએક્સટેન્શન ફ્રેમવર્કનો ઉપયોગ કરીને.

આ માળખું એવા લક્ષણોનો લાભ લે છે જેનો ઉપયોગ તમે તમારા પેટા વર્ગોને સુશોભિત કરવા માટે કરી શકો છો જેથી સિસ્ટમ એ શોધી શકે કે કયા પેટા વર્ગનો ઉપયોગ શેના સંચાલન માટે થવો જોઈએ. તમારે હજી પણ બાંધકામ પદ્ધતિની જરૂર પડશે, પરંતુ જો યોગ્ય રીતે કરવામાં આવે, તો તમારે નવા પેટા વર્ગો ઉમેરતી વખતે તેને ક્યારેય સુધારવાની જરૂર રહેશે નહીં.

ચાલો આપણે એક કાલ્પનિક ઉદાહરણ જોઈએ અને કહીએ કે તમે એક વંશવેલો અમલમાં મૂકવા જઈ રહ્યા છો જે ઇન્વેન્ટટ્રાન્સ ટેબલ પર આધારિત અમુક પ્રકારની પ્રક્રિયા કરે છે. કઈ પ્રક્રિયા કરવી તેનો આધાર રેકોર્ડ્સના સ્ટેટસરિસિપ્ટ અને સ્ટેટસઆઈએસયુ પર રહેલો છે, તેમજ રેકોર્ડ્સ સેલ્સલાઈન, પર્ચલાઈન કે બંનેમાંથી કોઈ પણ સાથે સંબંધિત છે કે કેમ તેના પર આધાર રાખે છે. પહેલેથી જ, તમે ઘણા બધા વિવિધ સંયોજનો જોઈ રહ્યા છો.

ચાલો આપણે કહીએ કે તમે જાણો છો કે હમણાં માટે તમારે ફક્ત મુઠ્ઠીભર સંયોજનોને સંભાળવાની જરૂર છે, પરંતુ તમે એ પણ જાણો છો કે તમને સમય જતાં વધુને વધુ સંયોજનોને સંભાળવા માટે સક્ષમ બનવાનું કહેવામાં આવશે.

ચાલો આપણે તેને પ્રમાણમાં સરળ રાખીએ અને કહીએ કે હાલ પૂરતું તમારે સેલ્સલાઇન સાથે સંબંધિત રેકોર્ડ્સને માત્ર રિઝર્વફિઝિકલ અથવા રિઝર્વઓર્ડર્ડના સ્ટેટસ ઇસ્યુ સાથે હેન્ડલ કરવાની જરૂર છે, અન્ય તમામ સંયોજનોને હમણાં માટે અવગણી શકાય છે, પરંતુ તમે જાણો છો કે તમારે પછીથી તેમને હેન્ડલ કરવું પડશે, તેથી તમે તમારા કોડને એવી રીતે ડિઝાઇન કરવા માંગો છો કે જે તેને સરળતાથી બહાર કાઢે.

તમારો વંશવેલો હમણાં માટે કંઈક આવો દેખાઈ શકે છે:

MyProcessor
- MyProcessor_Sales
  - MyProcessor_Sales_ReservOrdered
  - MyProcessor_Sales_ReservPhysical

હવે, તમે સુપર ક્લાસમાં એક પદ્ધતિનો સરળતાથી અમલ કરી શકો છો જે મોડ્યુલઇન્વેન્ટપર્ચસેલ્સ અને સ્ટેટસઆઇએસયુ એનમ પર આધારિત પેટાવર્ગને પ્રારંભ કરે છે. પરંતુ પછી જ્યારે પણ તમે પેટા વર્ગ ઉમેરશો ત્યારે તમારે સુપર ક્લાસમાં ફેરફાર કરવાની જરૂર પડશે, અને તે ખરેખર ઓબ્જેક્ટ-ઓરિએન્ટેડ પ્રોગ્રામિંગમાં વારસાનો વિચાર નથી. આખરે, જ્યારે પણ તમે નવી બેચ જોબ ઉમેરો ત્યારે તમારે RunBaaseBatch અથવા SysOperationServiceBaase ને સુધારવાની જરૂર નથી.

તેના બદલે, તમે SysExtension ફ્રેમવર્કનો ઉપયોગ કરી શકો છો. તે માટે તમારે બીજો વર્ગ ઉમેરવાની જરૂર પડશે, જેમાં સિઝએટ્રીબ્યુટને વિસ્તૃત કરવાની જરૂર છે. આ વર્ગનો ઉપયોગ એટ્રિબ્યુટ તરીકે કરવામાં આવશે જેની સાથે તમે તમારા પ્રોસેસિંગ વર્ગોને સજાવટ કરી શકો છો.

આ વર્ગ તમે કેવી રીતે SysOperation અમલીકરણ માટે ડેટા કોન્ટ્રાક્ટ ક્લાસ બનાવશો તેના જેવો જ છે, જેમાં તે મૂલ્યો મેળવવા અને સેટ કરવા માટે કેટલાક ડેટા સભ્યો અને પાર્મ પદ્ધતિઓ હશે.

આપણા કિસ્સામાં, વર્ગ-વર્ગીકરણ કંઈક આવું દેખાઈ શકે છે:

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

તમારે તમામ ડેટા મેમ્બર્સને ત્વરિત કરવા માટે એક નવી () પદ્ધતિ બનાવવાની જરૂર છે. જો તમે ઈચ્છો તો તમે તેમાંના કેટલાક અથવા બધા ડિફોલ્ટ મૂલ્યો આપી શકો છો, પરંતુ મેં તે કર્યું નથી.

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

    super();

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

અને તમારે દરેક ડેટા મેમ્બર માટે એક પાર્મ પદ્ધતિ પણ અમલમાં મૂકવી જોઈએ, પરંતુ મેં તે અહીં બાકાત રાખી છે કારણ કે મને ખાતરી છે કે તમે તે કેવી રીતે કરવું તે જાણો છો - અન્યથા, ચાલો આપણે તેને એક કવાયત ગણીએ ;-)

હવે તમે તમારા દરેક પ્રોસેસિંગ ક્લાસને સજાવવા માટે તમારા એટ્રિબ્યુટ ક્લાસનો ઉપયોગ કરી શકો છો. ઉદાહરણ તરીકે, વર્ગની ઘોષણાઓ આના જેવી હોઈ શકે છે:

[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() પદ્ધતિ છે. આ પદ્ધતિ શું કરે છે તે એ છે કે તે વંશવેલાના સુપર ક્લાસનું નામ સ્વીકારે છે (અને આ સુપર ક્લાસને વંશવેલાની ટોચ પર રહેવાની જરૂર નથી; તેનો સરળ અર્થ એ છે કે ફક્ત આ વર્ગને વિસ્તૃત કરતા વર્ગો જ પાત્ર બનશે) અને એક લક્ષણ ઓબ્જેક્ટ.

તે પછી તે વર્ગની ઓબ્જેક્ટ પરત કરે છે જે નિર્દિષ્ટ સુપર ક્લાસને વિસ્તૃત કરે છે અને સંબંધિત લક્ષણથી શણગારવામાં આવે છે.

તમે દેખીતી રીતે જ તમે ઇચ્છો તેટલી વધુ માન્યતા અથવા તર્કને કન્સ્ટ્રક્ટ પદ્ધતિમાં ઉમેરી શકો છો, પરંતુ અહીં મહત્વપૂર્ણ બાબત એ છે કે એકવાર અમલમાં મૂક્યા પછી, તમારે ફરીથી આ પદ્ધતિમાં ક્યારેય ફેરફાર કરવો જોઈએ નહીં. તમે પદાનુક્રમમાં પેટા વર્ગો ઉમેરી શકો છો અને જ્યાં સુધી તમે તેમને યોગ્ય રીતે શણગારવાની ખાતરી કરો ત્યાં સુધી, બાંધકામ પદ્ધતિ તેમને શોધી કાઢશે, તેમ છતાં જ્યારે તે લખાયું હતું ત્યારે તેઓ અસ્તિત્વમાં ન હતા.

પરફોર્મન્સનું શું? મેં પ્રામાણિકપણે તેને બેંચમાર્ક બનાવવાનો પ્રયાસ કર્યો નથી, પરંતુ મારી આંતરડાની લાગણી એ છે કે આ કદાચ ક્લાસિક સ્વિચ સ્ટેટમેન્ટ ડિઝાઇન કરતા પણ ખરાબ પ્રદર્શન કરે છે. જો કે, ડાયનેમિક્સ એએક્સમાં અત્યાર સુધીના સૌથી વધુ પ્રદર્શનના મુદ્દાઓ ડેટાબેઝ એક્સેસને કારણે થાય છે તે ધ્યાનમાં લેતા, હું તેના વિશે વધુ ચિંતા કરીશ નહીં.

અલબત્ત, જો તમે એવી કોઈ બાબતનો અમલ કરી રહ્યા હોવ કે જેમાં હજારો પદાર્થો ઝડપથી સર્જવાની જરૂર પડે, તો તમે કદાચ વધુ તપાસ કરવા માગતા હો, પરંતુ ક્લાસિક કિસ્સાઓમાં જ્યાં તમે કોઈ એક જ પદાર્થને અમુક લાંબી પ્રક્રિયા કરવા માટે ત્વરિત ત્વરિત બનાવો છો, તો મને શંકા છે કે તેનાથી કોઈ ફરક પડશે. ઉપરાંત, મારી સમસ્યાનિવારણની ટિપ (હવે પછીનો ફકરો) ને ધ્યાનમાં લેતાં, એવું લાગે છે કે સિઝએક્સટેન્શન ફ્રેમવર્ક કેશિંગ પર આધાર રાખે છે, તેથી ચાલુ સિસ્ટમમાં મને શંકા છે કે તે નોંધપાત્ર પ્રદર્શન હિટ છે. સમસ્યાનિવારણ: જો કન્સ્ટ્રક્ટ પદ્ધતિને તમારા પેટા વર્ગો ન મળે, તેમ છતાં તમને ખાતરી છે કે તેમને યોગ્ય રીતે શણગારવામાં આવ્યા છે, તો તે કેશિંગની સમસ્યા હોઈ શકે છે. ક્લાયન્ટ અને સર્વર બંને પર કેશને સાફ કરવાનો પ્રયત્ન કરો. ખરેખર એઓએસને ફરીથી શરૂ કરવું જરૂરી ન હોવું જોઈએ, પરંતુ તે છેલ્લો ઉપાય હોઈ શકે છે.