Dynamics AX 2012 SysOperation Framework விரைவான கண்ணோட்டம்

வெளியிடப்பட்டது: 15 பிப்ரவரி, 2025 அன்று பிற்பகல் 10:36:51 UTC

இந்த கட்டுரை டைனமிக்ஸ் AX 2012 மற்றும் டைனமிக்ஸ் 365 ஃபார் ஆபரேஷன்ஸில் உள்ள SysOperation கட்டமைப்பில் செயலாக்க வகுப்புகள் மற்றும் தொகுதி வேலைகளை எவ்வாறு செயல்படுத்துவது என்பது குறித்த விரைவான கண்ணோட்டத்தை (அல்லது ஏமாற்றுத் தாள்) வழங்குகிறது.

இந்தப் பக்கம் முடிந்தவரை பலருக்கு அணுகக்கூடியதாக இருக்க வேண்டும் என்பதற்காக ஆங்கிலத்திலிருந்து இயந்திர மொழிபெயர்ப்பு செய்யப்பட்டது. துரதிர்ஷ்டவசமாக, இயந்திர மொழிபெயர்ப்பு இன்னும் முழுமையான தொழில்நுட்பமாக இல்லை, எனவே பிழைகள் ஏற்படலாம். நீங்கள் விரும்பினால், அசல் ஆங்கிலப் பதிப்பை இங்கே காணலாம்:

Dynamics AX 2012 SysOperation Framework Quick Overview

இந்த இடுகையில் உள்ள தகவல்கள் Dynamics AX 2012 R3 ஐ அடிப்படையாகக் கொண்டவை. இது மற்ற பதிப்புகளுக்கு செல்லுபடியாகலாம் அல்லது செல்லுபடியாகாமல் இருக்கலாம். (புதுப்பி: இந்த கட்டுரையில் உள்ள தகவல்கள் செயல்பாடுகளுக்கான டைனமிக்ஸ் 365 க்கும் செல்லுபடியாகும் என்பதை என்னால் உறுதிப்படுத்த முடியும்)

இந்த இடுகை ஒரு விரைவான கண்ணோட்டம் மற்றும் ஏமாற்றுத் தாள் மட்டுமே. நீங்கள் SysOperation கட்டமைப்பிற்கு புதியவர் என்றால், இந்த விஷயத்தில் மைக்ரோசாப்டின் வெள்ளை அறிக்கையையும் படிக்குமாறு நான் கடுமையாக பரிந்துரைக்கிறேன். இந்த கட்டமைப்புடன் செயல்பாடுகளை உருவாக்குவதில் ஈடுபட்டுள்ள பல்வேறு வகுப்புகளில் விரைவான தூரிகை தேவைப்பட்டால் இங்குள்ள தகவல்கள் பயனுள்ளதாக இருக்கும்.

வேறுபாடுகள் உள்ளன, ஆனால் நான் கட்டமைப்பைப் பயன்படுத்தும்போது நான் பொதுவாக மூன்று வகுப்புகளை செயல்படுத்துகிறேன்:

தரவு ஒப்பந்தம் (SysOperationDataContractBase ஐ நீட்டிக்க வேண்டும்)
சேவை (SysOperationServiceBase ஐ நீட்டிக்க வேண்டும்)
கட்டுப்படுத்தி (SysOperationServiceController ஐ நீட்டிக்க வேண்டும் )

கூடுதலாக, நான் ஒரு UIBuilder வகுப்பையும் செயல்படுத்தலாம் (SysOperationUIBuilder ஐ நீட்டிக்க வேண்டும் ), ஆனால் சில காரணங்களால் உரையாடல் கட்டமைப்பானது தானாக உருவாக்குவதை விட மேம்பட்டதாக இருந்தால் மட்டுமே அது அவசியம்.

தரவு ஒப்பந்தம்

தரவு ஒப்பந்தம் உங்கள் செயல்பாட்டிற்கு தேவையான தரவு உறுப்பினர்களை வைத்திருக்கிறது. இது ரன்பேஸ் கட்டமைப்பில் வரையறுக்கப்பட்ட வழக்கமான கரண்ட்லிஸ்ட் மேக்ரோவுடன் ஒப்பிடப்படலாம், ஆனால் அதற்கு பதிலாக ஒரு வகுப்பாக செயல்படுத்தப்படுகிறது. தரவு ஒப்பந்தம் SysOperationDataContractBase ஐ நீட்டிக்க வேண்டும், ஆனால் அது இல்லாவிட்டாலும் வேலை செய்யும். சூப்பர் கிளாஸை நீட்டிப்பதன் நன்மை என்னவென்றால், இது சில அமர்வு தகவல்களை வழங்குகிறது, அது எளிது.

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

இந்த எடுத்துக்காட்டில், உருப்படி ஒரு தரவு உறுப்பினர். ஒவ்வொரு தரவு உறுப்பினருக்கும் நீங்கள் ஒரு பார்ம் முறையை செயல்படுத்த வேண்டும் மற்றும் அதை DataMemberAttribute உடன் குறிக்க வேண்டும், எனவே கட்டமைப்பிற்கு அது என்னவென்று தெரியும். இது உங்களுக்கான உரையாடலை தானாகவே உருவாக்க கட்டமைப்பை செயல்படுத்துகிறது.

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

கட்டுப்பாடு

கட்டுப்படுத்தி வகுப்பு உங்கள் செயல்பாட்டின் செயல்படுத்தல் மற்றும் தொகுதி செயலாக்கத்தை கையாளுகிறது. அதிகபட்ச செயல்திறனுக்காக குறியீடு 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();
}

நீங்கள் அடிப்படையில் முடித்துவிட்டீர்கள். மேலே உள்ளவை வெளிப்படையாக மிகவும் எளிமையான எடுத்துக்காட்டு மற்றும் கட்டமைப்பில் ஏராளமான பிற விருப்பங்கள் மற்றும் சாத்தியக்கூறுகள் உள்ளன, ஆனால் நீங்கள் சிறிது நேரம் கட்டமைப்பைப் பயன்படுத்தாதபோது உங்களுக்கு ஒரு தூரிகை தேவைப்பட்டால் இது விரைவான கண்ணோட்டமாக செயல்படுகிறது.