Comparação entre X++ e C#

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

Comparação X++, C#: Hello World

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

Comparações X++ com C#

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

Semelhanças

Os seguintes recursos do 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.
• != (não igual a) operador para determinar se dois valores não são equivalentes.
• + (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#. Ambas as amostras obtêm o mesmo resultado. Os seguintes recursos X++ são demonstrados:

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

Exemplo de X++

Este exemplo de código X++ está na forma de um trabalho. Há um nó intitulado Jobs na Application Object Tree (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.");
    }
}

Resultado

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

Exemplo de C#

O seguinte programa C# é 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.");
        }
    }
}

Resultado

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

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.
• enquanto instrução para loops.
• quebrar instrução para sair de um loop.
• Continue a declaração para saltar para o topo 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#.

Impressão e Global::info

Os exemplos de código X++ para loops usam a print função para exibir resultados. Em X++ você pode usar a print instrução pode exibir qualquer tipo de dados primitivo sem ter que chamar funções que o convertem em uma cadeia de caracteres primeiro. Isso é print útil em situações de teste rápido. 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 em conjunto com info. Uma limitação é que você não pode copiar o conteúdo da janela Imprimir para a área de print transferência (como Ctrl+C). Global::info grava na janela Infolog que suporta cópia para a área de transferência.

Exemplo 1: O loop while

A palavra-chave while suporta looping em X++ e C#.

Exemplo de X++ de enquanto

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

Resultado

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

1
2
3
4

Exemplo de C# de enquanto

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

Resultado

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 suporta looping em X++ e C#.

Exemplo de X++ de for

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

Resultado

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

1
2
3
4

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

Resultado

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

Em X++ e C#, a instrução switch envolve as palavras-chave case, break e default. A tabela a seguir lista as diferenças na instrução switch entre X++ e C#.

Exemplos de código para switch

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

Exemplo de switch X++

O exemplo de opção X++ mostra o seguinte:

• case iTemp: e case (93-90): para mostrar que as expressões de caso não se limitam a constantes, como 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 de caso no 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 switch C#

O exemplo de opção C# mostra o seguinte:

• Caso 1: tem um comentário explicando que apenas expressões constantes podem ser dadas em uma cláusula de caso .
• break; as instruções ocorrem após a última instrução em cada bloco de caso que tem instruções, como é 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#: String Case e Delimitadores

Esta seção compara o tratamento de cadeias de caracteres com caixa mista 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 do 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 é escrito imediatamente antes das aspas abertas de uma cadeia de caracteres.
• O sinal de adição (+) é o operador de concatenação de cadeia de caracteres.

Diferenças

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

Exemplo 1: Sensibilidade a 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#, como ilustrado pelo exemplo a seguir.

Exemplo 2: O operador de concatenação + String

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

Exemplo 3: Incorporação e fuga de delimitadores de cadeia de caracteres

As aspas simples ou duplas podem ser usadas para delimitar cadeias de caracteres no X++. O caractere de escape (\) pode ser usado para incorporar delimitadores em uma cadeia de caracteres. Estes são ilustrados no quadro seguinte.

Exemplo 4: Personagem de fuga única

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

Comparação: Sintaxe da 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, existem muitas diferenças.

Diferenças

A tabela a seguir lista áreas na sintaxe [] para matrizes que são 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#. Ambas as amostras alcançam 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]));
    }
}

Resultado

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

Resultado

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 X++ adicionais semelhantes a arrays

O contêiner é um tipo de dados especial que está disponível no X++. Pode ser considerado 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 que é usado em C# tem uma classe semelhante chamada System.Collections.Generic.List.

Comparando o uso das classes de lista

A tabela a seguir compara métodos na classe X++ List com os métodos do System.Collections.Generic.List .NET Framework e 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 anexar 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 inserir em qualquer ponto da coleção com base em um valor de índice. No 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 através de uma lista

Tanto o X++ quanto o 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 é frequentemente usada para simplificar a tarefa de iterar através de uma lista. O exemplo de código a seguir se comporta da mesma forma que o exemplo 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 própria coleção 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 Map classe collection. A Map coleção contém pares de valores, o valor da chave mais um valor de dados. Isso é semelhante à classe .NET Framework chamada System.Collections.Generic.Dictionary.

Semelhanças

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

• Ambos evitam chaves duplicadas.
• Ambos usam um enumerador (ou iterador) para percorrer os itens.
• Ambos os objetos de coleção chave-valor são construídos com designações dos tipos que são 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 suas 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 de 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

Quase não há diferença em como um item é adicionado a uma coleção de 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 através de uma coleção Key-Value

Os enumeradores são usados para percorrer as coleções de 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 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 pelos 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

Existem algumas semelhanças, mas muitas diferenças quando comparamos o comportamento relacionado a exceções 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 lançadas e apanhadas são diferentes para as duas línguas.

