Dynamics AX 2012 SysOperation Framework శీఘ్ర అవలోకనం

ప్రచురణ: 15 ఫిబ్రవరి, 2025 10:36:44 PM UTCకి
చివరిగా నవీకరించబడింది: 12 జనవరి, 2026 8:39:56 AM UTCకి

ఈ వ్యాసం డైనమిక్స్ AX 2012 మరియు ఆపరేషన్స్ కోసం డైనమిక్స్ 365 లోని SysOperation ఫ్రేమ్‌వర్క్‌లో ప్రాసెసింగ్ తరగతులు మరియు బ్యాచ్ ఉద్యోగాలను ఎలా అమలు చేయాలో శీఘ్ర అవలోకనాన్ని (లేదా చీట్ షీట్) అందిస్తుంది.

వీలైనంత ఎక్కువ మందికి అందుబాటులో ఉండేలా ఈ పేజీని ఇంగ్లీష్ నుండి యాంత్రికంగా అనువదించారు. దురదృష్టవశాత్తు, యాంత్రిక అనువాదం ఇంకా పరిపూర్ణమైన సాంకేతికత కాదు, కాబట్టి లోపాలు సంభవించవచ్చు. మీరు కోరుకుంటే, మీరు అసలు ఆంగ్ల సంస్కరణను ఇక్కడ చూడవచ్చు:

Dynamics AX 2012 SysOperation Framework Quick Overview

ఈ పోస్ట్‌లోని సమాచారం Dynamics AX 2012 R3 ఆధారంగా రూపొందించబడింది. ఇది ఇతర వెర్షన్‌లకు చెల్లుబాటు కావచ్చు లేదా కాకపోవచ్చు. (నవీకరణ: ఈ వ్యాసంలోని సమాచారం Dynamics 365 for Operations కు కూడా చెల్లుబాటు అవుతుందని నేను నిర్ధారించగలను)

ఈ పోస్ట్ కేవలం ఒక త్వరిత అవలోకనం మరియు చీట్ షీట్ కోసం ఉద్దేశించబడింది. మీరు 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();
}

మరియు మీరు ప్రాథమికంగా పూర్తి చేసారు. పైన పేర్కొన్నది స్పష్టంగా చాలా సులభమైన ఉదాహరణ మరియు ఫ్రేమ్‌వర్క్‌లో అనేక ఇతర ఎంపికలు మరియు అవకాశాలు ఉన్నాయి, కానీ మీరు కొంతకాలంగా ఫ్రేమ్‌వర్క్‌ను ఉపయోగించనప్పుడు మీకు బ్రష్ అప్ అవసరమైతే ఇది శీఘ్ర అవలోకనం వలె ఉపయోగపడుతుంది.

మరింత చదవడానికి

మీరు ఈ పోస్ట్‌ను ఆస్వాదించినట్లయితే, మీరు ఈ సూచనలను కూడా ఇష్టపడవచ్చు: