Comparação entre X++ e C#

Este artigo compara a sintaxe e a programação de X++ e C#.

Comparação X++, C#: Olá, Mundo

Esta seção compara o programa X++ mais simples com seu equivalente em C#.

Comparações de X++ a C#

As seções a seguir descrevem algumas semelhanças básicas e diferenças entre X++ e C#.

Semelhanças

Os seguintes recursos X++ são os mesmos para C#:

• Comentários de linha única (//) e de várias linhas (/* */).
• == Operador (igual) para determinar se dois valores são iguais.
• != Operador (não igual a) para determinar se dois valores não são equivalentes.
• + Operador (sinal de adição) para concatenação de cadeia de caracteres.

Diferenças

A tabela a seguir lista os recursos X++ que são diferentes em C#.

Exemplos de X++ e C#

Esta seção contém dois exemplos de código simples. Um exemplo é escrito em X++, e o outro está em C#. Ambos os exemplos alcançam o mesmo resultado. Os seguintes recursos X++ são demonstrados:

• // comentário de linha única
• /\* \*/ comentário de várias linhas
• Instrução if
• Operador ==
• Operador !=
• + operador para concatenar cadeias de caracteres
• Global::info para saída de mensagem, com e sem o prefixo Global::
• Global::error for message output
• O uso de caracteres de aspas simples e duplas (' e ") como delimitadores de cadeia de caracteres.

Exemplo de X++

Este exemplo de código X++ está na forma de um trabalho. Há um nó intitulado Trabalhos na Árvore de Objetos do Aplicativo (AOT). Este exemplo pode ser adicionado no nó Trabalhos e, em seguida, o trabalho pode ser executado.

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

Saída

Aqui está a saída da janela Infolog: Mensagem (09:49:48) Olá, Mundo, 1. Olá, Mundo, 2. Isso é como informações, mas é para avisos, 3. Isso é como informações, mas é para erros, 4.

Exemplo de C#

O programa C# a seguir é uma reescrita do programa X++ anterior.

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

Saída

Aqui está a saída real para o console do 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.

Comparação X++, C#: Loops

Esta seção compara os recursos de loop entre X++ e C#.

Semelhanças

Os seguintes recursos são os mesmos em X++ e C#:

• Declarações para variáveis do tipo de dados primitivo int. As declarações para outros tipos primitivos são quase as mesmas, mas os tipos podem ter nomes diferentes.
• instrução while para loops.
• instrução break para sair de um loop.
• instrução continue a saltar até a parte superior de um loop.
• <= (menor ou igual) operador de comparação.

Diferenças

A tabela a seguir lista os recursos X++ que são diferentes em C#.

Imprimir e Global::info

Os exemplos de código X++ para loops usam a print função para exibir resultados. No X++, você pode usar a print instrução pode exibir qualquer tipo de dados primitivo sem precisar chamar funções que a convertem em uma cadeia de caracteres primeiro. Isso torna print útil em situações de teste rápidas. Geralmente, o método Global::info é usado com mais frequência do que print. O info método só pode exibir cadeias de caracteres. Portanto, a função strfmt é frequentemente usada junto com info. Uma limitação é print que você não pode copiar o conteúdo da janela Imprimir para a área de transferência (como com Ctrl+C). Gravações globais::info na janela do Infolog que dá suporte à cópia para a área de transferência.

Exemplo 1: o loop while

A palavra-chave while dá suporte a looping em X++ e C#.

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

Saída

A saída na janela Impressão X++ é a seguinte:

1
2
3
4

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

Saída

A saída do console do programa C# é a seguinte:

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

Exemplo 2: o loop for

A palavra-chave for dá suporte a looping em X++ e C#.

Exemplo de X++ para

Em X++, a variável de contador não pode ser declarada como parte da instrução 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;
}

Saída

A saída na janela Impressão X++ é a seguinte:

1
2
3
4

Exemplo de C# para

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

Saída

A saída do console do programa C# é a seguinte:

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

Comparação X++, C#: Alternar

Em X++ e C#, a instrução switch envolve o caso, a quebra e o padrão das palavras-chave. A tabela a seguir lista as diferenças na instrução switch entre X++ e C#.

Exemplos de código para comutador

As seções a seguir mostram instruções de comutador comparáveis em X++ e C#.

Exemplo de comutador X++

O exemplo de comutador X++ mostra o seguinte:

• case iTemp: e case (93-90): para mostrar que as expressões maiúsculas e minúsculas não estão limitadas a constantes, como estão em C#.
• //break; para mostrar que break; as instruções não são necessárias no X++, embora sejam quase sempre desejáveis.
• case 2, (93-90), 5: para mostrar que várias expressões podem ser listadas em uma cláusula case em 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
***

Exemplo de comutador C#

O exemplo de comutador C# mostra o seguinte:

• caso 1: tem um comentário explicando que somente expressões constantes podem ser fornecidas em uma cláusula case .
• break; as instruções ocorrem após a última instrução em cada bloco de maiúsculas e minúsculas que tem instruções, conforme exigido pelo 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
>>
***/

Comparação X++, C#: Caso de cadeia de caracteres e delimitadores

Esta seção compara o tratamento de cadeias de caracteres com maiúsculas e minúsculas misturadas em X++ e C#. Ele também explica os delimitadores de cadeia de caracteres que estão disponíveis no X++.

Semelhanças

Os seguintes recursos X++ são os mesmos do C#:

• A barra invertida (\) é o operador de escape para delimitadores de cadeia de caracteres.
• O sinal de at (@) anula o efeito de escape da barra invertida quando o sinal de at é gravado imediatamente antes da aspa aberta de uma cadeia de caracteres.
• O sinal de adição (+) é o operador de concatenação de cadeia de caracteres.

Diferenças

Os recursos X++ que são diferentes em C# são listados na tabela a seguir.

Exemplo 1: Diferenciação de maiúsculas e minúsculas do operador ==

Os == operadores != e != não diferenciam maiúsculas de minúsculas em X++, mas diferenciam maiúsculas de minúsculas em C#, conforme ilustrado pelo exemplo a seguir.

Exemplo 2: o operador + concatenação de cadeia de caracteres

Os operadores + e += são usados para concatenar cadeias de caracteres em X++ e C#, conforme mostrado pelos exemplos na tabela a seguir.

Exemplo 3: Delimitadores de cadeia de caracteres de inserção e escape

Aspas simples ou duplas podem ser usadas para delimitar cadeias de caracteres em X++. O caractere de escape (\) pode ser usado para inserir delimitadores em uma cadeia de caracteres. Elas são ilustradas na tabela a seguir.

Exemplo 4: caractere de escape único

Exemplos que ilustram o caractere de escape único na entrada ou na saída são mostrados na tabela a seguir.

Comparação: Sintaxe de matriz

Há semelhanças e diferenças nos recursos e sintaxe para matrizes em X++ versus C#.

Semelhanças

No geral, há muita semelhança na sintaxe e no tratamento de matrizes em X++ e C#. No entanto, há muitas diferenças.

Diferenças

A tabela a seguir lista áreas na sintaxe [] para matrizes diferentes para X++ e C#.

Exemplos de X++ e C#

Os exemplos de código a seguir mostram como matrizes de tipos de dados primitivos são tratadas. O primeiro exemplo está em X++, e o segundo exemplo está em C#. Ambos os exemplos obtêm os mesmos resultados.

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

Saída

A saída para o Infolog é a seguinte:

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

Exemplo de 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

Saída

A saída do programa C# para o console de linha de comando é a seguinte:

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

Recursos adicionais do X++ semelhantes à matriz

O contêiner é um tipo de dados especial que está disponível no X++. Ele pode ser considerado como semelhante a uma matriz ou semelhante a uma List coleção.

Comparação: coleções

Em um aplicativo de finanças e operações, você pode usar a classe de coleção X++ List . O .NET Framework usado em C# tem uma classe semelhante chamada System.Collections.Generic.List.

Comparando o uso das classes de lista

A tabela a seguir compara os métodos na classe X++ List com os métodos System.Collections.Generic.List do .NET Framework e do C#.

Exemplo 1: Declaração de uma lista

Os exemplos de código a seguir estão em X++ e C# que declaram List coleções.

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

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

Exemplo 2: Construção de uma lista

Em ambos os idiomas, o tipo de itens que a coleção armazena deve ser especificado no momento da construção. Para tipos de classe, X++ não pode obter mais específico do que se o tipo é uma classe (Types::Class). Os exemplos de código a seguir estão em X++ e C#.

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

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

Exemplo 3: Adicionar itens a uma lista

Em X++ e C#, a coleção fornece um método para acrescentar um item ao final da coleção e para inserir um item no início. Em C#, a coleção fornece um método para inserção em qualquer ponto da coleção com base em um valor de índice. Em X++ um iterador de coleção pode inserir um item em sua posição atual. Os exemplos de código a seguir estão em X++ e 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");

Exemplo 4: iterar por meio de uma lista

X++ e C# têm classes de iterador que você pode usar para percorrer os itens em uma coleção, conforme mostrado nos exemplos a seguir.

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

Exemplo 4b: foreach em C#

Em C#, a palavra-chave foreach geralmente é usada para simplificar a tarefa de iterar por meio de uma lista. O exemplo de código a seguir se comporta da mesma forma que o exemplo de C# anterior.

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

Exemplo 5: excluir o segundo item

Os exemplos de código a seguir excluem o segundo item da coleção. No X++ isso requer um iterador. Em C#, a coleção em si fornece o método para remover um item.

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

// C#
listStrings.RemoveAt(1);

Exemplo 6: Combinar duas coleções

Os exemplos de código a seguir combinam o conteúdo de duas coleções em uma.

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

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

Comparação: coleções de chaves com valores

Em um aplicativo de finanças e operações, você pode usar a classe de Map coleção. A Map coleção contém pares de valores, o valor da chave mais um valor de dados. Isso se assemelha à classe .NET Framework chamada System.Collections.Generic.Dictionary.

Semelhanças

A lista a seguir descreve as semelhanças entre X++ e C# em relação às suas coleções que armazenam pares chave-valor:

• Ambos impedem chaves duplicadas.
• Ambos usam um enumerador (ou iterador) para fazer loop pelos itens.
• Ambos os objetos de coleção chave-valor são construídos com designações dos tipos armazenados como chave e valor.
• Ambos podem armazenar objetos de classe e não estão limitados a armazenar primitivos como int.

Diferenças

A tabela a seguir descreve as diferenças entre X++ e C# em relação às classes de coleções que armazenam pares chave-valor:

Exemplo 1: Declaração de uma coleção Key-Value

Em ambos os idiomas, o tipo de itens que a coleção chave-valor armazena deve ser especificado. Em X++ o tipo é especificado no momento da construção. Em C#, o tipo é especificado no momento da declaração e no momento da construção. Os exemplos de código a seguir estão em X++ e C#.

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

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

Exemplo 2: Construção da coleção

Em ambos os idiomas, o tipo de itens que a coleção chave-valor armazena especificado durante a construção. Para tipos de classe, X++ não pode obter mais específico do que se o tipo é uma classe (Types::Class). Os exemplos de código a seguir estão em X++ e C#.

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

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

Exemplo 3: Adicionar um item à coleção

Não há quase nenhuma diferença em como um item é adicionado a uma coleção chave-valor em X++ e C#, conforme mostrado nos exemplos de código a seguir.

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

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

Exemplo 4: iterar por meio de uma coleção de Key-Value

Os enumeradores são usados para fazer loop por meio das coleções chave-valor em X++ e C#, conforme mostrado nos exemplos de código a seguir.

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

Exemplo 5: atualizar o valor associado a uma chave

A sintaxe é muito diferente entre os dois idiomas para uma atualização do valor associado a uma determinada chave. Os exemplos de código de ollowing são para a chave 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.”;

Exemplo 6: Excluir um item

A sintaxe é muito diferente entre os dois idiomas para excluir um par chave-valor de uma coleção, enquanto itera por meio dos membros da coleção. Exemplos de código para a chave 102 são mostrados abaixo.

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

Comparação: exceções

Há algumas semelhanças, mas muitas diferenças quando comparamos o comportamento relacionado à exceção entre X++ e C#. As palavras-chave try, catch e throw se comportam da mesma forma em X++ e C#. Mas os tipos de exceções geradas e capturadas são diferentes para os dois idiomas.

Semelhanças

As semelhanças entre X++ e C# em relação aos recursos de exceção incluem os seguintes exemplos:

• Ambos os idiomas têm a mesma palavra-chave try .
• Ambos têm a mesma palavra-chave catch .
• Ambos habilitam para uma instrução catch que não especifica nenhuma exceção específica. Tal instrução catch captura todas as exceções que a alcançam.
• Ambos têm a mesma palavra-chave de lançamento .

Diferenças

As diferenças relacionadas à exceção entre X++ e C# são descritas na tabela a seguir.

Exemplos

Os seguintes recursos X++ são demonstrados:

• palavra-chave try .
• palavra-chave catch .
• O comportamento após uma exceção de Exceção::Erro ocorre.

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

Saída

Aqui está a saída da janela do 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.

Exemplo de C#

O programa C# a seguir é uma reescrita do programa X++ anterior.

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

Saída

Aqui está a saída para o console do C#:

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

Comparação: Repetição automatizada após uma exceção

Às vezes, você pode escrever código em um bloco catch que corrige a causa de uma exceção que ocorre durante o tempo de execução. O X++ fornece uma palavra-chave de repetição que só pode ser usada dentro de um bloco catch . A palavra-chave de repetição permite que um programa volte para o início do bloco try depois que o problema tiver sido corrigido pelo código no bloco catch . C# não tem uma palavra-chave de repetição . No entanto, o código C# pode ser gravado para fornecer um comportamento equivalente.

Exemplos de código para repetição

O programa de exemplo X++ a seguir faz com que uma Exceção::Erro seja gerada. Isso ocorre quando ele tenta ler pela primeira vez um elemento da sStrings matriz usando um valor de índice inválido. Quando a exceção é capturada, a ação corretiva é executada durante o tempo de execução dentro do bloco catch . A instrução de repetição, em seguida, salta de volta para a primeira instrução no bloco try . Esta segunda iteração funciona sem encontrar nenhuma exceção.

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

Saída

Aqui está a saída para a janela Imprimir:

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.

Exemplo de C#

O exemplo de C# a seguir não é uma tradução linha a linha do exemplo X++ anterior. Em vez disso, o programa C# tem uma estrutura diferente para que ele imite o comportamento da palavra-chave de repetição na qual o programa X++ depende. Os blocos try e catch estão em um método chamado. As variáveis usadas no bloco try são armazenadas no método de chamador. O método de chamador passa as variáveis como parâmetros decorados com a palavra-chave ref , para que seus valores possam ser corrigidos dentro do bloco catch do método chamado. O método chamado captura todas as exceções e retorna um booliano para se comunicar com o chamador se uma segunda chamada é necessária.

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

Saída

Aqui está a saída para o 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.

Comparação: operadores

Esta seção compara os operadores entre X++ e C#.

Operadores de atribuição

A tabela a seguir exibe as diferenças entre os operadores de atribuição em X++ e C#.

Operadores aritméticos

A tabela a seguir lista os operadores aritméticos.

Operadores bit a bit

A tabela a seguir compara os operadores bit a bit entre X++ e C#.

Operadores relacionais

Os seguintes operadores relacionais são os mesmos em X++ e C#:

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

Comparação: eventos

Há algumas diferenças na forma como X++ e C# implementam o padrão de design de evento. Para obter mais informações, consulte Terminologia de eventos e palavras-chave.

Comparação de eventos entre X++ e C#

Há diferenças na maneira como os delegados são usados para eventos em X++ versus C#.

Exemplo de X++

Os itens importantes a serem notados são os seguintes no exemplo X++:

• O XppClass tem um membro delegado chamado myDelegate.

  Observação

  O AOT contém um nó para o delegado. O nó está localizado nas classes > AOT > XppClass > myDelegate. Vários nós do manipulador de eventos podem ser localizados no nó myDelegate. Os manipuladores de eventos representados por nós no AOT não podem ser removidos pelo operador -= durante o tempo de execução.

• As {} chaves no final da declaração delegada são necessárias, mas não podem ter nenhum código nelas.

• O XppClass tem dois métodos cujas assinaturas de parâmetro são compatíveis com o delegado. Um método é estático.

• Os dois métodos compatíveis são adicionados ao delegado com o operador += e a palavra-chave eventHandler . Essas instruções não chamam os métodos do manipulador de eventos, as instruções só adicionam os métodos ao delegado.

• O evento é gerado por uma chamada para o delegado.

• O valor do parâmetro passado para o delegado é recebido por cada método de manipulador de eventos.

• O trabalho X++ curto na parte superior do exemplo inicia o teste.

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

A saída do trabalho X++ anterior é a seguinte:

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.

Exemplo de C#

Esta seção contém um exemplo de código C# para o padrão de design de evento da amostra X++ anterior.

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

A saída da amostra anterior do C# é a seguinte:

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.

Eventos e a AOT

Há outros sistemas de eventos que se aplicam somente a itens no AOT. Para obter mais informações, consulte Nós do Manipulador de Eventos no AOT.

Comparação: Diretivas de pré-preenchimento

X++ e C# compartilham algumas palavras-chave para sua sintaxe de diretiva de pré-preenchimento, mas os significados nem sempre são os mesmos.

Semelhanças

Os compiladores X++ e C# reconhecem muitas das mesmas palavras-chave. Na maioria dos casos, as palavras-chave significam o mesmo para ambos os compiladores de linguagem.

Diferenças

Uma diferença fundamental entre as diretivas de pré-preenchimento em X++ versus C# é a palavra-chave #define que ambos os pré-compiladores de idioma reconhecem. Ao contrário de C#, em X++ a diretiva #define requer um ponto em sua sintaxe. Em X++, parênteses podem ser usados para dar um valor ao símbolo definido. Essas diferenças são mostradas nos seguintes exemplos:

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

Uma pequena diferença é que em C# pode haver espaços e caracteres de guia entre o caractere # e a palavra-chave de diretiva, como # definir Teste.

Palavras-chave idênticas

A tabela a seguir lista as diretivas de pré-preenchimento semelhantes em X++ e C#.

Palavras-chave diferentes com o mesmo resultado de processamento

A tabela a seguir lista as diretivas de pré-preenchimento que são nomeadas de forma diferente em X++ e C#, mas que fornecem os mesmos resultados quando processadas.

Diretivas de pré-preenchimento exclusivas para X++

A tabela a seguir lista as diretivas de pré-preenchimento X++ que não têm nenhum equivalente direto em C#.

Comparação: Programação orientada a objetos

Os princípios de OOP (programação orientada a objeto) do X++ diferem de C#.

Comparações conceituais

A tabela a seguir compara a implementação de princípios OOP entre X++ e C#.

Comparações de palavra-chave

A tabela a seguir lista as palavras-chave relacionadas ao OOP em X++ e C#.

Comparação: classes

Quando você usa C# no .NET Framework, as classes são agrupadas em namespaces. Cada namespace se concentra em uma área funcional, como operações de arquivo ou reflexão. No entanto, quando você usa as classes em X++, não há agrupamentos visíveis como um namespace.

Comparação: classes sobre reflexão

No X++, a TreeNode classe fornece acesso à Árvore de Objetos do Aplicativo (AOT). A TreeNode classe é o centro da funcionalidade de reflexão em X++. A TreeNode classe e seus métodos podem ser comparados ao System.Reflection namespace no .NET Framework que o C# usa.

A tabela a seguir lista várias classes que estão disponíveis para você ao escrever código C#. Estas são classes do .NET Framework. Para esta tabela, todas as classes C# estão no System.Reflection namespace, a menos que sejam especificadas de outra forma. Cada linha mostra a classe correspondente, ou membro da classe, que está disponível para você quando o código de gravação X++.

Comparação: Classes sobre E/S de Arquivo

Há várias classes que executam operações de E/S (entrada e saída) de arquivo. No .NET Framework usado em C#, os equivalentes a essas classes residem no System.IO namespace.

A tabela a seguir lista várias classes do .NET Framework para C# que estão no System.IO namespace. Cada linha na tabela mostra a classe X++ ou o método que melhor corresponde à classe .NET Framework.

Comparação de SQL X++, ANSI: Seleção de SQL

Em X++, a sintaxe de instrução de seleção do SQL difere da especificação ANSI (American National Standards Institute).

Seleção de Tabela Única

A tabela a seguir lista as diferenças entre as instruções selecionadas do SQL X++ e do SQL ANSI.

Exemplo de código

O exemplo de código a seguir ilustra os recursos na tabela anterior.

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

Palavras-chave do SQL X++

As seguintes palavras-chave do SQL X++ estão entre as que não fazem parte do SQL ANSI:

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

Cláusula Join

A tabela a seguir lista as diferenças sobre a palavra-chave de junção do SQL X++ e do SQL ANSI.

Exemplo de código

O exemplo de código a seguir ilustra a sintaxe de junção no SQL X++.

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

Campos de Agregação

A tabela a seguir lista algumas diferenças na forma como os campos de agregação na lista de colunas selecionadas são referenciados entre o SQL X++ e o SQL ANSI. Campos de agregação são aqueles derivados por funções como soma ou média.

Exemplo de código

No exemplo de código a seguir, a chamada para o método de informações ilustra a maneira de referenciar campos agregados (consulte 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.
***/

Outras diferenças

A tabela a seguir lista outras diferenças da instrução select entre o SQL X++ e o SQL ANSI.