Compartir a través de

Observable.FromAsyncPattern<T1, método TResult (Func<T1, AsyncCallback, Object, IAsyncResult>, Func<IAsyncResult>, TResult>)

Convierte un par de función de invocación Begin/End en una función asincrónica.

Espacio de nombres:System.Reactive.Linq
Ensamblaje: System.Reactive (en System.Reactive.dll)

Sintaxis

'Declaration
Public Shared Function FromAsyncPattern(Of T1, TResult) ( _
    begin As Func(Of T1, AsyncCallback, Object, IAsyncResult), _
    end As Func(Of IAsyncResult, TResult) _
) As Func(Of T1, IObservable(Of TResult))

'Usage
Dim begin As Func(Of T1, AsyncCallback, Object, IAsyncResult)
Dim end As Func(Of IAsyncResult, TResult)
Dim returnValue As Func(Of T1, IObservable(Of TResult))

returnValue = Observable.FromAsyncPattern(begin, _
    end)

public static Func<T1, IObservable<TResult>> FromAsyncPattern<T1, TResult>(
    Func<T1, AsyncCallback, Object, IAsyncResult> begin,
    Func<IAsyncResult, TResult> end
)

public:
generic<typename T1, typename TResult>
static Func<T1, IObservable<TResult>^>^ FromAsyncPattern(
    Func<T1, AsyncCallback^, Object^, IAsyncResult^>^ begin, 
    Func<IAsyncResult^, TResult>^ end
)

static member FromAsyncPattern : 
        begin:Func<'T1, AsyncCallback, Object, IAsyncResult> * 
        end:Func<IAsyncResult, 'TResult> -> Func<'T1, IObservable<'TResult>> 

JScript does not support generic types and methods.

Parámetros de tipo

  • T1
    Primer tipo de función.
  • TResult
    Tipo de resultado.

Parámetros

Valor devuelto

Tipo: System.Func<T1, IObservable<TResult>>
Par de función de invocación Begin/End.

Comentarios

El operador FromAsyncPattern se usa para simplificar la realización de llamadas asincrónicas. Encapsula una llamada asincrónica para comenzar o finalizar la invocación con una función asincrónica que controla la llamada asincrónica automáticamente. La función devuelve una secuencia observable que es del mismo tipo que el resultado. Por ejemplo, podría configurar una llamada asincrónica a System.IO.Directory.GetFiles. El resultado de ese método es una matriz de cadenas que contiene la lista de archivos solicitados. Por lo tanto, la función asincrónica devuelta desde el operador FromAsyncPattern devolvería una secuencia observable de cadena[]. Esto se muestra en el código de ejemplo de este tema. Hay varias sobrecargas de este operador para controlar las llamadas de método que toman un número diferente de parámetros de entrada. Para configurar una llamada asincrónica, especifique los tipos con la llamada al operador FromAsyncPattern. El tipo final especificado es el tipo de valor devuelto. Por ejemplo, System.IO.Directory.GetFiles puede tomar hasta tres parámetros de entrada y devuelve una matriz de cadenas como resultado. El siguiente fragmento de código muestra el orden de los tipos.

delegate string[] GetFilesDelegate(string searchPath, string searchPattern, SearchOption searchOption);


GetFilesDelegate getFiles = Directory.GetFiles;


//**************************************************************************************************//
//***  Observable.FromAsyncPattern<Param 1 Type, Param 2 Type, Param 3 Type, Return value type>  ***//
//**************************************************************************************************//
var getFileList = Observable.FromAsyncPattern<string, string, SearchOption, string[]>(getFiles.BeginInvoke, getFiles.EndInvoke);

Ejemplos

En este ejemplo se muestra cómo llamar a System.IO.Direcotry.GetFile de forma asincrónica para enumerar todos los archivos en el directorio C:\Archivos de programa. En el ejemplo se usa la función asincrónica proporcionada por el operador FromAsyncPattern. Un controlador de eventos de acción actúa como la devolución de llamada de la llamada asincrónica para escribir cada nombre de archivo en el resultado en la ventana de la consola.

using System;
using System.Reactive.Linq;
using System.IO;

namespace Example
{                                       
  delegate string[] GetFilesDelegate(string searchPath, string searchPattern, SearchOption searchOption);

  class Program
  {
    static void Main()
    {                                                                                                                    
      //********************************************************************************************************************//
      //*** For this example, Reactive Extensions is used to wrap an asynchronous call that recursively enumerates files ***//
      //*** in a given directory.                                                                                        ***//
      //********************************************************************************************************************//
      string mySearchPath = "C:\\Program Files";                                                                                   
      GetFilesDelegate getFiles = Directory.GetFiles;


      //*****************************************************************************************************************************//
      //*** Reactive Extensions will wrap the asynchronous call to the delegate returning the asynchronous function, getFileList. ***//
      //*** Calling the asynchronous function returns the observable sequence of the string[].                                    ***//
      //***                                                                                                                       ***//
      //*** There are many overloaded versions of the FromAsyncPattern operator. The types signified here are based on parameters ***//
      //*** in the signature of actual method being called asynchronously. The types are specified in their proper order followed ***//
      //*** by the return type (ex. <Param 1 type, Param 2 type, Param 3 type, return type> ).                                    ***//
      //*****************************************************************************************************************************//
      var getFileList = Observable.FromAsyncPattern<string, string, SearchOption, string[]>(getFiles.BeginInvoke, getFiles.EndInvoke);    
      IObservable<string[]> fileObservable = getFileList(mySearchPath,"*.*",SearchOption.AllDirectories);


      //*********************************************************************************************************************//
      //*** We subscribe to this sequence with an action event handler defined with the lambda expression. It acts as the ***//
      //*** callback for completion of the asynchronous operation.                                                        ***//
      //*********************************************************************************************************************//
      fileObservable.Subscribe(fileList =>
      {
        foreach (string f in fileList)
        {
          Console.WriteLine(f.ToString());
        }
      });


      Console.WriteLine("Running async enumeration of the {0} directory.\n\nPress ENTER to cancel...\n",mySearchPath);
      Console.ReadLine();
    }
  }
}

El código de ejemplo genera la siguiente salida de ejemplo.

Running async enumeration of the C:\Program Files directory.

Press ENTER to cancel...

C:\Program Files\desktop.ini
C:\Program Files\ATI\CIM\Bin64\atdcm64a.sys
C:\Program Files\ATI\CIM\Bin64\ATILog.dll
C:\Program Files\ATI\CIM\Bin64\ATIManifestDLMExt.dll
C:\Program Files\ATI\CIM\Bin64\ATISetup.exe
C:\Program Files\ATI\CIM\Bin64\CompressionDLMExt.dll
C:\Program Files\ATI\CIM\Bin64\CRCVerDLMExt.dll
C:\Program Files\ATI\CIM\Bin64\DetectionManager.dll
C:\Program Files\ATI\CIM\Bin64\difxapi.dll
C:\Program Files\ATI\CIM\Bin64\DLMCom.dll
C:\Program Files\ATI\CIM\Bin64\EncryptionDLMExt.dll
C:\Program Files\ATI\CIM\Bin64\InstallManager.dll
C:\Program Files\ATI\CIM\Bin64\InstallManagerApp.exe
C:\Program Files\ATI\CIM\Bin64\InstallManagerApp.exe.manifest
C:\Program Files\ATI\CIM\Bin64\LanguageMgr.dll
C:\Program Files\ATI\CIM\Bin64\mfc80u.dll
C:\Program Files\ATI\CIM\Bin64\Microsoft.VC80.ATL.manifest
C:\Program Files\ATI\CIM\Bin64\Microsoft.VC80.CRT.manifest
C:\Program Files\ATI\CIM\Bin64\Microsoft.VC80.MFC.manifest
C:\Program Files\ATI\CIM\Bin64\Microsoft.VC80.MFCLOC.manifest
C:\Program Files\ATI\CIM\Bin64\Microsoft.VC80.OpenMP.manifest
C:\Program Files\ATI\CIM\Bin64\msvcp80.dll
C:\Program Files\ATI\CIM\Bin64\msvcr80.dll
C:\Program Files\ATI\CIM\Bin64\PackageManager.dll
C:\Program Files\ATI\CIM\Bin64\readme.rtf
C:\Program Files\ATI\CIM\Bin64\SetACL64.exe

Consulte también

Referencia

Observable (clase)

Sobrecarga fromAsyncPattern

Espacio de nombres System.Reactive.Linq

  • Last updated on