ಡೈನಾಮಿಕ್ಸ್ AX 2012 ನಲ್ಲಿ ಯಾವ ಉಪವರ್ಗವನ್ನು ತ್ವರಿತವಾಗಿ ಮಾಡಬೇಕು ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯಲು SysExtension ಫ್ರೇಮ್ವರ್ಕ್ ಅನ್ನು ಬಳಸುವುದು

ಪ್ರಕಟಣೆ: ಫೆಬ್ರವರಿ 16, 2025 ರಂದು 12:26:27 ಪೂರ್ವಾಹ್ನ UTC ಸಮಯಕ್ಕೆ
ಕೊನೆಯದಾಗಿ ನವೀಕರಿಸಲಾಗಿದೆ: ಜನವರಿ 12, 2026 ರಂದು 08:43:37 ಪೂರ್ವಾಹ್ನ UTC ಸಮಯಕ್ಕೆ

ಈ ಲೇಖನವು ಡೈನಾಮಿಕ್ಸ್ AX 2012 ಮತ್ತು ಡೈನಾಮಿಕ್ಸ್ 365 ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ ಕಡಿಮೆ-ತಿಳಿದಿರುವ SysExtension ಚೌಕಟ್ಟನ್ನು ಗುಣಲಕ್ಷಣ ಅಲಂಕಾರಗಳ ಆಧಾರದ ಮೇಲೆ ಉಪವರ್ಗಗಳನ್ನು ತ್ವರಿತಗೊಳಿಸಲು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ, ಇದು ಸಂಸ್ಕರಣಾ ವರ್ಗದ ಶ್ರೇಣಿಯ ಸುಲಭವಾಗಿ ವಿಸ್ತರಿಸಬಹುದಾದ ವಿನ್ಯಾಸವನ್ನು ಅನುಮತಿಸುತ್ತದೆ.

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

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

ಈ ಪೋಸ್ಟ್‌ನಲ್ಲಿರುವ ಮಾಹಿತಿಯು ಡೈನಾಮಿಕ್ಸ್ AX 2012 R3 ಅನ್ನು ಆಧರಿಸಿದೆ. ಇದು ಇತರ ಆವೃತ್ತಿಗಳಿಗೆ ಮಾನ್ಯವಾಗಿರಬಹುದು ಅಥವಾ ಇಲ್ಲದಿರಬಹುದು. (ನವೀಕರಣ: ಈ ಲೇಖನದಲ್ಲಿನ ಮಾಹಿತಿಯು ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ ಡೈನಾಮಿಕ್ಸ್ 365 ಗೆ ಸಹ ಮಾನ್ಯವಾಗಿದೆ ಎಂದು ನಾನು ಖಚಿತಪಡಿಸಬಲ್ಲೆ)

ಡೈನಾಮಿಕ್ಸ್ AX ನಲ್ಲಿ ಸಂಸ್ಕರಣಾ ತರಗತಿಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ, ಪ್ರತಿಯೊಂದು ಉಪವರ್ಗವು ಒಂದು ಎನಮ್ ಮೌಲ್ಯಕ್ಕೆ ಅನುಗುಣವಾಗಿರುವ ಅಥವಾ ಬೇರೆ ಕೆಲವು ಡೇಟಾ ಜೋಡಣೆಯನ್ನು ಹೊಂದಿರುವ ವರ್ಗ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುವುದನ್ನು ನೀವು ಹೆಚ್ಚಾಗಿ ಎದುರಿಸಬೇಕಾಗುತ್ತದೆ. ಒಂದು ಶ್ರೇಷ್ಠ ವಿನ್ಯಾಸವೆಂದರೆ ಸೂಪರ್ ಕ್ಲಾಸ್‌ನಲ್ಲಿ ನಿರ್ಮಾಣ ವಿಧಾನವನ್ನು ಹೊಂದಿರುವುದು, ಇದು ಇನ್‌ಪುಟ್ ಆಧರಿಸಿ ಯಾವ ವರ್ಗವನ್ನು ತ್ವರಿತಗೊಳಿಸಬೇಕೆಂದು ನಿರ್ಧರಿಸುವ ಸ್ವಿಚ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಇದು ತಾತ್ವಿಕವಾಗಿ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಆದರೆ ನೀವು ಹಲವು ವಿಭಿನ್ನ ಸಂಭಾವ್ಯ ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದರೆ (ಒಂದು ಎನಮ್‌ನಲ್ಲಿ ಹಲವು ಅಂಶಗಳು ಅಥವಾ ಬಹುಶಃ ಇನ್‌ಪುಟ್ ಹಲವಾರು ವಿಭಿನ್ನ ಮೌಲ್ಯಗಳ ಸಂಯೋಜನೆಯಾಗಿರಬಹುದು), ಅದನ್ನು ನಿರ್ವಹಿಸಲು ಬೇಸರದ ಮತ್ತು ದೋಷ-ಪೀಡಿತವಾಗಬಹುದು ಮತ್ತು ವಿನ್ಯಾಸವು ಯಾವಾಗಲೂ ಅನಾನುಕೂಲತೆಯನ್ನು ಹೊಂದಿರುತ್ತದೆ, ನೀವು ಎಂದಾದರೂ ಹೊಸ ಉಪವರ್ಗವನ್ನು ಸೇರಿಸಿದರೆ ಅಥವಾ ಯಾವ ಇನ್‌ಪುಟ್ ಅನ್ನು ಆಧರಿಸಿ ಯಾವ ಉಪವರ್ಗವನ್ನು ಬಳಸಬೇಕು ಎಂಬುದನ್ನು ಬದಲಾಯಿಸಿದರೆ ನೀವು ಹೇಳಿದ ನಿರ್ಮಾಣ ವಿಧಾನವನ್ನು ಮಾರ್ಪಡಿಸಬೇಕಾಗುತ್ತದೆ.

ಅದೃಷ್ಟವಶಾತ್, ಇದನ್ನು ಮಾಡಲು ಹೆಚ್ಚು ಸೊಗಸಾದ, ಆದರೆ ದುರದೃಷ್ಟವಶಾತ್ ಕಡಿಮೆ ತಿಳಿದಿರುವ ಒಂದು ಮಾರ್ಗವಿದೆ, ಅಂದರೆ SysExtension ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ಬಳಸುವುದು.

ಈ ಚೌಕಟ್ಟು ನಿಮ್ಮ ಉಪವರ್ಗಗಳನ್ನು ಅಲಂಕರಿಸಲು ನೀವು ಬಳಸಬಹುದಾದ ಗುಣಲಕ್ಷಣಗಳ ಪ್ರಯೋಜನವನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತದೆ, ಇದರಿಂದಾಗಿ ವ್ಯವಸ್ಥೆಯು ಯಾವ ಉಪವರ್ಗವನ್ನು ಯಾವುದನ್ನು ನಿರ್ವಹಿಸಲು ಬಳಸಬೇಕೆಂದು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ನಿಮಗೆ ಇನ್ನೂ ನಿರ್ಮಾಣ ವಿಧಾನದ ಅಗತ್ಯವಿರುತ್ತದೆ, ಆದರೆ ಸರಿಯಾಗಿ ಮಾಡಿದರೆ, ಹೊಸ ಉಪವರ್ಗಗಳನ್ನು ಸೇರಿಸುವಾಗ ನೀವು ಅದನ್ನು ಎಂದಿಗೂ ಮಾರ್ಪಡಿಸಬೇಕಾಗಿಲ್ಲ.

ಒಂದು ಕಾಲ್ಪನಿಕ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ ಮತ್ತು ನೀವು ಇನ್ವೆಂಟ್‌ಟ್ರಾನ್ಸ್ ಕೋಷ್ಟಕವನ್ನು ಆಧರಿಸಿ ಕೆಲವು ರೀತಿಯ ಸಂಸ್ಕರಣೆಯನ್ನು ಮಾಡುವ ಶ್ರೇಣಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಿದ್ದೀರಿ ಎಂದು ಹೇಳೋಣ. ಯಾವ ಸಂಸ್ಕರಣೆಯನ್ನು ಮಾಡಬೇಕೆಂಬುದು ದಾಖಲೆಗಳ StatusReceipt ಮತ್ತು StatusIssue ಅನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ, ಜೊತೆಗೆ ದಾಖಲೆಗಳು SalesLine, PurchLine ಗೆ ಸಂಬಂಧಿಸಿವೆಯೇ ಅಥವಾ ಎರಡಕ್ಕೂ ಸಂಬಂಧಿಸಿವೆಯೇ ಎಂಬುದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ. ಈಗಾಗಲೇ, ನೀವು ಬಹಳಷ್ಟು ವಿಭಿನ್ನ ಸಂಯೋಜನೆಗಳನ್ನು ನೋಡುತ್ತಿದ್ದೀರಿ.

ಹಾಗಾದರೆ ಈಗ ನೀವು ಕೆಲವೇ ಸಂಯೋಜನೆಗಳನ್ನು ಮಾತ್ರ ನಿರ್ವಹಿಸಬೇಕಾಗಿದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ ಎಂದು ಹೇಳೋಣ, ಆದರೆ ಕಾಲಾನಂತರದಲ್ಲಿ ಹೆಚ್ಚು ಹೆಚ್ಚು ಸಂಯೋಜನೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನಿಮ್ಮನ್ನು ಕೇಳಲಾಗುತ್ತದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ.

ತುಲನಾತ್ಮಕವಾಗಿ ಸರಳವಾಗಿ ಹೇಳೋಣ ಮತ್ತು ಈಗ ನೀವು ಸೇಲ್ಸ್‌ಲೈನ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ದಾಖಲೆಗಳನ್ನು ರಿಸರ್ವ್‌ಫಿಸಿಕಲ್ ಅಥವಾ ರಿಸರ್ವ್‌ಆರ್ಡರ್ಡ್‌ನ ಸ್ಟೇಟಸ್ ಇಶ್ಯೂನೊಂದಿಗೆ ಮಾತ್ರ ನಿರ್ವಹಿಸಬೇಕಾಗಿದೆ, ಎಲ್ಲಾ ಇತರ ಸಂಯೋಜನೆಗಳನ್ನು ಇದೀಗ ನಿರ್ಲಕ್ಷಿಸಬಹುದು, ಆದರೆ ನೀವು ಅವುಗಳನ್ನು ನಂತರ ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿರುವುದರಿಂದ, ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸುಲಭವಾಗಿ ವಿಸ್ತರಿಸಬಹುದಾದ ರೀತಿಯಲ್ಲಿ ವಿನ್ಯಾಸಗೊಳಿಸಲು ನೀವು ಬಯಸುತ್ತೀರಿ.

ನಿಮ್ಮ ಕ್ರಮಾನುಗತವು ಇದೀಗ ಈ ರೀತಿ ಕಾಣಿಸಬಹುದು:

ನನ್ನಪ್ರೊಸೆಸರ್ನನ್ನಪ್ರೊಸೆಸರ್_ಮಾರಾಟಗಳುನನ್ನಪ್ರೊಸೆಸರ್_ಮಾರಾಟ_ರಿಸರ್ವ್ಆರ್ಡರ್ ಮಾಡಲಾಗಿದೆನನ್ನಪ್ರೊಸೆಸರ್_ಮಾರಾಟ_ರಿಸರ್ವ್ಫಿಸಿಕಲ್

ಈಗ, ನೀವು ಸೂಪರ್ ಕ್ಲಾಸ್‌ನಲ್ಲಿ ModuleInventPurchSales ಮತ್ತು StatusIssue enum ಅನ್ನು ಆಧರಿಸಿದ ಉಪವರ್ಗವನ್ನು ತ್ವರಿತಗೊಳಿಸುವ ವಿಧಾನವನ್ನು ಸುಲಭವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು. ಆದರೆ ನೀವು ಪ್ರತಿ ಬಾರಿ ಉಪವರ್ಗವನ್ನು ಸೇರಿಸಿದಾಗ ಸೂಪರ್ ಕ್ಲಾಸ್ ಅನ್ನು ಮಾರ್ಪಡಿಸಬೇಕಾಗುತ್ತದೆ, ಮತ್ತು ಅದು ನಿಜವಾಗಿಯೂ ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ಆನುವಂಶಿಕತೆಯ ಕಲ್ಪನೆಯಲ್ಲ. ಎಲ್ಲಾ ನಂತರ, ನೀವು ಪ್ರತಿ ಬಾರಿ ಹೊಸ ಬ್ಯಾಚ್ ಕೆಲಸವನ್ನು ಸೇರಿಸಿದಾಗ RunBaseBatch ಅಥವಾ SysOperationServiceBase ಅನ್ನು ಮಾರ್ಪಡಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.

ಬದಲಾಗಿ, ನೀವು SysExtension ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ಬಳಸಬಹುದು. ಅದಕ್ಕೆ ನೀವು ಇನ್ನೊಂದು ವರ್ಗವನ್ನು ಸೇರಿಸಬೇಕಾಗುತ್ತದೆ, ಅದು SysAttribute ಅನ್ನು ವಿಸ್ತರಿಸಬೇಕಾಗುತ್ತದೆ. ಈ ವರ್ಗವನ್ನು ನಿಮ್ಮ ಸಂಸ್ಕರಣಾ ತರಗತಿಗಳನ್ನು ಅಲಂಕರಿಸಬಹುದಾದ ಗುಣಲಕ್ಷಣವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಈ ವರ್ಗವು SysOperation ಅನುಷ್ಠಾನಕ್ಕಾಗಿ ನೀವು ಡೇಟಾ ಒಪ್ಪಂದ ವರ್ಗವನ್ನು ಹೇಗೆ ಮಾಡುತ್ತೀರಿ ಎಂಬುದಕ್ಕೆ ಹೋಲುತ್ತದೆ, ಏಕೆಂದರೆ ಇದು ಕೆಲವು ಡೇಟಾ ಸದಸ್ಯರು ಮತ್ತು ಆ ಮೌಲ್ಯಗಳನ್ನು ಪಡೆಯಲು ಮತ್ತು ಹೊಂದಿಸಲು ಪಾರ್ಮ್ ವಿಧಾನಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ClassDeclaration ಈ ರೀತಿ ಕಾಣಿಸಬಹುದು:

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 ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸುವ ಅಗತ್ಯವಿಲ್ಲ, ಆದರೆ ಇದು ಕೊನೆಯ ಉಪಾಯವಾಗಿರಬಹುದು.

ಹೆಚ್ಚಿನ ಓದಿಗೆ

ನೀವು ಈ ಪೋಸ್ಟ್ ಅನ್ನು ಆನಂದಿಸಿದ್ದರೆ, ನೀವು ಈ ಸಲಹೆಗಳನ್ನು ಸಹ ಇಷ್ಟಪಡಬಹುದು: