Dynamics AX 2012-ൽ ഏത് ഉപവിഭാഗമാണ് തൽക്ഷണം നൽകേണ്ടതെന്ന് കണ്ടെത്താൻ SysExtension Framework ഉപയോഗിക്കുന്നു

പ്രസിദ്ധീകരിച്ചത്: 2025, ഫെബ്രുവരി 16 12:28:21 AM UTC
അവസാനം അപ്ഡേറ്റ് ചെയ്തത്: 2026, ജനുവരി 12 8:43:44 AM UTC

ആട്രിബ്യൂട്ട് ഡെക്കറേഷനുകളെ അടിസ്ഥാനമാക്കിയുള്ള സബ് ക്ലാസുകൾ ഇൻസ്റ്റന്റ് ചെയ്യുന്നതിന്, ഡൈനാമിക്സ് എഎക്സ് 2012, ഡൈനാമിക്സ് 365 എന്നിവയിലെ അധികം അറിയപ്പെടാത്ത സിസ് എക്സ്റ്റൻഷൻ ഫ്രെയിംവർക്ക് എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ഈ ലേഖനം വിവരിക്കുന്നു, ഇത് പ്രോസസ്സിംഗ് ക്ലാസ് ശ്രേണിയുടെ എളുപ്പത്തിൽ വിപുലീകരിക്കാവുന്ന രൂപകൽപ്പന അനുവദിക്കുന്നു.

ഈ പേജ് കഴിയുന്നത്ര ആളുകൾക്ക് ആക്‌സസ് ചെയ്യുന്നതിനായി ഇംഗ്ലീഷിൽ നിന്ന് മെഷീൻ വിവർത്തനം ചെയ്‌തിരിക്കുന്നു. നിർഭാഗ്യവശാൽ, മെഷീൻ വിവർത്തനം ഇതുവരെ പൂർണ്ണത നേടിയിട്ടില്ലാത്ത ഒരു സാങ്കേതികവിദ്യയാണ്, അതിനാൽ പിശകുകൾ സംഭവിക്കാം. നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ഇവിടെ യഥാർത്ഥ ഇംഗ്ലീഷ് പതിപ്പ് കാണാൻ കഴിയും:

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

ഈ പോസ്റ്റിലെ വിവരങ്ങൾ ഡൈനാമിക്സ് AX 2012 R3 അടിസ്ഥാനമാക്കിയുള്ളതാണ്. മറ്റ് പതിപ്പുകൾക്ക് ഇത് സാധുതയുള്ളതോ അല്ലാത്തതോ ആകാം. (അപ്ഡേറ്റ്: ഈ ലേഖനത്തിലെ വിവരങ്ങൾ ഡൈനാമിക്സ് 365 ഫോർ ഓപ്പറേഷനുകൾക്കും സാധുതയുള്ളതാണെന്ന് എനിക്ക് സ്ഥിരീകരിക്കാൻ കഴിയും)

ഡൈനാമിക്സ് AX-ൽ പ്രോസസ്സിംഗ് ക്ലാസുകൾ നടപ്പിലാക്കുമ്പോൾ, ഓരോ ഉപവിഭാഗവും ഒരു enum മൂല്യവുമായി പൊരുത്തപ്പെടുന്നതോ അല്ലെങ്കിൽ മറ്റേതെങ്കിലും ഡാറ്റ കപ്ലിംഗ് ഉള്ളതോ ആയ ഒരു ക്ലാസ് ശ്രേണി സൃഷ്ടിക്കേണ്ടിവരാറുണ്ട്. ഒരു ക്ലാസിക് ഡിസൈൻ എന്നത് സൂപ്പർ ക്ലാസിൽ ഒരു കൺസ്ട്രക്റ്റ് രീതി ഉണ്ടായിരിക്കുക എന്നതാണ്, അതിൽ ഇൻപുട്ടിനെ അടിസ്ഥാനമാക്കി ഏത് ക്ലാസ് ഇൻസ്റ്റന്റൈസ് ചെയ്യണമെന്ന് നിർണ്ണയിക്കുന്ന ഒരു സ്വിച്ച് ഉണ്ട്.

തത്വത്തിൽ ഇത് നന്നായി പ്രവർത്തിക്കുന്നു, പക്ഷേ നിങ്ങൾക്ക് നിരവധി വ്യത്യസ്ത ഇൻപുട്ടുകൾ ഉണ്ടെങ്കിൽ (ഒരു enum-ലെ നിരവധി ഘടകങ്ങൾ അല്ലെങ്കിൽ ഒരുപക്ഷേ ഇൻപുട്ട് നിരവധി വ്യത്യസ്ത മൂല്യങ്ങളുടെ സംയോജനമായിരിക്കാം), ഇത് പരിപാലിക്കുന്നത് മടുപ്പിക്കുന്നതും പിശകുകൾക്ക് സാധ്യതയുള്ളതുമായി മാറും, കൂടാതെ ഡിസൈനിന് എല്ലായ്പ്പോഴും ഒരു പോരായ്മയുണ്ട്, നിങ്ങൾ എപ്പോഴെങ്കിലും ഒരു പുതിയ സബ്ക്ലാസ് ചേർക്കുകയോ ഏത് ഇൻപുട്ടിനെ അടിസ്ഥാനമാക്കി ഏത് സബ്ക്ലാസ് ഉപയോഗിക്കണമെന്ന് മാറ്റങ്ങൾ വരുത്തുകയോ ചെയ്താൽ പറഞ്ഞ കൺസ്ട്രക്റ്റ് രീതി പരിഷ്കരിക്കേണ്ടതുണ്ട്.

ഭാഗ്യവശാൽ, ഇത് ചെയ്യുന്നതിന് കൂടുതൽ സുന്ദരമായ, എന്നാൽ നിർഭാഗ്യവശാൽ വളരെ കുറച്ച് അറിയപ്പെടുന്ന ഒരു മാർഗമുണ്ട്, അതായത് SysExtension ഫ്രെയിംവർക്കിന്റെ ഉപയോഗം.

ഏത് സബ് ക്ലാസ് ഏത് കൈകാര്യം ചെയ്യുന്നതിനായി ഉപയോഗിക്കണമെന്ന് സിസ്റ്റത്തിന് മനസ്സിലാക്കാൻ കഴിയുന്ന തരത്തിൽ, നിങ്ങളുടെ സബ് ക്ലാസുകൾ അലങ്കരിക്കാൻ നിങ്ങൾക്ക് ഉപയോഗിക്കാവുന്ന ആട്രിബ്യൂട്ടുകൾ ഈ ഫ്രെയിംവർക്ക് പ്രയോജനപ്പെടുത്തുന്നു. നിങ്ങൾക്ക് ഇപ്പോഴും ഒരു കൺസ്ട്രക്റ്റ് രീതി ആവശ്യമായി വരും, പക്ഷേ ശരിയായി ചെയ്താൽ, പുതിയ സബ് ക്ലാസുകൾ ചേർക്കുമ്പോൾ നിങ്ങൾ അത് ഒരിക്കലും പരിഷ്കരിക്കേണ്ടതില്ല.

ഒരു സാങ്കൽപ്പിക ഉദാഹരണം നോക്കാം, നിങ്ങൾ InventTrans പട്ടികയെ അടിസ്ഥാനമാക്കി ഒരുതരം പ്രോസസ്സിംഗ് നടത്തുന്ന ഒരു ശ്രേണി നടപ്പിലാക്കാൻ പോകുന്നുവെന്ന് പറയാം. ഏത് പ്രോസസ്സിംഗ് നടത്തണം എന്നത് റെക്കോർഡുകളുടെ StatusReceipt, StatusIssue എന്നിവയെ ആശ്രയിച്ചിരിക്കുന്നു, അതുപോലെ റെക്കോർഡുകൾ SalesLine, PurchLine എന്നിവയുമായി ബന്ധപ്പെട്ടതാണോ അതോ രണ്ടും രണ്ടുമല്ലേ എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു. ഇപ്പോൾ തന്നെ, നിങ്ങൾ നിരവധി വ്യത്യസ്ത കോമ്പിനേഷനുകൾ നോക്കുകയാണ്.

ഇനി, ഇപ്പോൾ നിങ്ങൾക്ക് ചുരുക്കം ചില കോമ്പിനേഷനുകൾ മാത്രമേ കൈകാര്യം ചെയ്യേണ്ടതുള്ളൂ എന്ന് നിങ്ങൾക്കറിയാമെന്ന് പറയാം, എന്നാൽ കാലക്രമേണ കൂടുതൽ കൂടുതൽ കോമ്പിനേഷനുകൾ കൈകാര്യം ചെയ്യാൻ നിങ്ങളോട് ആവശ്യപ്പെടുമെന്നും നിങ്ങൾക്കറിയാം.

