VSoft.Awaitable

Vsoft.awaitable

Esta é uma biblioteca simples para fazer chamadas de função assíncrona. É um invólucro sobre o omnithreadlibrary e é baseado em sua própria funcionalidade paralela.

Parallel.async não fornece uma maneira simples de cancelar chamadas e ser notificada do cancelamento e não permite o retorno dos resultados.

Uso

Inclua vsoft.awaitable em sua cláusula de uso.

    TAsync.Configure<string>(
        function ( const cancelToken : ICancellationToken) : string
        var
          i: Integer;
        begin
            result := ' Hello ' + value ;
            for i := 0 to 2000 do
            begin
              Sleep( 1 );
              // in loops, check the token
              if cancelToken.IsCancelled then
                exit;
            end ;

            // where api's can take a handle for cancellation, use the token.handle
            WaitForSingleObject(cancelToken.Handle, 5000 );

            // any unhandled exceptions here will result in the on exception proc being called (if configured)
            // raise Exception.Create('Error Message');
        end , token);
    )
    .OnException(
        procedure ( const e : Exception)
        begin
          Label1.Caption := e.Message;
        end )
    .OnCancellation(
        procedure
        begin
            // clean up
            Label1.Caption := ' Cancelled ' ;
        end )
    .Await(
        procedure ( const value : string)
        begin
            // use result
            Label1.Caption := value ;
        end );

Você também pode devolver IAwaitable<TResult> de funções

 function LoadAsyncWithToken ( const token : ICancellationToken; const value : string) : IAwaitable<string>;
begin
  // configure our async call and return the IAwaitable<string>
  result := TAsync.Configure<string>(
        function( const cancelToken : ICancellationToken) : string
        begin
            // .... do some long running thing
            result := ' Hello ' + value ;
        end , token);
end ;

// for when there is no result to return
function RunIt ( const token : ICancellationToken; const value : string) : IAwaitable;
begin
  // configure our async call and return the IAwaitable<string>
  result := TAsync.Configure(
        procedure( const cancelToken : ICancellationToken)
        begin
        // .... do some long running thing
        end , token);
end ;


procedure UseIt ;
begin
     LoadAsyncWithToken( ' param ' , FTokenSource.Token)
     .OnException(
        procedure ( const e : Exception)
        begin
          Label1.Caption := e.Message;
        end )
    .OnCancellation(
        procedure
        begin
            // clean up
            Label1.Caption := ' Cancelled ' ;
        end )
    .Await(
        procedure ( const value : string)
        begin
            // use result
            Label1.Caption := value ;
        end );

     RunIt( ' param ' , FTokenSource.Token)
     .OnException(
        procedure ( const e : Exception)
        begin
          Label1.Caption := e.Message;
        end )
    .OnCancellation(
        procedure
        begin
            // clean up
            Label1.Caption := ' Cancelled ' ;
        end )
    .Await(
        procedure
        begin
            // use result
            Label1.Caption := ' Done ' ;
        end );

Observe que aguarda realmente chama a função assíncrona. Há também uma sobrecarga no Tasync.Configure que não leva um token de cancelamento para quando você não precisa cancelar.