డైనమిక్స్ AX 2012 లో ఏ సబ్‌క్లాస్‌ను ఇన్‌స్టాంటియేట్ చేయాలో తెలుసుకోవడానికి SysExtension ఫ్రేమ్‌వర్క్‌ని ఉపయోగించడం

ప్రచురణ: 16 ఫిబ్రవరి, 2025 12:26:19 AM UTCకి

ఈ వ్యాసం డైనమిక్స్ AX 2012 మరియు డైనమిక్స్ 365 ఫర్ ఆపరేషన్స్‌లో అంతగా తెలియని SysExtension ఫ్రేమ్‌వర్క్‌ను ఉపయోగించి లక్షణ అలంకరణల ఆధారంగా ఉప తరగతులను ఎలా తక్షణం రూపొందించాలో వివరిస్తుంది, ఇది ప్రాసెసింగ్ క్లాస్ సోపానక్రమం యొక్క సులభంగా విస్తరించదగిన డిజైన్‌ను అనుమతిస్తుంది.

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

Using the SysExtension Framework to Find Out Which Subclass to Instantiate in Dynamics AX 2012

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

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

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

అదృష్టవశాత్తూ, దీన్ని చేయడానికి చాలా సొగసైన, కానీ దురదృష్టవశాత్తు చాలా తక్కువగా తెలిసిన మార్గం ఉంది, అంటే SysExtension ఫ్రేమ్‌వర్క్ ఉపయోగించడం ద్వారా.

ఈ ఫ్రేమ్‌వర్క్ మీ సబ్ క్లాస్‌లను అలంకరించడానికి మీరు ఉపయోగించగల లక్షణాలను ఉపయోగించుకుంటుంది, తద్వారా సిస్టమ్ ఏ సబ్ క్లాస్‌ను దేనిని నిర్వహించడానికి ఉపయోగించాలో గుర్తించగలదు. మీకు ఇప్పటికీ నిర్మాణ పద్ధతి అవసరం, కానీ సరిగ్గా చేస్తే, కొత్త సబ్ క్లాస్‌లను జోడించేటప్పుడు మీరు దానిని ఎప్పటికీ సవరించాల్సిన అవసరం ఉండదు.

ఒక ఊహాత్మక ఉదాహరణను చూద్దాం మరియు మీరు InventTrans పట్టిక ఆధారంగా ఒక విధమైన ప్రాసెసింగ్ చేసే సోపానక్రమాన్ని అమలు చేయబోతున్నారని అనుకుందాం. ఏ ప్రాసెసింగ్ చేయాలో అనేది రికార్డుల యొక్క StatusReceipt మరియు StatusIssueపై ఆధారపడి ఉంటుంది, అలాగే రికార్డులు SalesLine, PurchLine లేదా రెండింటికీ సంబంధించినవా అనే దానిపై ఆధారపడి ఉంటుంది. ఇప్పటికే, మీరు చాలా విభిన్న కలయికలను చూస్తున్నారు.

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

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

మీ సోపానక్రమం ప్రస్తుతానికి ఇలా కనిపించవచ్చు:

నాప్రాసెసర్
- నాప్రాసెసర్_సేల్స్
  - నాప్రాసెసర్_సేల్స్_రిజర్వ్ చేయబడింది
  - నాప్రాసెసర్_సేల్స్_రిజర్వ్ ఫిజికల్

ఇప్పుడు, మీరు సూపర్ క్లాస్‌లో ModuleInventPurchSales మరియు StatusIssue enum ఆధారంగా సబ్‌క్లాస్‌ను ఇన్‌స్టాంటియేట్ చేసే పద్ధతిని సులభంగా అమలు చేయవచ్చు. కానీ మీరు సబ్ క్లాస్‌ను జోడించిన ప్రతిసారీ సూపర్ క్లాస్‌ను సవరించాల్సి ఉంటుంది మరియు అది నిజంగా ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్‌లో వారసత్వం యొక్క ఆలోచన కాదు. అన్నింటికంటే, మీరు కొత్త బ్యాచ్ జాబ్‌ను జోడించిన ప్రతిసారీ RunBaseBatch లేదా SysOperationServiceBaseను సవరించాల్సిన అవసరం లేదు.

బదులుగా, మీరు SysExtension ఫ్రేమ్‌వర్క్‌ను ఉపయోగించుకోవచ్చు. దానికి మీరు మరొక తరగతిని జోడించాల్సి ఉంటుంది, దీనికి SysAttributeని పొడిగించాలి. ఈ తరగతి మీరు మీ ప్రాసెసింగ్ తరగతులను అలంకరించగల లక్షణంగా ఉపయోగించబడుతుంది.

ఈ క్లాస్ మీరు SysOperation అమలు కోసం డేటా కాంట్రాక్ట్ క్లాస్‌ను ఎలా తయారు చేస్తారో దానికి చాలా పోలి ఉంటుంది, దీనిలో కొన్ని డేటా సభ్యులు మరియు ఆ విలువలను పొందడానికి మరియు సెట్ చేయడానికి parm పద్ధతులు ఉంటాయి.

మా విషయంలో, క్లాస్‌డిక్లరేషన్ ఇలా ఉండవచ్చు:

class MyProcessorSystemAttribute extends SysAttribute
{
    ModuleInventPurchSales  module;
    StatusIssue             statusIssue;
    StatusReceipt           statusReceipt
}

మీరు అన్ని డేటా సభ్యులను ఇన్‌స్టాంటియేట్ చేయడానికి ఒక కొత్త() పద్ధతిని తయారు చేయాలి. మీరు కోరుకుంటే వాటిలో కొన్ని లేదా అన్ని డిఫాల్ట్ విలువలను ఇవ్వవచ్చు, కానీ నేను అలా చేయలేదు.

public void new(ModuleInventPurchSales  _module,
                StatusIssue             _statusIssue,
                StatusReceipt           _statusReceipt)
{
    ;

    super();

    module          = _module;
    statusIssue     = _statusIssue;
    statusReceipt   = _statusReceipt;
}

మరియు మీరు ప్రతి డేటా సభ్యునికి ఒక పార్మ్ పద్ధతిని కూడా అమలు చేయాలి, కానీ మీరు దానిని ఎలా చేయాలో తెలుసుకుంటారని నేను ఖచ్చితంగా అనుకుంటున్నాను కాబట్టి నేను వాటిని ఇక్కడ విస్మరించాను - లేకపోతే, దీనిని ఒక వ్యాయామంగా పరిశీలిద్దాం ;-)

ఇప్పుడు మీరు మీ ప్రతి ప్రాసెసింగ్ క్లాస్‌ను అలంకరించడానికి మీ లక్షణ తరగతిని ఉపయోగించవచ్చు. ఉదాహరణకు, క్లాస్ డిక్లరేషన్‌లు ఇలా ఉండవచ్చు:

[MyProcessorSystemAttribute(ModuleInventPurchSales::Sales,
                            StatusIssue::None,
                            StatusReceipt::None)]
class MyProcessor_Sales extends MyProcessor
{
}

[MyProcessorSystemAttribute(ModuleInventPurchSales::Sales,
                            StatusIssue::ReservOrdered,
                            StatusReceipt::None)]
class MyProcessor_Sales_ReservOrdered extends MyProcessor_Sales
{
}

[MyProcessorSystemAttribute(ModuleInventPurchSales::Sales,
                            StatusIssue::ReservPhysical,
                            StatusReceipt::None)]
class MyProcessor_Sales_ReservPhysical extends MyProcessor_Sales
{
}

మీరు మీ తరగతులకు మీకు నచ్చిన విధంగా పేరు పెట్టవచ్చు, ఇక్కడ ముఖ్యమైన భాగం ఏమిటంటే, మీ తరగతులు ఏ రకమైన ప్రాసెసింగ్ చేస్తాయో దానికి అనుగుణంగా ఉండే లక్షణాలతో అలంకరించడం. (కానీ డైనమిక్స్ AXలో తరగతి సోపానక్రమాలకు నామకరణ సంప్రదాయాలు ఉన్నాయని గుర్తుంచుకోండి మరియు వీలైతే వాటిని అనుసరించడం ఎల్లప్పుడూ మంచి ఆలోచన).

ఇప్పుడు మీరు మీ తరగతులను అలంకరించారు, వాటిలో ప్రతి ఒక్కటి ఎలాంటి ప్రాసెసింగ్ చేస్తుందో గుర్తించడానికి, మీరు అవసరమైన విధంగా ఉప తరగతుల వస్తువులను ఇన్‌స్టాంటియేట్ చేయడానికి SysExtension ఫ్రేమ్‌వర్క్‌ను ఉపయోగించుకోవచ్చు.

మీ సూపర్ క్లాస్ (మైప్రాసెసర్) లో, మీరు ఇలాంటి నిర్మాణ పద్ధతిని జోడించవచ్చు:

public static MyProcessor construct(ModuleInventPurchSales _module,
StatusIssue _statusIssue,
StatusReceipt _statusReceipt)
{
    MyProcessor                 ret;
    MyProcessorSystemAttribute  attribute;
    ;

    attribute = new MyProcessorSystemAttribute( _module,
                                                _statusIssue,
                                                _statusReceipt);

    ret = SysExtensionAppClassFactory::getClassFromSysAttribute(classStr(MyProcessor), attribute);

    if (!ret)
    {
        //  no class found
        //  here you could throw an error, instantiate a default
        //  processor instead, or just do nothing, up to you
    }

    return ret;
}

ఈ మొత్తం పోస్ట్ యొక్క నిజంగా ఆసక్తికరమైన భాగం - మరియు నిజంగా ఆబ్జెక్ట్ (క్షమించండి) - SysExtensionAppClassFactory క్లాస్‌లోని getClassFromSysAttribute() పద్ధతి. ఈ పద్ధతి ఏమిటంటే ఇది సోపానక్రమం యొక్క సూపర్ క్లాస్ పేరును అంగీకరిస్తుంది (మరియు ఈ సూపర్ క్లాస్ సోపానక్రమం పైభాగంలో ఉండవలసిన అవసరం లేదు; దీని అర్థం ఈ తరగతిని విస్తరించే తరగతులు మాత్రమే అర్హత పొందుతాయి) మరియు లక్షణ వస్తువు.

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

మీరు కోరుకున్నంత ఎక్కువ ధ్రువీకరణ లేదా తర్కాన్ని నిర్మాణ పద్ధతికి జోడించవచ్చు, కానీ ఇక్కడ ముఖ్యమైన విషయం ఏమిటంటే, ఒకసారి అమలు చేసిన తర్వాత, మీరు ఈ పద్ధతిని మళ్లీ ఎప్పటికీ సవరించాల్సిన అవసరం లేదు. మీరు సోపానక్రమానికి ఉప తరగతులను జోడించవచ్చు మరియు మీరు వాటిని తగిన విధంగా అలంకరించాలని నిర్ధారించుకున్నంత వరకు, నిర్మాణ పద్ధతి వాటిని కనుగొంటుంది, అయినప్పటికీ అవి వ్రాయబడినప్పుడు ఉనికిలో లేవు.

పనితీరు గురించి ఏమిటి? నిజాయితీగా చెప్పాలంటే నేను దీన్ని బెంచ్‌మార్క్ చేయడానికి ప్రయత్నించలేదు, కానీ ఇది బహుశా క్లాసిక్ స్విచ్ స్టేట్‌మెంట్ డిజైన్ కంటే అధ్వాన్నంగా పనిచేస్తుందని నా అంతర్లీన భావన. అయితే, డైనమిక్స్ AXలో చాలా పనితీరు సమస్యలు డేటాబేస్ యాక్సెస్ వల్ల సంభవిస్తాయని పరిగణనలోకి తీసుకుంటే, నేను దాని గురించి పెద్దగా చింతించను.

అయితే, మీరు వేలకొద్దీ వస్తువులను త్వరగా సృష్టించాల్సిన అవసరం ఉన్నదాన్ని అమలు చేస్తుంటే, మీరు మరింత దర్యాప్తు చేయాలనుకోవచ్చు, కానీ మీరు కొంత సుదీర్ఘ ప్రాసెసింగ్ చేయడానికి ఒకే వస్తువును ఇన్‌స్టాంటియేట్ చేసే క్లాసిక్ సందర్భాలలో, అది ముఖ్యమని నేను అనుమానిస్తున్నాను. అలాగే, నా ట్రబుల్షూటింగ్ చిట్కాను (తదుపరి పేరా) పరిశీలిస్తే, SysExtension ఫ్రేమ్‌వర్క్ కాషింగ్‌పై ఆధారపడి ఉన్నట్లు కనిపిస్తోంది, కాబట్టి నడుస్తున్న సిస్టమ్‌లో ఇది గణనీయమైన పనితీరును కలిగి ఉందని నేను అనుమానిస్తున్నాను. ట్రబుల్షూటింగ్: నిర్మాణ పద్ధతి మీ ఉప తరగతులను సరిగ్గా అలంకరించబడిందని మీరు ఖచ్చితంగా చెప్పినప్పటికీ, అది కాషింగ్ సమస్య కావచ్చు. క్లయింట్ మరియు సర్వర్ రెండింటిలోనూ కాష్‌లను క్లియర్ చేయడానికి ప్రయత్నించండి. వాస్తవానికి AOSని పునఃప్రారంభించడం అవసరం లేదు, కానీ ఇది చివరి ప్రయత్నం కావచ్చు.