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

ప్రచురణ: 15 ఫిబ్రవరి, 2025 10:36:44 PM UTCకి

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

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

Dynamics AX 2012 SysOperation Framework Quick Overview

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

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

వైవిధ్యాలు ఉన్నాయి, కానీ నేను ఫ్రేమ్వర్క్ను ఉపయోగించినప్పుడు నేను సాధారణంగా మూడు తరగతులను అమలు చేస్తాను:

డేటా కాంట్రాక్ట్ (SysOperationDataContractBaseని పొడిగించాలి)
సేవ (SysOperationServiceBaseని విస్తరించాలి)
కంట్రోలర్ (తప్పనిసరిగా పొడిగించాలి SysOperationServiceController)

అదనంగా, నేను ఒక UI బిల్డర్ తరగతిని కూడా అమలు చేయవచ్చు (SysOprationUIBuilderను పొడిగించాలి ), కానీ కొన్ని కారణాల వల్ల సంభాషణ స్వయంచాలకంగా ఉత్పత్తి చేసే దానికంటే మరింత అడ్వాన్స్ డ్ గా ఉండాలి.

డేటా కాంట్రాక్ట్

డేటా కాంట్రాక్ట్ మీ ఆపరేషన్ కు అవసరమైన డేటా సభ్యులను కలిగి ఉంటుంది. దీనిని రన్ బేస్ ఫ్రేమ్ వర్క్ లో నిర్వచించిన సాధారణ కరెంట్ లిస్ట్ మాక్రోతో పోల్చవచ్చు, కానీ బదులుగా ఒక తరగతిగా అమలు చేయవచ్చు. డేటా కాంట్రాక్ట్ SysOperationDataContractబేస్ ను పొడిగించాలి, కానీ అది చేయకపోయినా పనిచేస్తుంది. సూపర్ క్లాసును పొడిగించడం వల్ల కలిగే ప్రయోజనం ఏమిటంటే, ఇది కొన్ని సెషన్ సమాచారాన్ని అందిస్తుంది.

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

కంట్రోలర్

కంట్రోలర్ క్లాస్ మీ ఆపరేషన్ యొక్క అమలు మరియు బ్యాచ్ ప్రాసెసింగ్ ను నిర్వహిస్తుంది. గరిష్ట పనితీరు కోసం సిఐఎల్ లో కోడ్ అమలు చేయబడిందని కూడా ఇది నిర్ధారిస్తుంది. కంట్రోలర్ తరగతి సాధారణంగా సిస్ఆపరేషన్ సర్వీసెస్ కంట్రోలర్ తరగతి నుండి వారసత్వంగా పొందుతుంది, అయినప్పటికీ ఇతర ఎంపికలు కూడా ఉన్నాయి.

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();
}

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