ഡൈനാമിക്സ് എഎക്സ് 2012 സിസ്ഓപ്പറേഷൻ ഫ്രെയിംവർക്ക് ദ്രുത അവലോകനം

പ്രസിദ്ധീകരിച്ചത്: 2025, ഫെബ്രുവരി 15 10:38:20 PM UTC

ഡൈനാമിക്സ് AX 2012-ലും ഓപ്പറേഷനുകൾക്കായുള്ള ഡൈനാമിക്സ് 365-ലും SysOperation ഫ്രെയിംവർക്കിൽ പ്രോസസ്സിംഗ് ക്ലാസുകളും ബാച്ച് ജോലികളും എങ്ങനെ നടപ്പിലാക്കാം എന്നതിനെക്കുറിച്ചുള്ള ഒരു ദ്രുത അവലോകനം (അല്ലെങ്കിൽ ചീറ്റ് ഷീറ്റ്) ഈ ലേഖനം നൽകുന്നു.

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

Dynamics AX 2012 SysOperation Framework Quick Overview

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

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

വ്യത്യാസങ്ങളുണ്ട്, പക്ഷേ ഞാൻ ഫ്രെയിംവർക്ക് ഉപയോഗിക്കുമ്പോൾ സാധാരണയായി മൂന്ന് ക്ലാസുകൾ നടപ്പിലാക്കുന്നു:

ഡാറ്റ കരാർ (SysOperationDataContractBase വിപുലീകരിക്കണം)
സേവനം (SysOperationServiceBase വിപുലീകരിക്കണം)
കൺട്രോളർ ( SysOperationServiceController വിപുലീകരിക്കണം )

കൂടാതെ, എനിക്ക് ഒരു UIBuilder ക്ലാസ്സും നടപ്പിലാക്കാൻ കഴിയും (SysOperationUIBuilder വിപുലീകരിക്കണം ), പക്ഷേ ചില കാരണങ്ങളാൽ ഡയലോഗ് ഫ്രെയിംവർക്ക് സ്വയമേവ സൃഷ്ടിക്കുന്നതിനേക്കാൾ കൂടുതൽ വിപുലമായിരിക്കണമെങ്കിൽ മാത്രമേ അത് ആവശ്യമുള്ളൂ.

ഡാറ്റ കരാർ

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

[DataContractAttribute]
class MyDataContract extends SysOperationDataContractBase
{
    ItemId itemId;
}

ഈ ഉദാഹരണത്തിൽ, itemId ഒരു ഡാറ്റ അംഗമാണ്. ഓരോ ഡാറ്റ അംഗത്തിനും നിങ്ങൾ ഒരു parm രീതി നടപ്പിലാക്കുകയും DataMemberAttribute ഉപയോഗിച്ച് അതിനെ ടാഗ് ചെയ്യുകയും വേണം, അതുവഴി ഫ്രെയിംവർക്കിന് അത് എന്താണെന്ന് അറിയാൻ കഴിയും. ഇത് ഫ്രെയിംവർക്കിനെ നിങ്ങൾക്കായി ഡയലോഗ് സ്വയമേവ നിർമ്മിക്കാൻ പ്രാപ്തമാക്കുന്നു.

[DataMemberAttribute]
public ItemId parmItemId(ItemId _itemId = itemId)
{
    ;

    itemId = _itemId;
    return itemId;
}

സേവനം

യഥാർത്ഥ ബിസിനസ് ലോജിക് ഉൾക്കൊള്ളുന്ന ക്ലാസാണ് സർവീസ് ക്ലാസ്. ഡയലോഗുകൾ, ബാച്ച് പ്രോസസ്സിംഗ് അല്ലെങ്കിൽ അതുപോലുള്ള എന്തെങ്കിലും കാണിക്കുന്നതിൽ ഇത് ആശങ്കാകുലമല്ല - അതാണ് കൺട്രോളർ ക്ലാസിന്റെ ഉത്തരവാദിത്തം. ഇത് വേർതിരിക്കുന്നതിലൂടെ, നിങ്ങളുടെ കോഡ് നന്നായി രൂപകൽപ്പന ചെയ്യാനും കൂടുതൽ പുനരുപയോഗിക്കാവുന്ന കോഡ് നിർമ്മിക്കാനും നിങ്ങൾക്ക് കൂടുതൽ സാധ്യതയുണ്ട്.

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

class MyService extends SysOperationServiceBase
{
}

റൺ എന്ന രീതി ഉപയോഗിച്ച്:

[SysEntryPointAttribute]
public void run(MyDataContract _dataContract)
{
    // run business logic here
}

കൺട്രോളർ

നിങ്ങളുടെ പ്രവർത്തനത്തിന്റെ എക്സിക്യൂഷനും ബാച്ച് പ്രോസസ്സിംഗും കൺട്രോളർ ക്ലാസ് കൈകാര്യം ചെയ്യുന്നു. പരമാവധി പ്രകടനത്തിനായി കോഡ് CIL-ൽ എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്നുണ്ടെന്ന് ഇത് ഉറപ്പാക്കുന്നു. കൺട്രോളർ ക്ലാസ് സാധാരണയായി SysOperationServiceController ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്നു, എന്നിരുന്നാലും മറ്റ് ഓപ്ഷനുകളും ഉണ്ട്.

class MyController extends SysOperationServiceController
{
}

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

public static MyController construct()
{
    ;

    return new MyController(classStr(MyService),
    methodStr(MyService, run));
}

അപ്പോൾ MyController ക്ലാസിന്റെ പ്രധാന രീതി വളരെ ലളിതമായിരിക്കും

public static void main(Args _args)
{
    ;

    MyController::construct().startOperation();
}

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