X++ eta C# konparazioa

Oharra

Komunitatearen interes taldeak Yammer-etik Microsoft Viva Engage-ra mugitu dira. Viva Engage komunitate batean sartzeko eta azken eztabaidetan parte hartzeko, bete Eskatu Finantza eta Eragiketak Viva Engage komunitatearen sarbidea inprimakia eta aukeratu sartu nahi duzun komunitatean.

Artikulu honek X++ eta C# sintaxia eta programazioa alderatzen ditu.

X++, C # konparazioa: Kaixo mundua

Atal honek X++ programa sinpleena C#-ko bere homologoarekin alderatzen du.

X++ eta C # arteko konparazioak

Ondorengo ataletan X++ eta C#-ren arteko oinarrizko antzekotasun eta desberdintasun batzuk deskribatzen dira.

Antzekotasunak

X++-ren ezaugarri hauek C#-rako berdinak dira:

• Lerro bakarreko (//) eta lerro anitzeko (/* */) iruzkinak.
• == (berdina) eragilea, bi balio berdinak diren ala ez zehazteko.
• != (ez da berdina) eragilea bi balio baliokideak ez diren ala ez zehazteko.
• + (plus zeinua) kate-kateen katearen eragilea.

Desberdintasunak

Ondorengo taulan C#-n desberdinak diren X++ ezaugarriak agertzen dira.

Eginbidea	X++	C#	Iruzkinak
if Baldintzapeko else adierazpenak	Instrukzioak if automatikoki boolear bihur daitekeen edozein adierazpen mota onartzen du. Adibide arruntak 0 faltsua esan nahi duen objektu bat dira int , edo nuluak gezurra esan nahi duen objektu bat.	Adierazpen honek if adierazpen boolearra eskatzen du.	Parentesi kizkurren eta parentesi kizkurren sintaxi-egitura berdina da X++ eta C# artean.
Kate literala	Kate literal bat muga daiteke metodo hauetakoren bat erabiliz: Komatxo bikoitzeko (") karaktereak. Komatxo bakuneko (') karaktere-bikotea.	Kate literal bat komatxo bikoitzeko (") karaktereekin mugatu behar da.	X++-rentzat, komatxo bikoitzak kateak mugatzeko erabili ohi dira. Hala ere, komenigarria da komatxo bakuneko karaktereak dituen kate bat mugatzea, zure kateak komatxo bikoitzak izan behar dituenean.
karakterea type	X++-en ez karaktere mota char bat. Luzera bat deklara str dezakezu, baina kate bat da oraindik: str 1 myString = "a";	A char C # da. Ezin diozu a char parametro gisa parametro bat string sartzen duen metodo bati pasatu, nahiz eta lehenik eta behin esplizituki bihur dezakezun charstring.	X++ datu motei buruzko informazio gehiago nahi izanez gero, ikus Datu mota primitiboak.
Mezuen irteera	X++-k erabiltzaileari mezuak bidaltzen dizkio Infolog leihoan. Metodo arruntak honako hauek dira: Inprimatutako adierazpena: Klaseko metodo estatikoak Global : Globala::info Global::warning Globala::errorea	Komando-lerroko programa batean, mezuak kontsolara bidal daitezke. Metodo arruntak honako hauek dira: Console.Out.WriteLine Console.Error.WriteLine

X++ eta C# laginak

Atal honek bi kode adibide sinple ditu. Lagin bat X++-n idatzita, eta bestea C#-n. Bi laginek emaitza berdina lortzen dute. X++ ezaugarri hauek erakusten dira:

• // Lerro bakarreko iruzkina
• /\* \*/ Lerro anitzeko iruzkina
• if Instrukzioa
• == Eragilea
• != Eragilea
• + Kateak kateatzeko eragilea
• Global::info mezuaren irteerarako, Global:: aurrizkiarekin eta gabe
• Orokorra: errorea mezuaren irteeran
• Komatxo bakoitzeko eta bikoitzak (' eta ") erabiltzea kate-mugatzaile gisa.

Oharra

Praktika onena komatxo bikoitzak erabiltzea da, erabiltzaileari bistara daitekeen edozein kateetan.

X++ lagina

X++ kodearen adibide hau lan moduan. Aplikazioaren objektuen zuhaitzean (AOT) Jobs izeneko nodo bat. Lagin hau Lanpostuak nodoan gehitu daiteke, eta, ondoren, lana exekutatu daiteke.

static void JobRs001a_HelloWorld(Args _args)
{
    if (1 == 1) 
    {
        // These two info() calls are identical to the X++ compiler.
        // The second form is the one typically used in X++.
        Global::info("Hello World, 1.");
        info('Hello World, 2.');
    }
    if (1 != 1)
    {
        error("This message will not appear.");
    }
    else
    {
        // These two methods are also from the Global class.
        // The + operator concatenates two strings.
        warning("This is like info, but is for warnings, 3.");
        error("This is like info, but is for errors, 4.");
    }
}

Irteerako elementua

Hona hemen Infolog leihoaren irteera: Mezua (09:49:48) Kaixo mundua, 1. Kaixo mundua, 2. Informazioa bezalakoa da, baina ohartarazpenetarako da, 3. Informazioaren antzekoa da, baina akatsak dira, 4.

C# lagina

Ondorengo C# programa aurreko X++ programaren berridatzia da.

using System;
class Pgm_CSharp
{
    static void Main( string[] args )
    {
        new Pgm_CSharp().Rs001a_CSharp_HelloWorld();
    }
    void Rs001a_CSharp_HelloWorld()
    {
        if (1 == 1) 
        {
            Console .Out .WriteLine("Hello World, Explicit .Out , 1.");
            Console .WriteLine("Hello World, Implicit default to .Out , 2.");
        }
        if (1 != 1)
        {
            Console .Error .WriteLine("This message will not appear.");
        }
        else
        {
            Console .Error .WriteLine(".Error is like .Out, but can be for warnings, 3.");
            Console .Error .WriteLine(".Error is like .Out, but is for errors, 4.");
        }
    }
}

Irteerako elementua

Hona hemen C # kontsolaren benetako irteera:

Hello World, Explicit .Out, 1. 
Hello World, Implicit default to .Out, 2. 
.Error is like .Out, but can be for warnings, 3. 
.Error is like .Out, but is for errors, 4.

X++, C# konparazioa: begiztak

Atal honek X++ eta C# arteko begizta-ezaugarriak alderatzen ditu.

Antzekotasunak

Ondorengo ezaugarriak berdinak dira X++ eta C#-n:

• Int datu mota primitiboko aldagaien adierazpenak. Beste mota primitibo batzuen adierazpenak ia berdinak dira, baina motek izen desberdinak izan ditzakete.
• Begiztak adierazten dituen bitartean.
• Break instrukzioa begizta batetik irteteko.
• Jarraitu instrukzioa begizta baten goialdera salto egiteko.
• <= (baino txikiagoa edo berdina) konparazio-eragilea.

Desberdintasunak

Ondorengo taulan C#-n desberdinak diren X++ ezaugarriak agertzen dira.

Eginbideak	X++	C#	Iruzkinak
Adierazpena for .	for adierazpena begiztarako erabilgarri.	C# for instrukzioa zertxobait desberdina for da X++-en.	C#-n, kontagailuaren osoko zenbakia deklara dezakezu instrukzioan for . X++-en, ordea, kontagailua adierazpenetik for kanpo deklaratu behar da.
++ gehikuntza eragilea.	++ gehikuntza eragilea X++-n erabilgarri. Baina ++-rekin apainduta dagoen int aldagaia instrukzio gisa bakarrik erabil daiteke, ez adierazpen gisa. Adibidez, X++ kodearen lerro hauek ez lirateke konpilatuko: int age=42; print age++; Hala ere, X++ kodearen lerro hauek konpilatuko lirateke: int age=42; age++; print age;	C# ++ eragilea X ++ eragilea baino malguagoa da.	Ondorengo kode-lerroak berdinak dira bi hizkuntzetan: ++ myInteger; myInteger++; Baina ondorengo kode-lerroek elkarren arteko efektu desberdina dute, eta C#-n soilik balio dute: yourInt = ++myInt; yourInt = myInt ++;
Modulo eragilea.	X++-en modulu-eragilea mod da.	C#-n modulu-eragilea %da.	Modulu-eragilearen sinboloak desberdinak dira, baina haien portaera berdina da bi hizkuntzetan.
Dagoeneko hasitako kontsola programa bat aldi baterako eseki.	Adierazpena pause .	C#-n, komando-lerroko programa bat kode-lerro honen bidez pausa daiteke: Console.In.Read();	X++-en, elkarrizketa-koadro modal bateko Ados botoian klik eginez. C#-n, teklatuaren edozein teklatu sakatuz jarraitu behar duzu.
Bistaratu mezu bat.	X++-en, instrukzioak print mezu bat bistaratzen du Inprimatu leihoan.	C#-n mezu bat kontsolan bistara daiteke kode-lerro honen bidez: Console.WriteLine();	X++ print funtzioa probatzen duzunean bakarrik erabiltzen da. Ia beti erabiltzen print duen X++ programa batek kodearen beranduago erabiltzen pause du adierazpena. Ekoizpeneko X++ kodeari dagokionez, erabili Global::info metodoa print. Funtzio hau strfmt askotan elkarrekin infoerabiltzen da. Ez arrazoirik ondoren pauseerabiltzekoinfo.
Egin soinu bat.	Bip funtzioak entzun dezakezun soinua sortzen du.	C#-n entzun dezakezun soinua honako kode-lerro honek igortzen du: Console.Beep();	Adierazpen bakoitzak tonu labur bat sortzen du.

Inprimatu eta Globala::info

Begiztarako X++ kode-laginek funtzioa print erabiltzen dute emaitzak bistaratzeko. X++-en instrukzioa print erabil dezakezu, edozein datu mota primitibo bistaratu ahal izango duzu, lehenik kate bihurtzen duten funtzioak deitu beharrik gabe. Proba azkarreko egoeretan erabilgarria da print . Orokorrean, Global::info metodoa maizago printerabiltzen da. Metodoak info kateak soilik bistara ditzake. Beraz, strfmt funtzioa askotan erabiltzen infoda. Muga print bat da ezin duzula Inprimatu leihoaren edukia arbelean kopiatu (adibidez, Ktrl+C erabiliz). Global::info Infolog leihoan idazten du, arbelean kopiatzea onartzen duena.

1. adibidea: Bitartean begizta

while gako-hitzak begizta onartzen du X++ eta C#-n.

X++ Bitartean

static void JobRs002a_LoopsWhile(Args _args)
{
    int nLoops = 1;
    while (nLoops <= 88)
    {
        print nLoops;
        pause;
        // The X++ modulo operator is mod.
        if ((nLoops mod 4) == 0)
        {
            break;
        }
        ++ nLoops;
    }
    beep(); // Function.
    pause; // X++ keyword.
} 

Irteerako elementua

X++ Inprimatzeko leihoaren irteera honako hau da:

1
2
3
4

C# Denboraldiaren lagin

using System;
public class Pgm_CSharp
{
    static void Main( string[] args )
    {
        new Pgm_CSharp().WhileLoops();
    }

    void WhileLoops()
    {
        int nLoops = 1;
        while (nLoops <= 88)
        {
            Console.Out.WriteLine(nLoops.ToString());
            Console.Out.WriteLine("(Press any key to resume.)");
            // Paused until user presses a key.
            Console.In.Read();
            if ((nLoops % 4) == 0) {
                break;
            }
            ++ nLoops;
        }
        Console.Beep();
        Console.In.Read();
    }
}

Irteerako elementua

C# programaren kontsolaren irteera honako hau da:

1
(Press any key to resume.)
2
(Press any key to resume.)
3
(Press any key to resume.)
4
(Press any key to resume.)

2. adibidea: for begizta

for gako-hitzak begizta onartzen du X++ eta C#-n.

X++ for lagina

X++-en, kontagailu aldagaia ezin da for instrukzioaren zati gisa deklaratu.

static void JobRs002a_LoopsWhileFor(Args _args)
{
    int ii; // The counter.
    for (ii=1; ii < 5; ii++)
    {
        print ii;
        pause;
        // You must click the OK button to proceed beyond a pause statement.
        // ii is always less than 99.
        if (ii < 99)
        {
            continue;
        }
        print "This message never appears.";
    }
    pause;
}

Irteerako elementua

X++ Inprimatzeko leihoaren irteera honako hau da:

1
2
3
4

C# for lagina

using System;
public class Pgm_CSharp
{
    static void Main( string[] args )
    {
        new Pgm_CSharp().ForLoops();
    }
    void ForLoops()
    {
        int nLoops = 1, ii;
        for (ii = 1; ii < 5; ii++)
        {
            Console.Out.WriteLine(ii.ToString());
            Console.Out.WriteLine("(Press any key to resume.)");
            Console.In.Read();
            if (ii < 99)
            {
                continue;
            }
            Console.Out.WriteLine("This message never appears.");
        }
        Console.Out.WriteLine("(Press any key to resume.)");
        Console.In.Read();
    }
}

Irteerako elementua

C# programaren kontsolaren irteera honako hau da:

1
(Press any key to resume.)
2
(Press any key to resume.)
3
(Press any key to resume.)
4
(Press any key to resume.)
(Press any key to resume.)

X++, C# konparazioa: Switch

Bai X++ bai C#-n, switch instrukzioak gako-hitzak maiuskula, etenaldia eta lehenetsia barne hartzen ditu. Ondorengo taulan X++ eta C# arteko switch-instrukzioaren desberdintasunak agertzen dira.

Eginbidea	X++	C#	Iruzkinak
break; Kasu bloke bakoitzaren amaieran	X++-n, edozein case bloke switch klausularen adierazpen-balioarekin bat datorrenean, gainerako case eta lehenetsitako bloke guztiak exekutatzen dira instrukzio batera break; iritsi arte. break; X ++ switch instrukzio batean ez da inoiz instrukziorik behar, baina break; adierazpenak garrantzitsuak dira ia egoera praktiko guztietan.	C#-n, instrukzio bat break; behar da beti kasu edo bloke lehenetsi bateko instrukzioen ondoren. Kasu klausula batek bere eta hurrengo kasu klausularen artean adierazpenik ez badu, break; ez da bi kasu klausulen artean adierazpenik behar.	Edozein kasu break; ondoren instrukzioa ez baztertzea gomendatzen dugu, kodea editatzen duen hurrengo programatzailea nahastu baitezake.
break; Bloke lehenetsiaren amaieran	X++-en ez bloke break; amaieran instrukzio bat gehitzearen efekturik.	C#-n, konpilatzaileak instrukzio bat break; behar du bloke lehenetsiaren amaieran.	Informazio gehiago nahi izanez gero, ikus Aldatu instrukzioak.
Balio konstanteak soilik maiuskula-bloke batean	X++-en, balio literal bat edo aldagai bat zehaztu dezakezu kasu-bloke batean. Adibidez, myInteger maiuskulak idatzi ditzakezu:	C#-n balio literal bat zehaztu behar duzu kasu-bloke bakoitzean, eta ez da aldagairik onartzen.	Ez iruzkinik.
Balio anitz maiuskula-bloke batean	X++-en balio anitz zehaztu ditzakezu kasu-bloke bakoitzean. Balioak koma batez bereizi behar dira. Adibidez, idatzi case 4,5,myInteger:dezakezu.	C#-n, balio bat zehaztu behar duzu kasu-bloke bakoitzean.	X++-en hobe da kasu-bloke batean balio anitz idaztea, kasu-bloke baten edo gehiagoren amaieran dagoen instrukzioa break; alde batera uztea baino.

Kode-adibideak aldatzaileentzat

Ondorengo ataletan switch instrukzio konparagarriak agertzen dira X++ eta C#-n.

X++ kommutazioaren adibidea

X++ kommutazioaren adibideak honako hau erakusten du:

• case iTemp: eta case (93-90): erakusteko kasu adierazpenak ez direla konstanteetara mugatzen, C#-n bezala.
• //break; X++-en adierazpenak ez direla beharrezkoak erakusteko break; , nahiz eta ia beti desiragarriak izan.
• case 2, (93-90), 5: X++-en kasu klausula batean adierazpen anitz zerrendatu daitezkeela erakusteko.

static void GXppSwitchJob21(Args _args)  // X++ job in AOT > Jobs.
{
    int iEnum = 3;
    int iTemp = 6;
    switch (iEnum)
    {
        case 1:
        case iTemp:  // 6
            info(strFmt("iEnum is one of these values: 1,6: %1", iEnum));
            break;
        case 2, (93-90), str2Int("5"):  // Equivalent to three 'case' clauses stacked, valid in X++.
            //case 2:
            //case (93-90):  // Value after each 'case' can be a constant, variable, or expression; in X++.
            //case str2Int("5"):
            info(strFmt("iEnum is one of these values: 2,3,5: %1", iEnum));
            //break;  // Not required in X++, but usually wanted.
        case 4:
            info(strFmt("iEnum is one of these values: 4: %1", iEnum));
            break;
        default:
            info(strFmt("iEnum is an unforeseen value: %1", iEnum));
            break;
            // None of these 'break' occurrences in this example are required for X++ compiler.
    }
    return;
}

/*** Copied from the Infolog:
Message (02:32:08 pm)
iEnum is one of these values: 2,3,5: 3
iEnum is one of these values: 4: 3
***

C# kommutadorearen adibidea

C# kommutadorearen adibideak honako hau erakusten du:

• 1. kasua: iruzkin bat dauka kasu klausula batean adierazpen konstanteak soilik eman daitezkeela azaltzen duena.
• break; instrukzioak azken instrukzioaren ondoren gertatzen dira instrukzioak dituen kasu bakoitzeko bloke bakoitzean, C#-k eskatzen duen bezala.

using System;
namespace CSharpSwitch2
{
    class Program
    {
        static void Main(string[] args)  // C#
        {
            int iEnum = 3;
            switch (iEnum)
            {
                case 1:  // Value after each 'case' must be a constant.
                case 6:
                    Console.WriteLine("iEnum is one of these values: 1,6: " + iEnum.ToString());
                    break;
                //case 2,3,5:  // In C# this syntax is invalid, and multiple 'case' clauses are needed.
                case 2:
                case 3:
                case 5:
                    Console.WriteLine("iEnum is one of these values: 2,3,5: " + iEnum.ToString());
                    break;
                case 4:
                    Console.WriteLine("iEnum is one of these values: 4: " + iEnum.ToString());
                    break;
                default:
                    Console.WriteLine("iEnum is an unforeseen value: " + iEnum.ToString());
                    break;
                // All 'break' occurrences in this example are required for C# compiler.
            }
          return;
        }
    }
}
/*** Output copied from the console:
>> CSharpSwitch2.exe
iEnum is one of these values: 2,3,5: 3
>>
***/

X++, C# konparazioa: kate-maiuskulak eta mugatzaileak

Atal honetan kateen tratamendua X++ eta C#-n maiuskula-mistoekin alderatzen da. X++-en eskuragarri dauden kate-mugatzaileak ere azaltzen ditu.

Antzekotasunak

X++-ren ezaugarri hauek C#-ren berdinak dira:

• Alderantzizko barra (\) kate-mugatzaileen ihes-eragilea da.
• at (@) zeinuak alderantzizko barra ihes-efektua baliogabetzen du at ikurra kate baten komatxo irekien aurretik idazten denean.
• Plus ikurra (+) kate-katearen kate-konkatearen eragilea da.

Desberdintasunak

C#-n desberdinak diren X++ ezaugarriak ondorengo taulan zerrendatzen dira.

Eginbidea	X++	C#	Iruzkinak
== Konparazio-eragilea	Insensitive: eragileak == ez du sentikorra kateen maiuskularen arteko desberdintasunekiko.	C#-n, eragilea == sentikorra da kateen maiuskulen arteko desberdintasunekiko.	X++-en, strCmp funtzioa erabil dezakezu kateen arteko maiuskulak eta minuskulak bereizteko.
Kate-mugatzaileak	X++-en, komatxo bakarra (') edo bikoitza (") erabil dezakezu kate-mugatzaile gisa. Oharra: Normalean, praktika onena komatxo bikoitzak erabiltzea da, erabiltzaileari bistara daitezkeen kateetan. Hala ere, komenigarria da komatxo bakunekin kate bat mugatzea komatxo bikoitza katearen karaktereetako bat denean.	C#-n, komatxo bikoitzak erabili behar dituzu kate-mugatzaile gisa. Motari System.Stringdagokio.	X++ eta C#-n mugatzaile bat kate literal batean txertatzeko eta ihes egiteko aukera duzu. X++-en komatxo bakunak komatxo bikoitz (edo alderantziz) mugatutako kate batean txertatzeko aukera ere badago, ihesbidea erabili beharrik gabe.
Karaktere-mugatzaileak	X++-k kate-datu mota bat du (str), baina ez karaktere motarik.	C#-n komatxo bakunak erabili behar dituzu karaktere-mugatzaile gisa. Motari System.Chardagokio.	.NET Framework-en, System.String luzera bat karaktere bat baino System.Char datu mota desberdina da.

1. adibidea: == eragilearen maiuskulak eta minuskulak

Eta != eragileak == ez dira maiuskulak eta minuskulak bereizten X ++-en, baina maiuskulak eta minuskulak bereizten dituzte C#-n, ondorengo adibidean erakusten den bezala.

X++	C#	Iruzkinak
"HELLO" == "hello" Egia da X++-en.	"HELLO" == "hello" Faltsua C#-n.	X++ eta C# arteko konparazio desberdinak.

2. adibidea: + katearen katearen katearen eragilea

+ eta += eragileak X++ eta C# kateak kateatzeko erabiltzen dira, ondorengo taulako adibideek erakusten duten bezala.

X++	C#	Iruzkinak
myString1 = "Hello" + " world"; Emaitza berdintasuna: myString1 == "Hello world"	(X++ bezalakoa)	Bai X++ bai C#-n, + eragilearen portaera bere operandoen datu motaren araberakoa da. Eragileak kateak konkateatzen ditu edo zenbakiak gehitzen ditu.
mystring2 = "Hello"; myString2 += " world"; Emaitza berdintasuna: myString2 == "Hello world"	(X++ bezalakoa)	X++ eta C#-n, ondorengo adierazpenak baliokideak dira: a = a + b; a += b;

3. adibidea: Kate-mugatzaileak kapsulatzea eta ihes egitea

Komatxo banatu edo bikoitzak erabil daitezke X++-en kateak mugatzeko. Ihes-karakterea (\) erabil daiteke mugatzaileak kate batean kapsulatzeko. Hauek hurrengo taulan azaltzen dira.

X++	C#	Iruzkinak
myString1 = "They said \"yes\"."; Emaitza: They said "yes".	(X++ bezalakoa)	Ihes karaktereak kate-mugatzaileak kateen barruan kapsulatzeko aukera ematen dizu.
myString2 = 'They said "yes".'; Emaitza: They said "yes".	C# sintaxiak ez du baimentzen komatxo bakundeak kateak mugatzeko.	Erabiltzaileak ikus ditzakeen kateen kasuan, praktika ona da ihes-karakterea erabiltzea komatxo bakunen ordez, adibidean erakusten den bezala.
myString3 = "They said 'yes'."; Emaitza: They said 'yes'.	(X++ bezalakoa)	X++-en, komatxo bakunak ez dira mugatzaile gisa tratatzen, katea komatxo bakarreko mugatzaile batekin hasten ez bada. C#-n, komatxo bakunek ez dute esanahi berezirik kateen kasuan, eta ezin da kateak mugatzeko erabili. C#-n komatxo bakunak beharrezko mugatzailea System.Chardira. X++-k ez du karaktere-datu motarik.
str myString4 = 'C'; Hemen komatxo bakarra kate mugatzaile bat da.	char myChar4 = 'C'; Komatxo bakunak mugatzaile bat System.Char dira, ez mugatzaile bat System.String .	X++-k ez du .NET Framework-en dagokion System.Char datu motarik. X++ katea bat luzera batera mugatzen dena kate bat da, ez karaktere-datu mota bat.

4. adibidea: Ihes karaktere bakarra

Sarreran edo irteeran ihes-karaktere bakarra erakusten duten adibideak ondorengo taulan erakusten dira.

X++	C#	Iruzkinak
myString1 = "Red\ shoe"; Emaitza: Red shoe	C#-ko kate literal batek ezin du ihesaren bi karaktere-sekuentzia eduki, eta ondoren zuriune bat, adibidez, "\". Konpilatzailearen errorea gertatzen da.	X++ konpilatzaileak "\" bi karaktere-sekuentzia aurkitzen duenean, ihes-karaktere bakarra baztertzen du.
myString2 = "Red\\ shoe"; Emaitza: Red\ shoe	(X++ bezalakoa)	Ihes egiteko pertsonaia pare batean, lehenengoak bigarrenaren esanahi berezia ezeztatzen du.

Konparazioa: Array sintaxia

Antzekotasunak eta desberdintasunak daude X++-ko array-en ezaugarri eta sintaxian C#-ren aldean.

Antzekotasunak

Orokorrean, antzekotasun handia X++ eta C#-ko matrizeen sintaxian eta tratamenduan. Hala ere, desberdintasun asko daude.

Desberdintasunak

Ondorengo taulan X++ eta C#-rako desberdinak diren matrizeen [] sintaxiko eremuak agertzen dira.

Kategoria	X++	C#	Iruzkinak
Adierazpena	Matrize bat aldagaiaren izenari parentesi karratuekin adierazten da.	Matrize bat deklaratzen da datu motari parentesi karratuekin erantsita.	int myInts[]; // X++ Oharra: X++ array bat ezin da parametro bat izan metodo batean. int[] myInts; // C#
Adierazpena	Array sintaxiak datu mota primitiboak soilik onartzen ditu, hala int nola eta str. Sintaxiak ez du klaserik edo taularik onartzen.	Array sintaxiak datu mota eta klase primitiboak onartzen ditu.	X++-en Array erabil Array dezakezu objektuen matrize baterako.
Adierazpena	X++ dimentsio bakarreko matrizeetara mugatzen da (myStrings[8]).	C#-k dimentsio anitzeko matrizeetarako (myStrings[8,3]) eta matrize zorrotzetarako (myStrings[8][3]) euskarria gehitzen du.	X++-en ezin da matrize-matrizerik izan. Hala ere, array handi batek kontsumitu dezakeen memoria aktibo kopurua mugatzeko sintaxia aurreratua, C #-ko dimentsio anitzeko sintaxiaren antza duena: int intArray[1024,16];. Informazio gehiago nahi izanez gero, ikus Praktika egokien errendimenduaren optimizazioa: matrizeak diskoan trukatzea.
Adierazpena	X++-n array bat eraikuntza berezi bat da, baina ez da objektu bat.	C#-n matrize guztiak objektuak dira, sintaxi-aldaerak kontuan hartu gabe.	X++-k Array klase bat du, baina bere azpiko mekanismoa [] sintaxia erabiliz sortutako matrizeetatik desberdina da. C#-n, matrize guztiek azpiko mekanismo bera erabiltzen dute, zure kodean [] klasearen System.Array sintaxia erabiltzen den ala ez kontuan hartu gabe.
Largura	X++-en, tamaina estatikoko matrize baten luzera deklarazioaren sintaxian zehazten da.	C#-n, matrize baten tamaina zehazten da matrize-objektua eraikitzean.	X++-en [] deklarazioaren sintaxia erabiltzen duzunean, ez da prestaketa gehiago behar matrizeari balioak esleitu aurretik. C#-n, matrizea deklaratu eta eraiki behar duzu esleitu aurretik.
Largura	X++ array batek luzera dinamikoa izan dezake, populazioa hasi ondoren ere handitu daitekeena. Hau soilik aplikatzen da matrizea zenbakirik gabe deklaratzen denean [] barruan. Errendimendua moteldu egin daiteke array dinamikoaren luzera askotan handitzen bada.	C#-n ezin da matrize baten luzera aldatu luzera ezarri ondoren.	X++ kodearen hurrengo zatian, array soilik myInts dinamikoa da eta tamaina handitu dezake. int myInts[]; int myBools[5]; myInts[2] = 12; myInts[3] = 13; myBools[6] = 26; //Error
Largura	Matrize batzuen luzera lor dezakezu funtzioa erabiliz dimOf .	C# matrizeak propietate bat Length duten objektuak dira.	Ez iruzkinik.
Indexazioa	Array indexazioa 1 oinarrituta.	Array indexazioa 0 oinarrituta.	mtIntArray[0] errorea eragingo luke X++-en.
Etengabeko	X++-en balio konstante bat lortzen da hobeto #define aurrekonpilatzailearen zuzentaraua erabiliz.	C#-n, aldagaien deklarazioa const gako-hitzarekin apaindu dezakezu, balio konstante bat lortzeko.	X++-k ez du const gako-hitzik. C#-k ezin die baliorik esleitu bere #define aurrekonpilatzailearen zuzentarauak sortutako aldagaiei.

X++ eta C# laginak

Ondorengo kode-adibideek datu mota primitiboen matrizeak nola kudeatzen diren erakusten dute. Lehenengo lagina X++ formatuan, eta bigarrena C# formatuan. Bi laginek emaitza berdinak lortzen dituzte.

X++ lagina

static void JobRs005a_ArraySimple(Args _args)
{
    #define.macroArrayLength(3)
    // Static length.
    str sSports[#macroArrayLength];
    // Dynamic length, changeable during run time.
    int years[];
    int xx;
    Global::warning("-------- SPORTS --------");
    sSports[#macroArrayLength] = "Baseball";
    for (xx=1; xx <= #macroArrayLength; xx++)
    {
        info(int2str(xx) + " , [" + sSports[xx] + "]");
    }
    warning("-------- YEARS --------");
    years[ 4] = 2008;
    years[10] = 1930;
    for (xx=1; xx <= 10; xx++)
    {
        info(int2str(xx) + " , " + int2str(years[xx]));
    }
}

Irteerako elementua

Infolog-aren irteera honakoa da:

Message (14:16:08)
-------- SPORTS --------
1 , []
2 , []
3 , [Baseball]
-------- YEARS --------
1 , 0
2 , 0
3 , 0
4 , 2008
5 , 0
6 , 0
7 , 0
8 , 0
9 , 0
10 , 1930

C# lagina

using System;
public class Pgm_CSharp
{
    static public void Main( string[] args )
    {
        new Pgm_CSharp().ArraySimple();
    }
    private void ArraySimple()
    {
        const int const_iMacroArrayLength = 3;
        // In C# the length is set at construction during run.
        string[] sSports;
        int[] years;
        int xx;
        Console.WriteLine("-------- SPORTS --------");
        sSports = new string[const_iMacroArrayLength];
        sSports[const_iMacroArrayLength - 1] = "Baseball";
        for (xx=0; xx < const_iMacroArrayLength; xx++)
        {
            Console.WriteLine(xx.ToString() + " , [" + sSports[xx] + "]");
        }
        Console.WriteLine("-------- YEARS --------");
        // In C# you must construct the array before assigning to it.
        years = new int[10];
        years[ 4] = 2008;
        years[10 - 1] = 1930;
        for (xx=0; xx < 10; xx++)
        {
            Console.WriteLine(xx.ToString() + " , [" + years[xx].ToString() + "]");
        }
    }
} // EOClass

Irteerako elementua

C# programaren irteera komando-lerroko kontsolara honakoa da:

-------- SPORTS --------
0 , []
1 , []
2 , [Baseball]
-------- YEARS --------
0 , [0]
1 , [0]
2 , [0]
3 , [0]
4 , [2008]
5 , [0]
6 , [0]
7 , [0]
8 , [0]
9 , [1930]

Array antzeko X++ ezaugarri gehigarriak

Edukiontzia X++ formatuan eskuragarri dagoen datu mota berezi bat da. Matrize baten antzekotzat har daiteke, edo bilduma baten List antzekoa.

Konparazioa: Bildumak

Finantza eta eragiketen aplikazio batean, X++ List bilduma klasea erabil dezakezu. C#-n erabiltzen den .NET Framework-ek antzeko klase System.Collections.Generic.Listbat du.

Zerrenda-klaseen erabilera konparatzea

Ondorengo taulan X++ List klaseko System.Collections.Generic.List metodoak .NET Framework eta C# metodoekin alderatzen dira.

Eginbidea	X++	C#	Iruzkinak
Bildumaren deklarazioa	List myList;	List<string> myList;	X++ deklarazioak ez du gorde beharreko elementu mota barne.
Iteradorearen deklarazioa	ListIterator iter ListEnumerator enumer;	IEnumerator<string> iter;	X++-en objektuak ListIterator metodoak ditu, eta insert elementuak deleteListditzake. X++ListEnumerator-k ezin du .List X++ ListEnumerator -en objektua beti sortzen da maila Listberean. Hori ez da beti egia izaten ListIterator.
Iteradore bat lortzea	new ListIterator (myList) myList.getEnumerator()	myList.GetEnumerator()	Bai X++ bai C#-n, List objektuak geter metodoa du asoziatutako enumeratzaile baterako.
Eraikitzailea	new List(Types::String)	new List<string>()	Klaseen barruan List gorde beharreko objektu motari buruzko informazioa eraikitzaileari ematen zaio X++ eta C#-n.
Datuak eguneratzen	Zenbatzailea: zenbatzailea baliogabetu egiten da elementuak List gehitzen edo kentzen badira. Iterator: iteradoreak elementuak Listtxertatu eta ezabatzen dituzten metodoak ditu. Iteradoreak baliozkoa izaten jarraitzen du.	Zenbatzailea: zenbatzailea baliogabetu egiten da elementuak List gehitzen edo kentzen badira.	Zenbatzaileak baliogabeak bihurtzen dira elementuak gehitu edo ezabatu Listondoren X++ eta C#-n.
Datuak eguneratzen	X++-en klaseak List zerrendaren hasieran edo amaieran elementuak gehitzeko metodoak ditu.	C#-n, klaseak List zerrendako edozein posiziotan kideak gehitzeko metodoak ditu. Elementuak edozein posiziotatik kentzeko metodoak ere baditu.	X++-n elementuak iteratore batek kendu List ditzake.

1. adibidea: Zerrenda baten deklarazioa

Ondorengo kode-adibideak X++ eta C#-n daude, bildumak deklaratzen dituztenak List .

// X++
List listStrings ,list2 ,listMerged;
ListIterator literator;

// C#
using System;
using System.Collections.Generic;
List<string> listStrings ,list2 ,listMerged; IEnumerator<string> literator;

2. adibidea: Zerrenda bat eraikitzea

Bi hizkuntzetan, bildumak gordetzen dituen elementu motak zehaztu behar dira eraikuntzaren unean. Klase moten kasuan, X++-k ezin du mota klase bat den ala ez zehatzagoa izan (Types::Class). Ondorengo kode-adibideak X++ eta C# formatuetan daude.

// X++
listStrings = new List( Types::String );

// C#
listStrings = new List<string>;

3. adibidea: Gehitu elementuak zerrenda batean

Bai X++ bai C#-n, bildumak metodo bat eskaintzen du elementu bat bildumaren amaieran erantsi eta elementu bat hasieran txertatzeko. C#-n, bildumak bildumaren edozein puntutan txertatzeko metodo bat eskaintzen du, indize-balio batean oinarrituta. X++-en, bildumaren iteratzaile batek elementu bat bere uneko posizioan txerta dezake. Ondorengo kode-adibideak X++ eta C# formatuetan daude.

// X++
listStrings.addEnd ("StringBB."); 
listStrings.addStart ("StringAA.");
// Iterator performs a midpoint insert at current position. 
listIterator.insert ("dog");

// C#
listStrings.Add ("StringBB."); 
listStrings.Insert (0 ,"StringAA.");
// Index 7 determines the insertion point.
listStrings.Insert (7 ,"dog");

4. adibidea: Zerrenda baten bidez iteratu

Bai X++ bai C#-k iteratzaile klaseak dituzte, bilduma bateko elementuak urratsez urrats egiteko erabil ditzakezunak, ondorengo adibideetan erakusten den bezala.

// X++
literator = new ListIterator (listStrings); 
// Now the iterator points at the first item.

// The more method answers whether 
// the iterator currently points 
// at an item. 
while (literator.more()) 
{ 
    info(any2str (literator.value())); 
    literator.next(); 
}

// C#
literator = listStrings .GetEnumerator(); 
// Now enumerator points before the first item, not at the first item.

// The MoveNext method both advances the item pointer, and 
// answers whether the pointer is pointing at an item. 
while (literator.MoveNext()) 
{ 
    Console.WriteLine (literator.Current); 
}

4b adibidea: foreach in C#

C#-n foreach gako-hitza askotan erabiltzen da zerrenda baten bidez iteratzeko zeregina errazteko. Ondorengo kode-adibideak aurreko C# adibidearen antzeko portaera du.

foreach (string currentString in listStrings)
{ 
    Console.WriteLine(currentString);
}

5. adibidea: Ezabatu bigarren elementua

Ondorengo kode-adibideek bigarren elementua ezabatzen dute bildumatik. X++-en iteradore bat behar da. C#-n, bildumak berak elementu bat kentzeko metodoa eskaintzen du.

// X++
literator.begin(); 
literator.next(); 
literator.delete();

// C#
listStrings.RemoveAt(1);

6. adibidea: Bi bilduma konbinatzea

Ondorengo kode-adibideek bi bildumen edukia konbinatzen dituzte bakarrean.

// X++
listStrings = List::merge(listStrings ,listStr3);
// Or use the .appendList method:
listStrings.appendList (listStr3);

// C#
listStrings.InsertRange(listStrings.Count ,listStr3);

Konparazioa: balioak dituzten gakoen bildumak

Finantza eta eragiketen aplikazio batean, bilketa klasea Map erabil dezakezu. Bildumak Map balio bikoteak ditu, gako-balioa gehi datu-balio bat. .NET Framework klasearen System.Collections.Generic.Dictionaryantzekoa da.

Antzekotasunak

Ondorengo zerrendan X++ eta C#-ren arteko antzekotasunak deskribatzen dira gako-balio bikoteak gordetzen dituzten bildumei dagokienez:

• Biek gako bikoiztuak saihesten dituzte.
• Biek zenbatzaile bat (edo iteradorea) erabiltzen dute elementuak zeharkatzeko.
• Gako-balio bildumako bi objektuak gako eta balio gisa gordetzen diren moten izendapenekin eraikitzen dira.
• Biek klase objektuak gorde ditzakete, eta ez dira int bezalako primitiboak gordetzera mugatzen.

Desberdintasunak

Ondorengo taulan X++ eta C#-ren arteko desberdintasunak deskribatzen dira gako-balio bikoteak gordetzen dituzten bildumen klaseei dagokienez:

Eginbidea	X++	C#	Iruzkinak
Gako bikoiztuak	X++-en, klaseak Map gako bikoiztuak saihesten ditu, bere metodoari egindako insert deia gakoarekin lotutako balioa soilik eguneratzeko eragiketa gisa tratatuz.	C#-n, klaseak Dictionary salbuespen bat botatzen du gako bikoiztu bat gehitzen saiatzen zarenean.	Bi hizkuntzetan gako bikoiztuak saihesten dira, nahiz eta teknika desberdinen bidez.
Ezabatu elementuak	X++ delete -en, objektu iteratzaile baten metodoa erabiltzen da nahi ez den gako-balio bikote Mapbat kentzeko.	C#-n klaseak Dictionary metodo bat remove du.	Bi hizkuntzetan, zenbatzaile bat baliogabetu egiten da bildumako elementuen kopurua zenbatzailearen bizitzan zehar aldatzen bada.

1. adibidea: Key-Value bilduma baten deklarazioa

Bi hizkuntzetan, gako-balio bildumak gordetzen dituen elementu motak zehaztu behar dira. X++-en mota eraikuntzaren unean zehazten da. C#-n mota deklarazioaren unean eta eraikuntza-unean zehazten da. Ondorengo kode-adibideak X++ eta C# formatuetan daude.

// X++
Map mapKeyValue;
MapEnumerator enumer;
MapIterator mapIter;

// C#
Dictionary<int,string> dictKeyValue;
IEnumerator<SysCollGen.KeyValuePair<int,string>> enumer;
KeyValuePair<int,string> kvpCurrentKeyValuePair;

2. adibidea: Bildumaren eraikuntza

Bi hizkuntzetan, eraikuntzan zehar zehaztutako gako-balio bildumak gordetzen dituen elementu mota. Klase moten kasuan, X++-k ezin du mota klase bat den ala ez zehatzagoa izan (Types::Class). Ondorengo kode-adibideak X++ eta C# formatuetan daude.

// X++
mapKeyValue = new Map(Types::Integer, Types::String);

// C#
dictKeyValue = new Dictionary<int,string>();

3. adibidea: Gehitu elementu bat bildumari

Ia ez desberdintasunik elementu bat X ++ eta C # gako-balio bilduma batean gehitzen den moduan, ondorengo kode-adibideetan erakusten den bezala.

// X++
mapKeyValue.insert(xx ,int2str(xx) + “_Value”);

// C#
dictKeyValue.Add(xx ,xx.ToString() + “_Value”);

4. adibidea: Bilduma Key-Value baten bidez iteratu

Zenbatzaileak X++ eta C# gako-balio bildumak zeharkatzeko erabiltzen dira, ondorengo kode-adibideetan erakusten den bezala.

// X++ 
enumer = mapKeyValue.getEnumerator();
while (enumer.moveNext())
{
    iCurrentKey = enumer.currentKey();
    sCurrentValue = enumer.currentValue();
    // Display key and value here.
}

// C#
enumer = dictKeyValue.GetEnumerator();
while (enumer.MoveNext())
{
    kvpCurrentKeyValuePair = enumer.Current;
    // Display .Key and .Value properties=
    // of kvpCurrentKeyValuePair here.
}

5. adibidea: Eguneratu gako batekin lotutako balioa

Bi hizkuntzen artean sintaxia oso desberdina da gako jakin bati lotutako balioa eguneratzeko. Kodearen adibideak 102 gakoari dagozkio.

// X++
mapKeyValue.insert(
    102 ,
    ”.insert(), Re-inserted” + ” key 102 with a different value.”);

// C#
dictKeyValue[102] = 
    “The semi-hidden .item property in C#, Updated the value for key 102.”;

6. adibidea: Elementu bat ezabatu

Bi hizkuntzen arteko sintaxia oso desberdina da bilduma batetik gako-balio bikote bat ezabatzeko, bildumako kideen bidez iteratzen den bitartean. 102 gakoaren kode-adibideak behean erakusten dira.

// X++
mapIter = new MapIterator(mapKeyValue);
//mapIter.begin();
while (mapIter.more())
{
    iCurrentKey = mapIter.key();
    if (104 == iCurrentKey)
    {
        // mapKeyValue.remove would invalidate the iterator.
        mapIter.delete();
        break;
    }
    mapIter.next();
}

// C#
dictKeyValue.Remove(104);

Konparazioa: Salbuespenak

Antzekotasun batzuk daude, baina desberdintasun asko X ++ eta C # arteko salbuespenekin lotutako portaera alderatzen dugunean. Try, catch, etathrow gako-hitzek berdin jokatzen dute X++ eta C#-n. Baina jaurtitako eta harrapatutako salbuespen motak desberdinak dira bi hizkuntzetan.

Antzekotasunak

X++ eta C#-ren arteko antzekotasunak salbuespen-ezaugarriei dagokienez, honako adibide hauek dira:

• Bi hizkuntzek hitz gako berdina dute.
• Biek dute gako-hitz bera.
• Biek salbuespen zehatzik zehazten ez duen catch instrukzio baterako gaitzen dute. Horrelako harrapaketa adierazpen batek salbuespen guztiak harrapatzen ditu.
• Biek dute gako-hitz bera.

Desberdintasunak

X++ eta C# arteko salbuespenekin lotutako desberdintasunak ondorengo taulan azaltzen dira.

Eginbidea	X++	C#	Iruzkinak
saiatu berriro	Erlazionatutako saiakera blokeko lehenengo agindura salto egiten du. Informazio gehiago nahi izanez gero, ikus Salbuespenen kudeaketa saiatu eta harrapatu gako-hitzekin.	Retry gako-hitzaren funtzionalitatea C# kodean imita daiteke, baina ez dagokion gako-hitzik.	X++-k soilik badu berriro saiatu gako-hitza. C#-k ez du parekorik. Informazio gehiago nahi izanez gero, ikus X++, C# Konparazioa: salbuespen baten ondoren berriro saiakera automatikoa.
Azkenik,	finally Gako-hitza eta gako-hitzak try jarraitzeko catch onartzen da.	Azkeneko gako-hitzak saiatu eta harrapatu blokeak jarraitzen dituen kode-blokea markatzen du. Azkena exekutatuko da, salbuespenen bat bota edo harrapatu den kontuan hartu gabe.	Semantika C#-ko semantikaren berdina da.
Salbuespen zehatzak	X++-en, salbuespen bat enum-eko Exception elementu bat da, hala nola Error, Deadlock edo CodeAccessSecurity. Salbuespenak ezin du beste bat izan.	C#-n, salbuespen bat oinarrizko System.Exception klasearen instantzia bat da, edo harengandik heredatzen den edozein klase. Salbuespen bat jaurtitako salbuespenaren propietatean egon InnerException daiteke.	X++-en, jaurtitako salbuespen bakoitza salbuespenaren balioa da. Informazio gehiago nahi izanez gero, ikus Salbuespenen zerrenda.
Salbuespen-mezua	X++-n, salbuespen bat sortzen denean sortzen den mezua Infolog-en soilik erabilgarri, eta mezua ez salbuespenarekin zuzenean lotuta.	C#-n, mezua objektuaren Message kidea System.Exception da.	X++-en, Global::error metodoa salbuespen-mezuak Infolog-en bistaratzen dituen mekanismoa da. Informazio gehiago nahi izanez gero, ikus Salbuespenen kudeaketa saiatu eta harrapatu gako-hitzekin.
Salbuespen-baldintzak	X++-en, errore bat gertatzen da oraindik ezer esleitu ez dion objektu-aldagai bati instantzia metodo bat deitzen diozunean. Hala ere, ez da salbuespenik sortzen akats honekin batera. Beraz, bloke batek ezin catch du kontrola eskuratu, nahiz eta esleitu gabeko aldagaia bloke batean try gaizki erabiltzen den. Ondorengo kode-adibidean, kodeak box4.toString(); eragindako erroreak ez du kontrola bloke batera catch transferitzea eragiten: DialogBox box4;try { box4.toString(); info("toString did not error, but expected an error."); } catch (Salbuespena::Error) // Salbuespenik gabeko balioak hau harrapatzen du. { info("Invalid use of box4 gave control to catch, unexpected."); }	C#-n a System.NullReferenceException sortzen da hasieratu gabeko aldagai bat objektu-erreferentzia gisa tratatzen denean.	Salbuespenak sortzen dituzten baldintzetan beste desberdintasun batzuk egon daitezke.
SQL transakzioak	X++-n, ttsBegin - ttsCommit transakzio batean SQL salbuespen bat gertatzen denean, transakzio-blokearen barruan ez catch instrukziorik salbuespena prozesatu.	C#-n, SQL transakzio baten barruko bloke batek salbuespena harrapa dezake.

Adibideak

X++ ezaugarri hauek erakusten dira:

• saiatu gako-hitza.
• Harrapatu gako-hitza.
• Salbuespena::Errorearen salbuespenaren ondorengo portaera gertatzen da.

X++ adibidea

// X++
static void JobRs008a_Exceptions(Args _args)
{
    str sStrings[4];
    int iIndex = 77;
    try
    {
        info("On purpose, this uses an invalid index for this array: " + sStrings[iIndex]);
        warning("This message doesn't appear in the Infolog," + " it's unreached code.");
    }
    // Next is a catch for some of the values of
    // the X++ Exception enumeration.
    catch (Exception::CodeAccessSecurity)
    {
        info("In catch block for -- Exception::CodeAccessSecurity");
    }
    catch (Exception::Error)
    {
        info("In catch block for -- Exception::Error");
    }
    catch (Exception::Warning)
    {
        info("In catch block for -- Exception::Warning");
    }
    catch
    {
        info("This last 'catch' is of an unspecified exception.");
    }
    //finally
    //{
    //    //Global::Warning("'finally' is not an X++ keyword, although it's in C#.");
    //}
    info("End of program.");
}

Irteerako elementua

Hona hemen Infolog leihoaren irteera:

Message (18:07:24)
Error executing code: Array index 77 is out of bounds.
Stack trace
(C)\Jobs\JobRs008a_Exceptions - line 8
In catch block for -- Exception::Error
End of program.

C# lagina

Ondorengo C# programa aurreko X++ programaren berridatzia da.

// C#
using System;
public class Pgm_CSharp
{
    static void Main( string[] args )
    {
        new Pgm_CSharp().Rs008a_CSharp_Exceptions();
    }
    void Rs008a_CSharp_Exceptions()
    {
        //str sStrings[4];
        string[] sStrings = new string[4];
        try
        {
            Console.WriteLine("On purpose, this uses an invalid index for this array: " + sStrings[77]);
            Console.Error.WriteLine("This message doesn't appear in the Infolog, it's unreached code.");
        }
        catch (NullReferenceException exc)
        {
            Console.WriteLine("(e1) In catch block for -- " + exc.GetType().ToString() );
        }
        catch (IndexOutOfRangeException exc)
        {
            Console.WriteLine("(e2) In catch block for -- " + exc.GetType().ToString() );
        }
        // In C#, System.Exception is the base of all
        // .NET Framework exception classes.
        // No as yet uncaught exception can get beyond
        // this next catch.
        catch (Exception exc)
        {
            Console.WriteLine("This last 'catch' is of the abstract base type Exception: "
                + exc.GetType().ToString());
        }
        // The preceding catch of System.Exception makes this catch of
        // an unspecified exception redundant and unnecessary.
        //catch
        //{
        //    Console.WriteLine("This last 'catch' is"
        //        + " of an unspecified exception.");
        //}
        finally
        {
            Console.WriteLine("'finally' is not an X++ keyword, although it's in C#.");
        }
        Console.WriteLine("End of program.");
    }
} // EOClass

Irteerako elementua

Hona hemen C # kontsolaren irteera:

(e2) In catch block for -- System.IndexOutOfRangeException
'finally' is not an X++ keyword, although it's in C#.
End of program.

Konparazioa: salbuespen baten ondoren berriro saiakera automatikoa

Batzuetan, kodea bloke batean idatzi dezakezu, exekuzio-denboran gertatzen den salbuespen baten kausa konpontzen duena. X++-k retry gako-hitza eskaintzen du, harrapaketa bloke baten barruan soilik erabil daitekeena. Retry gako-hitzak aukera ematen dio programa bat saiatzeko blokearen hasierara itzultzeko, arazoa harrapaketa-blokeko kodearen bidez konpondu ondoren. C#-k ez du saiakera gako-hitzik. Hala ere, C # kodea portaera baliokidea emateko idatzi daiteke.

Berriro saiatzeko kode-adibideak

Honako X++ adibide-programak Exception::Error bat sortzen du. Hau gertatzen da matrizetik sStrings elementu bat irakurtzen saiatzen denean indize-balio baliogabea erabiliz. Salbuespena harrapatzen denean, ekintza zuzentzaileak egiten dira harrapaketa blokearen barruan exekuzio-denboran. Ondoren, saiakera blokeko lehen adierazpenera itzultzen da. Bigarren iterazio honek salbuespenik aurkitu gabe funtzionatzen du.

static void JobRs008b_ExceptionsAndRetry(Args _args)
{
    str sStrings[4];
    str sTemp;
    int iIndex = 0;

    sStrings[1] = "First array element.";
    try
    {
        print("At top of try block: " + int2str(iIndex));
        sTemp = sStrings[iIndex];
        print( "The array element is: " + sTemp );
    }
    catch (Exception::Error)
    {
        print("In catch of -- Exception::Error (will retry)." + " Entering catch.");
        ++iIndex;
        print("In catch of -- Exception::Error (will retry)." + " Leaving catch.");
        // Here is the retry statement.
        retry;
    }
    print("End of X++ retry program.");
    pause;
}

Irteerako elementua

Hona hemen Inprimatzeko leihoaren irteera:

At top of try block: 0
In catch of -- Exception::Error (will retry). Entering catch.
In catch of -- Exception::Error (will retry). Leaving catch.
At top of try block: 1
The array element is: First array element.
End of X++ retry program.

C# lagina

Ondorengo C# adibidea ez da aurreko X++ laginaren lerroz lerro itzulpena. Horren ordez, C# programak beste egitura bat du, X++ programak oinarritzen duen berriro saiatzeko gako-hitzaren portaera imitatzeko. Saiatu eta harrapatu blokeak metodo izeneko batean daude. Try blokean erabiltzen diren aldagaiak deitzailearen metodoan gordetzen dira. Deitzailearen metodoak aldagaiak ref gako-hitzarekin apaindutako parametro gisa pasatzen ditu, deitutako metodoaren harrapaketa-blokearen barruan haien balioak zuzendu ahal izateko. Deitutako metodoak salbuespen guztiak harrapatzen ditu, eta boolear bat itzultzen du deitzaileari bigarren dei bat behar den ala ez komunikatzeko.

// C#
using System;
public class Pgm_CSharp
{
    static void Main(string[] args)
    {
        new Pgm_CSharp() .Rs008b_CSharp_ExceptionsAndRetry();
    }
    void Rs008b_CSharp_ExceptionsAndRetry() // Caller
    {
        int iIndex = -1
            , iNumRetriesAllowed = 3;
        bool bReturnCode = true; // Means call the callee method.
        for (int xx=0; xx <= iNumRetriesAllowed; xx++)
        {
            if (bReturnCode)
            {
                bReturnCode = this.Rs008b_CSharp_ExceptionsAndRetry_Callee(ref iIndex);
            }
            else
            {
                break;
            }
        }
        Console.WriteLine("End of C# caller method.");
    }
    
    private bool Rs008b_CSharp_ExceptionsAndRetry_Callee(ref int iIndex)
    {
        bool bReturnCode = true; // Means call this method again.
        string[] sStrings = new string[4];
        string sTemp;
        sStrings[0] = "First array element.";
        try
        {
            Console.WriteLine("At top of try block: " + iIndex.ToString());
            sTemp = sStrings[iIndex];
            Console.WriteLine( "The array element is: " + sTemp );
            bReturnCode = false; // Means do not call this method again.
        }
        catch (Exception)
        {
            Console.WriteLine("In catch of -- Exception. Entering catch.");
            ++iIndex; // The 'ref' parameter in C#.
            Console.WriteLine("In catch of -- Exception. Leaving catch.");
            //retry;
            // In C# we let the caller method do the work
            // that the retry keyword does in X++.
        }
        Console.WriteLine("End of C# callee method.");
        return bReturnCode;
    }
}

Irteerako elementua

Hona hemen kontsolaren irteera:

At top of try block: -1
In catch of -- Exception. Entering catch.
In catch of -- Exception. Leaving catch.
End of C# callee method.
At top of try block: 0
The array element is: First array element.
End of C# callee method.
End of C# caller method.

Konparazioa: Operadoreak

Atal honetan X++ eta C# arteko eragileak konparatzen dira.

Esleipen-eragileak

Ondorengo taulan X++ eta C#-ko esleipen-eragileen arteko desberdintasunak erakusten dira.

X++ eta C#	Desberdintasunak
=	X++-en, eragile honek bihurketa inplizitua eragiten du zehaztasun galera bat gerta daitekeen bakoitzean, adibidez, int64 batetik int batera esleitzeko. Baina C#-n esleipenak konpilazio-errorea eragiten du.
+= eta -=	Desberdintasun bakarra da C#-n eragile hauek delegatuen manipulazioan ere erabiltzen direla.
++ eta --	Hauek dira bi hizkuntzetako gehikuntza eta dekrementu eragileak. Hurrengo lerroa berdina da bi hizkuntzetan: ++myInteger; X++-en, ordea, bi eragile hauek adierazpenetarako dira, ez adierazpenetarako. Beraz, ondorengo lerroek konpilazio-erroreak sortzen dituzte X++-en: myStr = int2str(++myInteger); myIntA = myIntBB++;

Eragile aritmetikoak

Ondorengo taulan eragile aritmetikoak agertzen dira.

X++ eta C#	Desberdintasunak
*	Eragile biderkatzaile gisa, ez desberdintasunik. Oharra: Izartxoa X++ lengoaiaren parte diren SQL instrukzioetan ere erabiltzen da. SQL instrukzio hauetan, izartxoa honako hauetako bat ere izan daiteke: Zutabe guztiak itzuli behar direla adierazten duen komodin. Antzeko klausula batean erabiltzen den kate bateko karaktereentzako komodina.
/	Zatiketa eragilea berdina da X++ eta C#-n.
MOD	Modulu-eragiketetarako, desberdintasun bakarra da % ikurra C#-n erabiltzen dela.
+	Gehiketa eragilea berdina da X++ eta C#-n. Plus ikurra kate-katearen kateak kateatzeko ere erabiltzen da. Eragile honek zenbakiak gehitzen ditu eta kateak konkateatzen ditu bi hizkuntzetan.
-	Kenketa eragilea berdina da X++ eta C#-n.

Bit mailako eragileak

Ondorengo taulan X++ eta C# arteko bit-wise eragileak konparatzen dira.

X++ eta C#	Desberdintasunak
<<	Ezkerreko desplazamendu-eragilea berdina da X++ eta C#-n.
>>	Eskuineko desplazamendu-eragilea berdina da X++ eta C#-n.
~	NOT eragilea berdina da X++ eta C#-n.
&	AND eragile bitarra berdina da X++ eta C#-n.
^	XOR eragile bitarra berdina da X++ eta C#-n.

Eragile erlazionalak

Eragile erlazional hauek berdinak dira X++ eta C#-n:

• ==
• <=
• <=
• >
• <
• !=
• &&
• ||
• !
• ? :

Konparazioa: Gertaerak

Desberdintasun batzuk daude X ++ eta C # gertaeren diseinu eredua inplementatzeko moduan. Informazio gehiago nahi izanez gero, ikus Gertaeren terminologia eta gako-hitzak.

X++ eta C-ren arteko gertaeren konparazioa#

Desberdintasunak daude ordezkariak X ++ gertaerak erabiltzeko moduan eta C #.

Kontzeptua	X++	C#	Iruzkinak
delegatu	X++-n, delegatu bat klase bateko kide gisa soilik deklara daiteke. Ordezkari bat ezin da mahai gainean izan. Ordezkari guztiak beren klaseko kideak dira, ez estatikoak . Ezin da sarbide-aldatzailerik erabili delegatuen adierazpen batean, delegatu guztiak babestutako kideak direlako. Beraz, gertaera kodearen bidez soilik sortu daiteke klase bereko kodearen bidez, non delegatua kide den. Hala ere, delegatu baten izaera pribatuaren salbuespen bakarra da bere klasetik kanpoko kodeak delegatuekin funtziona dezakeela += eta -= eragileak erabiliz.	C#-n, delegatu bakoitza mota bat da, klase bakoitza mota bat den bezala. Delegatua edozein klasetik independenteki deklaratzen da. Gertaera gako-hitzik gabe, metodo batean delegatu bat izan dezakezu parametro mota gisa, klase bat parametro mota gisa izan dezakezun bezala. Ordezkari baten instantzia bat eraiki dezakezu parametroaren balioa pasatzeko.	X++-n, klase bakoitza mota bat da, baina delegaturik ez da mota bat. Ezin da delegatu baten instantzia bat eraiki. Ezin da delegaturik metodo baten parametro izan. Baina kide delegatu bat duen klase bat sor dezakezu, eta klasearen instantziak parametro-balio gisa pasa ditzakezu. Informazio gehiago nahi izanez gero, ikus X++ gako-hitzak.
Gertaera	X++ kodean, gertaera bat honako hau da: Ordezkari bati dei esplizitua. Metodo baten hasiera edo amaiera. Ez gertaera gako-hitzik X++-en.	C#-n, gertaera-gako-hitzaordezkari mota klase bateko kide gisa deklaratzeko erabiltzen da. Gertaera-hitzaren efektua delegatua babestuta egotea da, baina += eta -= eragileentzat eskuragarri egotea. Gertaera-kudeatzailearen metodoak gertaera baterako harpidetu ditzakezu += eragilea erabiliz. Ordezkari bat erabilgarria izan daiteke gertaera-gako-hitzik gabe, funtzio-erakusle bat parametro gisa metodo batera pasatzeko teknika gisa.	Metodo bat hasi aurretik eta metodo bat amaitu ondoren gertatzen diren gertaera automatikoak AOT erabiliz soilik harpidetu daitezke.
+= eta -= eragileak	X++-n, += eragilea erabiltzen duzu delegatu bati metodoak harpidetzeko. -= eragileak metodo baten harpidetza kentzen du.	C#-n, += eragilea erabiltzen duzu gertaera baten metodoak harpidetzeko, edo gertaera gako-hitzarekin erabiltzen ez den delegatu bati.	Delegatuak delegatuaren metodoak harpidetuta dituzten objektu guztien erreferentzia du. Objektu horiek ez dira zabor bilketarako onargarriak erreferentzia horiek gordetzen dituen bitartean.
eventHandler	X++-n, eventHandler gako-hitza beharrezkoa da += edo -= eragilea erabiltzen duzunean delegatu baten metodo bat harpidetzeko edo harpidetza kentzeko.	System.EventHandler .NET Framework-en delegatu mota bat da.	Termino hau modu desberdinean erabiltzen da X++-n C# edo .NET Framework-en baino. Informazio gehiago nahi izanez gero, ikus X++ gako-hitzak.

X++ adibidea

Kontuan hartu beharreko gauza garrantzitsuak X++ adibidean honako hauek dira:

• XppClass Izendatutako myDelegateordezkari bat dauka.

  Oharra

  AOTk nodo bat dauka delegatuarentzat. Nodoa AOT > klaseetan > , XppClass > myDelegate. Gertaera-kudeatzaile hainbat nodo egon daitezke myDelegate nodoaren azpian. AOTko nodoek ordezkatzen dituzten gertaera-kudeatzaileak ezin ditu -= operadoreak kendu exekuzio denboran.

• {} Delegatuaren adierazpenaren amaieran dauden parentesak beharrezkoak dira, baina ezin dute koderik eduki.

• Bi XppClass metodo ditu, eta horien sinadura parametroak delegatuarekin bateragarriak dira. Metodo bat estatikoa da.

• Bi metodo bateragarriak delegatuari gehitzen zaizkio += eragilearekin eta eventHandler gako-hitzarekin. Instrukzio hauek ez diete gertaeren kudeatzailearen metodoei deitzen, instrukzioek metodoak delegatuari gehitzen dizkiote.

• Ekitaldia delegatuari dei bakar baten bidez planteatzen da.

• Delegatuari pasatutako parametroaren balioa gertaera-kudeatzailearen metodo bakoitzak jasotzen du.

• Adibidearen goialdean dagoen X++ lan laburrak proba hasten du.

// X++
// Simple job to start the delegate event test.
static void DelegateEventTestJob()
{
    XppClass::runTheTest("The information from the X++ job.");
}
// The X++ class that contains the delegate and the event handlers.
class XppClass
{
    delegate void myDelegate(str _information)
    {
    }
    public void myEventSubscriberMethod2(str _information)
    {
        info("X++, hello from instance event handler 2: " + _information);
    }
    static public void myEventSubscriberMethod3(str _information)
    {
        info("X++, hello from static event handler 3: " + _information);
    }
    static public void runTheTest(str _stringFromJob)
    {
        XppClass myXppClass = new XppClass();
        // Subscribe two event handler methods to the delegate.
        myXppClass.myDelegate += eventHandler(myXppClass.myEventSubscriberMethod2);
        myXppClass.myDelegate += eventHandler(XppClass::myEventSubscriberMethod3);
        // Raise the event by calling the delegate one time,
        // which calls all the subscribed event handler methods.
        myXppClass.myDelegate(_stringFromJob);
    }
}

Aurreko X++ lanaren irteera honako hau da:

X++, hello from static event handler 
3: The information from the X++ job. X++, hello from instance event handler 
2: The information from the X++ job.

C# lagina

Atal honek aurreko X++ laginaren gertaeren diseinu-ereduaren C# kodearen lagin bat dauka.

// C#
using System;
// Define the delegate type named MyDelegate.
public delegate void MyDelegate(string _information);
public class CsClass
{
    protected event MyDelegate MyEvent;
    static public void Main()
    {
        CsClass myCsClass = new CsClass();
        // Subscribe two event handler methods to the delegate.
        myCsClass.MyEvent += new MyDelegate(myCsClass.MyEventSubscriberMethod2);
        myCsClass.MyEvent += new MyDelegate(CsClass.MyEventSubscriberMethod3);
        // Raise the event by calling the event one time, which
        // then calls all the subscribed event handler methods.
        myCsClass.MyEvent("The information from the C# Main.");
    }
    public void MyEventSubscriberMethod2(string _information)
    {
        Console.WriteLine("C#, hello from instance event handler 2: " + _information);
    }
    static public void MyEventSubscriberMethod3(string _information)
    {
        Console.WriteLine("C#, hello from static event handler 3: " + _information);
    }
}

Aurreko C# laginaren irteera honako hau da:

CsClass.exe C#, hello from instance event handler 
2: The information from the C\# Main. C\#, hello from static event handler 
3: The information from the C\# Main.

Ekitaldiak eta AOT

Badira beste gertaera sistema batzuk AOTko elementuei soilik aplikatzen zaizkienak. Informazio gehiago nahi izanez gero, ikus AOTko gertaeren kudeatzailearen nodoak.

Konparazioa: Aurrekonpilatzailearen zuzentarauak

X++ eta C# hitz-hitz batzuk partekatzen dituzte beren aurrekonpilatzailearen zuzentarauaren sintaxirako, baina esanahiak ez dira beti berdinak.

Antzekotasunak

X++ eta C# konpilatzaileek gako-hitz asko ezagutzen dituzte. Kasu gehienetan, gako-hitzek berdin esan nahi dute bi hizkuntza-konpilatzaileentzat.

Desberdintasunak

X++-ko aurrekonpilatzaileen zuzentarauen eta C#-ren arteko funtsezko desberdintasuna bi hizkuntza-aurrekonpilatzaileek ezagutzen duten #define gako-hitza da. C# ez bezala, X++-en #define zuzentarauak puntu bat eskatzen du bere sintaxian. X++-n, parentesi erabil daitezke definitutako ikurrari balio bat emateko. Desberdintasun hauek ondorengo adibideetan agertzen dira:

• X++-en: #define. Hasierako urtea(2003)
• C#: #define hasierako urtea

Desberdintasun txiki bat da C#-n # karakterearen eta zuzentarauaren gako-hitzaren artean zuriuneak eta tabulazio-karaktereak egon daitezkeela, adibidez # define Testing.

Gako-hitz berdinak

Ondorengo taulan X++ eta C#-n antzekoak diren aurrekonpilatzailearen zuzentarauak agertzen dira.

Gako-hitza	X++	C#	Iruzkinak
#define	X++-n, aurrekonpilatzailearen aldagaien izen bat defini daiteke, eta balio bat eman daiteke aldagai horri.	C#-n, aurrekonpilatzailearen aldagaien izena defini daiteke, baina aldagai horri ezin zaio baliorik eman. Gainera, C#-ko #define fitxategiaren goialdean agertu behar da, eta ezin da inolako koderik gertatu, hala nola using instrukzio edo klase deklarazioa.	C# konpilatzaileak komando-lerroko parametro bat sar dezake aurrekonpilatzailearen aldagaiaren izena definitzeko, /define aldagaia C# kode-fitxategi batean definitu gabe. X++ konpilatzaileak ez du parekorik /define.
#if	X++-n, #if aurrekonpilatzailearen aldagai bat existitzen den eta aldagaiak balio jakin bat duen ala ez zehaztu dezake.	C#-n, #if aldagai aurrekonpilatzaile bat existitzen den ala ez soilik zehaztu dezake. Ezin du inolako baliorik probatu, ezin baita baliorik esleitu.
#endif	X++-n, #endif bloke #if baten amaiera markatzen du. Bloke #ifnot bat ere amaitzen da.	C#-n, #endif bloke #if baten amaiera markatzen du, blokeak #else bat duen ala ez kontuan hartu gabe.

Prozesamenduaren emaitza bera duten gako-hitz desberdinak

Ondorengo taulan X++ eta C#-n izen desberdinak dituzten aurrekonpilatzaileen zuzentarauak zerrendatzen dira, baina prozesatzean emaitza berdinak ematen dituztenak.

X++	C#	Iruzkinak
#ifnot	#if #else	Ez #else zuzentaraurik X++-n, baina #ifnot antzeko funtzionalitatea eskaintzen du. X++-n, #ifnot aurrekonpilatzailearen aldagai bat existitzen den eta aldagaiak balio zehatz bat ez duen zehaztu dezake. C#-n, #if zehaztu dezake aurrekonpilatzailearen aldagaia existitzen den ala ez '!' Ikurra aldagaiaren izenaren aurrizkia da.
//BP Deviation documented	#pragma abisua	X++ eta C# sarrera hauek ez dira baliokideak, baina antzekotasun partziala. Biek konpilatzailearen abisu-mezuak ezabatzen dituzte.
#macrolib	. HPP fitxategia C++-n	Antzekotasun partziala X++ zuzentarauaren #macrolib eta . HPP fitxategia C++ formatuan. Biek hainbat adierazpen #define izan ditzakete.

Aurrekonpilatzailearen zuzentarauak X++-rako esklusiboak

Ondorengo taulan C#-n zuzeneko parekiderik ez duten X++ aurrekonpilatzailearen zuzentarauak zerrendatzen dira.

X++	Iruzkinak
#linenumber	#linenumber zuzentaraua lerro-zenbakia lortzeko da, Infolog-era irten ahal izateko. C# zuzentaraua #line desberdina da, bere helburua lerro-zenbakia ezartzea delako.
#defdec #definc
#globaldefine	X++-en, desberdintasun txiki bat #globaldefine eta #define. Aldea da #globaldefine ez duela inoiz gainidazten #define aurrekonpilatzaile aldagai bati esleitutako uneko balio ez-nulua. C#-k ez du desberdintasun horren antzekorik, C#-n aurrekonpilatzailearen aldagaiaren izenari ezin zaiolako baliorik eman.
#localmacro #macro	X++-n, #localmacro lerro anitzeko balio bat aurrekonpilatzaile aldagai bati esleitzeko aukera ematen dizu. #macro sinonimoa da, baina #localmacro gomendagarria da. C#-n, #define zuzentarauak funtzionalitate horren zati bat du, baina ezin dio baliorik esleitu aurrekonpilatzailearen aldagai bati.
#globalmacro	X++-en, #globalmacro hobetsitako #localmacro berdina da.

Izenburua: Objektuetara bideratutako programazioa

X++-ren objektuetara bideratutako programazioaren (OOP) printzipioak C#-tik bereizten dira.

Konparazio kontzeptualak

Ondorengo taulan OOP printzipioen inplementazioa X++ eta C# artean alderatzen da.

Eginbidea	X++	C#	Iruzkinak
Casting-a	X++ lengoaiak is eta as gako-hitzak ditu, downcasts seguruak eta esplizituak egiteko erabiltzen direnak. Aholkua: X++-k ez du as gako-hitza erabiltzea eskatzen oinarrizko klase-aldagai bat klase eratorriko aldagai batera jaitsi behar duzunean. Hala ere, gomendatzen dugu downcast adierazpen guztiek as gako-hitza erabiltzea.	Objektu bat herentzia-bidean gora edo behera bota daiteke. Downcasts-ek gako-hitz gisa behar du.	X++ gako-hitzei buruzko informazio gehiago nahi izanez gero, ikus Adierazpen eragileak: Is eta As herentzia.
Funtzio lokalak	Metodo batek deklarazioa eta kode-gorputza eduki ditzake zero funtzio lokal edo gehiagorentzat. Metodo honek bakarrik izan ditzake funtzio lokalaren deiak.	C# 3.0-k lambda adierazpenak onartzen ditu, funtzio anonimoekin eta funtzio lokalekin antzekotasun batzuk dituztenak. Lambda adierazpenak maiz erabiltzen dira delegatuekin.
Metodoaren gainkarga	Metodoa gainkargatzea ez da onartzen. Metodo baten izena klase bakoitzeko behin bakarrik ager daiteke.	Metodoen gainkarga onartzen da. Metodo baten izena hainbat aldiz ager daiteke klase batean, kasu bakoitzean parametro sinadura desberdinekin.	X++-k metodoen aukerako parametroak onartzen ditu. Aukerako parametroek metodoaren gainkarga partzialki imita dezakete. Informazio gehiago nahi izanez gero, ikus taula honetako aukerako parametroen errenkada.
Metodoa gainidaztea	Metodoa gainidatzi onartzen da. Klase eratorri batek oinarrizko klasearen izen bereko metodo bat izan dezake, baldin eta parametroaren sinadura berdina bada bi kasuetan. Salbuespen bakarra da gainidatzitako metodoak balio lehenetsi bat gehitu diezaiokeela parametro bati.	Metodoa gainidatzi onartzen da. Gako-hitz birtuala metodo bati aplikatu behar zaio metodo eratorri batean metodoa gainidatzi ahal izateko.	Metodo bat gainidaztearen kontzeptuak metodoaren izena, bere parametroaren sinadura eta itzultzaile mota barne hartzen ditu. Metodoaren gainidatziaren kontzeptua ez da aplikatzen oinarrizko metodoa eta gainidatzizko metodoa alderdi horietako batean desberdinak badira.
Aukerako parametroak	Parametroen deklarazioari balio-esleipen lehenetsi baten ondoren egon daiteke. Metodo-deitzaileak parametro horren balio bat pasatzeko aukera du, edo balio lehenetsia onartzeko parametroari ez jaramonik egiteko. Ezaugarri honek metodoaren gainkarga imitatzen du, metodo izen bereko bi deiek parametro kopuru desberdinak pasa ditzaketelako. Balio lehenetsia duen parametro bakoitzak balio lehenetsia ez duen azken parametroari jarraitu behar dio.	Aukerako parametroak params gako-hitzak onartzen ditu. Params gako-hitzik gabe ere, deitzailearen ikuspegitik, metodoaren gainkargak funtzionalitate partzialki antzekoa eman dezake.	Informazio gehiago nahi izanez gero, ikus Parametroak eta esparrua eta Aukerako parametroak erabiltzea.
Herentzia bakarra	Zure X++ klasea beste X++ klase batetik eratorri dezakezu extends gako-hitza erabiliz zure klaseko classDeclaration nodoan, AOT-n. Klase bat ere ez da zuzenean beste klase batetik eratorria. Zure klasea klasetik zuzenean eratorria Object izatea nahi baduzu, extends gako-hitza erabili behar duzu. Klase bakarra zehaztu dezakezu extends gako-hitzean. Kontuz: Beste klase batzuetatik eratorritako X++ oinarrizko klase bat aldatzen duzunean, oinarrizko klase hori berriro konpilatu behar duzu Konpilatu aurrera erabiliz. Aukera honek klase eratorriak ere birkonpilatzen direla ziurtatzen du. Eratorritako klaseak ere birkonpilatzen direla ziurtatzeko, egin klik eskuineko botoiarekin oinarrizko klasearen nodoan, eta egin klik Add-Ins > Konpilatu aurrerantz. Eraiki > konpilatu klik egitea (edo F7 tekla sakatzea) batzuetan ez da nahikoa oinarrizko klasea aldatzeko. Klase batek zero eta hainbat interfaze inplementa ditzake. X++ taula batek inplizituki heredatzen du taulatik Common eta xRecord klasetik.	C#-k extends gako-hitza erabiltzen du beste klase batetik eratorritzeko. .NET Framework klase guztiak inplizituki klasetik eratorriak dira System.Object , beste klase batetik esplizituki eratorriak ez badira.

Gako-hitzen konparazioak

Ondorengo taulan OOPekin erlazionatutako gako-hitzak agertzen dira X++ eta C#-n.

Gako-hitza	X++	C#	Iruzkinak
Laburpena			Desberdintasunik ez.
klasea	Aldatzaile publikoak eta pribatuak ez dira kontuan hartzen klase-deklarazioetan. Ez klaseen izen-espazioaren kontzepturik. Ez punturik (.) klaseen izenetan.	Aldatzaile publikoak eta pribatuak klase deklarazioak aldatzeko erabil daitezke. C# barneko gako-hitza ere badu, klaseak mihiztatze-fitxategietan nola taldekatzen diren erlazionatzen duena.	Ez klase babestuaren kontzepturik, klase bateko kide babestuak baizik.
hedatzen da	Klase deklarazio batek beste klase batetik heredatu dezake extends gako-hitza erabiliz.	Bi puntu (:) erabiltzen dira gako-hitzak X++-n hedatzen diren eta inplementazioak erabiltzen direnean.
Behin betiko	Azken metodo bat ezin da gainidatzi klase eratorri batean. Azken klasea ezin da luzatu.	Klase batean zigilatutako gako-hitzak X ++ klase batean final esan nahi duen gauza bera esan nahi du.
inplementazioak	Klase-adierazpen batek interfaze bat inplementa dezake implements gako-hitza erabiliz.
Interfazea	Interfaze batek klaseak inplementatu behar dituen metodoak zehaztu ditzake.	Interfaze batek klaseak inplementatu behar dituen metodoak zehaztu ditzake.
Berria	Gako-hitz berria klase baten instantzia berri bat esleitzeko erabiltzen da. Ondoren, automatikoki deitzen zaio eraikitzaileari. Klase bakoitzak eraikitzaile bakarra du, eta eraikitzaileak izena newdu. Eraikitzaileak zein parametro sartu behar dituen erabaki dezakezu.	Gako-hitz berria klase baten instantzia berria sortzeko erabiltzen da. Ondoren, automatikoki deitzen zaio eraikitzaileari. Eraikitzaile metodoek ez dute izenik new, klasearen izen bera dute. Oharra: Gako-hitz berria metodo batean ere erabil daiteke, metodoak oinarrizko klaseko metodo bera gainidazten duen modua aldatzeko.	Bai X++ bai C# eraikitzaile lehenetsia suposatzen dute beren kodean esplizituki idatzitako eraikitzailerik ez duten klaseentzat.
baliogabea			Desberdintasunik ez.
Pribatua eta babestua	Gako-hitz pribatuak eta babestuak klase-kide baten deklarazioa aldatzeko erabil daitezke.	Gako-hitz pribatuak eta babestuak klase-kide baten deklarazioa aldatzeko erabil daitezke.
publikoa	Publikoa, babestua edo pribatua bidez aldatzen ez den metodoak sarbide-maila lehenetsia du publikoa.	Publikoa, babestua edo pribatua bezala aldatzen ez den metodoak sarbide-maila lehenetsia du pribatua.
estatikoa	Metodo bat estatikoa izan daiteke, baina eremu bat ez.	Metodoak eta eremuak estatikoak izan daitezke.
super	Super gako-hitza eratorritako klase batean erabiltzen da oinarrizko klaseko metodo bera sartzeko. void method2() { // Call method2 method // on the base class. super(); }	Oinarrizko gako-hitza klase eratorri batean erabiltzen da oinarrizko klaseko hainbat metodo sartzeko. void method2() { // Call methods on // the base class. base.method2(); base.method3(); }	C#-n, oinarrizko eraikitzaileari deitzeko oinarria erabiltzeko sintaxia berezia.
hau	Objektu berean instantzia metodo batetik bestera deitzeko, deitutako metodoaren kalifikatzaile bat behar da. This gako-hitza uneko objektuaren kalifikatzaile gisa erabilgarri.	Objektu berean instantzia metodo batetik bestera dei bat egiteko, ez da deitutako metodoaren kalifikatzailerik behar. Hala ere, gako-hitz hau uneko objektuaren kalifikatzaile gisa erabilgarri. Praktikan, gako-hitza lagungarria izan daiteke IntelliSense informazioa bistaratuz.
finalize	Klaseak Object metodoa finalize dauka. Metodoa finalize ez da behin betikoa, eta gainditu egin daiteke. Metodoa finalize C#-ko metodoaren System.Object.Finalize antzekoa dirudi, baina X++ finalize -en metodoak ez du inolako esanahi berezirik. Objektu bat automatikoki kentzen da memoriatik, objektuaren azken erreferentziak objektuari erreferentzia egiteari uzten dionean. Adibidez, hau gerta daiteke azken erreferentzia esparrutik kanpo dagoenean edo beste objektu bat esleitzen zaionean erreferentzia egiteko.	Metodoak Finalize eta Dispose klase mota batzuetan ohikoak dira. Zabor-biltzaileak eta Finalize metodoak Dispose deitzen ditu suntsitzen duenean eta objektua.	C#-n, .NET Framework-eko metodoa System.GC.Collect deitu daiteke zabor-biltzailea abiarazteko. X++-n ez antzeko funtziorik, X++-k zabor-biltzaile determinista bat erabiltzen duelako.
main	Menu batetik deitzen diren klaseei sistemak deitzen dio metodoa main .	Komando-lerroko kontsola batetik deitzen diren klaseei sistemak beren Main metodoa deitzen du.

Konparazioa: Klaseak

.NET Framework-en C# erabiltzen duzunean, klaseak izen-espazioetan taldekatzen dira. Izen-espazio bakoitza eremu funtzional batean zentratzen da, hala nola fitxategien eragiketak edo isla. Hala ere, X++-ko klaseak erabiltzen dituzunean, ez izen-espazioa bezalako taldeka-ikusgairik.

Konparazioa: Hausnarketari buruzko klaseak

X++-en, klaseak TreeNode Application Object Tree (AOT) sarbidea eskaintzen du. Klasea TreeNode X ++-ko isla funtzionaltasunaren zentroa da. Klasea TreeNode eta bere metodoak C# erabiltzen duen .NET Framework-eko izen-espazioarekin System.Reflection alderatu daitezke.

Ondorengo taulan C# kodea idaztean erabilgarri dauden hainbat klase agertzen dira. .NET Framework klaseak dira. Taula honetarako, C# klase guztiak izen-espazioan System.Reflection daude, kontrakoa zehaztu ezean. Errenkada bakoitzak dagokion klasea edo klase-kidea erakusten du, X++ kodea idazterakoan eskuragarri dagoena.

X++	C#	Iruzkinak
TreeNode	System .Assembly	Assembly C# programa batek hausnarketa-informazioa biltzen duenean erabili beharreko lehen klasea da. X++ klaseko TreeNode metodo estatikoak X++-en hausnarketaren abiapuntua dira.
TreeNode	System .Type	Instantzia metodoak on TreeNode instantzia metodoei dagozkie System.Type.
TreeNode .AOTgetSource	MethodInfo	Metodoak AOTgetSource hainbat informazio itzultzen ditu kate bakarrean. X++ iturburu-kodea metodoan sartzen da. Informazio MethodInfo bakoitzerako kide bereizi bat du.
TreeNode .AOTfirstChild TreeNode .AOTnextSibling TreeNode .AOTiterator AOTiterator	MethodInfo[] (matrize bat)	C#-n, GetMethods on metodoak System.Type MethodInfo objektuen matrize bat itzultzen du. Array zehar begizta dezakezu indexatzaile bat gehitzeko teknika arruntaren bidez. Aitzitik, X++ eredua AOTren zuhaitz-kontrolean nabigatzea da. Nabigazioaren TreeNode metodoak AOTfirstChild eta AOTnextSibling gauzatzea. Alternatiba baliokide gisa, X++ AOTiterator klasea AOTren zuhaitz-kontrolean nabigatzeko diseinatuta. Klase nodo bat hainbat metodo-nodoen gurasoa da. Urratsak AOTiterator nodo umeetan zehar, bakoitza beste TreeNode instantzia bat bezala itzuliz. Baliabide gehigarriak, TreeNode izendatzen AOTparent diren metodoak eta AOTprevious.
TreeNode .AOTgetProperty TreeNode .AOTgetProperties TreeNode .AOTname	PropertyInfo	X++-n, metodoak AOTgetProperties kate luze bat itzultzen du, izen-balio bikoteak TreeNodedituena. Metodoak izen propietatearen balioa soilik duen kate bat itzultzen du AOTname .
TreeNode .AOTsave TreeNode .AOTinsert	System .Reflection .Emit (Klaseen izen-espazioa)	Metodoak AOTsave X++ kodeko objektu baten TreeNode aldaketak AOTra aplikatzen ditu, eta aldaketak mantentzen dira. Kode-lagin handi bat lortzeko, ikus TreeNode.AOTsave metodoa.

Konparazioa: I.O. fitxategiari buruzko klaseak

Fitxategien sarrera eta irteera (IO) eragiketak egiten dituzten hainbat klase daude. C#-n erabiltzen den .NET Framework-en, klase horien parekoak izen-espazioan System.IO daude.

Ondorengo taulan izen-espazioan System.IO dauden C# .NET Framework klase batzuk zerrendatzen dira. Taulako errenkada bakoitzak .NET Framework klaseari hobekien bat datorren X++ klasea edo metodoa erakusten du.

X++	C#	Iruzkinak
BinaryIo	FileStream BinaryReader BinaryWriter	X++ klaseak, hala BinaryIo nola, klase Io abstraktutik hedatzen direnak, korronte gisa balio dute, eta korronte horren irakurle eta idazle gisa ere balio dute. C#-n, korrontea irakurketa eta idazketa metodo zehatzagoak dituen klasetik bereizitako klase bat da.
TextBuffer	MemoryStream	Klase hauek memoriako buffer bat dute, eta metodo batzuek bufferra disko gogorreko fitxategi bat balitz bezala tratatzen dute.
WINAPI::createDirectory WINAPI::folderExists WINAPI::removeDirectory	Directory DirectoryInfo Path	X++-k klaseko metodo estatikoak WINAPI erabil ditzake direktorioak inplikatzen dituzten oinarrizko sistema eragilearen funtzio askotarako.
WINAPI::getDriveType	DriveInfo DriveType	Klase eta metodo hauek unitatearekin lotutako informazioa lortzeko erabiltzen dira.
WINAPI::copyFile WINAPI::createFile WINAPI::d eleteFile WINAPI::fileExists	File FileAttributes FileInfo	X++-k klaseko metodo estatikoak WINAPI erabil ditzake fitxategiak inplikatzen dituzten oinarrizko sistema eragilearen funtzio askotarako.
CommaIo Comma7Io	(Ez dagokion klaserik.)	X++ klase hauek Microsoft Excel-ek inportatu ditzakeen fitxategiak sor ditzakete. X++-en, EPPlus liburutegiaren erreferentzia bat eskuragarri Excel-ekin elkarrekintza gehigarrirako.
AsciiIo TextIo	FileStream TextReader TextWriter	Klase hauek kode-orri desberdinak erabiltzen dituzte.
Io	Stream StreamReader StreamWriter FileStream	Hauek askotan beste klase batzuek zabaltzen dituzten oinarrizko klase gisa erabiltzen dira.
CodeAccessPermission FileIoPermission	System.Security .CodeAccessPermission Izen-espazioak System.Security.Permissions honako klase hauek ditu: CodeAccessSecurityAttribute FileIOPermissionAttribute FileIOPermission FileIOPermissionAccess	Kontzeptuak eta metodoak assert, demandeta revertAssert bi hizkuntzei aplikatzen zaizkie. Hala ere, C#-n erabilgarri dauden eta deny metodoak revertDeny ez daude erabilgarri X++-en.

X++, ANSI SQL konparazioa: SQL Select

X++-en, SQL select instrukzioaren sintaxia American National Standards Institute (ANSI) zehaztapenetik bereizten da.

Taula bakarreko hautapena

Ondorengo taulan X++ SQL eta ANSI SQLren selectatutako instrukzioen arteko desberdintasunak agertzen dira.

Eginbidea	X++ SQL	ANSI SQL	Iruzkinak
Taularen izena from klausulan.	from klausulak taula batetik deklaratzen den erregistro-bufferraren instantzia zerrendatzen du, adibidez, taulatikCustTable.	from klausulak taularen izena agertzen du, ez buffer baten izena.	Erregistro-bufferrak klaseak X++-n dituen metodo xRecordguztiak ditu.
Ordenaren arabera versus where klausulen sintaxi-sekuentzia.	Klausularen araberako agindua non klausularen aurretik agertu behar da. Klausularen araberako ordena from edojoin klausularen ondoren agertu behar da. Group by klausulak ordenak jarraitzen dituen sintaxiaren kokapen arau berberak jarraitu behar ditu.	Klausularen araberako agindua non klausularen ondoren agertu behar da. Where klausulak from edo join klausularen ondoren agertu behar du.	Bai X++ bai ANSI SQL-n, from eta join klausulak order by eta where klausulen aurretik agertu behar dira.
Baldintza ukazioa.	Exclamation mark ('!') erabiltzen da ukaziorako.	Not gako-hitza ukaziorako erabiltzen da.	X++-k ez du onartzen !like sintaxia. Horren ordez, aplikatu behar duzu! Klausula baten eragilea.
Antzeko eragilearen komodinak.	0 to many – Izartxoa ('*') 1 - Galdera-ikurra ('?')	0 to many - Ehuneko zeinua ('%') Zehazki 1 - Azpiko barra ('_')
Eragile logikoak where klausulan.	eta - && Edo - ||	Eta - eta Edo - edo

Kodearen adibidea

Ondorengo kode-adibideak aurreko taulako ezaugarriak azaltzen dira.

static void OByWhere452Job(Args _args)
{
    // Declare the table buffer variable.
    CustTable tCustTable;
    ;
    while
    SELECT * from tCustTable
        order by tCustTable.AccountNum desc
        where (!(tCustTable.Name like '*i*i*') && tCustTable.Name like 'T?e *')
    {
        info(tCustTable.AccountNum + " , " + tCustTable.Name);
    }
}
/*** InfoLog output
Message (04:02:29 pm)
4010 , The Lamp Shop
4008 , The Warehouse
4001 , The Bulb
***/

X++ SQL gako-hitzak

X++ SQL gako-hitz hauek ANSI SQL-ren parte ez direnen artean daude:

• konpainia gurutzatua
• Lehenengoa100
• Indar-literalak
• forcenestedloop
• Indarrez leku-markak
• Behartu hautatzeko ordena
• baliozko denbora-egoera

Elkartze-klausula

Ondorengo taulan X++ SQL eta ANSI SQLren joint gako-hitzaren inguruko desberdintasunak agertzen dira.

Eginbidea	X++ SQL	ANSI SQL	Iruzkinak
Zutabeen zerrenda.	Zutabe-zerrendako zutabe guztiak from klausulan zerrendatutako taulatik etorri behar dira, eta ez join klausula bateko taula batetik. Zerrendako zutabeak ezin dira taularen izenaren arabera sailkatu.	Zutabe-zerrendako zutabeak from edo join klausuletako edozein taupatik etor daitezke. Beste batzuek zure kodea mantentzen laguntzen dute zerrendako zutabeak taularen izenarekin sailkatzen dituzunean.	Informazio gehiago nahi izanez gero, ikus Hautatu adierazpenak eremuetan.
Join klausularen sintaxia.	Join klausulak where klausulari jarraitzen dio.	Join klausulak from klausularen taula baten ondoren jarraitzen du.	X++ kodearen adibidean, elkartze irizpideak balioen berdintasuna SalesPoolId dira.
Barneko gako-hitza.	Elkartze modu lehenetsia barneko elkartzea da. Ez barneko gako-hitzik.	Elkartze modu lehenetsia barneko elkartzea da. Barneko gako-hitza eskuragarri kodea esplizituki egiteko.	Kanpoko gako-hitza X++ SQL eta ANSI SQL-n.
Ezkerreko eta eskuineko gako-hitzak.	Ezkerreko eta eskuineko gako-hitzak ez daude erabilgarri. Elkarte guztiak geratzen dira.	Ezkerreko eta eskuineko gako-hitzak erabilgarri daude elkartze-hitza aldatzeko.	Ez iruzkinik.
Berdintasun eragilea.	Berdintasun bikoitza eragilea ('==') bi balioen berdintasuna egiaztatzeko erabiltzen da.	Berdintasun eragile bakarra ('=') bi balioen berdintasuna egiaztatzeko erabiltzen da.	Ez iruzkinik.

Kodearen adibidea

Ondorengo kode-adibideak X++ SQL-ko elkartze-sintaxia erakusten du.

static void OByWhere453Job(Args _args)
{
    // Declare table buffer variables.
    CustTable tCustTable;
    SalesPool tSalesPool;
    ;
    while
    SELECT
            // Not allowed to qualify by table buffer.
            // These fields must be from the table
            // in the from clause.
            AccountNum,
            Name
        from tCustTable
            order by tCustTable.AccountNum desc
            where (tCustTable.Name like 'The *')
        join tSalesPool
            where tCustTable.SalesPoolId == tSalesPool.SalesPoolId
    {
        info(tCustTable.AccountNum + " , " + tCustTable.Name);
    }
}

Batu eremuak

Ondorengo taulan X ++ SQL eta ANSI SQLren artean hautatutako zutabe-zerrendako eremu agregatuen erreferentzian dauden desberdintasun batzuk agertzen dira. Eremu agregatuak batura edo batez besteko funtzioen bidez eratorriak dira.

Eginbidea	X++ SQL	ANSI SQL	Iruzkinak
Batu eremu-izenaren aliasa.	Agregazioaren balioa agregatutako eremuan.	As gako-hitza erabil dezakezu eremu agregatu bat izen aliasarekin etiketatzeko. Ezizena hurrengo kodean erreferentzia daiteke.	Informazio gehiago nahi izanez gero, ikus Agregatu funtzioak: X++ eta SQLren arteko desberdintasunak

Kodearen adibidea

Ondorengo kode-adibidean, info metodoari egindako deiak eremu agregatuei erreferentzia egiteko modua erakusten du (ikus tPurchLine.QtyOrdered).

static void Null673Job(Args _args)
{
    PurchLine tPurchLine;
    ;
    while
    select
        // This aggregate field cannot be assigned an alias name.
        sum(QtyOrdered)
        from tPurchLine
    {
        info(
            // QtyOrdered is used to reference the sum.
            "QtyOrdered:  " + num2str(tPurchLine.QtyOrdered, 
            3,  // Minimum number of output characters.
            2,  // Required number of decimal places in the output.
            1,  // '.'  Separator to mark the start of the decimal places.
            2   // ','  The thousands separator.
            ));
    }
    info("End.");
}
/***
Message (12:23:08 pm)
QtyOrdered:  261,550.00
End.
***/

Beste desberdintasun batzuk

Ondorengo taulan Select instrukzioaren beste desberdintasun batzuk agertzen dira X++ SQL eta ANSI SQLren artean.

Eginbidea	X++ SQL	ANSI SQL	Iruzkinak
Hitz gakoa.	Ez gako-hitzik.	having gako-hitzak aukera ematen dizu group by klausulak sortzen dituen errenkaden iragazki-irizpideak zehazteko.	Ez iruzkinik.
Emaitza nuluak.	While select instrukzio batean, where klausulak errenkada guztiak iragazten baditu, ez da zenbaketa errenkada berezirik itzuliko horren berri emateko.	Hautapen batean, where klausulak errenkada guztiak iragazten baditu, zenbaketa-errenkada berezi bat itzuliko da. Zenbaketaren balioa 0 da.	Ez iruzkinik.
Itzulitako errenkadetan nabigatzeko kurtsoreak.	while select instrukzioak kurtsorearen funtzionalitatea eskaintzen du. Alternatiba hurrengo gako-hitza erabiltzea da.	Kurtsorea deklara dezakezu select instrukzio batetik itzultzen diren errenkadak begiztatzeko.
Klausulatik .	from gako-hitza aukerakoa da zutaberik ez dagoenean eta taula bakarra erreferentzia egiten denean. Ondorengo bi sintaxi-aukera baliokideak dira: select \* from tCustTable; select tCustTable;	Select instrukzio batek ezin du taula batetik irakurri from klausula erabiltzen ez bada.	X++ SQL-n, select instrukzio sinpleak taulako bufferraren aldagaia betetzen du itzulitako lehen errenkadarekin. Hau honako kode-zati honek erakusten du: select \* from tCustTable; info(tCustTable.Name);