Comparaison X++ et C#

Cet article compare la syntaxe et la programmation X++ et C#.

Comparaison X++, C# : Hello World

Cette section compare le programme X++ le plus simple à son équivalent en C#.

Comparaisons X++ vers C#

Les sections suivantes décrivent certaines similitudes et différences de base entre X++ et C#.

Similitudes

Les fonctionnalités X++ suivantes sont les mêmes pour C# :

• Commentaires à ligne unique (//) et à plusieurs lignes (/* */).
• == Opérateur (égal) pour déterminer si deux valeurs sont égales.
• != (pas égal à) opérateur pour déterminer si deux valeurs ne sont pas équivalentes.
• + (signe plus) pour la concaténation de chaîne.

Differences

Le tableau suivant répertorie les fonctionnalités X++ différentes en C#.

Exemples X++ et C#

Cette section contient deux exemples de code simples. Un exemple est écrit en X++, et l’autre est en C#. Les deux exemples obtiennent le même résultat. Les fonctionnalités X++ suivantes sont illustrées :

• // commentaire sur une seule ligne
• /\* \*/ Commentaire sur plusieurs lignes
• Instruction if
• == opérateur
• != opérateur
• + opérateur pour concaténer des chaînes
• Global ::info pour la sortie du message, avec et sans le préfixe Global ::
• Global ::error pour la sortie du message
• Utilisation de guillemets simples et doubles (' et ") en tant que délimiteurs de chaîne.

Exemple X++

Cet exemple de code X++ se présente sous la forme d’un travail. Il existe un nœud intitulé Travaux dans l’arborescence d’objets d’application (AOT). Cet exemple peut être ajouté sous le nœud Travaux, puis le travail peut être exécuté.

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

Voici la sortie de la fenêtre Infolog : Message (09:49:48) Hello World, 1. Hello World, 2. C’est comme des informations, mais c’est pour les avertissements, 3. C’est comme des informations, mais c’est pour des erreurs, 4.

Exemple C#

Le programme C# suivant est une réécriture du programme X++ précédent.

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

Voici la sortie réelle dans la console C# :

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.

Comparaison X++, C# : boucles

Cette section compare les fonctionnalités de boucle entre X++ et C#.

Similitudes

Les fonctionnalités suivantes sont les mêmes dans X++ et C# :

• Déclarations pour les variables du type de données primitive int. Les déclarations d’autres types primitifs sont presque identiques, mais les types peuvent avoir des noms différents.
• while, instruction for loops.
• instruction break pour quitter une boucle.
• continuez l’instruction pour passer en haut d’une boucle.
• <= opérateur de comparaison (inférieur ou égal).

Differences

Le tableau suivant répertorie les fonctionnalités X++ différentes en C#.

Imprimer et global ::info

Les exemples de code X++ pour les boucles utilisent la print fonction pour afficher les résultats. Dans X++, vous pouvez utiliser l’instruction print peut afficher n’importe quel type de données primitif sans avoir à appeler des fonctions qui la convertissent en chaîne en premier. Cela rend print utile dans les situations de test rapide. En règle générale, la méthode Global ::info est utilisée plus souvent que print. La info méthode ne peut afficher que des chaînes. Par conséquent, la fonction strfmt est souvent utilisée avec info. Une limitation print est que vous ne pouvez pas copier le contenu de la fenêtre Imprimer dans le Presse-papiers (par exemple, avec Ctrl+C). Global ::info écrit dans la fenêtre Infolog qui prend en charge la copie dans le Presse-papiers.

Exemple 1 : Boucle while

Le mot clé while prend en charge la boucle dans X++ et C#.

Exemple X++ de 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

La sortie de la fenêtre Imprimer X++ est la suivante :

1
2
3
4

Exemple C# de 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

La sortie de la console du programme C# est la suivante :

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

Exemple 2 : Boucle for

Le mot clé for prend en charge la boucle dans X++ et C#.

Exemple X++ de for

Dans X++, la variable de compteur ne peut pas être déclarée dans le cadre de l’instruction for .

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

La sortie de la fenêtre Imprimer X++ est la suivante :

1
2
3
4

Exemple C# de for

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

La sortie de la console du programme C# est la suivante :

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

Comparaison X++, C# : Commutateur

Dans X++ et C#, l’instruction switch implique les mots clés case, break et default. Le tableau suivant répertorie les différences dans l’instruction switch entre X++ et C#.

Exemples de code pour le commutateur

Les sections suivantes présentent des instructions switch comparables dans X++ et C#.

Exemple de commutateur X++

L’exemple de commutateur X++ montre les éléments suivants :

• case iTemp: et case (93-90): pour montrer que les expressions de cas ne sont pas limitées aux constantes, car elles se trouvent en C#.
• //break; pour montrer que les break; instructions ne sont pas requises dans X++, bien qu’elles soient presque toujours souhaitables.
• case 2, (93-90), 5: pour montrer que plusieurs expressions peuvent être répertoriées sur une clause case dans 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
***

Exemple de commutateur C#

L’exemple de commutateur C# montre les éléments suivants :

• case 1 : a un commentaire expliquant que seules les expressions constantes peuvent être données sur une clause case .
• break; les instructions se produisent après la dernière instruction dans chaque bloc de cas qui a des instructions, comme cela est requis par 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
>>
***/

Comparaison X++, C# : Casse de chaîne et délimiteurs

Cette section compare le traitement des chaînes à la casse mixte en X++ et en C#. Il explique également les délimiteurs de chaînes disponibles dans X++.

Similitudes

Les fonctionnalités X++ suivantes sont les mêmes que dans C# :

• La barre oblique inverse (\) est l’opérateur d’échappement pour les délimiteurs de chaîne.
• Le signe at (@) nullifie l’effet d’échappement de la barre oblique inverse lorsque le signe at est écrit immédiatement avant le guillemet ouvert d’une chaîne.
• Le signe plus (+) est l’opérateur de concaténation de chaîne.

Differences

Les fonctionnalités X++ différentes en C# sont répertoriées dans le tableau suivant.

Exemple 1 : Sensibilité de la casse de l’opérateur ==

Les == opérateurs et != ne respectent pas la casse dans X++, mais respectent la casse en C#, comme illustré dans l’exemple suivant.

Exemple 2 : Opérateur de concaténation de chaîne +

Les opérateurs + et += sont utilisés pour concaténer des chaînes dans X++ et C#, comme illustré par les exemples du tableau suivant.

Exemple 3 : Délimiteurs de chaînes incorporés et d’échappement

Les guillemets simples ou doubles peuvent être utilisés pour délimiter des chaînes dans X++. Le caractère d’échappement (\) peut être utilisé pour incorporer des délimiteurs dans une chaîne. Elles sont illustrées dans le tableau suivant.

Exemple 4 : caractère d’échappement unique

Les exemples illustrant le caractère d’échappement unique dans l’entrée ou la sortie sont présentés dans le tableau suivant.

Comparaison : Syntaxe de tableau

Il existe des similitudes et des différences dans les fonctionnalités et la syntaxe des tableaux dans X++ et C#.

Similitudes

Dans l’ensemble, la syntaxe et le traitement des tableaux sont très similaires dans X++ et C#. Toutefois, il existe de nombreuses différences.

Differences

Le tableau suivant répertorie les zones de la syntaxe [] pour les tableaux qui sont différents pour X++ et C#.

Exemples X++ et C#

Les exemples de code suivants montrent comment les tableaux de types de données primitifs sont gérés. Le premier exemple est X++, et le deuxième exemple est en C#. Les deux échantillons obtiennent les mêmes résultats.

Exemple X++

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

La sortie du journal d’informations est la suivante :

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

Exemple C#

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

La sortie du programme C# vers la console de ligne de commande est la suivante :

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

Fonctionnalités X++ de type tableau supplémentaires

Le conteneur est un type de données spécial disponible dans X++. Elle peut être considérée comme similaire à un tableau ou similaire à une List collection.

Comparaison : Collections

Dans une application finance et opérations, vous pouvez utiliser la classe de collection X++ List . Le .NET Framework utilisé en C# a une classe similaire nommée System.Collections.Generic.List.

Comparaison de l’utilisation des classes de liste

Le tableau suivant compare les méthodes de la classe X++ List aux méthodes sur System.Collections.Generic.List le .NET Framework et C#.

Exemple 1 : Déclaration d’une liste

Les exemples de code suivants sont dans X++ et C# qui déclarent List des collections.

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

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

Exemple 2 : Construction d’une liste

Dans les deux langues, le type d’éléments que la collection stocke doit être spécifié au moment de la construction. Pour les types de classes, X++ ne peut pas obtenir plus spécifique que si le type est une classe (Types ::Class). Les exemples de code suivants sont dans X++ et C#.

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

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

Exemple 3 : Ajouter des éléments à une liste

Dans X++ et C#, la collection fournit une méthode permettant d’ajouter un élément à la fin de la collection et d’insérer un élément au début. En C#, la collection fournit une méthode d’insertion à n’importe quel point de la collection en fonction d’une valeur d’index. Dans X++, un itérateur de collection peut insérer un élément à sa position actuelle. Les exemples de code suivants sont dans X++ et 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");

Exemple 4 : Itérer dans une liste

X++ et C# ont des classes d’itérateur que vous pouvez utiliser pour parcourir les éléments d’une collection, comme illustré dans les exemples suivants.

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

Exemple 4b : foreach en C#

En C#, le mot clé foreach est souvent utilisé pour simplifier la tâche d’itération dans une liste. L’exemple de code suivant se comporte de la même façon que l’exemple C# précédent.

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

Exemple 5 : Supprimer le deuxième élément

Les exemples de code suivants suppriment le deuxième élément de la collection. Dans X++, cela nécessite un itérateur. En C# la collection elle-même fournit la méthode de suppression d’un élément.

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

// C#
listStrings.RemoveAt(1);

Exemple 6 : Combiner deux collections

Les exemples de code suivants combinent le contenu de deux collections en un seul.

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

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

Comparaison : Collections de clés avec des valeurs

Dans une application finance et opérations, vous pouvez utiliser la classe de Map collection. La Map collection contient des paires de valeurs, la valeur de clé et une valeur de données. Cela ressemble à la classe .NET Framework nommée System.Collections.Generic.Dictionary.

Similitudes

La liste suivante décrit les similitudes entre X++ et C# concernant leurs collections qui stockent des paires clé-valeur :

• Les deux empêchent les clés dupliquées.
• Les deux utilisent un énumérateur (ou itérateur) pour parcourir les éléments.
• Les deux objets de collection clé-valeur sont construits avec des désignations des types stockés en tant que clé et valeur.
• Les deux peuvent stocker des objets de classe et ne sont pas limités au stockage de primitives comme int.

Differences

Le tableau suivant décrit les différences entre X++ et C# concernant leurs classes de collections qui stockent des paires clé-valeur :

Exemple 1 : Déclaration d’une collection Key-Value

Dans les deux langues, le type d’éléments que la collection clé-valeur stocke doit être spécifié. Dans X++, le type est spécifié au moment de la construction. En C#, le type est spécifié à la fois au moment de la déclaration et de l’heure de construction. Les exemples de code suivants sont dans X++ et C#.

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

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

Exemple 2 : Construction de la collection

Dans les deux langages, le type d’éléments que la collection clé-valeur stocke spécifié lors de la construction. Pour les types de classes, X++ ne peut pas obtenir plus spécifique que si le type est une classe (Types ::Class). Les exemples de code suivants sont dans X++ et C#.

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

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

Exemple 3 : Ajouter un élément à la collection

Il n’existe presque aucune différence dans la façon dont un élément est ajouté à une collection clé-valeur dans X++ et C#, comme illustré dans les exemples de code suivants.

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

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

Exemple 4 : Itérer au sein d’une collection Key-Value

Les énumérateurs sont utilisés pour parcourir les collections clé-valeur dans X++ et C#, comme illustré dans les exemples de code suivants.

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

Exemple 5 : Mettre à jour la valeur associée à une clé

La syntaxe est très différente entre les deux langues pour une mise à jour de la valeur associée à une clé donnée. Les exemples de code ollowing concernent la clé 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.”;

Exemple 6 : Supprimer un élément

La syntaxe est très différente entre les deux langages pour supprimer une paire clé-valeur d’une collection, tout en itérant dans les membres de la collection. Les exemples de code de la clé 102 sont présentés ci-dessous.

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

Comparaison : Exceptions

Il existe des similitudes, mais de nombreuses différences s’affichent lorsque nous comparons le comportement lié aux exceptions entre X++ et C#. Les mots clés try, catch et throw se comportent de la même façon dans X++ et C#. Toutefois, les types d’exceptions levées et interceptées sont différents pour les deux langues.

Similitudes

Les similitudes entre X++ et C# concernant leurs fonctionnalités d’exception incluent les exemples suivants :

• Les deux langues ont le même mot clé try .
• Les deux ont le même mot clé catch .
• Activez les deux pour une instruction catch qui ne spécifie aucune exception particulière. Une telle instruction catch intercepte toutes les exceptions qui l’atteignent.
• Les deux ont le même mot clé de levée .

Differences

Les différences liées aux exceptions entre X++ et C# sont décrites dans le tableau suivant.

Examples

Les fonctionnalités X++ suivantes sont illustrées :

• essayez le mot clé.
• mot clé catch .
• Comportement après une exception Exception ::Error se produit.

Exemple X++

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

Voici la sortie de la fenêtre Infolog :

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.

Exemple C#

Le programme C# suivant est une réécriture du programme X++ précédent.

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

Voici la sortie de la console C# :

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

Comparaison : Nouvelle tentative automatisée après une exception

Parfois, vous pouvez écrire du code dans un bloc catch qui corrige la cause d’une exception qui se produit pendant l’exécution. X++ fournit un mot clé de nouvelle tentative qui peut être utilisé uniquement à l’intérieur d’un bloc catch . Le mot clé de nouvelle tentative permet à un programme de revenir au début du bloc try une fois que le problème a été corrigé par le code dans le bloc catch . C# n’a pas de mot clé de nouvelle tentative . Toutefois, le code C# peut être écrit pour fournir un comportement équivalent.

Exemples de code pour réessayer

L’exemple de programme X++ suivant déclenche une exception ::Error. Cela se produit lorsqu’il tente d’abord de lire un élément à partir du tableau à l’aide sStrings d’une valeur d’index non valide. Lorsque l’exception est interceptée, une action corrective est effectuée pendant l’exécution à l’intérieur du bloc catch . L’instruction de nouvelle tentative revient ensuite à la première instruction du bloc try . Cette deuxième itération fonctionne sans rencontrer d’exception.

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

Voici la sortie de la fenêtre Imprimer :

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.

Exemple C#

L’exemple C# suivant n’est pas une traduction ligne par ligne de l’exemple X++ précédent. Au lieu de cela, le programme C# a une structure différente pour qu’il imite le comportement du mot clé de nouvelle tentative sur lequel repose le programme X++. Les blocs try et catch se trouvent dans une méthode appelée. Les variables utilisées dans le bloc try sont stockées dans la méthode de l’appelant. La méthode appelant transmet les variables en tant que paramètres décorés avec le mot clé ref , afin que leurs valeurs puissent être corrigées à l’intérieur du bloc catch de la méthode appelée. La méthode appelée capture toutes les exceptions et retourne une valeur booléenne pour communiquer avec l’appelant si un deuxième appel est requis.

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

Voici la sortie de la console :

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.

Comparaison : opérateurs

Cette section compare les opérateurs entre X++ et C#.

Opérateurs d’affectation

Le tableau suivant affiche les différences entre les opérateurs d’affectation dans X++ et C#.

Opérateurs arithmétiques

Le tableau suivant répertorie les opérateurs arithmétiques :

Opérateurs au niveau du bit

Le tableau suivant compare les opérateurs au niveau du bit entre X++ et C#.

Opérateurs relationnels

Les opérateurs relationnels suivants sont identiques dans X++ et C# :

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

Comparaison : événements

Il existe des différences dans la façon dont X++ et C# implémentent le modèle de conception d’événements. Pour plus d’informations, consultez terminologie et mots clés des événements.

Comparaison des événements entre X++ et C#

Il existe des différences dans la façon dont les délégués sont utilisés pour les événements dans X++ et C#.

Exemple X++

Les points importants à noter sont les suivants dans l’exemple X++ :

• Le XppClass membre délégué est nommé myDelegate.

  Note

  L’AOT contient un nœud pour le délégué. Le nœud se trouve dans les classes > AOT > XppClass > myDelegate. Plusieurs nœuds de gestionnaire d’événements peuvent se trouver sous le nœud myDelegate. Les gestionnaires d’événements représentés par des nœuds dans l’AOT ne peuvent pas être supprimés par l’opérateur -= pendant l’exécution.

• Les {} accolades à la fin de la déclaration de délégué sont requises, mais elles ne peuvent pas contenir de code.

• Il XppClass existe deux méthodes dont les signatures de paramètre sont compatibles avec le délégué. Une méthode est statique.

• Les deux méthodes compatibles sont ajoutées au délégué avec l’opérateur += et le mot clé eventHandler . Ces instructions n’appellent pas les méthodes du gestionnaire d’événements, les instructions ajoutent uniquement les méthodes au délégué.

• L’événement est déclenché par un appel au délégué.

• La valeur du paramètre transmise au délégué est reçue par chaque méthode de gestionnaire d’événements.

• Le travail X++ court en haut de l’exemple démarre le 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);
    }
}

La sortie du travail X++ précédent est la suivante :

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.

Exemple C#

Cette section contient un exemple de code C# pour le modèle de conception d’événements de l’exemple X++ précédent.

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

La sortie de l’exemple C# précédent est la suivante :

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.

Événements et AOT

Il existe d’autres systèmes d’événements qui s’appliquent uniquement aux éléments de l’AOT. Pour plus d’informations, consultez Nœuds du gestionnaire d’événements dans aOT.

Comparaison : Directives de précompiler

X++ et C# partagent certains mots clés pour leur syntaxe de directive précompiler, mais les significations ne sont pas toujours les mêmes.

Similitudes

Les compilateurs X++ et C# reconnaissent la plupart des mêmes mots clés. Dans la plupart des cas, les mots clés signifient les mêmes pour les deux compilateurs de langage.

Differences

Une différence fondamentale entre les directives de précompileur dans X++ et C# est le mot clé #define que les précompileurs de langage reconnaissent. Contrairement à C#, dans X++, la directive #define nécessite un point dans sa syntaxe. Dans X++, les parenthèses peuvent être utilisées pour donner au symbole défini une valeur. Ces différences sont présentées dans les exemples suivants :

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

Une différence mineure est que dans C# il peut y avoir des espaces et des caractères de tabulation entre le caractère # et le mot clé de directive, tel que # define Testing.

Mots clés identiques

Le tableau suivant répertorie les directives de précompileur similaires dans X++ et C#.

Mots clés différents avec le même résultat de traitement

Le tableau suivant répertorie les directives de précompiler nommées différemment dans X++ et C#, mais qui donnent les mêmes résultats lors du traitement.

Directives de précompiler exclusives à X++

Le tableau suivant répertorie les directives de précompileur X++ qui n’ont aucun équivalent direct en C#.

Comparaison : Programmation orientée objet

Les principes de programmation orientée objet (OOP) de X++ diffèrent de C#.

Comparaisons conceptuelles

Le tableau suivant compare l’implémentation des principes OOP entre X++ et C#.

Comparaisons de mots clés

Le tableau suivant répertorie les mots clés liés à l’OOP dans X++ et C#.

Comparaison : classes

Lorsque vous utilisez C# dans .NET Framework, les classes sont regroupées en espaces de noms. Chaque espace de noms se concentre sur une zone fonctionnelle telle que les opérations de fichier ou la réflexion. Toutefois, lorsque vous utilisez les classes dans X++, il n’existe aucun regroupement visible comme un espace de noms.

Comparaison : Classes sur la réflexion

Dans X++, la TreeNode classe fournit l’accès à l’arborescence d’objets d’application (AOT). La TreeNode classe est le centre de la fonctionnalité de réflexion dans X++. La TreeNode classe et ses méthodes peuvent être comparées à l’espace System.Reflection de noms dans le .NET Framework que C# utilise.

Le tableau suivant répertorie plusieurs classes disponibles lorsque vous écrivez du code C#. Il s’agit de classes .NET Framework. Pour cette table, toutes les classes C# se trouvent dans l’espace System.Reflection de noms, sauf indication contraire. Chaque ligne affiche la classe correspondante, ou membre de classe, qui est disponible lorsque votre code X++ écrit.

Comparaison : Classes sur les E/S de fichier

Il existe plusieurs classes qui effectuent des opérations d’entrée et de sortie de fichier (E/S). Dans le .NET Framework utilisé en C#, les équivalents de ces classes résident dans l’espace System.IO de noms.

Le tableau suivant répertorie plusieurs classes .NET Framework pour C# qui se trouvent dans l’espace System.IO de noms. Chaque ligne du tableau affiche la classe ou la méthode X++ qui correspond le mieux à la classe .NET Framework.

Comparaison X++, ANSI SQL : SQL Select

Dans X++, la syntaxe de l’instruction SQL select diffère de la spécification ANSI (American National Standards Institute).

Sélection d’une table unique

Le tableau suivant répertorie les différences entre les instructions select de X++ SQL et ANSI SQL.

Exemple de code

L’exemple de code suivant illustre les fonctionnalités du tableau précédent.

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

Mots clés SQL X++

Les mots clés SQL X++ suivants sont parmi ceux qui ne font pas partie d’ANSI SQL :

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

Join, clause

Le tableau suivant répertorie les différences relatives au mot clé de jointure de X++ SQL et ANSI SQL.

Exemple de code

L’exemple de code suivant illustre la syntaxe de jointure dans 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);
    }
}

Champs d’agrégation

Le tableau suivant répertorie certaines différences dans la façon dont les champs d’agrégation de la liste de colonnes select sont référencés entre X++ SQL et ANSI SQL. Les champs d’agrégation sont ceux dérivés par des fonctions telles que somme ou moyenne.

Exemple de code

Dans l’exemple de code suivant, l’appel à la méthode d’informations illustre la façon de référencer des champs d’agrégation (voir 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.
***/

Autres différences

Le tableau suivant répertorie d’autres différences de l’instruction select entre les sql X++ et ANSI SQL.