Implementazione del framework asincrono

I processi a esecuzione prolungata possono raggiungere il timeout nelle app per la finanza e le operazioni. Per evitare questo problema, l'elaborazione asincrona consente agli utenti di continuare a lavorare mentre il processo viene eseguito in background.

Ad esempio, potrebbe essere necessario eseguire un'elaborazione nell'applicazione che gestisce una grande quantità di dati o transazioni e non si vuole interrompere i processi di business quotidiani. Pertanto, è possibile usare il framework asincrono per eseguire questi processi in background, mentre gli utenti possono continuare il proprio lavoro senza interruzioni.

Per eseguire un processo in modo asincrono, è necessario usare i metodi runAsync dalle classi FormRun e Global per chiamare il metodo statico che si desidera eseguire. Se il processo viene eseguito sul lato client, consigliamo di usare il metodo runAsync della classe FormRun. La classe Global ha un metodo runAsync che consigliamo per eseguire il codice all'esterno del client.

È possibile usare un metodo di richiamata per visualizzare un messaggio al termine del processo. Il messaggio viene immediatamente visualizzato solo con il metodo runAsync della classe FormRun. Se si usa il metodo runAsync della classe Global, è necessario aggiornare la pagina.

La firma del metodo statico deve:

• Essere statica.
• Restituire un contenitore come parametro di output.
• Avere un contenitore per i parametri di input. Il contenitore può includere più valori, se necessario.
• Avere un token di annullamento per i parametri di input.

L'esempio seguente illustra un metodo statico che è possibile usare come runAsync :

    /// <summary>
    /// Create entities asynchronously
    /// </summary>
    /// <param name = "_params">Parameters</param>
    /// <param name = "_cancellationToken">CancellationToken object</param>
    /// <returns></returns>
    static container runAsyncJob(container _params, System.Threading.CancellationToken _cancellationToken)
    {
        System.Exception _ex;

        try
        {
            // do something
        }
        catch(_ex)
        {
            throw error("Unsuccessfull");
        }

        return ["Successfull"];
    }

È possibile usare un altro metodo statico per il risultato, che può essere positivo o un'eccezione, e la sua firma deve:

• Essere statica.
• Restituire void.
• Avere AsyncTaskResult come parametro di input.

L'esempio seguente illustra un metodo statico per un risultato:

    /// <summary>
    /// Async callback
    /// </summary>
    /// <param name = "taskResult">Result of async import or export processing</param>
    static public void processAsyncDataExecutionResult(AsyncTaskResult taskResult)
    {
        container returnValue;
        System.Exception exception;

        if (taskResult != null)
        {
            // Return value from async method
            returnValue = taskResult.getResult();

            // Exception thrown by async method invocation.
            exception = taskResult.getException();

            if (ClrInterop::isNull(exception))
            {
                info(con2Str(returnValue));
            }
            else
            {
                error(exception.Message);
            }
        }
    }

Ora la funzione runAsync può usare i due metodi (le funzioni senza un nome di classe sono definite nella classe globale).

    public static void main(Args _args)
    {
        System.Threading.CancellationTokenSource tokenSource = new System.Threading.CancellationTokenSource();
        
        // run job asynchronously
        
        runAsync(classNum(MyASyncClass),
                 staticMethodStr(MyASyncClass, runAsyncJob),
                 conNull(),
                 tokenSource.Token,
                 classNum(MyASyncClass),
                 staticMethodStr(MyASyncClass, processAsyncDataExecutionResult));
    }

I parametri usati dalla funzione runAsync devono avere i seguenti componenti:

• Un numero di classe per la classe da eseguire.
• Un metodo statico che viene eseguito in modo asincrono.
• Un contenitore per i parametri di input. Il valore dei parametri del contenitore viene impostato come elenco di parametri per il metodo di implementazione.
• Un token di fallback. Il valore del parametro del token di fallback viene impostato come token per il metodo di implementazione.
• Un numero di classe per il risultato restituito.
• Un metodo statico per il risultato.

Per vedere un esempio delle informazioni precedenti in un'applicazione standard, si consiglia di esaminare la funzione Aggiorna elenco di entità nelle app per la finanza e le operazioni, area di lavoro Gestione dati, Parametri framework e Impostazioni entità.