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

പ്രസിദ്ധീകരിച്ചത്: 2025, ഫെബ്രുവരി 16 12:28:21 AM UTC

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

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

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

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

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

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

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

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

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

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

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

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

MyProcessor
- MyProcessor_Sales
  - MyProcessor_Sales_ReservOrdered
  - MyProcessor_Sales_ReservPhysical

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

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

ഒരു സിസ്റ്റ് ഓപ്പറേഷൻ നടപ്പാക്കലിനായി നിങ്ങൾ എങ്ങനെ ഒരു ഡാറ്റാ കോൺട്രാക്റ്റ് ക്ലാസ് ഉണ്ടാക്കും എന്നതിനോട് ഈ ക്ലാസ് വളരെ സാമ്യമുള്ളതാണ്, അതിൽ ചില ഡാറ്റാ അംഗങ്ങളും ആ മൂല്യങ്ങൾ നേടുന്നതിനും ക്രമീകരിക്കുന്നതിനുമുള്ള പാർം രീതികളും ഉണ്ടായിരിക്കും.

ഞങ്ങളുടെ കാര്യത്തിൽ, ക്ലാസ് പ്രഖ്യാപനം ഇതുപോലെ തോന്നാം:

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

തീർച്ചയായും നിങ്ങൾക്ക് ഇഷ്ടമുള്ള രീതിയിൽ നിങ്ങളുടെ ക്ലാസുകൾക്ക് പേരിടാം, ഇവിടെയുള്ള പ്രധാന ഭാഗം നിങ്ങളുടെ ക്ലാസുകൾ അവ ഏത് തരത്തിലുള്ള പ്രോസസ്സിംഗ് ചെയ്യുന്നു എന്നതിനനുസൃതമായ ആട്രിബ്യൂട്ടുകൾ ഉപയോഗിച്ച് അലങ്കരിക്കുക എന്നതാണ്. (എന്നാൽ ഡൈനാമിക്സ് എഎക്സിൽ ക്ലാസ് ശ്രേണികൾക്കായി നാമകരണ കൺവെൻഷനുകൾ ഉണ്ടെന്ന് ഓർമ്മിക്കുക, അവ പിന്തുടരുന്നത് എല്ലായ്പ്പോഴും നല്ലതാണ്, കഴിയുമെങ്കില് ).

ഓരോന്നും ഏതുതരം പ്രോസസ്സിംഗ് ചെയ്യുന്നുവെന്ന് തിരിച്ചറിയാൻ ഇപ്പോൾ നിങ്ങൾ നിങ്ങളുടെ ക്ലാസുകൾ അലങ്കരിച്ചിരിക്കുന്നു, ആവശ്യാനുസരണം ഉപ ക്ലാസുകളിലെ വസ്തുക്കളെ തൽക്ഷണം കൈകാര്യം ചെയ്യുന്നതിന് നിങ്ങൾക്ക് സിസ്റ്റ് എക്സ്റ്റൻഷൻ ചട്ടക്കൂട് പ്രയോജനപ്പെടുത്താം.

നിങ്ങളുടെ സൂപ്പർ ക്ലാസിൽ (മൈപ്രൊസസ്സർ), നിങ്ങൾക്ക് ഇതുപോലുള്ള ഒരു നിർമ്മാണ രീതി ചേർക്കാം:

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 ക്ലാസ്സിലെ GetClass FromSysAttribute () രീതിയാണ്. ഈ രീതി എന്താണ് ചെയ്യുന്നത്, ഇത് ഒരു ശ്രേണിയുടെ സൂപ്പർ ക്ലാസിന്റെ പേര് സ്വീകരിക്കുന്നു (ഈ സൂപ്പർ ക്ലാസ് ശ്രേണിയുടെ മുകളിൽ ആയിരിക്കേണ്ടതില്ല; ഈ ക്ലാസ് വിപുലീകരിക്കുന്ന ക്ലാസുകൾക്ക് മാത്രമേ യോഗ്യതയുള്ളൂ എന്നാണ് ഇതിനർത്ഥം) ഒരു ആട്രിബ്യൂട്ട് ഒബ്ജക്റ്റും.

നിർദ്ദിഷ്ട സൂപ്പർ ക്ലാസ് വിപുലീകരിക്കുകയും അനുബന്ധ ആട്രിബ്യൂട്ട് ഉപയോഗിച്ച് അലങ്കരിക്കുകയും ചെയ്യുന്ന ഒരു ക്ലാസിന്റെ ഒരു വസ്തുവിനെ ഇത് തിരികെ നൽകുന്നു.

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

Performance എങ്ങനെ? ഞാൻ സത്യസന്ധമായി ഇത് ബെഞ്ച്മാർക്ക് ചെയ്യാൻ ശ്രമിച്ചിട്ടില്ല, പക്ഷേ ഇത് ക്ലാസിക് സ്വിച്ച് സ്റ്റേറ്റ്മെന്റ് രൂപകൽപ്പനയേക്കാൾ മോശമാണെന്ന് എന്റെ മനസ്സ് തോന്നുന്നു. എന്നിരുന്നാലും, ഡൈനാമിക്സ് എഎക്സിലെ ഏറ്റവും മികച്ച പ്രകടന പ്രശ്നങ്ങൾ ഡാറ്റാബേസ് ആക്സസ് മൂലമാണെന്ന് കണക്കിലെടുക്കുമ്പോൾ, ഞാൻ അതിനെക്കുറിച്ച് വളരെയധികം വിഷമിക്കില്ല.

തീർച്ചയായും, ആയിരക്കണക്കിന് വസ്തുക്കൾ വേഗത്തിൽ സൃഷ്ടിക്കാൻ ആവശ്യമായ എന്തെങ്കിലും നിങ്ങൾ നടപ്പാക്കുകയാണെങ്കിൽ, നിങ്ങൾ കൂടുതൽ അന്വേഷിക്കാൻ ആഗ്രഹിച്ചേക്കാം, പക്ഷേ ചില നീണ്ട പ്രോസസ്സിംഗ് നടത്താൻ നിങ്ങൾ ഒരു വസ്തുവിനെ തൽക്ഷണം ഉപയോഗിക്കുന്ന ക്ലാസിക് സന്ദർഭങ്ങളിൽ, അത് കാര്യമാക്കുമെന്ന് ഞാൻ സംശയിക്കുന്നു. കൂടാതെ, എന്റെ പ്രശ്നപരിഹാര നുറുങ്ങ് (അടുത്ത ഖണ്ഡിക) പരിഗണിക്കുമ്പോൾ, സിസ്റ്റ് എക്സ്റ്റൻഷൻ ചട്ടക്കൂട് കാച്ചിംഗിനെ ആശ്രയിച്ചിരിക്കുന്നുവെന്ന് തോന്നുന്നു, അതിനാൽ ഒരു റണ്ണിംഗ് സിസ്റ്റത്തിൽ ഇതിന് കാര്യമായ പ്രകടന വിജയം ഉണ്ടെന്ന് ഞാൻ സംശയിക്കുന്നു. പ്രശ്നപരിഹാരം: നിങ്ങളുടെ ഉപ ക്ലാസുകൾ ശരിയായി അലങ്കരിച്ചിട്ടുണ്ടെന്ന് നിങ്ങൾക്ക് ഉറപ്പുണ്ടായിട്ടും നിർമ്മാണ രീതി കണ്ടെത്തുന്നില്ലെങ്കിൽ, അത് ഒരു കാച്ചിംഗ് പ്രശ്നമായിരിക്കാം. ക്ലയന്റിലും സെർവറിലും കാഷുകൾ വൃത്തിയാക്കാൻ ശ്രമിക്കുക. എഒഎസ് യഥാർത്ഥത്തിൽ പുനരാരംഭിക്കേണ്ട ആവശ്യമില്ല, പക്ഷേ ഇത് അവസാന ആശ്രയമായിരിക്കാം.