Implementar delegados

Concluído

Ao criar soluções extensíveis, você pode usar delegados inscrevendo-se no delegado em X++.

Os delegados são tipos de dados compostos que fazem parte de como os aplicativos de finanças e operações podem criar extensões. Você pode definir delegados em um método. Então, quando o método for chamado, ele também chamará seus métodos de assinante.

Não recomendamos que você crie novos delegados no aplicativo. Em vez disso, recomendamos que você assine os delegados existentes e use a CoC (Cadeia de Comando), que fornece um mecanismo de extensão mais avançado, mais robusto e mais conciso que substitui os delegados.

Em vez de criar delegados, estruture seu código em métodos menores para que você possa usá-lo na CoC.

Se você usar delegados, eles normalmente residirão no meio de um método porque, se pré-eventos e pós-eventos estiverem presentes e a CoC for usada, eles estarão no início e no final de um método, respectivamente.

Você pode usar delegados nos aplicativos padrão de finanças e operações, e eles são úteis para soluções de ISV (fornecedores independentes de software).

Os delegados em X++ devem ter o tipo de retorno void. Além disso, os delegados podem ser métodos estáticos e de instância e podem usar EventHandlerResult como parâmetro de método para retornar um resultado.

Os assinantes dos delegados não controlam a ordem de implementação.

Criar delegados

Normalmente, você criaria delegados em seu código em tabelas, formulários ou classes.

Defina o delegado no código e defina uma chamada para o delegado vazio para que os assinantes possam usá-lo.

O exemplo de código a seguir mostra como um delegado pode for mostrado em uma classe:

/// <summary>
    /// Delegate for construct <c>MyCustTableClass</c> instances.
    /// </summary>
    /// <param name = "_buffer">The buffer to create the instance from.</param>
    /// <param name = "_eventHandlerResult">An <c>EventHandlerResult</c></param>
    static delegate void constructDelegate(Common _buffer,EventHandlerResult _eventHandlerResult)
    {
    }

Você chamaria os delegados no código da seguinte maneira:

/// <summary>
    /// Construct method <c>MyCustTableClass</c> instances.
    /// </summary>
    /// <param name = "_buffer">The buffer to create the instance from.</param>
    /// <returns>
    /// MyCustTableClass.
    /// </returns>
    public static MyCustTableClass construct(Common _buffer)
    {
        switch (_buffer.TableId)
        {
            case tablenum(CustTable):
                return new MyCustTableClass(_buffer);

            default:
                EventHandlerResult result = EventHandlerResult::newSingleResponse();
                MyCustTableClass::constructDelegate(_buffer, result);
                if (result.hasResult())
                {
                    return result.result() as MyCustTableClass;
                }
                break;
        }

        throw error(Error::missingRecord(classstr(MyCustTableClass)));
    }

Conforme mostrado no exemplo anterior, a chamada para MyCustTableClass::constructDelegate estático é feita no meio do método; portanto, você não pode usar pré-eventos e pós-eventos ou CoC. Como você criou delegados, uma extensão agora está habilitada.

O sistema usa EventHandlerResult para retornar o resultado, que você pode validar. validado.

Assinar um delegado

Você pode realizar extensões assinando o delegado, o que permite fazer modificações, como mostra o exemplo de código a seguir:

/// <summary>
    /// <c>MyCustTableClass</c> class delegate subscriber.
    /// </summary>
    [SubscribesTo(classstr(MyCustTableClass), staticDelegateStr(MyCustTableClass, constructDelegate))]
    public static void myConstruct(Common _buffer, EventHandlerResult _eventHandlerResult)
    {
        CustTable custTable = _buffer as CustTable;

        // do something

        _eventHandlerResult.result(custTable);
    }

Os assinantes usam o atributo SubscribesTo com o nome da classe e o nome do método delegado e o sistema usa o método EventHandlerResult para definir o resultado desejado.

Usar delegados pode ser útil, mas a prática recomendada é usar CoC, pois fornece um mecanismo de extensão mais avançado, robusto e conciso. Além disso, você pode aplicar CoC dividindo e estruturando o código em partes menores.