ગતિશીલતા AX 2012 SysOperation ફ્રેમવર્ક ઝડપી ઝાંખી

પ્રકાશિત: 15 ફેબ્રુઆરી, 2025 એ 10:37:34 PM UTC વાગ્યે
છેલ્લે અપડેટ કરેલ: 12 જાન્યુઆરી, 2026 એ 08:40:13 AM UTC વાગ્યે

આ લેખ Dynamics AX 2012 અને Dynamics 365 for Operations માં SysOperation ફ્રેમવર્કમાં પ્રોસેસિંગ ક્લાસ અને બેચ જોબ્સ કેવી રીતે અમલમાં મૂકવા તે અંગે એક ઝડપી ઝાંખી (અથવા ચીટ શીટ) પ્રદાન કરે છે.

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

Dynamics AX 2012 SysOperation Framework Quick Overview

આ પોસ્ટમાંની માહિતી ડાયનેમિક્સ AX 2012 R3 પર આધારિત છે. તે અન્ય સંસ્કરણો માટે માન્ય હોઈ શકે છે અથવા ન પણ હોઈ શકે. (અપડેટ: હું પુષ્ટિ કરી શકું છું કે આ લેખમાંની માહિતી ઓપરેશન્સ માટે ડાયનેમિક્સ 365 માટે પણ માન્ય છે)

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

તેમાં વિવિધતાઓ છે, પરંતુ જ્યારે હું ફ્રેમવર્કનો ઉપયોગ કરું છું ત્યારે હું સામાન્ય રીતે ત્રણ વર્ગોનો અમલ કરું છું:

ડેટા કોન્ટ્રાક્ટ (SysOperationDataContractBase ને વિસ્તૃત કરવું જોઈએ)
સેવા (SysOperationServiceBase ને વિસ્તૃત કરવી જોઈએ)
નિયંત્રક (SysOperationServiceController ને વિસ્તૃત કરવું આવશ્યક છે)

વધુમાં, હું UIBuilder ક્લાસ પણ અમલમાં મૂકી શકું છું (SysOperationUIBuilder ને વિસ્તૃત કરવું આવશ્યક છે), પરંતુ તે ફક્ત ત્યારે જ જરૂરી છે જો કોઈ કારણોસર સંવાદ ફ્રેમવર્ક આપમેળે જનરેટ કરે છે તેના કરતા વધુ અદ્યતન હોવો જોઈએ.

ડેટા કરાર

ડેટા કોન્ટ્રેક્ટ તમારા ઓપરેશન માટે જરૂરી ડેટા મેમ્બર્સ ધરાવે છે. તેની તુલના રનબેઝ ફ્રેમવર્કમાં વ્યાખ્યાયિત લાક્ષણિક CurrentList મેક્રો સાથે કરી શકાય છે, પરંતુ તેના બદલે તેને ક્લાસ તરીકે અમલમાં મૂકવામાં આવે છે. ડેટા કોન્ટ્રેક્ટમાં 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));
}

પછી માયકન્ટ્રોલર ક્લાસની મુખ્ય પદ્ધતિ એટલી સરળ હોઈ શકે છે

public static void main(Args _args)
{
    ;

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

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

વધુ વાંચન

જો તમને આ પોસ્ટ ગમી હોય, તો તમને આ સૂચનો પણ ગમશે: