ଡାଇନାମିକ୍ସ AX 2012 ସିସଅପରେସନ୍ ଫ୍ରେମୱାର୍କ ଶୀଘ୍ର ସମୀକ୍ଷା

ପ୍ରକାଶିତ: 10:39:10 PM UTC ଠାରେ ଫେବୃଆରୀ 15, 2025

ଏହି ଲେଖାଟି Dynamics AX 2012 ଏବଂ Dynamics 365 for Operations ରେ SysOperation ଫ୍ରେମୱାର୍କରେ ପ୍ରକ୍ରିୟାକରଣ ଶ୍ରେଣୀ ଏବଂ ବ୍ୟାଚ୍ କାର୍ଯ୍ୟଗୁଡ଼ିକୁ କିପରି କାର୍ଯ୍ୟକାରୀ କରିବେ ସେ ବିଷୟରେ ଏକ ସଂକ୍ଷିପ୍ତ ସାରାଂଶ (କିମ୍ବା ଚିଟ୍ ସିଟ୍) ପ୍ରଦାନ କରେ।

ଏହି ପୃଷ୍ଠାକୁ ଅଧିକରୁ ଅଧିକ ଲୋକଙ୍କ ପାଖରେ ପହଞ୍ଚାଇବା ପାଇଁ ଇଂରାଜୀରୁ ମେସିନ୍ ଅନୁବାଦ କରାଯାଇଥିଲା। ଦୁର୍ଭାଗ୍ୟବଶତଃ, ମେସିନ୍ ଅନୁବାଦ ଏପର୍ଯ୍ୟନ୍ତ ଏକ ସିଦ୍ଧ ପ୍ରଯୁକ୍ତିବିଦ୍ୟା ନୁହେଁ, ତେଣୁ ତ୍ରୁଟି ହୋଇପାରେ। ଯଦି ଆପଣ ଚାହାଁନ୍ତି, ତେବେ ଆପଣ ଏଠାରେ ମୂଳ ଇଂରାଜୀ ସଂସ୍କରଣ ଦେଖିପାରିବେ:

Dynamics AX 2012 SysOperation Framework Quick Overview

ଏହି ପୋଷ୍ଟରେ ଥିବା ସୂଚନା ଡାଇନାମିକ୍ସ AX 2012 R3 ଉପରେ ଆଧାରିତ। ଏହା ଅନ୍ୟ ସଂସ୍କରଣ ପାଇଁ ବୈଧ ହୋଇପାରେ କିମ୍ବା ନ ହୋଇପାରେ। (ଅପଡେଟ୍: ମୁଁ ନିଶ୍ଚିତ କରିପାରିବି ଯେ ଏହି ଆର୍ଟିକିଲରେ ଥିବା ସୂଚନା ଅପରେସନ୍ ପାଇଁ ଡାଇନାମିକ୍ସ 365 ପାଇଁ ମଧ୍ୟ ବୈଧ)

ଏହି ପୋଷ୍ଟଟି କେବଳ ଏକ ସଂକ୍ଷିପ୍ତ ସମୀକ୍ଷା ଏବଂ ଚିଟ୍ ସିଟ୍ ପାଇଁ ଉଦ୍ଦିଷ୍ଟ। ଯଦି ଆପଣ SysOperation ଫ୍ରେମୱାର୍କରେ ନୂତନ, ତେବେ ମୁଁ ଦୃଢ଼ ଭାବରେ ପରାମର୍ଶ ଦେଉଛି ଯେ ଆପଣ ଏହି ବିଷୟ ଉପରେ Microsoft ର ଶ୍ୱେତପତ୍ର ମଧ୍ୟ ପଢ଼ନ୍ତୁ। ଯଦି ଆପଣଙ୍କୁ ଏହି ଫ୍ରେମୱାର୍କ ସହିତ କାର୍ଯ୍ୟ ବିକାଶ କରିବାରେ ଜଡିତ ବିଭିନ୍ନ ଶ୍ରେଣୀ ଉପରେ ଶୀଘ୍ର ବ୍ରଶ୍ କରିବାକୁ ପଡିବ, ତେବେ ଏଠାରେ ଥିବା ସୂଚନା ଉପଯୋଗୀ ହୋଇପାରେ।

ଏଥିରେ ପରିବର୍ତ୍ତନ ଅଛି, କିନ୍ତୁ ଯେତେବେଳେ ମୁଁ ଫ୍ରେମୱାର୍କ ବ୍ୟବହାର କରେ, ମୁଁ ସାଧାରଣତଃ ତିନୋଟି ଶ୍ରେଣୀ କାର୍ଯ୍ୟକାରୀ କରେ:

ଡାଟା ଚୁକ୍ତିନାମା (SysOperationDataContractBase କୁ ବିସ୍ତାର କରିବା ଉଚିତ)
ସେବା (SysOperationServiceBase କୁ ବିସ୍ତାର କରିବା ଉଚିତ)
ନିୟନ୍ତ୍ରକ (SysOperationServiceController କୁ ବିସ୍ତାର କରିବା ଆବଶ୍ୟକ )

ଏହା ସହିତ, ମୁଁ ଏକ UIBuilder ଶ୍ରେଣୀ ମଧ୍ୟ କାର୍ଯ୍ୟକାରୀ କରିପାରେ (SysOperationUIBuilder କୁ ବିସ୍ତାର କରିବା ଆବଶ୍ୟକ ), କିନ୍ତୁ ଏହା କେବଳ ସେତେବେଳେ ଆବଶ୍ୟକ ଯଦି କୌଣସି କାରଣରୁ ସଂଳାପ ଫ୍ରେମୱାର୍କ ଦ୍ୱାରା ସ୍ୱୟଂଚାଳିତ ଭାବରେ ସୃଷ୍ଟି ହେଉଥିବା ଅପେକ୍ଷା ଅଧିକ ଉନ୍ନତ ହେବାକୁ ପଡ଼େ।

ଡାଟା ଚୁକ୍ତି

ଡାଟା କଣ୍ଟ୍ରାକ୍ଟ ଆପଣଙ୍କ କାର୍ଯ୍ୟ ପାଇଁ ଆବଶ୍ୟକ ଡାଟା ସଦସ୍ୟମାନଙ୍କୁ ଧାରଣ କରେ। ଏହାକୁ RunBase ଫ୍ରେମୱାର୍କରେ ପରିଭାଷିତ ସାଧାରଣ CurrentList ମାକ୍ରୋ ସହିତ ତୁଳନା କରାଯାଇପାରିବ, କିନ୍ତୁ ଏହା ବଦଳରେ ଏକ ଶ୍ରେଣୀ ଭାବରେ କାର୍ଯ୍ୟକାରୀ କରାଯାଏ। ଡାଟା କଣ୍ଟ୍ରାକ୍ଟ SysOperationDataContractBase କୁ ବିସ୍ତାର କରିବା ଉଚିତ, କିନ୍ତୁ ଏହା ନହେଲେ ମଧ୍ୟ କାମ କରିବ। ସୁପର କ୍ଲାସକୁ ବିସ୍ତାର କରିବାର ସୁବିଧା ହେଉଛି ଏହା କିଛି ସେସନ୍ ସୂଚନା ପ୍ରଦାନ କରେ ଯାହା ଉପଯୋଗୀ ହୋଇପାରେ।

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

ଏହି ଉଦାହରଣରେ, itemId ହେଉଛି ଏକ ଡାଟା ସଦସ୍ୟ। ଆପଣଙ୍କୁ ପ୍ରତ୍ୟେକ ଡାଟା ସଦସ୍ୟ ପାଇଁ ଏକ parm ପଦ୍ଧତି କାର୍ଯ୍ୟକାରୀ କରିବାକୁ ପଡିବ ଏବଂ ଏହାକୁ 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));
}

ତେବେ MyController ଶ୍ରେଣୀର ମୁଖ୍ୟ ପଦ୍ଧତି ଏତେ ସରଳ ହୋଇପାରେ

public static void main(Args _args)
{
    ;

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

ଏବଂ ତୁମେ ମୌଳିକ ଭାବରେ କାମ କରିଛ। ଉପରୋକ୍ତ ଉଦାହରଣ ସ୍ପଷ୍ଟ ଭାବରେ ଏକ ଅତି ସରଳ ଉଦାହରଣ ଏବଂ ଫ୍ରେମୱାର୍କରେ ଅନ୍ୟାନ୍ୟ ବିକଳ୍ପ ଏବଂ ସମ୍ଭାବନାର ପ୍ରଚୁରତା ରହିଛି, କିନ୍ତୁ ଯଦି ତୁମେ କିଛି ସମୟ ପାଇଁ ଫ୍ରେମୱାର୍କ ବ୍ୟବହାର କରିନାହଁ, ତେବେ ଏହା ଏକ ଶୀଘ୍ର ସାରାଂଶ ଭାବରେ କାମ କରେ।