Observable.FromAsyncPattern<T1, TResult-Methode> (Func<T1, AsyncCallback, Object, IAsyncResult>, Func<IAsyncResult, TResult>)
Konvertiert ein Begin/End-Aufruffunktionspaar in eine asynchrone Funktion.
Namespace:System.Reactive.Linq
Versammlung: System.Reactive (in System.Reactive.dll)
Syntax
'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.
Typparameter
- T1
Der erste Funktionstyp.
- TResult
Der Typ des Ergebnisses.
Parameter
- begin
Typ: System.Func<T1, AsyncCallback, Object, IAsyncResult>
Die begin-Invoke-Funktion.
- end
Typ: System.Func<IAsyncResult, TResult>
Die End invoke-Funktion.
Rückgabewert
Typ: System.Func<T1, IObservable<TResult>>
Ein Begin/End-Aufruffunktionspaar.
Bemerkungen
Der FromAsyncPattern-Operator wird verwendet, um asynchrone Aufrufe zu vereinfachen. Es umschließt einen asynchronen Aufruf für den Start-/End-Aufruf mit einer asynchronen Funktion, die den asynchronen Aufruf für Sie verarbeitet. Die Funktion gibt eine beobachtbare Sequenz zurück, die vom gleichen Typ wie das Ergebnis ist. Sie können beispielsweise einen asynchronen Aufruf von System.IO.Directory.GetFiles einrichten. Das Ergebnis dieser Methode ist ein Zeichenfolgenarray, das die Liste der angeforderten Dateien enthält. Daher würde die vom FromAsyncPattern-Operator zurückgegebene asynchrone Funktion eine beobachtbare Sequenz von string[] zurückgeben. Dies wird im Beispielcode für dieses Thema veranschaulicht. Es gibt verschiedene Überladungen dieses Operators, um Methodenaufrufe zu verarbeiten, die eine andere Anzahl von Eingabeparametern annehmen. Geben Sie zum Einrichten eines asynchronen Aufrufs die Typen mit dem Aufruf des FromAsyncPattern-Operators an. Der letzte angegebene Typ ist der Rückgabewerttyp. System.IO.Directory.GetFiles kann beispielsweise bis zu drei Eingabeparameter verwenden und als Ergebnis ein Zeichenfolgenarray zurückgeben. Der folgende Codeausschnitt zeigt die Reihenfolge der Typen.
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);
Beispiele
In diesem Beispiel wird das asynchrone Aufrufen von System.IO.Direcotry.GetFile veranschaulicht, um alle Dateien im Verzeichnis C:\Program Files aufzulisten. Im Beispiel wird die asynchrone Funktion verwendet, die vom FromAsyncPattern-Operator bereitgestellt wird. Ein Aktionsereignishandler fungiert als Rückruf für den asynchronen Aufruf, um die einzelnen Dateinamen im Ergebnis in das Konsolenfenster zu schreiben.
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();
}
}
}
Die folgende Beispielausgabe wird vom Beispielcode generiert.
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