X++ und C# im Vergleich

In diesem Artikel werden die X++- und C#-Syntax und die Programmierung verglichen.

X++-, C#-Vergleich: Hello World

In diesem Abschnitt wird das einfachste X++-Programm mit seinem Gegenstück in C# verglichen.

X++-zu-C#-Vergleiche

In den folgenden Abschnitten werden einige grundlegende Ähnlichkeiten und Unterschiede zwischen X++ und C# beschrieben.

Ähnlichkeiten

Die folgenden X++-Features sind für C# identisch:

• Einzeilige (//) und mehrzeilige (/* */) Kommentare.
• == (gleich) Operator zum Bestimmen, ob zwei Werte gleich sind.
• != (nicht gleich) Operator zum Bestimmen, ob zwei Werte nicht gleichwertig sind.
• + (Pluszeichen)-Operator für Zeichenfolgenverkettung.

Unterschiede

In der folgenden Tabelle sind X++-Features aufgeführt, die in C# unterschiedlich sind.

X++- und C#-Beispiele

Dieser Abschnitt enthält zwei einfache Codebeispiele. Ein Beispiel wird in X++ geschrieben, und das andere ist in C#. Beide Proben erzielen dasselbe Ergebnis. Die folgenden X++-Features werden veranschaulicht:

• // Einzelzeilenkommentar
• /\* \*/ Mehrzeilige Kommentare
• if-Anweisung
• ==-Operator
• !=-Operator
• + Operator zum Verketten von Zeichenfolgen
• Global::info für die Nachrichtenausgabe mit und ohne das Präfix Global::
• Global::error für die Nachrichtenausgabe
• Die Verwendung von einfachen und doppelten Anführungszeichen (' und ") als Zeichenfolgentrennzeichen.

X++-Beispiel

Dieses X++-Codebeispiel befindet sich in Form eines Auftrags. Es gibt einen Knoten mit dem Titel "Aufträge" in der Application-Objektstruktur (Application Object Tree, AOT). Dieses Beispiel kann unter dem Knoten Aufträge hinzugefügt werden, und dann kann der Auftrag ausgeführt werden.

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

Output

Hier sehen Sie die Ausgabe aus dem Infolog-Fenster: Nachricht (09:49:48) Hello World, 1. Hallo Welt, 2. Dies ist wie Informationen, aber für Warnungen, 3. Dies ist wie Informationen, aber für Fehler, 4.

C#-Beispiel

Das folgende C#-Programm ist eine Neuschreibung des vorherigen X++-Programms.

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

Output

Hier sehen Sie die tatsächliche Ausgabe in der C#-Konsole:

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#-Vergleich: Schleifen

In diesem Abschnitt werden die Schleifenfeatures zwischen X++ und C# verglichen.

Ähnlichkeiten

Die folgenden Features sind in X++ und C# identisch:

• Deklarationen für Variablen des Int-Grundtyps. Deklarationen für andere Grundtypen sind fast identisch, aber die Typen haben möglicherweise unterschiedliche Namen.
• while-Anweisung für Schleifen.
• break-Anweisung zum Beenden einer Schleife.
• continue-Anweisung, um zum Anfang einer Schleife zu springen.
• <= (kleiner oder gleich) Vergleichsoperator.

Unterschiede

In der folgenden Tabelle sind X++-Features aufgeführt, die in C# unterschiedlich sind.

Drucken und Global::info

Die X++-Codebeispiele für Schleifen verwenden die print Funktion zum Anzeigen von Ergebnissen. In X++ können Sie die print Anweisung verwenden, um einen beliebigen primitiven Datentyp anzuzeigen, ohne zuerst Funktionen aufrufen zu müssen, die sie in eine Zeichenfolge konvertieren. Dies macht print in Schnelltestsituationen nützlich. Im Allgemeinen wird die Global::info-Methode häufiger als printverwendet. Die info Methode kann nur Zeichenfolgen anzeigen. Daher wird die Strfmt-Funktion häufig zusammen mit info. Eine Einschränkung print besteht darin, dass Sie den Inhalt des Druckfensters nicht in die Zwischenablage kopieren können (z. B. mit STRG+C). Global::info schreibt in das Infolog-Fenster, das das Kopieren in die Zwischenablage unterstützt.

Beispiel 1: Die While-Schleife

Das Schlüsselwort while unterstützt Schleifen sowohl in X++ als auch in C#.

X++-Beispiel für "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.
} 

Output

Die Ausgabe im X++-Druckfenster lautet wie folgt:

1
2
3
4

C#-Beispiel für "While"

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

Output

Die Konsolenausgabe des C#-Programms lautet wie folgt:

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

Beispiel 2: For-Schleife

Das Schlüsselwort unterstützt Schleifen sowohl in X++ als auch in C#.

X++-Beispiel für

In X++ kann die Zählervariable nicht als Teil der for-Anweisung deklariert werden.

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

Output

Die Ausgabe im X++-Druckfenster lautet wie folgt:

1
2
3
4

C#-Beispiel für

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

Output

Die Konsolenausgabe des C#-Programms lautet wie folgt:

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#-Vergleich: Switch

Sowohl in X++ als auch in C# umfasst die Switch-Anweisung die Groß -/ Kleinschreibung, den Umbruch und den Standardwert. In der folgenden Tabelle sind die Unterschiede in der Switch-Anweisung zwischen X++ und C# aufgeführt.

Codebeispiele für Switch

In den folgenden Abschnitten werden vergleichbare Switch-Anweisungen in X++ und C# gezeigt.

X++-Switch (Beispiel)

Das X++-Switchbeispiel zeigt Folgendes:

• case iTemp: und case (93-90): um zu zeigen, dass Fallausdrücke nicht auf Konstanten beschränkt sind, wie sie sich in C# befinden.
• //break; um zu zeigen, dass break; Anweisungen in X++ nicht erforderlich sind, obwohl sie fast immer wünschenswert sind.
• case 2, (93-90), 5: um anzuzeigen, dass mehrere Ausdrücke in einer Fallklausel in X++ aufgeführt werden können.

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#-Schalter (Beispiel)

Das C#-Schalterbeispiel zeigt Folgendes:

• Fall 1: Enthält einen Kommentar, der erklärt, dass nur konstanten Ausdrücke in einer Fallklausel angegeben werden können.
• break; Anweisungen treten nach der letzten Anweisung in jedem Fallblock mit Anweisungen auf, wie von C# erforderlich.

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#-Vergleich: Zeichenfolgenfall und Trennzeichen

In diesem Abschnitt wird die Behandlung von Zeichenfolgen mit gemischter Groß-/Kleinschreibung in X++ und C# verglichen. Außerdem werden die Zeichenfolgentrennzeichen erläutert, die in X++ verfügbar sind.

Ähnlichkeiten

Die folgenden X++-Features sind identisch mit C#:

• Der umgekehrte Schrägstrich (\) ist der Escapeoperator für Zeichenfolgentrennzeichen.
• Mit dem At-Zeichen (@) wird der Escapeeffekt des umgekehrten Schrägstrichs aufgehoben, wenn das At-Zeichen unmittelbar vor dem geöffneten Anführungszeichen einer Zeichenfolge geschrieben wird.
• Das Pluszeichen (+) ist der Zeichenfolgenverkettungsoperator.

Unterschiede

X++-Features, die in C# unterschiedlich sind, sind in der folgenden Tabelle aufgeführt.

Beispiel 1: Groß-/Kleinschreibung des == Operators

Bei den == Operatoren und != wird die Groß-/Kleinschreibung in X++ nicht beachtet, die Groß-/Kleinschreibung wird jedoch in C# beachtet, wie im folgenden Beispiel dargestellt.

Beispiel 2: Der +String-Verkettungsoperator

Die Operatoren +und += werden verwendet, um Zeichenfolgen sowohl in X++ als auch in C# zu verketten, wie in den Beispielen in der folgenden Tabelle dargestellt.

Beispiel 3: Einbetten und Entfernen von Zeichenfolgentrennzeichen

Entweder einfache oder doppelte Anführungszeichen können zum Trennen von Zeichenfolgen in X++ verwendet werden. Das Escapezeichen (\) kann zum Einbetten von Trennzeichen in eine Zeichenfolge verwendet werden. Diese werden in der folgenden Tabelle veranschaulicht.

Beispiel 4: Einzelnes Escapezeichen

Beispiele zur Veranschaulichung des einzelnen Escapezeichens in der Eingabe oder ausgabe sind in der folgenden Tabelle dargestellt.

Vergleich: Arraysyntax

Es gibt Ähnlichkeiten und Unterschiede bei den Features und Syntax für Arrays in X++ im Vergleich zu C#.

Ähnlichkeiten

Insgesamt gibt es in der Syntax und Behandlung von Arrays in X++ und C# viel Ähnlichkeit. Es gibt jedoch viele Unterschiede.

Unterschiede

In der folgenden Tabelle sind Bereiche in der [] Syntax für Arrays aufgeführt, die für X++ und C# unterschiedlich sind.

X++- und C#-Beispiele

Die folgenden Codebeispiele zeigen, wie Arrays von primitiven Datentypen behandelt werden. Das erste Beispiel befindet sich in X++, und das zweite Beispiel befindet sich in C#. Beide Proben erzielen dieselben Ergebnisse.

X++-Beispiel

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

Output

Die Ausgabe im Infolog lautet wie folgt:

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#-Beispiel

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

Output

Die Ausgabe des C#-Programms in der Befehlszeilenkonsole lautet wie folgt:

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

Zusätzliche Array-ähnliche X++-Features

Der Container ist ein spezieller Datentyp, der in X++ verfügbar ist. Es kann als ähnlich wie ein Array oder eine Sammlung List angesehen werden.

Vergleich: Sammlungen

In einer Finanz- und Betriebsanwendung können Sie die X++ List -Sammlungsklasse verwenden. Das .NET Framework, das in C# verwendet wird, hat eine ähnliche Klasse namens System.Collections.Generic.List.

Vergleich der Verwendung der Listenklassen

In der folgenden Tabelle werden Methoden für die X++ List -Klasse mit den Methoden System.Collections.Generic.List aus .NET Framework und C# verglichen.

Beispiel 1: Deklaration einer Liste

Die folgenden Codebeispiele sind in X++ und C# enthalten, die Sammlungen deklarieren List .

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

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

Beispiel 2: Erstellen einer Liste

In beiden Sprachen muss der Typ der Elemente, die in den Sammlungsspeichern gespeichert werden, zum Zeitpunkt der Erstellung angegeben werden. Für Klassentypen kann X++ nicht spezifischer abrufen, als ob es sich bei dem Typ um eine Klasse (Types::Class) handelt. Die folgenden Codebeispiele sind in X++ und C# enthalten.

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

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

Beispiel 3: Hinzufügen von Elementen zu einer Liste

In X++ und C# stellt die Auflistung eine Methode zum Anfügen eines Elements an das Ende der Auflistung und zum Einfügen eines Elements am Anfang bereit. In C# stellt die Auflistung eine Methode zum Einfügen an einem beliebigen Punkt in der Auflistung basierend auf einem Indexwert bereit. In X++ kann ein Sammlungs-Iterator ein Element an seiner aktuellen Position einfügen. Die folgenden Codebeispiele sind in X++ und C# enthalten.

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

Beispiel 4: Durchlaufen einer Liste

Sowohl X++ als auch C# verfügen über Iteratorklassen, mit denen Sie die Elemente in einer Auflistung schrittweise durchlaufen können, wie in den folgenden Beispielen gezeigt.

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

Beispiel 4b: Foreach in C#

In C# wird das Schlüsselwort foreach häufig verwendet, um die Aufgabe der Iterierung durch eine Liste zu vereinfachen. Im folgenden Codebeispiel verhält sich dasselbe wie im vorherigen C#-Beispiel.

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

Beispiel 5: Löschen des zweiten Elements

Die folgenden Codebeispiele löschen das zweite Element aus der Auflistung. In X++ erfordert dies einen Iterator. In C# stellt die Auflistung selbst die Methode zum Entfernen eines Elements bereit.

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

// C#
listStrings.RemoveAt(1);

Beispiel 6: Kombinieren von zwei Auflistungen

Die folgenden Codebeispiele kombinieren den Inhalt von zwei Auflistungen in einer Auflistung.

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

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

Vergleich: Sammlungen von Schlüsseln mit Werten

In einer Finanz- und Betriebsanwendung können Sie die Map Sammlungsklasse verwenden. Die Map Auflistung enthält Wertepaare, den Schlüsselwert plus einen Datenwert. Dies ähnelt der .NET Framework-Klasse mit dem Namen System.Collections.Generic.Dictionary.

Ähnlichkeiten

In der folgenden Liste werden Ähnlichkeiten zwischen X++ und C# hinsichtlich ihrer Sammlungen beschrieben, die Schlüsselwertpaare speichern:

• Beide verhindern doppelte Schlüssel.
• Beide verwenden einen Enumerator (oder Iterator), um die Elemente zu durchlaufen.
• Beide Schlüsselwertauflistungsobjekte werden mit Bezeichnungen der Typen erstellt, die als Schlüssel und Wert gespeichert werden.
• Beide können Klassenobjekte speichern und sind nicht auf das Speichern von Grundtypen wie Int beschränkt.

Unterschiede

In der folgenden Tabelle werden die Unterschiede zwischen X++ und C# in Bezug auf die Auflistungsklassen beschrieben, die Schlüsselwertpaare speichern:

Beispiel 1: Deklaration einer Key-Value-Auflistung

In beiden Sprachen muss der Typ der Elemente, die von den Schlüsselwertauflistungsspeichern gespeichert werden, angegeben werden. In X++ wird der Typ zum Zeitpunkt der Konstruktion angegeben. In C# wird der Typ sowohl zum Zeitpunkt der Deklaration als auch zum Zeitpunkt der Konstruktion angegeben. Die folgenden Codebeispiele sind in X++ und C# enthalten.

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

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

Beispiel 2: Erstellen der Auflistung

In beiden Sprachen wird der Typ der Elemente, die von der Schlüsselwertauflistung während der Erstellung angegeben werden, gespeichert. Für Klassentypen kann X++ nicht spezifischer abrufen, als ob es sich bei dem Typ um eine Klasse (Types::Class) handelt. Die folgenden Codebeispiele sind in X++ und C# enthalten.

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

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

Beispiel 3: Hinzufügen eines Elements zur Auflistung

Es gibt fast keinen Unterschied darin, wie ein Element einer Schlüsselwertauflistung in X++ und C# hinzugefügt wird, wie in den folgenden Codebeispielen gezeigt.

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

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

Beispiel 4: Durchlaufen einer Key-Value Auflistung

Enumeratoren werden verwendet, um die Schlüsselwertauflistungen sowohl in X++ als auch in C# zu durchlaufen, wie in den folgenden Codebeispielen gezeigt.

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

Beispiel 5: Aktualisieren des werts, der einem Schlüssel zugeordnet ist

Die Syntax unterscheidet sich sehr zwischen den beiden Sprachen für eine Aktualisierung des Werts, der einem bestimmten Schlüssel zugeordnet ist. Die Ollowing-Codebeispiele beziehen sich auf den Schlüssel 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.”;

Beispiel 6: Löschen eines Elements

Die Syntax unterscheidet sich zwischen den beiden Sprachen, um ein Schlüssel-Wert-Paar aus einer Auflistung zu löschen, während die Auflistungselemente durchlaufen werden. Codebeispiele für den Schlüssel 102 finden Sie unten.

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

Vergleich: Ausnahmen

Es gibt einige Ähnlichkeiten, aber viele Unterschiede beim Vergleichen des Ausnahmeverhaltens zwischen X++ und C#. Die Schlüsselwörter "Try", " Catch" und "Throw " verhalten sich in X++ und C# gleich. Die Arten von ausgelösten und abgefangenen Ausnahmen unterscheiden sich jedoch für die beiden Sprachen.

Ähnlichkeiten

Ähnlichkeiten zwischen X++ und C# bezüglich ihrer Ausnahmefeatures sind die folgenden Beispiele:

• Beide Sprachen haben dasselbe Try-Schlüsselwort .
• Beide weisen dasselbe Catch-Schlüsselwort auf.
• Beide aktivieren eine Catch-Anweisung , die keine bestimmte Ausnahme angibt. Eine solche Catch-Anweisung erfasst alle Ausnahmen, die sie erreichen.
• Beide weisen dasselbe Throw-Schlüsselwort auf .

Unterschiede

Ausnahmebezogene Unterschiede zwischen X++ und C# werden in der folgenden Tabelle beschrieben.

Examples

Die folgenden X++-Features werden veranschaulicht:

• try keyword.
• Catch-Schlüsselwort .
• Das Verhalten nach einer Ausnahme::Fehler-Ausnahme tritt auf.

X++-Beispiel

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

Output

Hier sehen Sie die Ausgabe aus dem Infolog-Fenster:

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#-Beispiel

Das folgende C#-Programm ist eine Neuschreibung des vorherigen X++-Programms.

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

Output

Dies ist die Ausgabe in der C#-Konsole:

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

Vergleich: Automatische Wiederholung nach einer Ausnahme

Manchmal können Sie Code in einem Catch-Block schreiben, der die Ursache einer Ausnahme behebt, die während der Laufzeit auftritt. X++ stellt ein Wiederholungsstichwort bereit, das nur innerhalb eines Catch-Blocks verwendet werden kann. Mit dem Schlüsselwort "Wiederholen " kann ein Programm zum Anfang des Try-Blocks zurückkehren, nachdem das Problem durch Code im Catch-Block behoben wurde. C# verfügt nicht über ein Wiederholungsstichwort . C#-Code kann jedoch geschrieben werden, um ein entsprechendes Verhalten bereitzustellen.

Codebeispiele für Wiederholungen

Das folgende X++-Beispielprogramm bewirkt, dass eine Ausnahme::Fehler ausgelöst wird. Dies tritt auf, wenn zuerst versucht wird, ein Element aus dem sStrings Array mithilfe eines ungültigen Indexwerts zu lesen. Wenn die Ausnahme abgefangen wird, wird während der Laufzeit innerhalb des Catch-Blocks Korrekturmaßnahmen ergriffen. Die Wiederholungsanweisung springt dann zurück zur ersten Anweisung im Try-Block . Diese zweite Iteration funktioniert ohne Ausnahme.

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

Output

Hier sehen Sie die Ausgabe im Fenster "Drucken":

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#-Beispiel

Das folgende C#-Beispiel ist keine Zeilenübersetzung aus dem vorherigen X++-Beispiel. Stattdessen weist das C#-Programm eine andere Struktur auf, sodass es das Verhalten des Wiederholungsstichworts nachahmt, auf dem das X++-Programm basiert. Die Try - und Catch-Blöcke befinden sich in einer aufgerufenen Methode. Die Variablen, die im Try-Block verwendet werden, werden in der Aufrufermethode gespeichert. Die Aufrufermethode übergibt die Variablen als Parameter, die mit dem Ref-Schlüsselwort versehen sind, sodass ihre Werte innerhalb des Catch-Blocks der aufgerufenen Methode korrigiert werden können. Die aufgerufene Methode erfasst alle Ausnahmen und gibt einen booleschen Wert zurück, der an den Aufrufer zurückgibt, ob ein zweiter Aufruf erforderlich ist.

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

Output

Dies ist die Ausgabe in der Konsole:

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.

Vergleich: Operatoren

In diesem Abschnitt werden die Operatoren zwischen X++ und C# verglichen.

Zuordnungsoperatoren

In der folgenden Tabelle werden die Unterschiede zwischen den Zuordnungsoperatoren in X++ und C# angezeigt.

Arithmetische Operatoren

Die folgende Tabelle listet die arithmetischen Operatoren auf.

Bitweise Operatoren

In der folgenden Tabelle werden die bitweisen Operatoren zwischen X++ und C# verglichen.

Relationale Operatoren

Die folgenden relationalen Operatoren sind in X++ und C# identisch:

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

Vergleich: Ereignisse

Es gibt einige Unterschiede bei der Implementierung des Ereignisentwurfsmusters durch X++ und C#. Weitere Informationen finden Sie unter Ereignisterminologie und Schlüsselwörter.

Vergleich von Ereignissen zwischen X++ und C#

Es gibt Unterschiede in der Art und Weise, wie Stellvertretungen für Ereignisse in X++ und C# verwendet werden.

X++-Beispiel

Die wichtigsten Punkte, die Sie beachten müssen, sind im X++-Beispiel folgendes:

• Das Hat XppClass ein Delegatmitglied, das benannt myDelegateist.

  Hinweis

  Das AOT enthält einen Knoten für den Delegaten. Der Knoten befindet sich unter AOT > Classes > XppClass > myDelegate. Mehrere Ereignishandlerknoten können sich unter dem MyDelegate-Knoten befinden. Ereignishandler, die durch Knoten im AOT dargestellt werden, können während der Laufzeit nicht vom Operator -= entfernt werden.

• Die {} geschweiften Klammern am Ende der Stellvertretungsdeklaration sind erforderlich, können aber keinen Code enthalten.

• Dies XppClass hat zwei Methoden, deren Parametersignaturen mit dem Delegaten kompatibel sind. Eine Methode ist statisch.

• Die beiden kompatiblen Methoden werden dem Delegaten mit dem Operator += und dem EventHandler-Schlüsselwort hinzugefügt. Diese Anweisungen rufen nicht die Ereignishandlermethoden auf, die Anweisungen fügen nur die Methoden zum Delegaten hinzu.

• Das Ereignis wird durch einen Aufruf der Stellvertretung ausgelöst.

• Der Parameterwert, der an den Delegaten übergeben wird, wird von jeder Ereignishandlermethode empfangen.

• Der kurze X++-Auftrag oben im Beispiel startet den Test.

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

Die Ausgabe des vorherigen X++-Auftrags lautet wie folgt:

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#-Beispiel

Dieser Abschnitt enthält ein C#-Codebeispiel für das Ereignisentwurfsmuster des vorherigen X++-Beispiels.

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

Die Ausgabe aus dem vorherigen C#-Beispiel lautet wie folgt:

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.

Ereignisse und das AOT

Es gibt andere Ereignissysteme, die nur für Elemente im AOT gelten. Weitere Informationen finden Sie unter Ereignishandlerknoten im AOT.

Vergleich: Präkompilerdirektiven

X++ und C# teilen einige Schlüsselwörter für ihre Präkompilerdirektivesyntax, aber die Bedeutungen sind nicht immer identisch.

Ähnlichkeiten

Die X++- und C#-Compiler erkennen viele der gleichen Schlüsselwörter. In den meisten Fällen bedeuten die Schlüsselwörter für beide Sprachcompiler das gleiche.

Unterschiede

Ein grundlegender Unterschied zwischen den Präcompilerdirektiven in X++ und C# ist das #define Schlüsselwort, das beide Sprachvorkompilierer erkennen. Im Gegensatz zu C# erfordert die #define direktive in X++ einen Punkt in der Syntax. In X++ können Klammern verwendet werden, um dem definierten Symbol einen Wert zuzuweisen. Diese Unterschiede werden in den folgenden Beispielen gezeigt:

• In X++: #define. InitialYear(2003)
• In C#: #define InitialYear

Ein kleiner Unterschied besteht darin, dass in C# Leerzeichen und Tabstoppzeichen zwischen dem #-Zeichen und dem Direktive-Schlüsselwort vorhanden sein können, z. B. #define Testing.

Identische Schlüsselwörter

In der folgenden Tabelle sind Präkompilerdirektiven aufgeführt, die in X++ und C# ähnlich sind.

Verschiedene Schlüsselwörter mit demselben Verarbeitungsergebnis

In der folgenden Tabelle sind Präkompilerdirektiven aufgeführt, die in X++ und C# unterschiedlich benannt werden, die jedoch bei der Verarbeitung dieselben Ergebnisse liefern.

Vorkompilierungsdirektiven ausschließlich für X++

In der folgenden Tabelle sind X++-Vorkompilierdirektiven aufgeführt, die kein direktes Gegenstück in C# aufweisen.

Vergleich: Objektorientierte Programmierung

Die objektorientierten Programmierprinzipien (OOP) von X++ unterscheiden sich von C#.

Konzeptionelle Vergleiche

In der folgenden Tabelle wird die Implementierung von OOP-Prinzipien zwischen X++ und C# verglichen.

Stichwortvergleiche

In der folgenden Tabelle sind die OOP-bezogenen Schlüsselwörter in X++ und C# aufgeführt.

Vergleich: Klassen

Wenn Sie C# im .NET Framework verwenden, werden Klassen in Namespaces gruppiert. Jeder Namespace konzentriert sich auf einen Funktionalen Bereich wie Dateivorgänge oder Spiegelung. Wenn Sie jedoch die Klassen in X++ verwenden, gibt es keine sichtbaren Gruppierungen wie einen Namespace.

Vergleich: Klassen über Spiegelung

In X++ bietet die TreeNode Klasse Zugriff auf die Application Object Tree (AOT). Die TreeNode Klasse ist das Zentrum der Spiegelungsfunktionalität in X++. Die TreeNode Klasse und die zugehörigen Methoden können mit dem System.Reflection Namespace in .NET Framework verglichen werden, den C# verwendet.

In der folgenden Tabelle sind mehrere Klassen aufgeführt, die Ihnen beim Schreiben von C#-Code zur Verfügung stehen. Dies sind .NET Framework-Klassen. Für diese Tabelle befinden sich alle C#-Klassen im System.Reflection Namespace, sofern nicht anders angegeben. Jede Zeile zeigt die entsprechende Klasse oder den entsprechenden Klassenmemmemm an, der Ihnen beim Schreiben von X++-Code zur Verfügung steht.

Vergleich: Klassen zu Datei-E/A

Es gibt mehrere Klassen, die Dateieingabe- und Ausgabevorgänge (IO) ausführen. In .NET Framework, das in C# verwendet wird, befinden sich die Gegenstücke zu diesen Klassen im System.IO Namespace.

In der folgenden Tabelle sind mehrere .NET Framework-Klassen für C# aufgeführt, die sich System.IO im Namespace befinden. Jede Zeile in der Tabelle zeigt die X++-Klasse oder -Methode, die der .NET Framework-Klasse am besten entspricht.

X++, ANSI SQL-Vergleich: SQL Select

In X++ unterscheidet sich die SQL Select-Anweisungssyntax von der Spezifikation des American National Standards Institute (ANSI).

Einzelne Tabelle auswählen

In der folgenden Tabelle sind unterschiede zwischen den Auswahlanweisungen von X++ SQL und ANSI SQL aufgeführt.

Codebeispiel

Das folgende Codebeispiel veranschaulicht Features in der vorherigen Tabelle.

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-Schlüsselwörter

Die folgenden X++-SQL-Schlüsselwörter gehören zu denen, die nicht Teil von ANSI SQL sind:

• crosscompany
• firstonly100
• forceliterals
• forcenestedloop
• forceplaceholders
• forceselectorder
• validtimestate

Join-Klausel

In der folgenden Tabelle sind Unterschiede zum Join-Schlüsselwort von X++ SQL und ANSI SQL aufgeführt.

Codebeispiel

Im folgenden Codebeispiel wird die Verknüpfungssyntax in X++ SQL veranschaulicht.

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

Aggregatfelder

In der folgenden Tabelle sind einige Unterschiede in der Art und Weise aufgeführt, wie Aggregatfelder in der Auswahlspaltenliste zwischen X++ SQL und ANSI SQL referenziert werden. Aggregatfelder sind diejenigen, die von Funktionen wie Summe oder Mittelwert abgeleitet werden.

Codebeispiel

Im folgenden Codebeispiel veranschaulicht der Aufruf der Info-Methode die Methode zum Verweisen auf Aggregatfelder (siehe 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.
***/

Andere Unterschiede

In der folgenden Tabelle sind weitere Unterschiede der Select-Anweisung zwischen X++ SQL und ANSI SQL aufgeführt.