താരതമ്യേന ലളിതമായി പറയാം, ഇപ്പോൾ നിങ്ങൾ ReservPhysical അല്ലെങ്കിൽ ReserveOrdered എന്ന StatusIssue ഉപയോഗിച്ച് SalesLine-മായി ബന്ധപ്പെട്ട റെക്കോർഡുകൾ മാത്രമേ കൈകാര്യം ചെയ്യേണ്ടതുള്ളൂ. മറ്റെല്ലാ കോമ്പിനേഷനുകളും ഇപ്പോൾ അവഗണിക്കാം, എന്നാൽ പിന്നീട് അവ കൈകാര്യം ചെയ്യേണ്ടിവരുമെന്ന് നിങ്ങൾക്കറിയാവുന്നതിനാൽ, നിങ്ങളുടെ കോഡ് എളുപ്പത്തിൽ വിപുലീകരിക്കാൻ കഴിയുന്ന രീതിയിൽ രൂപകൽപ്പന ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിക്കും.

നിങ്ങളുടെ ശ്രേണി ഇപ്പോൾ ഇതുപോലെയായിരിക്കാം:

എന്റെപ്രോസസർഎന്റെപ്രോസസർ_സെയിൽസ്എന്റെപ്രോസസർ_സെയിൽസ്_റിസർവ്ഓർഡർ ചെയ്തുഎന്റെപ്രോസസർ_സെയിൽസ്_റിസർവ്ഫിസിക്കൽ

ഇനി, സൂപ്പർ ക്ലാസ്സിൽ ഒരു ModuleInventPurchSales ഉം StatusIssue enum ഉം അടിസ്ഥാനമാക്കിയുള്ള ഒരു സബ്ക്ലാസ് സൃഷ്ടിക്കുന്ന ഒരു രീതി നിങ്ങൾക്ക് എളുപ്പത്തിൽ നടപ്പിലാക്കാൻ കഴിയും. എന്നാൽ നിങ്ങൾ ഒരു സബ് ക്ലാസ് ചേർക്കുമ്പോഴെല്ലാം സൂപ്പർ ക്ലാസ് പരിഷ്കരിക്കേണ്ടതുണ്ട്, ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് പ്രോഗ്രാമിംഗിൽ പാരമ്പര്യത്തിന്റെ ആശയം അതല്ല. എല്ലാത്തിനുമുപരി, നിങ്ങൾ ഒരു പുതിയ ബാച്ച് ജോലി ചേർക്കുമ്പോഴെല്ലാം RunBaseBatch അല്ലെങ്കിൽ SysOperationServiceBase പരിഷ്കരിക്കേണ്ടതില്ല.

പകരം, നിങ്ങൾക്ക് SysExtension ഫ്രെയിംവർക്ക് ഉപയോഗിക്കാം. അതിനായി നിങ്ങൾ മറ്റൊരു ക്ലാസ് ചേർക്കേണ്ടതുണ്ട്, അത് SysAttribute വിപുലീകരിക്കേണ്ടതുണ്ട്. നിങ്ങളുടെ പ്രോസസ്സിംഗ് ക്ലാസുകൾ അലങ്കരിക്കാൻ കഴിയുന്ന ആട്രിബ്യൂട്ടായി ഈ ക്ലാസ് ഉപയോഗിക്കും.

ഒരു 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 ഫ്രെയിംവർക്കിന്റെ പ്രയോജനം നേടാം.

നിങ്ങളുടെ സൂപ്പർ ക്ലാസ്സിൽ (MyProcessor), നിങ്ങൾക്ക് ഇതുപോലുള്ള ഒരു കൺസ്ട്രക്റ്റ് രീതി ചേർക്കാൻ കഴിയും:

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 പുനരാരംഭിക്കേണ്ട ആവശ്യമില്ല, പക്ഷേ അത് അവസാന ആശ്രയമായിരിക്കാം.

കൂടുതൽ വായനയ്ക്ക്

നിങ്ങൾക്ക് ഈ പോസ്റ്റ് ഇഷ്ടപ്പെട്ടെങ്കിൽ, ഈ നിർദ്ദേശങ്ങളും നിങ്ങൾക്ക് ഇഷ്ടപ്പെട്ടേക്കാം: