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

પ્રકાશિત: 15 ફેબ્રુઆરી, 2025 એ 10:37:34 PM UTC વાગ્યે

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

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

Dynamics AX 2012 SysOperation Framework Quick Overview

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

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

તેમાં ભિન્નતા છે, પરંતુ જ્યારે હું માળખાનો ઉપયોગ કરું છું ત્યારે હું સામાન્ય રીતે ત્રણ વર્ગો લાગુ કરું છું:

માહિતી કરાર (SysOperationDataContractBase ને વિસ્તૃત કરવું જોઈએ)
સેવા (SysOperationServiceBase ને વિસ્તારતી હોવી જોઇએ)
નિયંત્રક (SysOperationServiceController ને વિસ્તારવુ જ જોઇએ )

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

માહિતી કરાર

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

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

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

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

    itemId = _itemId;
    return itemId;
}

સેવા

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

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

class MyService extends SysOperationServiceBase
{
}

રન તરીકે ઓળખાતી પદ્ધતિ સાથે:

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

નિયંત્રક

નિયંત્રક વર્ગ તમારા ઓપરેશનના એક્ઝેક્યુશન અને બેચ પ્રોસેસિંગનું સંચાલન કરે છે. તે એ પણ સુનિશ્ચિત કરે છે કે મહત્તમ કામગીરી માટે સીઆઈએલમાં કોડ ચલાવવામાં આવે છે. નિયંત્રક વર્ગને સામાન્ય રીતે 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();
}

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