Implementar el marco Async

Completado

Los procesos de larga duración pueden exceder el tiempo de espera en las aplicaciones de finanzas y operaciones. Para evitar este problema, el procesamiento asincrónico permite a los usuarios seguir trabajando mientras el proceso se ejecuta en segundo plano.

Por ejemplo, es posible que deba ejecutar el procesamiento en la aplicación que se ocupa de una gran cantidad de datos o transacciones, y no desea interrumpir los procesos de negocio diarios. Por lo tanto, puede usar el marco asincrónico para ejecutar estos procesos en segundo plano, mientras que los usuarios pueden continuar su trabajo sin ninguna interrupción.

A fin de ejecutar un proceso de forma asincrónica, debe usar los métodos runAsync de las clases FormRun y Global para llamar al método estático que desea ejecutar. Si el proceso se ejecuta en el lado del cliente, le recomendamos que utilice el método runAsync de la clase FormRun. La clase global tiene un método runAsync que recomendamos para ejecutar código fuera del cliente.

Puede usar un método de devolución de llamada para mostrar un mensaje cuando se haya completado el proceso. Solo el método runAsync de la clase FormRun muestra el mensaje de inmediato. Si usa el método runAsync de la clase Global, debe actualizar la página.

La firma del método estático debe cumplir con lo siguiente:

• Ser estática.
• Devolver un contenedor como parámetro de salida.
• Tener un contenedor para parámetros de entrada. El contenedor puede contener más valores si es necesario.
• Tener un token de cancelación para los parámetros de entrada.

En el siguiente ejemplo se muestra un método estático que puede utilizar como 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"];
    }

Puede utilizar otro método estático para el resultado, que es correcto o una excepción, y la firma debe cumplir con lo siguiente:

• Ser estática.
• Devolver "void".
• Tener AsyncTaskResult como parámetro de entrada.

A continuación, se muestra un ejemplo de un método estático para obtener un resultado:

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

Ahora, la función runAsync puede usar los dos métodos (las funciones sin un nombre de clase se definen en la clase global).

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

Los parámetros que utiliza la función runAsync deben tener los siguientes componentes:

• Número de clase de la clase que se va a ejecutar.
• Método estático que se ejecuta de forma asíncrona.
• Contenedor para parámetros de entrada. El valor de los parámetros del contenedor se establece como una lista de parámetros para el método de implementación.
• Token de reserva. El valor del parámetro del token de reserva se establece como un token para el método de implementación.
• Número de clase para el resultado devuelto.
• Método estático para el resultado.

Para revisar un ejemplo de la información anterior en una aplicación estándar, recomendamos que revise la función Actualizar lista de entidades en las aplicaciones de finanzas y operaciones, el espacio de trabajo Administración de datos, Parámetros de marco y Configuración de entidades.