ಡೈನಾಮಿಕ್ಸ್ AX 2012 ಸಿಸ್ ಆಪರೇಷನ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ತ್ವರಿತ ಅವಲೋಕನ

ಪ್ರಕಟಣೆ: ಫೆಬ್ರವರಿ 15, 2025 ರಂದು 10:37:29 ಅಪರಾಹ್ನ UTC ಸಮಯಕ್ಕೆ

ಈ ಲೇಖನವು ಡೈನಾಮಿಕ್ಸ್ AX 2012 ಮತ್ತು ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ ಡೈನಾಮಿಕ್ಸ್ 365 ರಲ್ಲಿ SysOperation ಚೌಕಟ್ಟಿನಲ್ಲಿ ಸಂಸ್ಕರಣಾ ತರಗತಿಗಳು ಮತ್ತು ಬ್ಯಾಚ್ ಕೆಲಸಗಳನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ತ್ವರಿತ ಅವಲೋಕನವನ್ನು (ಅಥವಾ ಚೀಟ್ ಶೀಟ್) ಒದಗಿಸುತ್ತದೆ.

ಸಾಧ್ಯವಾದಷ್ಟು ಜನರಿಗೆ ಲಭ್ಯವಾಗುವಂತೆ ಮಾಡಲು ಈ ಪುಟವನ್ನು ಇಂಗ್ಲಿಷ್‌ನಿಂದ ಯಂತ್ರಭಾಷಾಂತರಿಸಲಾಗಿದೆ. ದುರದೃಷ್ಟವಶಾತ್, ಯಂತ್ರಭಾಷಾಂತರವು ಇನ್ನೂ ಪರಿಪೂರ್ಣ ತಂತ್ರಜ್ಞಾನವಾಗಿಲ್ಲ, ಆದ್ದರಿಂದ ದೋಷಗಳು ಸಂಭವಿಸಬಹುದು. ನೀವು ಬಯಸಿದರೆ, ನೀವು ಮೂಲ ಇಂಗ್ಲಿಷ್ ಆವೃತ್ತಿಯನ್ನು ಇಲ್ಲಿ ವೀಕ್ಷಿಸಬಹುದು:

Dynamics AX 2012 SysOperation Framework Quick Overview

ಈ ಪೋಸ್ಟ್‌ನಲ್ಲಿರುವ ಮಾಹಿತಿಯು ಡೈನಾಮಿಕ್ಸ್ 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;
}

ಸೇವೆ

ಸೇವಾ ವರ್ಗವು ನಿಜವಾದ ವ್ಯವಹಾರ ತರ್ಕವನ್ನು ಒಳಗೊಂಡಿರುವ ವರ್ಗವಾಗಿದೆ. ಇದು ಸಂವಾದಗಳನ್ನು ತೋರಿಸುವುದು, ಬ್ಯಾಚ್ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು ಅಥವಾ ಅಂತಹ ಯಾವುದನ್ನಾದರೂ ತೋರಿಸುವುದರ ಬಗ್ಗೆ ಕಾಳಜಿ ವಹಿಸುವುದಿಲ್ಲ - ಅದು ನಿಯಂತ್ರಕ ವರ್ಗದ ಜವಾಬ್ದಾರಿಯಾಗಿದೆ. ಇದನ್ನು ಬೇರ್ಪಡಿಸುವ ಮೂಲಕ, ನೀವು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಚೆನ್ನಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸುವ ಮತ್ತು ಹೆಚ್ಚು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ಮಾಡುವ ಸಾಧ್ಯತೆ ಹೆಚ್ಚು.

ಡೇಟಾ ಒಪ್ಪಂದ ವರ್ಗದಂತೆ, ಸೇವಾ ವರ್ಗವು ನಿರ್ದಿಷ್ಟವಾಗಿ ಯಾವುದರಿಂದಲೂ ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯಬೇಕಾಗಿಲ್ಲ, ಆದರೆ ಸೂಪರ್ ವರ್ಗವು ಬ್ಯಾಚ್ ಸಂದರ್ಭದ ಬಗ್ಗೆ ಕೆಲವು ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸುವುದರಿಂದ, ಸೇವೆಯನ್ನು ಬ್ಯಾಚ್ ಕೆಲಸವಾಗಿ ರನ್ ಮಾಡಲಾಗುತ್ತದೆ ಎಂದು ನೀವು ನಿರೀಕ್ಷಿಸಿದರೆ, ಅದು 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));
}

ನಂತರ ಮೈಕಂಟ್ರೋಲರ್ ವರ್ಗದ ಮುಖ್ಯ ವಿಧಾನವು ಸರಳವಾಗಿರಬಹುದು

public static void main(Args _args)
{
    ;

    MyController::construct().startOperation();
}

ಮತ್ತು ನೀವು ಮೂಲತಃ ಮುಗಿಸಿದ್ದೀರಿ. ಮೇಲೆ ಹೇಳಿದ್ದು ಸ್ಪಷ್ಟವಾಗಿ ತುಂಬಾ ಸರಳ ಉದಾಹರಣೆಯಾಗಿದೆ ಮತ್ತು ಫ್ರೇಮ್‌ವರ್ಕ್ ಇತರ ಆಯ್ಕೆಗಳು ಮತ್ತು ಸಾಧ್ಯತೆಗಳ ಸಮೃದ್ಧಿಯನ್ನು ಹೊಂದಿದೆ, ಆದರೆ ನೀವು ಸ್ವಲ್ಪ ಸಮಯದವರೆಗೆ ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ಬಳಸದೇ ಇರುವಾಗ ನೀವು ಸ್ವಲ್ಪ ಸಮಯದವರೆಗೆ ಸುಧಾರಿಸಬೇಕಾದರೆ ಇದು ತ್ವರಿತ ಅವಲೋಕನವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.