Semelhanças

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

• Ambas as línguas têm a mesma palavra-chave try .
• Ambos têm a mesma palavra-chave catch .
• Ambos habilitam uma instrução catch que não especifica nenhuma exceção específica. Essa declaração de captura captura todas as exceções que a atingem.
• Ambos têm a mesma palavra-chave.

Diferenças

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

Examples

Os seguintes recursos X++ são demonstrados:

• tente a palavra-chave.
• palavra-chave catch .
• O comportamento após uma exceção Exception::Error 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.");
}

Resultado

Aqui está a saída da janela 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 seguinte programa C# é 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

Resultado

Aqui está a saída para o console 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. X++ fornece uma palavra-chave retry que pode ser usada apenas dentro de um bloco catch . A palavra-chave retry permite que um programa volte para o início do bloco try depois que o problema foi corrigido pelo código no bloco catch . C# não tem uma palavra-chave de nova tentativa . No entanto, o código C# pode ser escrito para fornecer um comportamento equivalente.

Exemplos de código para repetição

O seguinte programa de exemplo X++ faz com que um Exception::Error seja gerado. 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, uma ação corretiva é tomada durante o tempo de execução dentro do bloco de captura . Em seguida, a instrução retry volta para a primeira instrução no bloco try . Esta segunda iteração funciona sem encontrar qualquer 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;
}

Resultado

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 por linha do exemplo X++ anterior. Em vez disso, o programa C# tem uma estrutura diferente para que ele imita o comportamento da palavra-chave retry 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 do chamador. O método chamador passa as variáveis como parâmetros que são 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 booleano para comunicar de volta ao 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;
    }
}

Resultado

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 Bitwise

A tabela a seguir compara os operadores bitwise 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 em 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++

As coisas importantes a observar são as seguintes no exemplo X++:

• O XppClass tem um membro delegado que é chamado myDelegate.

  Observação

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

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

• O XppClass tem dois métodos cujas assinaturas de parâmetros 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 apenas adicionam os métodos ao delegado.

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

• O valor do parâmetro que passou para o delegado é recebido por cada método 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 do exemplo 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 do exemplo C# anterior é 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 o AOT

Existem outros sistemas de eventos que se aplicam apenas a itens na AOT. Para obter mais informações, consulte Nós do manipulador de eventos na AOT.

Comparação: Diretivas pré-compiladoras

X++ e C# compartilham algumas palavras-chave para sua sintaxe de diretiva pré-compiladora, 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é-compilador em X++ versus C# é a palavra-chave #define que ambos os pré-compiladores de linguagem reconhecem. Ao contrário do 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. Ano Inicial(2003)
• Em C#: #define InitialYear

Uma pequena diferença é que em C# pode haver espaços e caracteres de tabulação entre o caractere # e a palavra-chave diretiva, como # define Testing.

Palavras-chave idênticas

A tabela a seguir lista diretivas de pré-compilador que são semelhantes em X++ e C#.

Palavras-chave diferentes com o mesmo resultado de processamento

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

Diretivas de pré-compilador exclusivas para X++

A tabela a seguir lista as diretivas de pré-compilador X++ que não têm contrapartida direta em C#.

Comparação: Programação Orientada a Objetos

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

Comparações conceptuais

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

Comparações de palavras-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 no X++, não há agrupamentos visíveis como um namespace.

Comparação: Aulas 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 no 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ê quando você escreve código C#. Estas são classes do .NET Framework. Para esta tabela, todas as classes C# estão no namespace, a System.Reflection menos que especificado de outra forma. Cada linha mostra a classe correspondente, ou membro da classe, que está disponível para você quando você escreve código X++.

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

Há várias classes que executam operações de entrada e saída de arquivo (IO). No .NET Framework que é usado em C#, as contrapartes para essas classes residem no System.IO namespace.

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

X++, Comparação ANSI SQL: SQL Select

No X++, a sintaxe da instrução SQL select 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 select de X++ SQL e ANSI SQL.

Exemplo de código

O exemplo de código a seguir ilustra 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 X++ SQL

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

• Empresa cruzada
• firstonly100
• forçaliterais
• forcenestedloop
• ForçaEspaços Reservados
• ForceSelectOrder
• ValidTimeState

Cláusula de adesão

A tabela a seguir lista as diferenças sobre a palavra-chave join de X++ SQL e ANSI SQL.

Exemplo de código

O exemplo de código a seguir ilustra a sintaxe de junção no 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);
    }
}

Campos agregados

A tabela a seguir lista algumas diferenças na forma como os campos agregados na lista de colunas selecionadas são referenciados entre X++ SQL e ANSI SQL. Campos agregados são aqueles que são 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 info ilustra a maneira de fazer referência a 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 X++ SQL e o ANSI SQL.