Observable.FromAsyncPattern<T1, méthode TResult> (Func<T1, AsyncCallback, Object, IAsyncResult>, Func<IAsyncResult, TResult>)
Convertit une paire de fonctions d’appel Begin/End en fonction asynchrone.
Espace de noms :System.Reactive.Linq
Assemblée: System.Reactive (en System.Reactive.dll)
Syntaxe
'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.
Paramètres de type
- T1
Premier type de fonction.
- TResult
Type de résultat.
Paramètres
- begin
Type : System.Func<T1, AsyncCallback, Object, IAsyncResult>
Fonction begin invoke.
- end
Type : System.Func<IAsyncResult, TResult>
Fonction d’appel de fin.
Valeur de retour
Type : System.Func<T1, IObservable<TResult>>
Une paire de fonctions d’appel Début/Fin.
Notes
L’opérateur FromAsyncPattern est utilisé pour simplifier l’exécution d’appels asynchrones. Il encapsule un appel asynchrone pour commencer/terminer l’appel avec une fonction asynchrone qui gère l’appel asynchrone pour vous. La fonction retourne une séquence observable du même type que le résultat. Par exemple, vous pouvez configurer un appel asynchrone à System.IO.Directory.GetFiles. Le résultat de cette méthode est un tableau de chaînes qui contient la liste des fichiers demandés. Par conséquent, la fonction asynchrone retournée à partir de l’opérateur FromAsyncPattern retournerait une séquence observable de chaîne[]. Cela est illustré dans l’exemple de code de cette rubrique. Il existe différentes surcharges de cet opérateur pour gérer les appels de méthode qui prennent un nombre différent de paramètres d’entrée. Pour configurer un appel asynchrone, spécifiez les types avec l’appel de l’opérateur FromAsyncPattern. Le dernier type spécifié est le type de valeur de retour. Par exemple, System.IO.Directory.GetFiles peut prendre jusqu’à trois paramètres d’entrée et retourne un tableau de chaînes comme résultat. L’extrait de code suivant montre l’ordre des types.
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);
Exemples
Cet exemple montre comment appeler System.IO.Direcotry.GetFile de manière asynchrone pour énumérer tous les fichiers sous le répertoire C:\Program Files. L’exemple utilise la fonction asynchrone fournie par l’opérateur FromAsyncPattern. Un gestionnaire d’événements d’action agit comme rappel de l’appel asynchrone pour écrire chaque nom de fichier dans le résultat dans la fenêtre de console.
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();
}
}
}
L’exemple de sortie suivant est généré par l’exemple de code.
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