Dynamics AX 2012-ലെ X++ കോഡിൽ നിന്ന് ഒരു ഇനത്തിന്റെ മൂലകങ്ങൾ എങ്ങനെ മറികടക്കാം

പ്രസിദ്ധീകരിച്ചത്: 2025, ഫെബ്രുവരി 15 11:15:41 PM UTC
അവസാനം അപ്ഡേറ്റ് ചെയ്തത്: 2026, ജനുവരി 12 8:42:26 AM UTC

ഡൈനാമിക്സ് AX 2012-ൽ ഒരു ബേസ് എനത്തിന്റെ ഘടകങ്ങൾ എങ്ങനെ എണ്ണാമെന്നും ലൂപ്പ് ചെയ്യാമെന്നും ഈ ലേഖനം വിശദീകരിക്കുന്നു, ഒരു X++ കോഡ് ഉദാഹരണം ഉൾപ്പെടെ.

ഈ പേജ് കഴിയുന്നത്ര ആളുകൾക്ക് ആക്‌സസ് ചെയ്യുന്നതിനായി ഇംഗ്ലീഷിൽ നിന്ന് മെഷീൻ വിവർത്തനം ചെയ്‌തിരിക്കുന്നു. നിർഭാഗ്യവശാൽ, മെഷീൻ വിവർത്തനം ഇതുവരെ പൂർണ്ണത നേടിയിട്ടില്ലാത്ത ഒരു സാങ്കേതികവിദ്യയാണ്, അതിനാൽ പിശകുകൾ സംഭവിക്കാം. നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ഇവിടെ യഥാർത്ഥ ഇംഗ്ലീഷ് പതിപ്പ് കാണാൻ കഴിയും:

How to Iterate Over the Elements of an Enum from X++ Code in Dynamics AX 2012

ഈ പോസ്റ്റിലെ വിവരങ്ങൾ ഡൈനാമിക്സ് AX 2012 R3 അടിസ്ഥാനമാക്കിയുള്ളതാണ്. മറ്റ് പതിപ്പുകൾക്ക് ഇത് സാധുതയുള്ളതോ സാധുതയില്ലാത്തതോ ആകാം.

ഒരു enum-ലെ ഓരോ എലമെന്റിനും ഒരു മൂല്യം പ്രദർശിപ്പിക്കേണ്ട ഒരു ഫോം ഞാൻ അടുത്തിടെ സൃഷ്ടിക്കുകയായിരുന്നു. ഫീൽഡുകൾ സ്വമേധയാ സൃഷ്ടിക്കുന്നതിനുപകരം (തുടർന്ന് enum എപ്പോഴെങ്കിലും പരിഷ്കരിച്ചാൽ ഫോം പരിപാലിക്കേണ്ടതുണ്ട്), റൺ ടൈമിൽ ഡിസൈനിലേക്ക് ഫീൽഡുകൾ സ്വയമേവ ചേർക്കുന്ന തരത്തിൽ അത് ചലനാത്മകമായി നടപ്പിലാക്കാൻ ഞാൻ തീരുമാനിച്ചു.

എന്നിരുന്നാലും, ഒരു എന്യൂമിലെ മൂല്യങ്ങൾ ആവർത്തിക്കുന്നത്, ഒരിക്കൽ എങ്ങനെയെന്ന് നിങ്ങൾക്ക് മനസ്സിലായിക്കഴിഞ്ഞാൽ വളരെ എളുപ്പമാണെങ്കിലും, അത് അൽപ്പം ആശയക്കുഴപ്പമുണ്ടാക്കുന്നതാണെന്ന് ഞാൻ പെട്ടെന്ന് കണ്ടെത്തി.

നിങ്ങൾ തീർച്ചയായും DictEnum ക്ലാസ്സിൽ നിന്നാണ് ആരംഭിക്കേണ്ടത്. നിങ്ങൾക്ക് കാണാൻ കഴിയുന്നതുപോലെ, സൂചികയിൽ നിന്നും മൂല്യത്തിൽ നിന്നും പേര്, ലേബൽ തുടങ്ങിയ വിവരങ്ങൾ നേടുന്നതിന് ഈ ക്ലാസ്സിൽ നിരവധി രീതികളുണ്ട്.

സൂചികയും മൂല്യവും തമ്മിലുള്ള വ്യത്യാസം, സൂചിക എന്നത് ഒരു എനമിലെ ഒരു എലമെന്റിന്റെ സംഖ്യയാണ് എന്നതാണ്, എനത്തിന്റെ ഘടകങ്ങൾ പൂജ്യത്തിൽ നിന്ന് ആരംഭിച്ച് ക്രമാനുഗതമായി അക്കമിട്ടിട്ടുണ്ടെങ്കിൽ, മൂല്യം മൂലകത്തിന്റെ യഥാർത്ഥ "മൂല്യ" സ്വത്താണ്. മിക്ക എനമുകൾക്കും 0 മുതൽ ക്രമാനുഗതമായി അക്കമിട്ടിരിക്കുന്നതിനാൽ, ഒരു എലമെന്റിന്റെ സൂചികയും മൂല്യവും പലപ്പോഴും ഒരുപോലെയായിരിക്കും, പക്ഷേ തീർച്ചയായും എല്ലായ്‌പ്പോഴും അല്ല.

പക്ഷേ ഒരു enum-ന് ഏതൊക്കെ മൂല്യങ്ങളാണുള്ളതെന്ന് നിങ്ങൾക്ക് എങ്ങനെ അറിയാം? ഇവിടെയാണ് അത് ആശയക്കുഴപ്പത്തിലാക്കുന്നത്. DictEnum ക്ലാസിൽ values() എന്ന ഒരു മെത്തേഡ് ഉണ്ട്. ഈ മെത്തേഡ് enum-ന്റെ മൂല്യങ്ങളുടെ ഒരു ലിസ്റ്റ് തിരികെ നൽകുമെന്ന് നിങ്ങൾ പ്രതീക്ഷിച്ചേക്കാം, പക്ഷേ അത് വളരെ എളുപ്പമായിരിക്കും, അതിനാൽ പകരം അത് enum-ൽ അടങ്ങിയിരിക്കുന്ന മൂല്യങ്ങളുടെ എണ്ണം തിരികെ നൽകുന്നു. എന്നിരുന്നാലും, മൂല്യങ്ങളുടെ എണ്ണത്തിന് യഥാർത്ഥ മൂല്യങ്ങളുമായി യാതൊരു ബന്ധവുമില്ല, അതിനാൽ മൂല്യാധിഷ്ഠിത രീതികളെ വിളിക്കുന്നതിന് പകരം സൂചിക അടിസ്ഥാനമാക്കിയുള്ള രീതികളെ വിളിക്കുന്നതിന് നിങ്ങൾ ഈ നമ്പർ ഉപയോഗിക്കേണ്ടതുണ്ട്.

ഈ രീതിക്ക് indexes() എന്ന് പേരിട്ടിരുന്നെങ്കിൽ, ആശയക്കുഴപ്പം കുറയുമായിരുന്നു ;-)

X++-ൽ 1-ൽ ആരംഭിക്കുന്ന അറേ, കണ്ടെയ്‌നർ സൂചികകളിൽ നിന്ന് വ്യത്യസ്തമായി, enum മൂല്യങ്ങൾ (പ്രത്യക്ഷത്തിൽ ഈ "സൂചികകൾ") 0-ൽ ആരംഭിക്കുന്നു എന്നതും ഓർമ്മിക്കുക. അതിനാൽ ഒരു enum-ലെ ഘടകങ്ങളെ ലൂപ്പ് ചെയ്യുന്നതിന് നിങ്ങൾക്ക് ഇതുപോലെ എന്തെങ്കിലും ചെയ്യാൻ കഴിയും:

DictEnum dictEnum = new DictEnum(enumNum(SalesStatus));
Counter  c;
;

for (c = 0; c < dictEnum.values(); c++)
{
    info(strFmt('%1: %2', dictEnum.index2Symbol(c), dictEnum.index2Label(c)));
}

ഇത് enum ലെ ഓരോ എലമെന്റിന്റെയും ചിഹ്നവും ലേബലും ഇൻഫോലോഗിലേക്ക് ഔട്ട്പുട്ട് ചെയ്യും.

കൂടുതൽ വായനയ്ക്ക്

നിങ്ങൾക്ക് ഈ പോസ്റ്റ് ഇഷ്ടപ്പെട്ടെങ്കിൽ, ഈ നിർദ്ദേശങ്ങളും നിങ്ങൾക്ക് ഇഷ്ടപ്പെട്ടേക്കാം: