Samanburður á X++ og C#

Athugasemd

Hagsmunahópar samfélagsins hafa nú færst frá Yammer yfir í Microsoft Viva Engage. Til að ganga í Viva Engage samfélag og taka þátt í nýjustu umræðum skaltu fylla út eyðublaðið Biðja um aðgang að Finance and Operations Viva Engage Community og velja samfélagið sem þú vilt ganga í.

Þessi grein ber saman X++ og C# setningafræði og forritun.

X++, C# Samanburður: Halló heimur

Þessi hluti ber einfaldasta X++ forritið saman við hliðstæðu þess í C#.

X++ til C# samanburður

Eftirfarandi kaflar lýsa nokkrum grundvallarlíkindum og mun á X++ og C#.

Líkt

Eftirfarandi X++ eiginleikar eru þeir sömu fyrir C#:

• Athugasemdir með einni línu (//) og mörgum línum (/* */).
• == (jafnt) virki til að ákvarða hvort tvö gildi séu jöfn.
• != (ekki jafnt og) virki til að ákvarða hvort tvö gildi séu ekki jafngild.
• + (plúsmerki) rekstraraðili fyrir strengjasamtengingu.

Mismunur

Eftirfarandi tafla sýnir X++ eiginleika sem eru mismunandi í C#.

Eiginleiki	X++	C#	Ummæli
if og else skilyrtar yfirlýsingar	Fullyrðingin if samþykkir hvers kyns segð sem hún getur sjálfkrafa umbreytt í Boole-gildi. Algeng dæmi eru þar sem int 0 þýðir ósatt, eða hlutur þar sem núll þýðir ósatt.	Fullyrðingin if krefst Boole-tjáningar.	Setningaskipanin varðandi krullaðar spelkur og sviga er nákvæmlega sú sama á milli X++ og C#.
Bókstaflegur strengur	Hægt er að afmarka bókstafsstreng með annarri af eftirfarandi aðferðum: Par af tvöföldum gæsalöppum (") stöfum. Par af stökum gæsalöppum (') stöfum.	Bókstafsstrengur verður að vera afmarkaður með tvöföldum gæsalöppum (") stöfum.	Fyrir X++ eru tvöfaldar gæsalappir venjulega notaðir til að afmarka strengi. Hins vegar er þægilegt að afmarka streng með stökum gæsalöppum þegar strengurinn þinn verður að innihalda tvöfalda gæsalappastaf.
Char type	Það er ekki a char eða stafagerð í X++. Þú getur lýst yfir lengd str einn, en það er samt strengur: str 1 myString = "a";	Það er a char í C#. Þú getur ekki sent a char sem færibreytu í aðferð sem setur inn færibreytu string , þó að þú getir fyrst breytt a í char a string.	Frekari upplýsingar um X++ gagnagerðir er að finna í Frumstæðar gagnagerðir.
Framleiðsla skilaboða	X++ sendir skilaboð til notandans í Infolog glugganum. Algengar aðferðir eru: Prentyfirlýsingin: Statískar aðferðir á bekknum Global : Global::info Global::viðvörun Hnattrænt::villa	Fyrir skipanalínuforrit er hægt að senda skilaboð á stjórnborðið. Algengar aðferðir eru: Console.Out.WriteLine Console.Error.WriteLine

X++ og C# sýnishorn

Þessi hluti inniheldur tvö einföld kóðasýni. Annað sýnishornið er skrifað í X++ og hitt er í C#. Bæði sýnin ná sömu niðurstöðu. Eftirfarandi X++ eiginleikar eru sýndir:

• // Athugasemd í einni línu
• /\* \*/ Athugasemd með mörgum línum
• if yfirlýsing
• == virki
• != virki
• + virkja til að sameina strengi
• Global::info fyrir skilaboðaúttak, með og án Global:: forskeytisins
• Global::villa fyrir skilaboðaúttak
• Notkun einfaldra og tvöfaldra gæsalappa (' og ") sem strengjaafmörkun.

Athugasemd

Bestu starfsvenjurnar eru að nota tvöfaldar gæsalappir fyrir hvaða streng sem gæti birst notandanum.

X++ sýnishorn

Þetta X++ kóðadæmi er í formi starfs. Það er hnútur sem heitir Störf í forritshlutatrénu (AOT). Þessu sýnishorni er hægt að bæta við undir hnútnum Störf og síðan er hægt að keyra verkið.

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.");
    }
}

Úttak

Hér er úttakið úr Infolog glugganum: Skilaboð (09:49:48) Halló heimur, 1. Halló heimur, 2. Þetta er eins og upplýsingar, en er fyrir viðvaranir, 3. Þetta er eins og upplýsingar, en er fyrir villur, 4.

C# sýnishorn

Eftirfarandi C# forrit er endurskrifun á fyrra X++ forriti.

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.");
        }
    }
}

Úttak

Hér er raunverulegt úttak á C# leikjatölvunni:

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# Samanburður: Lykkjur

Þessi hluti ber saman lykkjueiginleikana á milli X++ og C#.

Líkt

Eftirfarandi eiginleikar eru þeir sömu í X++ og C#:

• Yfirlýsingar fyrir breytur af frumstæðu gagnagerðinni int. Yfirlýsingar fyrir aðrar frumstæðar gerðir eru nánast þær sömu, en tegundirnar gætu haft mismunandi nöfn.
• en yfirlýsing fyrir lykkjur.
• brjóta yfirlýsingu til að fara út úr lykkju.
• halda áfram fullyrðingu til að hoppa upp efst í lykkju.
• <= (minna en eða jafnt) samanburðarvirki.

Mismunur

Eftirfarandi tafla sýnir X++ eiginleika sem eru mismunandi í C#.

Eiginleikar	X++	C#	Ummæli
Yfirlýsingin for .	For fullyrðingin er í boði fyrir lykkjur.	C# for fullyrðingin er aðeins frábrugðin for X++.	Í C# er hægt að lýsa yfir teljara heiltölu í fullyrðingunni for . En í X++ verður að lýsa teljaranum utan fullyrðingarinnar for .
++ hækka rekstraraðili.	++ hækkunarvirki er fáanlegt í X++. En int breyta sem er skreytt með ++ er aðeins hægt að nota sem fullyrðingu, ekki sem tjáningu. Til dæmis myndu eftirfarandi línur af X++ kóða ekki safnast saman: int age=42; print age++; Hins vegar myndu eftirfarandi línur af X++ kóða safnast saman: int age=42; age++; print age;	C# ++ rekstraraðilinn er sveigjanlegri en í X++.	Eftirfarandi kóðalínur eru þær sömu á báðum tungumálum: ++ myInteger; myInteger++; En eftirfarandi kóðalínur hafa mismunandi áhrif hver á aðra og gilda aðeins í C#: yourInt = ++myInt; yourInt = myInt++;
modulo rekstraraðili.	Í X++ er modulo rekstraraðilinn mod.	Í C# er modulo virkinn %.	Táknin fyrir modulo rekstraraðilann eru mismunandi, en hegðun þeirra er sú sama á báðum tungumálum.
Stöðva tímabundið leikjatölvuforrit sem þegar er hafið.	Yfirlýsingin pause .	Í C# er hægt að gera hlé á skipanalínuforriti með eftirfarandi kóðalínu: Console.In.Read();	Í X++ heldurðu áfram með því að smella á OK hnappinn í modal glugga. Í C# heldurðu áfram með því að ýta á hvaða lyklaborð sem er á lyklaborðinu.
Birta skilaboð.	Í X++ birtir yfirlitið print skilaboð í glugganum Prenta.	Í C# er hægt að birta skilaboð á stjórnborðinu með eftirfarandi kóðalínu: Console.WriteLine();	X++ print aðgerðin er aðeins notuð þegar þú prófar. X++ forrit sem notar print notar næstum alltaf fullyrðinguna einhvers pause staðar seinna í kóðanum. Fyrir framleiðslu X++ kóða skaltu nota Global::info aðferðina í stað print. Aðgerðin strfmt er oft notuð ásamt info. Það er engin ástæða til að nota pause eftir info.
Gefðu frá þér hljóð.	Pípaðgerðin gefur frá sér hljóð sem þú heyrir.	Í C# er hljóð sem þú heyrir gefið út með eftirfarandi kóðalínu: Console.Beep();	Fullyrðingarnar gefa hver um sig stuttan tón.

Prenta og global::info

X++ kóðadæmin fyrir lykkjur nota aðgerðina print til að birta niðurstöður. Í X++ geturðu notað fullyrðinguna print sem getur birt hvaða frumstæða gagnategund sem er án þess að þurfa að kalla á föll sem breyta henni í streng fyrst. Þetta er print gagnlegt í skyndiprófunaraðstæðum. Almennt er Global::info aðferðin notuð oftar en print. Aðferðin info getur aðeins birt strengi. Þess vegna er strfmt fallið oft notað ásamt info. Takmörkun print er að þú getur ekki afritað innihald prentgluggans yfir á klemmuspjaldið (eins og með Ctrl+C). Global::info skrifar í Infolog gluggann sem styður afritun á klemmuspjaldið.

Dæmi 1: While-lykkjan

Meðan leitarorðið styður lykkju bæði í X++ og C#.

X++ Dæmi um while

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.
} 

Úttak

Úttakið í X++ prentglugganum er sem hér segir:

1
2
3
4

C# Dæmi um meðan

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();
    }
}

Úttak

Úttak stjórnborðsins frá C# forritinu er sem hér segir:

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

Dæmi 2: Fyrir lykkju

Leitarorðið for styður lykkju bæði í X++ og C#.

X++ Dæmi um fyrir

Í X++ er ekki hægt að lýsa teljarabreytunni sem hluta af for fullyrðingunni.

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;
}

Úttak

Úttakið í X++ prentglugganum er sem hér segir:

1
2
3
4

C# Dæmi um fyrir

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();
    }
}

Úttak

Úttak stjórnborðsins frá C# forritinu er sem hér segir:

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# Samanburður: Rofi

Í bæði X++ og C# felur rofasetninginí sér lykilatriði, brot og sjálfgefið. Eftirfarandi tafla sýnir muninn á rofasetningunni milli X++ og C#.

Eiginleiki	X++	C#	Ummæli
break; í lok hverrar málsblokkar	Í X++, þegar einhver málsblokk passar við segðargildið á skiptisetningunni , eru allar aðrar lágstafa - og sjálfgefnar blokkir keyrðar þar til break; fullyrðingu er náð. Aldrei er krafist neinnar break; fullyrðingar í X++ switch yfirlýsingu, en break; fullyrðingar eru mikilvægar í næstum öllum hagnýtum aðstæðum.	Í C# break; er alltaf þörf á fullyrðingu á eftir fullyrðingum í máli eða sjálfgefinni blokk. Ef málsákvæði hefur engar yfirlýsingar á milli sín og næsta málsákvæðis er ekki krafist yfirlýsingar break; á milli málsákvæðanna tveggja.	Við mælum með því að sleppa fullyrðingunni break; eftir hvaða málsblokk sem er, vegna þess að það getur ruglað næsta forritara sem breytir kóðanum.
break; í lok sjálfgefna blokkarinnar	Í X++ eru engin áhrif af því að bæta break; við fullyrðingu í lok sjálfgefna blokkarinnar.	Í C# þarf break; þýðandinn yfirlýsingu í lok sjálfgefna blokkarinnar.	Frekari upplýsingar er að finna í Skiptayfirlit.
Aðeins föst gildi á málsblokk	Í X++ er hægt að tilgreina annað hvort bókstafsgildi eða breytu á málsblokk. Til dæmis er hægt að skrifa mál myInteger:.	Í C# verður þú að tilgreina nákvæmlega eitt bókstafsgildi á hverri málsblokk og engar breytur eru leyfðar.	Engar athugasemdir.
Mörg gildi í einum málsblokk	Í X++ er hægt að tilgreina mörg gildi á hverja málsblokk. Gildin verða að vera aðskilin með kommu. Til dæmis er hægt að skrifa case 4,5,myInteger:.	Í C# verður þú að tilgreina nákvæmlega eitt gildi á hverri málsblokk .	Í X++ er betra að skrifa mörg gildi á einn málsblokk en að sleppa fullyrðingunni break; í lok eins eða fleiri málsblokka.

Kóði Dæmi fyrir rofa

Eftirfarandi hlutar sýna sambærilegar rofasetningar í X++ og C#.

X++ rofi Dæmi

X++ rofadæmið sýnir eftirfarandi:

• case iTemp:og til að sýna fram á að case (93-90): takmarkist ekki við fasta, eins og þau eru í C#.
• //break; til að sýna fram á að break; fullyrðingar séu ekki nauðsynlegar í X++, þó þær séu næstum alltaf æskilegar.
• case 2, (93-90), 5: til að sýna að hægt sé að skrá margar segðir á einni fallsetningu í X++.

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# rofi Dæmi

C# rofadæmið sýnir eftirfarandi:

• Mál 1: Er með athugasemd sem útskýrir að aðeins er hægt að gefa fasta tjáningu á málssetningu.
• break; fullyrðingar eiga sér stað á eftir síðustu fullyrðingu í hverri málsblokk sem hefur fullyrðingar, eins og krafist er í C#.

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# Samanburður: Strengjahástafir og afmörkun

Þessi hluti ber saman meðferð strengja með blönduðum hástöfum í X++ og C#. Það útskýrir einnig strengjaafmörkin sem eru fáanleg í X++.

Líkt

Eftirfarandi X++ eiginleikar eru þeir sömu og í C#:

• Afturskástrik (\) er flóttavirki fyrir strengjaafmörkun.
• At-merkið (@) ógildir undanfallsáhrif bakstriksins þegar at-merkið er skrifað rétt á undan opnu gæsalöppum strengs.
• Plúsmerkið (+) er samtengingarvirki strengja.

Mismunur

X++ eiginleikar sem eru mismunandi í C# eru taldir upp í eftirfarandi töflu.

Eiginleiki	X++	C#	Ummæli
== samanburður rekstraraðili	Ónæmt: rekstraraðilinn er ónæmur == fyrir mismun á strengjahulstri.	Í C# er rekstraraðilinn viðkvæmur == fyrir mismun á strengjahulstri.	Í X++ er hægt að nota strCmp aðgerðina til að bera saman há- og lágstafi á milli strengja.
Strengjamörk	Í X++ er hægt að nota annað hvort einfalda (') eða tvöfalda (") gæsalappir sem strengjamerki. Nóta: Yfirleitt er best að nota tvöfaldar gæsalappir fyrir strengi sem gætu birst notandanum. Hins vegar er þægilegt að afmarka streng með einföldum gæsalöppum þegar tvöfaldar gæsalappir eru einn af stöfum í strengnum.	Í C# verður að nota tvöföldu gæsalappirnar sem strengjaafmörkun. Þetta vísar til tegundarinnar System.String.	Í X++ og C# hefurðu möguleika á að fella afmörkun inn í bókstafsstreng og sleppa honum með . Í X++ hefurðu einnig þann valkost að fella stakar gæsalappir inn í streng sem er afmarkaður með tvöföldum gæsalöppum (eða öfugt), án þess að þurfa að nota escape.
Afmörkun stafa	X++ er með strengjagagnagerð (str), en enga stafagerð.	Í C# verður að nota eina gæsalappa sem stafamerki. Þetta vísar til tegundarinnar System.Char.	Í .NET Framework er lengd System.String einn önnur gagnategund en System.Char stafur.

Dæmi 1: Hástafanæmi == rekstraraðila

Virkjarnir == og != eru há- og lágstafir í X++, en eru há- og lágstafir í C#, eins og sést í eftirfarandi dæmi.

X++	C#	Ummæli
"HELLO" == "hello" Satt í X++.	"HELLO" == "hello" Ósatt í C#.	Mismunandi samanburður á málum milli X++ og C#.

Dæmi 2: + strengjasamtengingarvirkið

Virkjanir + og += eru notaðir til að sameina strengi bæði í X++ og C#, eins og sést í dæmunum í eftirfarandi töflu.

X++	C#	Ummæli
myString1 = "Hello" + " world"; Niðurstaðan er jafnrétti: myString1 == "Hello world"	(Sama og fyrir X++.)	Í bæði X++ og C# fer hegðun + rekstraraðilans eftir gagnagerð óperanda hans. Virknitáknið tengir saman strengi eða bætir við tölum.
mystring2 = "Hello"; myString2 += " world"; Niðurstaðan er jafnrétti: myString2 == "Hello world"	(Sama og fyrir X++.)	Í bæði X++ og C# eru eftirfarandi fullyrðingar jafngildar: a = a + b; a += b;

Dæmi 3: Innfella og sleppa strengjamörkum

Hægt er að nota annað hvort einfaldar eða tvöfaldar gæsalappir til að afmarka strengi í X++. Hægt er að nota escape-stafinn (\) til að fella afmörkun inn í streng. Þetta er sýnt í eftirfarandi töflu.

X++	C#	Ummæli
myString1 = "They said \"yes\"."; Niðurstaða: They said "yes".	(Sama og fyrir X++.)	Escape-stafurinn gerir þér kleift að fella strengjamörk inn í strengi.
myString2 = 'They said "yes".'; Niðurstaða: They said "yes".	C# setningafræði leyfir ekki stökum gæsalöppum til að afmarka strengi.	Fyrir strengi sem notandinn kann að sjá er talið best að nota escape-stafinn í stað stakra gæsalappa eins og sýnt er í dæminu.
myString3 = "They said 'yes'."; Niðurstaða: They said 'yes'.	(Sama og fyrir X++.)	Í X++ eru stakar gæsalappir ekki meðhöndlaðar sem afmörkun nema strengurinn byrji á einu gæsalappamerki. Í C# hefur eina gæsalappin enga sérstaka merkingu fyrir strengi og ekki er hægt að nota hana til að afmarka strengi. Í C# er eina gæsalappin nauðsynleg afmörkun fyrir bókstafi af gerðinni System.Char. X++ hefur enga stafagagnategund.
str myString4 = 'C'; Hér er eina tilvitnunin strengjaafmörkun.	char myChar4 = 'C'; Hér er eina gæsalappin afmörkun System.Char , ekki System.String afmörkun.	X++ hefur enga gagnagerð sem samsvarar System.Char í .NET Framework. X++ strengur sem er takmarkaður við lengd eins er samt strengur, ekki stafagagnategund.

Dæmi 4: Single Escape persóna

Dæmi sem sýna staka escape-stafinn í annaðhvort inntakinu eða úttakinu eru sýnd í eftirfarandi töflu.

X++	C#	Ummæli
myString1 = "Red\ shoe"; Niðurstaða: Red shoe	Bókstaflegur strengur í C# getur ekki innihaldið tveggja stafa röð escape á eftir bili, eins og "\ ". Villa í þýðanda kemur upp.	Þegar X++ þýðandinn rekst á tveggja stafa röðina "\ ", fleygir hann staka escape-stafnum.
myString2 = "Red\\ shoe"; Niðurstaða: Red\ shoe	(Sama og fyrir X++.)	Í tveimur flóttapersónum afneitar sú fyrri sérstakri merkingu þeirrar seinni.

Samanburður: Fylkissetningafræði

Það eru líkindi og munur á eiginleikum og setningafræði fyrir fylki í X++ á móti C#.

Líkt

Á heildina litið er margt líkt í setningafræði og meðferð fylkja í X++ og C#. Hins vegar er mikill munur.

Mismunur

Eftirfarandi tafla sýnir svæði í [] setningafræði fyrir fylki sem eru mismunandi fyrir X++ og C#.

Tegund	X++	C#	Ummæli
Yfirlýsing	Fylki er gefið upp með hornklofa bætt við heiti breytunnar.	Fylki er lýst yfir með hornklofa bætt við gagnagerðina.	int myInts[]; // X++ Nóta: X++ fylki getur ekki verið færibreyta í aðferð. int[] myInts; // C#
Yfirlýsing	Fylkissetningafræðin styður aðeins frumstæðar gagnagerðir, svo sem int og .str Setningafræðin styður ekki flokka eða töflur.	Fylkissetningafræðin styður frumstæðar gagnagerðir og flokka.	Í X++ er hægt að nota fylkið Array fyrir fylki af hlutum.
Yfirlýsing	X++ takmarkast við einvíddarfylki (myStrings[8]).	C# bætir við stuðningi fyrir fjölvíddar fylki (myStrings[8,3]) og fyrir oddhvassar fylki (myStrings[8][3]).	Í X++ geturðu ekki haft fylki fylkja. Hins vegar er til háþróuð setningafræði til að takmarka magn virks minnis sem stórt fylki getur neytt, sem lítur út eins og fjölvíddar setningafræði í C#: int intArray[1024,16];. Frekari upplýsingar er að finna í Best Practice Performance Optimizations: Skipta um fylki yfir á disk.
Yfirlýsing	Í X++ er fylki sérstök smíð en það er ekki hlutur.	Í C# eru öll fylki hlutir óháð setningafræðilegum afbrigðum.	X++ er með Array flokk, en undirliggjandi vélbúnaður hans er frábrugðinn fylkjum sem búin eru til með því að nota [] setningafræðina. Í C# nota öll fylki sama undirliggjandi kerfi, óháð því hvort [] setningafræði klasans System.Array er notuð í kóðanum þínum.
Lengd	Í X++ er lengd fylkis af kyrrstæðri stærð ákvörðuð í setningafræði yfirlýsingarinnar.	Í C# er stærð fylkis ákvörðuð þegar fylkishluturinn er smíðaður.	Þegar [] yfirlitssetningaskipan er notuð í X++ er ekki þörf á frekari undirbúningi áður en gildum er úthlutað á fylkið. Í C# verður þú að lýsa yfir og smíða síðan fylkið áður en þú úthlutar því.
Lengd	X++ fylki getur haft kraftmikla lengd sem hægt er að auka jafnvel eftir að íbúafjöldi er byrjaður. Þetta á aðeins við þegar fylkið er gefið upp án tölu inni í []. Afköst gætu hægst ef lengd kraftmikla fylkisins er aukin margfalt.	Í C# er ekki hægt að breyta lengd fylkis eftir að lengdin er stillt.	Í eftirfarandi broti af X++ kóða er aðeins fylkið myInts kraftmikið og getur stækkað. int myInts[]; int myBools[5]; myInts[2] = 12; myInts[3] = 13; myBools[6] = 26; //Error
Lengd	Þú getur fengið lengd sumra fylkja með því að nota aðgerðina dimOf .	C# fylki eru hlutir sem hafa Length eiginleika.	Engar athugasemdir.
Flokkun	Fylkisflokkun er 1 byggð.	Fylkisflokkun er 0 byggð.	mtIntArray[0] myndi valda villu í X++.
Fasti	Í X++ er fasta gildi best náð með því að nota #define forþýðandatilskipunina.	Í C# geturðu skreytt breytuyfirlýsinguna þína með leitarorðinu const, til að ná stöðugu gildi.	X++ hefur ekkert const leitarorð. C# getur ekki úthlutað gildum til breytna sem eru búnar til með #define forþýðandatilskipun þess.

X++ og C# sýnishorn

Eftirfarandi kóðadæmi sýna hvernig fylki af frumstæðum gagnagerðum eru meðhöndluð. Fyrra sýnið er í X++ og seinna sýnið er í C#. Bæði sýnin ná sömu niðurstöðum.

X++ sýnishorn

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]));
    }
}

Úttak

Úttakið í upplýsingaskrána er sem hér segir:

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# sýnishorn

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

Úttak

Úttakið frá C# forritinu í skipanalínustjórnborðið er sem hér segir:

-------- 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]

Viðbótar fylkislíkir X++ eiginleikar

Gámurinn er sérstök gagnategund sem er fáanleg í X++. Það má líta á það sem svipað fylki, eða svipað safni List .

Samanburður: Söfn

Í fjármála- og rekstrarforriti er hægt að nota X++ List söfnunarklasa. .NET Framework sem er notað í C# er með svipaðan flokk sem heitir System.Collections.Generic.List.

Samanburður á notkun listaflokka

Eftirfarandi tafla ber saman aðferðir í X++ List flokki við aðferðir úr System.Collections.Generic.List .NET Framework og C#.

Eiginleiki	X++	C#	Ummæli
Yfirlýsing um innheimtu	List myList;	List<string> myList;	X++ yfirlýsingin inniheldur ekki tegund þátta sem á að geyma.
Yfirlýsing um endurtekningu	ListIterator iter ListEnumerator enumer;	IEnumerator<strengur> iter;	Í X++ hefur hluturinn ListIterator aðferðir sem geta insert og delete hlutir frá List. X++ ListEnumerator getur ekki breytt innihaldi .List Í X++ er hluturinn ListEnumerator alltaf búinn til á sama þrepi Listog . Þetta á ekki alltaf við um ListIterator.
Að fá endurtekningu	new ListIterator (myList) myList.getEnumerator()	myList.GetEnumerator()	Í bæði X++ og C# hefur List hluturinn getter aðferð fyrir tengdan teljara.
Framleiðandi	new List(Types::String)	new List<string>()	Upplýsingar um tegund hluta sem á að geyma inni í flokkunum List eru gefnar smiðnum bæði í X++ og C#.
Uppfærsla gagna	Upptalningamaður – upptalningin verður ógild ef einhverjum atriðum í er List bætt við eða fjarlægt. Iterator – endurtekningin hefur aðferðir til að setja inn og eyða atriðum úr .List Endurtekningin er enn í gildi.	Upptalningamaður – upptalningin verður ógild ef einhverjum atriðum í er List bætt við eða fjarlægt.	Teljarar verða ógildir eftir að atriðum er bætt við eða eytt úr List, bæði í X++ og C#.
Uppfærsla gagna	Í X++ hefur bekkurinn List aðferðir til að bæta við hlutum í upphafi eða lok listans.	Í C# hefur bekkurinn List aðferðir til að bæta við meðlimum í hvaða stöðu sem er á listanum. Það hefur einnig aðferðir til að fjarlægja hluti úr hvaða stöðu sem er.	Í X++ er hægt að fjarlægja atriði úr aðeins List með endurtekningu.

Dæmi 1: Yfirlýsing lista

Eftirfarandi kóðadæmi eru í X++ og C# sem lýsa List yfir söfnum.

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

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

Dæmi 2: Gerð lista

Á báðum tungumálum verður að tilgreina tegund vara sem safn geymir við byggingu. Fyrir klasagerðir getur X++ ekki orðið nákvæmari en hvort tegundin sé klasi (Types::Class). Eftirfarandi kóðadæmi eru í X++ og C#.

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

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

Dæmi 3: Bæta atriðum við lista

Í bæði X++ og C# býður safnið upp á aðferð til að bæta atriði við lok safnsins og til að setja atriði inn í byrjunina. Í C# veitir safnið aðferð til að setja inn hvenær sem er í safninu byggt á vísitölugildi. Í X++ getur söfnunartæki sett hlut inn á núverandi stað. Eftirfarandi kóðadæmi eru í X++ og C#.

// 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");

Dæmi 4: Endurtaka í gegnum lista

Bæði X++ og C# eru með endurtekningarklasa sem þú getur notað til að fara í gegnum atriðin í safni eins og sýnt er í eftirfarandi dæmum.

// 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); 
}

Sýnidæmi 4b: foreach í C#

Í C# er foreach leitarorðið oft notað til að einfalda það verkefni að endurtaka í gegnum lista. Eftirfarandi dæmi um kóða hegðar sér eins og fyrra C# dæmi.

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

Dæmi 5: Eyða seinna atriðinu

Eftirfarandi kóðadæmi eyða annarri vörunni úr safninu. Í X++ þarf þetta endurtekningu. Í C# veitir safnið sjálft aðferð til að fjarlægja hlut.

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

// C#
listStrings.RemoveAt(1);

Dæmi 6: Sameina tvö söfn

Eftirfarandi kóðadæmi sameina innihald tveggja safna í eitt.

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

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

Samanburður: Lyklasöfn með gildum

Í fjármála- og rekstrarforriti er hægt að nota innheimtuklasann Map . Safnið Map geymir pör af gildum, lykilgildið auk gagnagildis. Þetta líkist .NET Framework flokknum sem heitir System.Collections.Generic.Dictionary.

Líkt

Eftirfarandi listi lýsir líkindum milli X++ og C# varðandi söfn þeirra sem geyma lykilgildispör:

• Hvort tveggja kemur í veg fyrir tvítekna lykla.
• Báðir nota teljara (eða endurtekningu) til að fara í gegnum atriðin.
• Báðir lykilgildissöfnunarhlutirnir eru smíðaðir með tilnefningum þeirra gerða sem eru geymdar sem lykill og gildi.
• Báðir geta geymt flokkshluti og takmarkast ekki við að geyma frumstæður eins og int.

Mismunur

Eftirfarandi tafla lýsir muninum á X++ og C# varðandi safnflokka þeirra sem geyma lykilgildispar:

Eiginleiki	X++	C#	Ummæli
Afrita lykla	Í X++ kemur klasinn í veg fyrir tvítekna Map lykla með því að meðhöndla kallið þitt á aðferð sína insert sem aðgerð til að uppfæra aðeins gildið sem tengist lyklinum.	Í C# kastar bekkurinn undantekningu Dictionary þegar þú reynir að bæta við tvíteknum lykli.	Komið er í veg fyrir tvítekna lykla á báðum tungumálum, þó með mismunandi aðferðum.
Eyða atriðum	Í X++ er aðferðin delete á ítrekunarhlut notuð til að fjarlægja óæskilegt lykilgildispar úr Map.	Í C# er bekkurinn Dictionary með remove aðferð.	Á báðum tungumálum er talningamaður gerður ógildur ef fjölda safnhluta er breytt á líftíma talningaraðila.

Dæmi 1: Yfirlýsing um Key-Value innheimtu

Á báðum tungumálum verður að tilgreina tegund vara sem lyklavirðissöfnunin geymir. Í X++ er tegundin tilgreind við byggingu. Í C# er tegundin tilgreind bæði við yfirlýsingu og framkvæmdir. Eftirfarandi kóðadæmi eru í X++ og C#.

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

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

Dæmi 2: Bygging safnsins

Á báðum tungumálum, sú tegund vara sem lyklavirðissafnið geymir tilgreindi við byggingu. Fyrir klasagerðir getur X++ ekki orðið nákvæmari en hvort tegundin sé klasi (Types::Class). Eftirfarandi kóðadæmi eru í X++ og C#.

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

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

Dæmi 3: Bæta við vöru í safnið

Það er nánast enginn munur á því hvernig hlut er bætt við lykilgildissafn í X++ og C# eins og sýnt er í eftirfarandi kóðadæmum.

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

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

Dæmi 4: Endurtaka í gegnum Key-Value safn

Teljarar eru notaðir til að fara í gegnum lyklagildissöfnin bæði í X++ og C# eins og sýnt er í eftirfarandi kóðadæmum.

// 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.
}

Dæmi 5: Uppfærðu gildið sem tengist lykli

Setningafræðin er mjög mismunandi milli tungumálanna tveggja fyrir uppfærslu á gildinu sem tengist tilteknum lykli. Dæmin um ollowing kóða eru fyrir lykilinn 102.

// 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.”;

Dæmi 6: Eyða einu atriði

Setningafræðin er mjög mismunandi á milli tungumálanna tveggja til að eyða einu lykilgildispari úr safni, á meðan það endurtekur í gegnum safnmeðlimina. Kóðadæmi fyrir lykilinn 102 eru sýnd hér að neðan.

// 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);

Samanburður: Undantekningar

Það eru nokkur líkindi en margt ólíkt þegar við berum saman undantekningartengda hegðun milli X++ og C#. Leitarorðin try, catch og throw hegða sér eins í X++ og C#. En tegundir undantekninga sem kastað er og gripið eru mismunandi fyrir tungumálin tvö.

Líkt

Líkindi milli X++ og C# varðandi undantekningareiginleika þeirra eru eftirfarandi dæmi:

• Bæði tungumálin hafa sama leitarorðið .
• Báðir hafa sama leitarorðið .
• Báðir virkja fyrir aflayfirlýsingu sem tilgreinir ekki neina sérstaka undantekningu. Slík aflayfirlýsing grípur allar undantekningar sem ná henni.
• Báðir eru með sama kastlykilorðið .

Mismunur

Undantekningartengdum mun á X++ og C# er lýst í eftirfarandi töflu.

Eiginleiki	X++	C#	Ummæli
Reyna	Hoppar í fyrstu kennsluna í tilheyrandi tilraunablokk . Frekari upplýsingar er að finna í Meðhöndlun undantekninga með tilraun til að grípa leitarorð.	Hægt er að líkja eftir virkni leitarorðsins í C# kóða, en það er ekki samsvarandi leitarorð.	Aðeins X++ er með leitarorð fyrir endurtekna tilraun . C# á sér enga hliðstæðu. Frekari upplýsingar er að finna í X++, C# Samanburður: Sjálfvirk endurtekning eftir undantekningu.
loks	Leitarorðið finally er stutt til að fylgja og try leitarorðunumcatch.	Að lokum merkir lykilorðið kóðablokk sem fylgir tilrauna- og grípakubbunum. Að lokum verður það framkvæmt óháð því hvort undantekningum er kastað eða gripið.	Merkingarfræðin er eins og merkingarfræðin í C#.
Sérstakar undantekningar	Í X++ er undantekning þáttur í upptölunni, svo sem ExceptionError, Deadlock eða CodeAccessSecurity. Engin undantekning getur geymt aðra.	Í C# er undantekning dæmi um grunnflokkinn System.Exception , eða hvaða flokk sem erfir frá honum. Undantekning getur verið í InnerException eign undantekningarinnar sem kastað er.	Í X++ er hver undantekning sem kastað er gildi undantekningarinnar. Frekari upplýsingar er að finna í Undantekningaupptalning.
Skilaboð um undantekningu	Í X++ eru skilaboðin sem eru búin til þegar undantekning er sett fram aðeins aðgengileg í Infolog og skilaboðin eru ekki beintengd við undantekninguna.	Í C# eru skilaboðin meðlimur Message hlutarins System.Exception .	Í X++ er Global::error aðferðin vélbúnaðurinn sem birtir undantekningarskilaboð í upplýsingaskránni. Frekari upplýsingar er að finna í Meðhöndlun undantekninga með tilraun til að grípa leitarorð.
Undantekningarskilyrði	Í X++ kemur villa upp þegar þú kallar tilviksaðferð á hlutbreytu sem hefur ekki enn fengið neitt úthlutað. Hins vegar er engin undantekning nefnd samhliða þessari villu. Þess vegna getur engin catch blokk náð stjórn jafnvel þótt óúthlutað breytu sé misnotuð í try blokk. Í eftirfarandi kóðadæmi veldur villan sem stafar af kóðanum box4.toString(); ekki stýringu til að flytjast yfir í neina catch blokk: DialogBox box4;try { box4.toString(); info("toString did not error, but expected an error."); } catch (Exception::Error) // No Exception gildi grípur þetta. { info("Invalid use of box4 gave control to catch, unexpected."); }	Í C# er a System.NullReferenceException hækkað þegar ófrumstillt breyta er meðhöndluð sem hluttilvísun.	Það gæti verið nokkur annar munur á aðstæðum sem vekja undantekningar.
SQL viðskipti	Í X++ þegar SQL undantekning á sér stað í ttsBegin - ttsCommit færslu getur engin aflayfirlýsing innan færslublokkarinnar unnið úr undantekningunni.	Í C# getur aflablokk inni í SQL færslu náð undantekningunni.

Dæmi

Eftirfarandi X++ eiginleikar eru sýndir:

• Prófaðu leitarorð.
• grípa leitarorð.
• Hegðunin eftir undantekningu Undantekning::Villu á sér stað.

X++ Dæmi

// 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.");
}

Úttak

Hér er úttakið úr Infolog glugganum:

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# sýnishorn

Eftirfarandi C# forrit er endurskrifun á fyrra X++ forriti.

// 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

Úttak

Hér er úttakið á C# leikjatölvunni:

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

Samanburður: Sjálfvirk endurtekning eftir undantekningu

Stundum er hægt að skrifa kóða í grípablokk sem lagar orsök undantekningar sem á sér stað á keyrslutíma. X++ býður upp á endurreit leitarorð sem aðeins er hægt að nota inni í aflablokk . Lykilorðið retry gerir forriti kleift að hoppa aftur í upphaf tilraunablokkarinnar eftir að vandamálið hefur verið leiðrétt með kóða í grípublokkinni . C# er ekki með leitarorð fyrir endurtekna tilraun . Hins vegar er hægt að skrifa C# kóða til að veita samsvarandi hegðun.

Kóðasýnishorn fyrir endurtekna tilraun

Eftirfarandi X++ sýnishorn af forriti veldur því að Exception::Error kemur upp. Þetta gerist þegar það reynir fyrst að lesa einingu úr fylkinu sStrings með því að nota ógilt vísitölugildi. Þegar undantekningin er gripin er gripið til úrbóta á keyrslutíma inni í aflablokkinni . Yfirlýsingin um endurtekningu hoppar síðan aftur í fyrstu fullyrðinguna í tilraunablokkinni . Þessi seinni endurtekning virkar án þess að lenda í neinum undantekningum.

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;
}

Úttak

Hér er úttakið í prentglugganum:

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# sýnishorn

Eftirfarandi C# sýnishorn er ekki línu-fyrir-línu þýðing frá fyrra X++ sýnishorni. Þess í stað hefur C# forritið aðra uppbyggingu þannig að það líkir eftir hegðun endurprófunarleitarorðsins sem X++ forritið treystir á. Reyna og grípa blokkirnar eru í kallaðri aðferð. Breyturnar sem eru notaðar í tilraunablokkinni eru geymdar í kallaðferðinni. Kallaðferðin sendir breyturnar sem færibreytur sem eru skreyttar með tilvísun leitarorðinu, þannig að hægt sé að leiðrétta gildi þeirra inni í gripblokk kölluðu aðferðarinnar. Aðferðin sem hringt er í fangar allar undantekningar og skilar boolean til að senda skilaboð til þess sem hringir hvort þörf sé á öðru símtali.

// 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;
    }
}

Úttak

Hér er úttakið á stjórnborðinu:

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.

Samanburður: Rekstraraðilar

Þessi hluti ber saman rekstraraðila á milli X++ og C#.

Virkjar úthlutunar

Eftirfarandi tafla sýnir muninn á úthlutunarvirkjunum í X++ og C#.

X++ og C#	Mismunur
=	Í X++ veldur þessi virki óbeinni umbreytingu þegar tap á nákvæmni gæti átt sér stað, svo sem fyrir úthlutun frá int64 til int. En í C# veldur úthlutunin samsetningarvillu.
+= og -=	Eini munurinn er sá að í C# eru þessir virkjar einnig notaðir við meðhöndlun fulltrúa.
++ og --	Þetta eru stigvaxtar- og lækkunarvirkin á báðum tungumálum. Eftirfarandi lína er eins á báðum tungumálum: ++myInteger; En í X++ eru þessir tveir virkjar fyrir fullyrðingar, ekki fyrir tjáningar. Þess vegna mynda eftirfarandi línur samsetningarvillur í X++: myStr = int2str(++myInteger); myIntA = myIntBB++;

Reiknivirkjar

Í eftirfarandi töflu er listi yfir reiknivirkin.

X++ og C#	Mismunur
*	Sem margföldunarvirki er enginn munur. Nóta: Stjarnan er einnig notuð í SQL fullyrðingum sem eru hluti af X++ tungumálinu. Í þessum SQL fullyrðingum getur stjarnan einnig verið eitt af eftirfarandi: Algildistákn sem gefur til kynna að öllum dálkum eigi að skila. Algildistákn fyrir stafi í streng sem er notaður á svipaðri setningu.
/	Skiptingarvirkið er það sama í X++ og C#.
MOD	Fyrir módelaðgerðir er eini munurinn sá að % táknið er notað í C#.
+	Samlagningarvirkið er það sama í X++ og C#. Plúsmerkið er einnig notað fyrir strengjasamtengingu. Þessi virki bætir við tölum og tengir saman strengi á báðum tungumálum.
-	Frádráttarvirkinn er sá sami í X++ og C#.

Bitwise rekstraraðilar

Eftirfarandi tafla ber saman bitalega virkjana á milli X++ og C#.

X++ og C#	Mismunur
<<	Vinstri vaktarvirkinn er sá sami í X++ og C#.
>>	Hægri skiptastjórinn er sá sami í X++ og C#.
~	Bitalega NOT virkjaninn er sá sami í X++ og C#.
&	Tvöfaldur AND virkinn er sá sami í X++ og C#.
^	Tvöfaldur XOR virkinn er sá sami í X++ og C#.

Venslaðir rekstraraðilar

Eftirfarandi venslavirkjar eru þeir sömu í X++ og C#:

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

Samanburður: Viðburðir

Það er nokkur munur á því hvernig X++ og C# innleiða viðburðahönnunarmynstrið. Frekari upplýsingar er að finna í Hugtök og leitarorð tilvika.

Samanburður á atburðum milli X++ og C#

Það er munur á því hvernig fulltrúar eru notaðir fyrir viðburði í X++ á móti C#.

Hugmynd	X++	C#	Ummæli
fulltrúi	Í X++ er aðeins hægt að lýsa fulltrúa sem meðlim í bekk. Fulltrúi getur ekki verið meðlimur á borði. Allir fulltrúar eru dæmimeðlimir í sínum bekk, ekki kyrrstæðir meðlimir. Ekki er hægt að nota aðgangsbreytileika á yfirlýsingu fulltrúa þar sem allir fulltrúar eru verndaðir meðlimir. Þess vegna er aðeins hægt að hækka viðburðinn með kóða innan sama flokks þar sem fulltrúinn er meðlimur. Hins vegar er eina undantekningin frá einkaeðli fulltrúa að kóði utan flokks þeirra getur virkað á fulltrúa með því að nota virknina += og -=.	Í C# er hver fulltrúi týpa, rétt eins og hver flokkur er týpa. Fulltrúi er lýstur óháður hvaða stétt sem er. Án leitarorðs tilviks er hægt að hafa fulltrúa sem færibreytugerð á aðferð, rétt eins og hægt er að hafa klasa sem færibreytugerð. Hægt er að búa til tilvik fulltrúa til að senda inn fyrir færibreytugildið.	Í X++ er hver flokkur tegund, en enginn fulltrúi er tegund. Ekki er hægt að búa til tilvik fulltrúa. Enginn fulltrúi getur verið færibreyta fyrir aðferð. En þú getur búið til klasa sem hefur fulltrúameðlim og þú getur sent tilvik af klasanum sem færibreytugildi. Fyrir frekari upplýsingar, sjá X++ leitarorð.
atburður	Í X++ kóða er atburður einn af eftirfarandi: Skýrt ákall til fulltrúa. Upphaf eða endir aðferðar. Það er ekki lykilorð fyrir atburð í X++.	Í C# er lykilorð tilviksins notað til að lýsa yfir gerð fulltrúa sem meðlimur í flokki. Áhrif lykilorðs atburðarins eru að gera fulltrúann verndaðan, en samt aðgengilegan fyrir += og -= virkniaðilana. Hægt er að gerast áskrifandi að atviksstjórnunaraðferðum fyrir tilvik með því að nota virknitáknið +=. Fulltrúi getur verið gagnlegur án lykilorðs atburða, sem tækni til að senda fallbendil sem færibreytu inn í aðferð.	Sjálfvirka atburði sem eiga sér stað áður en aðferð hefst og eftir lok aðferðar er aðeins hægt að gerast áskrifandi að með því að nota AOT.
+= og -= virkjar	Í X++ notarðu virkinn += til að gerast áskrifandi að aðferðum fulltrúa. Rekstraraðilinn -= afskráir aðferð frá fulltrúa.	Í C# er notast við virknina += til að gerast áskrifandi að aðferðum tilviks eða fulltrúa sem er ekki notað með leitarorði tilviksins .	Fulltrúinn inniheldur tilvísun í alla hluti sem hafa aðferðir sem eru áskrifendur að fulltrúanum. Þessir hlutir eru ekki gjaldgengir til sorphirðu á meðan fulltrúi hefur þessar tilvísanir.
eventHandler	Í X++ er leitarorðið eventHandler nauðsynlegt þegar þú notar annaðhvort += eða -= virkjann til að gerast áskrifandi að eða segja upp áskrift að aðferð fulltrúa.	System.EventHandler er gerð fulltrúa í .NET Framework.	Þetta hugtak er notað öðruvísi í X++ en það er í C# eða .NET Framework. Fyrir frekari upplýsingar, sjá X++ leitarorð.

X++ Dæmi

Það sem er mikilvægt að taka eftir eru eftirfarandi í X++ dæminu:

• The XppClass er með fulltrúa sem heitir myDelegate.

  Athugasemd

  AOT inniheldur hnút fyrir fulltrúann. Hnúturinn er staðsettur á AOT > Classes > XppClass > myDelegate. Hægt er að finna nokkra atvikahnúta undir myDelegate hnútnum. Atvikastýringar sem eru táknaðir með hnútum í AOT geta ekki verið fjarlægðir af virkjanum -= á keyrslutíma.

• Axlaböndin {} í lok yfirlýsingar fulltrúa eru nauðsynlegar, en þær mega ekki hafa neinn kóða í þeim.

• Það XppClass hefur tvær aðferðir þar sem færibreytuundirskriftir eru samhæfðar fulltrúanum. Ein aðferðin er kyrrstæð.

• Samhæfðu aðferðunum tveimur er bætt við fulltrúann með += virknitákninu og eventHandler leitarorðinu. Þessar fullyrðingar kalla ekki atburðameðhöndlunaraðferðirnar, fullyrðingarnar bæta aðeins aðferðunum við fulltrúann.

• Viðburðinum er vakið með einu símtali til fulltrúans.

• Færibreytugildið sem sent er inn á fulltrúann er móttekið af hverri atviksstjórnunaraðferð.

• Stutta X++ vinnslan efst í dæminu byrjar prófið.

// 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);
    }
}

Úttakið frá fyrra X++ verki er sem hér segir:

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# sýnishorn

Þessi hluti inniheldur C# kóða sýnishorn fyrir atburðahönnunarmynstur fyrra X++ sýnis.

// 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);
    }
}

Úttakið úr fyrra C# sýnishorninu er sem hér segir:

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.

Viðburðir og AOT

Það eru önnur tilvikakerfi sem eiga aðeins við um atriði í AOT. Frekari upplýsingar er að finna í Atburðastýringarhnútar í AOT.

Samanburður: Tilskipanir fyrir þýðanda

X++ og C# deila nokkrum leitarorðum fyrir setningafræði forþýðandatilskipunarinnar, en merkingin er ekki alltaf sú sama.

Líkt

X++ og C# þýðendurnir þekkja mörg af sömu leitarorðunum. Í flestum tilfellum þýða leitarorðin það sama fyrir báða þýðendur tungumála.

Mismunur

Grundvallarmunur á fyrirmælum forþýðanda í X++ á móti C# er #define leitarorðið sem báðir tungumálaþýðendur þekkja. Ólíkt C#, í X++ krefst #define tilskipunin punkts í setningafræði sinni. Í X++ er hægt að nota sviga til að gefa skilgreindu tákni gildi. Þessi munur er sýndur í eftirfarandi dæmum:

• Í X++: #define. Upphafsár (2003)
• Í C#: #define Upphafsár

Smávægilegur munur er sá að í C# geta verið bil og flipastafir á milli # stafsins og tilskipunarleitarorðsins, eins og # define Testing.

Sams konar leitarorð

Eftirfarandi tafla sýnir fyrirmæli fyrir þýðanda sem eru svipaðar í X++ og C#.

Lykilorð	X++	C#	Ummæli
#define	Í X++ er hægt að skilgreina heiti forþýðanda breytu og gefa þeirri breytu gildi.	Í C# er hægt að skilgreina heiti forþýðanda breytu, en ekki er hægt að gefa því gildi fyrir þá breytu. Einnig verða allar #define í C# að eiga sér stað efst í skránni og geta ekki átt sér stað á eftir neinum kóða eins og using yfirlýsingu eða klasayfirlýsingu.	C# þýðandinn getur sett inn skipanalínubreytu til /define að skilgreina heiti forþýðanda breytu án þess að skilgreina breytuna í neinni C# kóðaskrá. X++ þýðandinn hefur enga hliðstæðu við /define.
#if	Í X++ getur #if ákvarðað hvort forþýðandi breyta sé til og hvort breytan hafi tiltekið gildi.	Í C# getur #if aðeins ákvarðað hvort forþýðandi breyta sé til. Það er ekki hægt að prófa fyrir nein gildi vegna þess að ekki er hægt að úthluta neinu gildi.
#endif	Í X++ markar #endif lok #if blokkar. Það endar líka #ifnot blokk.	Í C# markar #endif lok #if blokkar, óháð því hvort blokkin inniheldur #else.

Mismunandi leitarorð með sömu vinnsluniðurstöðu

Eftirfarandi tafla sýnir fyrirmæli fyrir þýðanda sem eru nefndar á annan hátt í X++ og C#, en gefa sömu niðurstöður þegar þær eru unnar.

X++	C#	Ummæli
#ifnot	#if #else	Það er ekki #else tilskipun í X++, en #ifnot býður upp á svipaða virkni. Í X++ getur #ifnot ákvarðað hvort forþýðandi breyta sé til og hvort breytan hafi ekki ákveðið tiltekið gildi. Í C# getur #if ákvarðað hvort forþýðandi breyta sé til þegar '!' táknið er forskeyti við heiti breytunnar.
//BP Deviation documented	#pragma viðvörun	Þessar X++ og C# færslur eru ekki jafngildar, en það er að hluta til líkt. Báðir bæla niður viðvörunarskilaboð þýðanda.
#macrolib	. HPP skrá í C++	Það er að hluta til líkt með X++ tilskipuninni #macrolib á móti . HPP skrá í C++. Báðir geta innihaldið nokkrar #define fullyrðingar.

Tilskipanir um forþýðanda eingöngu fyrir X++

Eftirfarandi tafla sýnir X++ forþýðartilskipanir sem hafa enga beina hliðstæðu í C#.

X++	Ummæli
#linenumber	#linenumber tilskipunin er til að fá línunúmerið, svo hægt sé að senda það út í Infolog. C# tilskipunin #line er öðruvísi vegna þess að tilgangur hennar er að stilla línunúmerið.
#defdec #definc
#globaldefine	Í X++ er lítill munur á #globaldefine á móti #define. Munurinn er sá að #globaldefine skrifar aldrei yfir núllgildi sem var úthlutað á forþýðandabreytu með #define. C# hefur ekkert svipað þessum mun, vegna þess að í C# er ekki hægt að gefa forþýðanda breytuheiti gildi.
#localmacro #macro	Í X++ gerir #localmacro þér kleift að úthluta fjöllínugildi á breytu fyrir þýðanda. #macro er samheiti, en mælt er með #localmacro. Í C# hefur #define tilskipunin hluta af þessari virkni, en hún getur ekki úthlutað gildi á forþýðandabreytu.
#globalmacro	Í X++ er #globalmacro næstum það sama og ákjósanlegt #localmacro.

Samanburður: Hlutbundin forritun

Hlutbundin forritun (OOP) meginreglur X++ eru frábrugðnar C#.

Huglægur samanburður

Eftirfarandi tafla ber saman innleiðingu OOP meginreglna milli X++ og C#.

Eiginleiki	X++	C#	Ummæli
Steypu	X++ tungumálið hefur leitarorðin is og as, sem eru notuð til að gera niðurslög örugg og skýr. Ábending: X++ krefst ekki notkunar á sem leitarorði þegar þú lækkar grunnklasabreytu í afleidda klasabreytu. Hins vegar mælum við með því að allar niðurdregnar fullyrðingar noti lykilorðið .	Hægt er að kasta hlut annað hvort upp eða niður erfðabrautina. Downcasts þurfa sem leitarorð.	Frekari upplýsingar um X++ leitarorðin is og as er að finna í Segðarvirki: Is og Eins og fyrir erfðir.
Staðbundnar aðgerðir	Aðferð getur innihaldið yfirlýsingu og meginmál kóða fyrir núll eða fleiri staðbundnar aðgerðir. Aðeins sú aðferð getur haft símtöl í staðbundna aðgerðina.	C# 3.0 styður lambda-tjáningar, sem líkjast nafnlausum föllum og staðbundnum aðgerðum. Lambda orðatiltæki eru oft notuð með fulltrúum.
Aðferð ofhleðsla	Ofhleðsla aðferða er ekki studd. Heiti aðferðar getur aðeins komið fyrir einu sinni í hverjum flokki.	Ofhleðsla aðferða er studd. Heiti aðferðar getur komið fyrir mörgum sinnum í einum flokki, með mismunandi færibreytuundirskriftum í hverju tilviki.	X++ styður valfrjálsar breytur á aðferðum. Valfrjálsar breytur geta að hluta til líkt eftir ofhleðslu aðferðarinnar. Nánari upplýsingar er að finna í línunni fyrir valfrjálsar færibreytur í þessari töflu.
Aðferð sem hnekkti	Hnekking aðferða er studd. Afleiddur flokkur getur haft aðferð með sama nafni og í grunnflokknum, svo framarlega sem breytuundirskriftin er sú sama í báðum tilvikum. Eina undantekningin er sú að hnekkjunaraðferðin getur bætt sjálfgefnu gildi við færibreytu.	Hnekking aðferða er studd. Nota verður sýndarleitarorðið á aðferð áður en hægt er að hnekkja aðferðinni í afleiddum flokki.	Hugmyndin um að hnekkja aðferð felur í sér heiti aðferðarinnar, breytuundirskrift hennar og skilagerð hennar. Hugmyndin um að aðferðinni sé hnekkt á ekki við ef grunnaðferðin og hnekkingaraðferðin eru ólík í einhverjum þessara þátta.
Valfrjálsar breytur	Hægt er að fylgja færibreytuyfirlýsingu með sjálfgefnu gildisúthlutun. Aðferðakallarinn hefur möguleika á að senda gildi fyrir þá færibreytu eða hunsa færibreytuna til að samþykkja sjálfgefið gildi. Þessi eiginleiki líkir eftir ofhleðslu aðferðar vegna þess að tvö köll á sama aðferðarheiti geta sent mismunandi fjölda færibreyta. Hver færibreyta sem hefur sjálfgefið gildi verður að fylgja síðustu færibreytunni sem er ekki með sjálfgefið gildi.	Valfrjálsar færibreytur eru studdar af params leitarorðinu. Jafnvel án params leitarorðsins, frá sjónarhóli þess sem hringir, getur ofhleðsla aðferða veitt svipaða virkni að hluta.	Frekari upplýsingar er að finna í Færibreytur og umfang og Notkun valfrjálsra færibreyta.
Einstök arfur	Þú getur leitt X++ klasann þinn úr öðrum X++ klasa með því að nota extend leitarorðið í classDeclaration hnútnum í þínum klasa, í AOT. Enginn flokkur kemur óbeint frá öðrum flokki. Ef þú vilt að bekkurinn þinn komi beint frá bekknum Object verður þú að nota leitarorðið framlengingar . Þú getur aðeins tilgreint einn klasa á leitarorðinu útvíkkar . Varúð: Þegar þú breytir X++ grunnklasa sem aðrir klasar eru dregnir af, verður þú að endurþýða þann grunnklasa með því að nota Þýða áfram. Þessi valkostur tryggir að afleiddu klasarnir séu einnig endurteknir. Til að tryggja að afleiddu klasarnir séu einnig endursamansettir, hægrismelltu á grunnklasahnútinn og smelltu síðan á Add-Ins > Þýða áfram. Valkosturinn að smella á Build > Compile (eða ýta á F7 takkann) er stundum ófullnægjandi fyrir grunnflokksbreytingu. Flokkur getur innleitt núll til mörg viðmót. X++ tafla erfir óbeint frá töflunni Common og frá klasanum xRecord .	C# notar leitarorðið til að leiða af öðrum flokki. Allir .NET Framework flokkar eru óbeint dregnir af flokknum, nema þeir séu beinlínis komnir frá öðrum flokki System.Object .

Samanburður á leitarorðum

Eftirfarandi tafla sýnir OOP tengd leitarorð í X++ og C#.

Lykilorð	X++	C#	Ummæli
útdráttur			Enginn munur.
farrými	Breytingarnar opinberar og einkareknar eru hunsaðar í stéttaryfirlýsingum. Það er ekki til hugmynd um nafnrýmisflokkun flokka. Það eru engir punktar (.) í neinum flokkanöfnum.	Hægt er að nota breytingarnar opinberar og einkareknar til að breyta klasayfirlýsingum. C# hefur einnig lykilorðið innra, sem tengist því hvernig flokkar eru flokkaðir saman í samsetningarskrám.	Það er ekki til hugmynd um verndaðan flokk, aðeins verndaða meðlimi flokks.
Nær	Klasayfirlýsing getur erft frá öðrum klasa með því að nota leitarorðið útvíkkar .	Tvípunktur (:) er notaður þar sem leitarorðin ná og útfærslur eru notaðar í X++.
endanlegur	Ekki er hægt að hnekkja endanlegri aðferð í afleiddum flokki. Ekki er hægt að lengja lokatíma .	Lykilorðið sem er innsiglað á flokki þýðir það sama og endanlegt þýðir á X++ flokki.
Framkvæmd	Klasayfirlýsing getur innleitt viðmót með því að nota leitarorðið implements .
Tengi	Viðmót getur tilgreint aðferðir sem klasinn verður að innleiða.	Viðmót getur tilgreint aðferðir sem klasinn verður að innleiða.
Nýtt	Nýja leitarorðið er notað til að úthluta nýju tilviki af flokki. Þá er sjálfkrafa hringt í smiðinn. Hver flokkur hefur nákvæmlega einn smið og smiðurinn er nefndur new. Þú getur ákveðið hvaða breytur smiðurinn á að setja inn.	Nýja leitarorðið er notað til að búa til nýtt tilvik af flokki. Þá er sjálfkrafa hringt í smiðinn. Smíðaaðferðir sjálfar eru ekki nefndar new, þær bera sama nafn og bekkurinn. Nóta: Einnig er hægt að nota nýja leitarorðið á aðferð til að breyta því hvernig aðferðin hnekkir sömu aðferð í grunnflokknum.	Bæði X++ og C# gera ráð fyrir sjálfgefnum smíði fyrir flokka sem hafa engan smíði sérstaklega skrifaðan í kóða sinn.
núll			Enginn munur.
einkarekið og verndað	Hægt er að nota einka - og vernduð leitarorð til að breyta yfirlýsingu bekkjarmeðlims.	Hægt er að nota einka - og vernduð leitarorð til að breyta yfirlýsingu bekkjarmeðlims.
opinber	Aðferð sem er ekki breytt með almenningi, varið eða einka hefur sjálfgefið aðgangsstig almennt.	Aðferð sem er ekki breytt með almenningi, varið eða einka hefur sjálfgefið aðgangsstig einka.
Truflanir	Aðferð getur verið kyrrstæð, en svið getur það ekki.	Bæði aðferðir og svið geta verið kyrrstæð.
frábær	Ofurleitarorðið er notað í afleiddum flokki til að fá aðgang að sömu aðferð á grunnflokki hans. void method2() { // Call method2 method // on the base class. super(); }	Grunnleitarorðið er notað í afleiddum flokki til að fá aðgang að ýmsum aðferðum í grunnflokki þess. void method2() { // Call methods on // the base class. base.method2(); base.method3(); }	Í C# er sérstök setningafræði til að nota grunn til að kalla á grunnsmiðinn.
þessi	Fyrir kall frá einni tilviksaðferð til annarrar á sama hlut er skilyrði fyrir kallaða aðferð krafist. Lykilorðið þetta er fáanlegt sem skilyrði fyrir núverandi hlut.	Fyrir kall frá einni tilviksaðferð til annarrar á sama hlut er ekki krafist skilyrðis fyrir kölluðu aðferðina. Hins vegar er þetta leitarorð fáanlegt sem skilyrði fyrir núverandi hlut. Í reynd er lykilorðið þetta getur verið gagnlegt með því að birta IntelliSense upplýsingar.
finalize	Bekkurinn Object inniheldur aðferðina finalize . Aðferðin finalize er ekki endanleg og hægt er að hnekkja henni. Aðferðin finalize virðist líkjast aðferðinni System.Object.Finalize í C# en í X++ hefur aðferðin finalize enga sérstaka merkingu af neinu tagi. Hlutur er sjálfkrafa fjarlægður úr minni þegar síðasta tilvísun í hlutinn hættir að vísa í hlutinn. Til dæmis getur þetta gerst þegar síðasta tilvísun fer út fyrir gildissvið eða er úthlutað öðrum hlut til að vísa í.	Aðferðirnar Finalize og Dispose eru algengar á sumum tegundum bekkja. Sorphirðumaðurinn kallar Finalize og Dispose aðferðir þegar það eyðileggur og mótmæla.	Í C# er hægt að kalla á aðferðina System.GC.Collect í .NET Framework til að ræsa sorphirðuna. Það er ekki svipuð aðgerð í X++ vegna þess að X++ notar ákveðinn sorpsöfnun.
main	Flokkar sem eru kallaðir fram úr valmynd hafa aðferð sína main kallaða af kerfinu.	Flokkar sem eru kallaðir fram frá skipanalínuborði hafa aðferð sína Main kallaða af kerfinu.

Samanburður: Flokkar

Þegar þú notar C# í .NET Framework eru klasar flokkaðir í nafnarými. Hvert nafnrými einbeitir sér að hagnýtu svæði eins og skráaraðgerðum eða speglun. Hins vegar, þegar þú notar flokkana í X++, þá eru engir sýnilegir hópar eins og nafnrými.

Samanburður: Námskeið um ígrundun

Í X++ veitir flokkurinn TreeNode aðgang að Application Object Tree (AOT). Bekkurinn TreeNode er miðpunktur speglunarvirkni í X++. Flokknum TreeNode og aðferðum hans má bera saman við nafnrýmið System.Reflection í .NET Framework sem C# notar.

Í eftirfarandi töflu eru nokkrir klasar sem eru í boði þegar þú skrifar C# kóða. Þetta eru .NET Framework flokkar. Fyrir þessa töflu eru allir C# flokkar í nafnrýminu System.Reflection nema annað sé tekið fram. Hver lína sýnir samsvarandi flokk, eða bekkjarmeðlim, sem er í boði fyrir þig þegar þú skrifar X++ kóða.

X++	C#	Ummæli
TreeNode	System .Assembly	Samsetning er fyrsti flokkurinn sem notaður er þegar C# forrit þarf að safna speglunarupplýsingum. Statískar aðferðir á X++ flokknum TreeNode eru upphafspunktur fyrir speglun í X++.
TreeNode	System .Type	Tilviksaðferðir á TreeNode samsvara tilviksaðferðum á System.Type.
TreeNode .AOTgetSource	MethodInfo	Aðferðin AOTgetSource skilar nokkrum upplýsingum saman í einum streng. Þetta felur í sér X++ frumkóðann í aðferðinni. Aftur á móti, MethodInfo hefur sérstakan meðlim fyrir hverja upplýsing.
TreeNode .AOTfirstChild TreeNode .AOTnextSibling TreeNode .AOTiterator AOTiterator	MethodInfo[] (fylki)	Í C# skilar aðferðin fylki GetMethodsSystem.Type MethodInfo hluta. Þú getur lykkjuð í gegnum fylkið með algengri tækni við að auka vísitölu. Aftur á móti er X++ líkanið til að vafra um trjástýringu AOT. Aðferðirnar TreeNode við AOTfirstChild og AOTnextSibling framkvæma siglinguna. Sem sambærilegur valkostur er X++ AOTiterator flokkurinn hannaður til að vafra um trjástýringu AOT. Klasahnútur er foreldri yfir nokkra aðferðarhnúta. Skrefin AOTiterator í gegnum undirhnúta og skila hverju sem öðru TreeNode tilviki. Önnur úrræði aðferðirnar TreeNode sem eru nefndar AOTparent og AOTprevious.
TreeNode .AOTgetProperty TreeNode .AOTgetProperties TreeNode .AOTname	PropertyInfo	Í X++ skilar aðferðin AOTgetProperties löngum streng sem inniheldur nafn-gildi pör fyrir alla eiginleika TreeNode. Aðferðin AOTname skilar streng sem inniheldur aðeins gildið fyrir nafneiginleikann.
TreeNode .AOTsave TreeNode .AOTinsert	System .Reflection .Emit (nafnrými flokka)	Aðferðin AOTsave beitir breytingum frá TreeNode hlut í X++ kóðanum þínum á AOT og breytingarnar eru viðvarandi. Fyrir stórt sýnishorn af kóða, sjá TreeNode.AOTsave aðferð.

Samanburður: Flokkar um skrá IO

Það eru nokkrir flokkar sem framkvæma skráarinntaks- og úttaksaðgerðir (IO). Í .NET Framework sem er notað í C# eru hliðstæður þessara klasa í nafnrýminu System.IO .

Í eftirfarandi töflu eru nokkrir .NET Framework flokkar fyrir C# sem eru í nafnrýminu System.IO . Hver lína í töflunni sýnir X++ klasann eða aðferðina sem samsvarar best .NET Framework klasanum.

X++	C#	Ummæli
BinaryIo	FileStream BinaryReader BinaryWriter	X++ flokkar eins BinaryIo og þeir sem ná frá abstraktflokknum Io þjóna sem straumur og þeir þjóna einnig sem lesandi og rithöfundur fyrir þann straum. Í C# er straumurinn aðskilinn flokkur frá bekknum sem hefur sértækari lestrar- og skrifaðferðir.
TextBuffer	MemoryStream	Þessir flokkar innihalda biðminni í minni og sumar aðferðirnar meðhöndla biðminni eins og það væri skrá á harða disknum.
WINAPI::createDirectory WINAPI::folderExists WINAPI::removeDirectory	Directory DirectoryInfo Path	X++ getur notað kyrrstæðar aðferðir í bekknum WINAPI fyrir margar grunnaðgerðir stýrikerfisins sem fela í sér möppur.
WINAPI::getDriveType	DriveInfo DriveType	Þessir flokkar og aðferðir eru notaðar til að afla aksturstengdra upplýsinga.
WINAPI::copyFile WINAPI::createFile WINAPI::d eleteFile WINAPI::fileExists	File FileAttributes FileInfo	X++ getur notað kyrrstæðar aðferðir í bekknum WINAPI fyrir margar grunnaðgerðir stýrikerfisins sem fela í sér skrár.
CommaIo Comma7Io	(Enginn samsvarandi flokkur.)	Þessir X++ flokkar geta búið til skrár sem Microsoft Excel getur flutt inn. Í X++ er EPPlus bókasafnstilvísun tiltæk fyrir frekari samskipti við Excel.
AsciiIo TextIo	FileStream TextReader TextWriter	Þessir flokkar nota mismunandi kóðasíður.
Io	Stream StreamReader StreamWriter FileStream	Þetta er oft notað sem grunnflokkar sem aðrir flokkar framlengja.
CodeAccessPermission FileIoPermission	System.Security .CodeAccessPermission Nafnrýmið System.Security.Permissions inniheldur eftirfarandi flokka: CodeAccessSecurityAttribute FileIOPermissionAttribute FileIOPermission FileIOPermissionAccess	Hugtökin og aðferðirnar assert, demand, og revertAssert eiga við um bæði tungumálin. Hins vegar eru og deny aðferðirnar revertDeny sem eru tiltækar í C# ekki tiltækar í X++.

X++, ANSI SQL Samanburður: SQL Veldu

Í X++ er SQL valsetningasetningin frábrugðin ANSI-forskriftinni (American National Standards Institute).

Velja stakt borð

Eftirfarandi tafla sýnir muninn á völdum fullyrðingum X++ SQL og ANSI SQL.

Eiginleiki	X++ SQL	ANSI SQL	Ummæli
Töfluheiti á frá-setningunni .	Frá-klausan sýnir tilvik færslubiðminni sem er lýst úr töflu, svo sem úr töflunniCustTable.	From klausan sýnir töfluheiti, ekki nafn biðminni.	Færslubiðminni hefur allar aðferðir sem bekkurinn xRecordhefur í X++.
Setningafræðileg röð röðarinnar eftir á móti hvar setningar.	Skipunin með ákvæði verður að koma fram á undan hvar-ákvæðinu . Röðin með ákvæði verður að koma fram á eftir frá - eða sameiningarákvæðinu . Flokka eftir setningu verður að fylgja sömu setningafræðilegum staðsetningarreglum og röðin eftir fylgir.	Röðin með ákvæði verður að koma fram á eftir hvar-ákvæðinu . Hvar ákvæðið verður að koma á eftir frá eða join ákvæðinu.	Í bæði X++ og ANSI SQL verða frá - og join-setningarnar að birtast á undan röð eftir og hvar setningar.
Afneitun skilyrðis.	Upphrópunarmerkið ('!') er notað fyrir afneitun.	Lykilorðið ekki er notað fyrir afneitun.	X++ styður ekki setningafræðina !like. Þess í stað verður þú að nota ! rekstraraðili að ákvæði.
Algildistafir fyrir svipaðan rekstraraðila.	0 eða margir – stjarna ('*') Nákvæmlega 1 – Spurningarmerki ('?')	0 til margir – Prósentumerki ('%') Nákvæmlega 1 – Underbar ('_')
Rökrænir rekstraraðilar í hvar setningunni.	Og – & Eða – ||	Og – og Eða – eða

Dæmi um kóða

Eftirfarandi kóðadæmi sýnir eiginleika í fyrri töflu.

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 leitarorð

Eftirfarandi X++ SQL leitarorð eru meðal þeirra sem eru ekki hluti af ANSI SQL:

• þvert á fyrirtæki
• firstonly100
• kraftur bókstafir
• forcenestedloop
• kraftstaðgenglar
• forceselectorder
• validtimestate

Taktu þátt í ákvæði

Eftirfarandi tafla sýnir mismun á tengingarleitarorðinu X++ SQL og ANSI SQL.

Eiginleiki	X++ SQL	ANSI SQL	Ummæli
Dálkar listi.	Dálkarnir í dálkalistanum verða allir að koma úr töflunni sem er skráð í fra-setningunni, en ekki úr neinni töflu í sameiningarákvæði. Dálkar á listanum geta ekki verið hæfir með töfluheiti sínu.	Dálkarnir í dálkalistanum geta komið úr hvaða töflu sem er í frá - eða sameiningarákvæðunum . Það hjálpar öðrum að viðhalda kóðanum þínum þegar þú hæfir dálkana í listanum með töfluheiti þeirra.	Frekari upplýsingar er að finna í Velja uppgjör á reitum.
Setningafræði tengingarsetningar .	Join-setningin kemur á eftir where-setningunni.	Sameiningaákvæðið fylgir töflu í frá-setningunni.	Í X++ kóðadæminu eru sameiningarviðmiðin jafngildi SalesPoolId gilda.
Innra leitarorð.	Sjálfgefin tengingarstilling er innri tenging. Það er ekki til innra leitarorð.	Sjálfgefin tengingarstilling er innri tenging. Innra leitarorðið er tiltækt til að gera kóðann skýran.	Ytra leitarorðið er til bæði í X++ SQL og ANSI SQL.
Vinstri og hægri leitarorð.	Vinstri og hægri leitarorð eru ekki tiltæk. Allar tengingar eru eftir.	Vinstri og hægri leitarorð eru tiltæk til að breyta tengingarleitarorðinu.	Engar athugasemdir.
Jafnrétti rekstraraðila.	Tvöfalda jöfnunarmerkið ('==') er notað til að prófa hvort tvö gildi séu jöfn.	Staka jöfnunarmerkið ('=') er notað til að prófa jafnræði tveggja gilda.	Engar athugasemdir.

Dæmi um kóða

Eftirfarandi kóðadæmi sýnir tengingarsetningafræði í X++ SQL.

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);
    }
}

Safna saman reitum

Eftirfarandi tafla sýnir einhvern mun á því hvernig vísað er í samanlagða reiti í valdálkalistanum milli X++ SQL og ANSI SQL. Uppsöfnuð svæði eru þau sem eru fengin af föllum eins og summa eða meðaltali.

Eiginleiki	X++ SQL	ANSI SQL	Ummæli
Samheiti reitarheiti.	Uppsafnað gildi er í reitnum sem var safnað saman.	Þú getur notað sem leitarorð til að merkja samanlagðan reit með nafnasamnefni. Hægt er að vísa í samnefnið í síðari kóða.	Frekari upplýsingar er að finna í Uppsöfnuð föll: Mismunur á X++ og SQL

Dæmi um kóða

Í eftirfarandi kóðadæmi sýnir köllunin í upplýsingaaðferðina hvernig á að vísa í uppsafnaða reiti (sjá 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.
***/

Annar munur

Eftirfarandi tafla sýnir annan mun á select-setningunni milli X++ SQL og ANSI SQL.

Eiginleiki	X++ SQL	ANSI SQL	Ummæli
Að hafa leitarorð.	Það er ekki til að hafa leitarorð.	Lykilorðið með gerir þér kleift að tilgreina síuviðmið fyrir línur sem eru búnar til af hópnum eftir ákvæði.	Engar athugasemdir.
Núll niðurstöður.	Í while select yfirlýsingu, ef where klausan síar út allar línur, er engri sérstakri talningarlínu skilað til að tilkynna það.	Í vali, ef where klausan síar út allar línur, er sérstakri talningarlínu skilað. Talningargildið er 0.	Engar athugasemdir.
Bendlar til að sigla um afturkomnar raðir.	Yfirlýsingin while select veitir bendilsvirkni. Valkosturinn er að nota næsta leitarorð.	Hægt er að lýsa yfir bendli til að lykkja í gegnum línurnar sem eru skilað úr völdum yrðingu.
Úr ákvæði.	Leitarorðið from er valfrjálst þegar engir dálkar eru skráðir og aðeins er vísað í eina töflu. Eftirfarandi tveir setningafræðivalkostir eru jafngildir: select \* from tCustTable; select tCustTable;	Select-setning getur ekki lesið úr töflu nema from klausan sé notuð.	Í X++ SQL fyllir einfalda valsetningin töflubiðminni breytuna með fyrstu línunni sem var skilað. Þetta er sýnt með eftirfarandi kóðabroti: select \* from tCustTable; info(tCustTable.Name);