Condividi tramite

AsyncResult Classe

  • Riferimento

Definizione

Spazio dei nomi:
System.Runtime.Remoting.Messaging
Assembly:
mscorlib.dll

Incapsula i risultati di un'operazione asincrona su un delegato.

public ref class AsyncResult : IAsyncResult, System::Runtime::Remoting::Messaging::IMessageSink
public class AsyncResult : IAsyncResult, System.Runtime.Remoting.Messaging.IMessageSink
[System.Runtime.InteropServices.ComVisible(true)]
public class AsyncResult : IAsyncResult, System.Runtime.Remoting.Messaging.IMessageSink
type AsyncResult = class
    interface IAsyncResult
    interface IMessageSink
[<System.Runtime.InteropServices.ComVisible(true)>]
type AsyncResult = class
    interface IAsyncResult
    interface IMessageSink
Public Class AsyncResult
Implements IAsyncResult, IMessageSink
Ereditarietà
Object
AsyncResult
Attributi
ComVisibleAttribute
Implementazioni
IAsyncResult IMessageSink

Esempio

Nell'esempio seguente viene illustrato come usare la AsyncWaitHandle proprietà per ottenere un WaitHandleoggetto e come attendere una chiamata asincrona su un delegato. L'oggetto WaitHandle viene segnalato al completamento della chiamata asincrona ed è possibile attenderlo chiamando il metodo WaitOne .

L'esempio è costituito da due classi, la classe che contiene il metodo chiamato in modo asincrono e la classe che contiene il Main metodo che effettua la chiamata.

Per altre informazioni e altri esempi di chiamata asincrona dei metodi tramite delegati, vedere Chiamata asincrona di metodi sincroni.

using namespace System;
using namespace System::Threading;
using namespace System::Runtime::InteropServices; 

namespace Examples {
namespace AdvancedProgramming {
namespace AsynchronousOperations
{
    public ref class AsyncDemo 
    {
    public:
        // The method to be executed asynchronously.
        String^ TestMethod(int callDuration, [OutAttribute] int% threadId) 
        {
            Console::WriteLine("Test method begins.");
            Thread::Sleep(callDuration);
            threadId = Thread::CurrentThread->ManagedThreadId;
            return String::Format("My call time was {0}.", callDuration);
        }
    };

    // The delegate must have the same signature as the method
    // it will call asynchronously.
    public delegate String^ AsyncMethodCaller(int callDuration, [OutAttribute] int% threadId);
}}}

using System;
using System.Threading;

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    public class AsyncDemo
    {
        // The method to be executed asynchronously.
        public string TestMethod(int callDuration, out int threadId)
        {
            Console.WriteLine("Test method begins.");
            Thread.Sleep(callDuration);
            threadId = Thread.CurrentThread.ManagedThreadId;
            return String.Format("My call time was {0}.", callDuration.ToString());
        }
    }
    // The delegate must have the same signature as the method
    // it will call asynchronously.
    public delegate string AsyncMethodCaller(int callDuration, out int threadId);
}

Imports System.Threading
Imports System.Runtime.InteropServices 

Namespace Examples.AdvancedProgramming.AsynchronousOperations
    Public Class AsyncDemo 
        ' The method to be executed asynchronously.
        Public Function TestMethod(ByVal callDuration As Integer, _
                <Out> ByRef threadId As Integer) As String
            Console.WriteLine("Test method begins.")
            Thread.Sleep(callDuration)
            threadId = Thread.CurrentThread.ManagedThreadId()
            return String.Format("My call time was {0}.", callDuration.ToString())
        End Function
    End Class

    ' The delegate must have the same signature as the method
    ' it will call asynchronously.
    Public Delegate Function AsyncMethodCaller(ByVal callDuration As Integer, _
        <Out> ByRef threadId As Integer) As String
End Namespace

#using <TestMethod.dll>

using namespace System;
using namespace System::Threading;
using namespace Examples::AdvancedProgramming::AsynchronousOperations;

void main() 
{
    // The asynchronous method puts the thread id here.
    int threadId;

    // Create an instance of the test class.
    AsyncDemo^ ad = gcnew AsyncDemo();

    // Create the delegate.
    AsyncMethodCaller^ caller = gcnew AsyncMethodCaller(ad, &AsyncDemo::TestMethod);
       
    // Initiate the asychronous call.
    IAsyncResult^ result = caller->BeginInvoke(3000, 
        threadId, nullptr, nullptr);

    Thread::Sleep(0);
    Console::WriteLine("Main thread {0} does some work.",
        Thread::CurrentThread->ManagedThreadId);

    // Wait for the WaitHandle to become signaled.
    result->AsyncWaitHandle->WaitOne();

    // Perform additional processing here.
    // Call EndInvoke to retrieve the results.
    String^ returnValue = caller->EndInvoke(threadId, result);

    // Close the wait handle.
    result->AsyncWaitHandle->Close();

    Console::WriteLine("The call executed on thread {0}, with return value \"{1}\".",
        threadId, returnValue);
}

/* This example produces output similar to the following:

Main thread 1 does some work.
Test method begins.
The call executed on thread 3, with return value "My call time was 3000.".
 */

using System;
using System.Threading;

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    public class AsyncMain
    {
        static void Main()
        {
            // The asynchronous method puts the thread id here.
            int threadId;

            // Create an instance of the test class.
            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.
            AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

            // Initiate the asychronous call.
            IAsyncResult result = caller.BeginInvoke(3000,
                out threadId, null, null);

            Thread.Sleep(0);
            Console.WriteLine("Main thread {0} does some work.",
                Thread.CurrentThread.ManagedThreadId);

            // Wait for the WaitHandle to become signaled.
            result.AsyncWaitHandle.WaitOne();

            // Perform additional processing here.
            // Call EndInvoke to retrieve the results.
            string returnValue = caller.EndInvoke(out threadId, result);

            // Close the wait handle.
            result.AsyncWaitHandle.Close();

            Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".",
                threadId, returnValue);
        }
    }
}

/* This example produces output similar to the following:

Main thread 1 does some work.
Test method begins.
The call executed on thread 3, with return value "My call time was 3000.".
 */

Imports System.Threading
Imports System.Runtime.InteropServices 

Namespace Examples.AdvancedProgramming.AsynchronousOperations

    Public Class AsyncMain 
        Shared Sub Main() 
            ' The asynchronous method puts the thread id here.
            Dim threadId As Integer

            ' Create an instance of the test class.
            Dim ad As New AsyncDemo()

            ' Create the delegate.
            Dim caller As New AsyncMethodCaller(AddressOf ad.TestMethod)
       
            ' Initiate the asynchronous call.
            Dim result As IAsyncResult = caller.BeginInvoke(3000, _
                threadId, Nothing, Nothing)

            Thread.Sleep(0)
            Console.WriteLine("Main thread {0} does some work.", _
                Thread.CurrentThread.ManagedThreadId)
            ' Perform additional processing here and then
            ' wait for the WaitHandle to be signaled.
            result.AsyncWaitHandle.WaitOne()

            ' Call EndInvoke to retrieve the results.
            Dim returnValue As String = caller.EndInvoke(threadId, result)

            ' Close the wait handle.
            result.AsyncWaitHandle.Close()

            Console.WriteLine("The call executed on thread {0}, with return value ""{1}"".", _
                threadId, returnValue)
        End Sub
    End Class
End Namespace

'This example produces output similar to the following:
'
'Main thread 1 does some work.
'Test method begins.
'The call executed on thread 3, with return value "My call time was 3000.".

Commenti

La AsyncResult classe viene usata in combinazione con le chiamate di metodo asincrone effettuate tramite delegati. È IAsyncResult possibile eseguire il cast dell'oggetto restituito dal metodo del BeginInvoke delegato a un oggetto AsyncResult. Dispone AsyncResult della AsyncDelegate proprietà che contiene l'oggetto delegato in cui è stata richiamata la chiamata asincrona.

Per altre informazioni sulle BeginInvoke chiamate asincrone tramite delegati, vedere Programmazione asincrona tramite delegati.

Proprietà

AsyncDelegate

Ottiene l'oggetto delegato sul quale è stata richiamata la chiamata asincrona.
AsyncState

Ottiene l'oggetto fornito come ultimo parametro di una chiamata di metodo BeginInvoke.
AsyncWaitHandle

Ottiene un oggetto WaitHandle che incapsula handle di sincronizzazione Win32 e consente l'implementazione di vari schemi di sincronizzazione.
CompletedSynchronously

Ottiene un valore che indica se la chiamata BeginInvoke è stata completata in modo sincrono.
EndInvokeCalled

Ottiene o imposta un valore che indica se EndInvoke è stato chiamato sul AsyncResult corrente.
IsCompleted

Ottiene un valore che indica se il server ha completato la chiamata.
NextSink

Ottiene il successivo sink di messaggi nella catena di sink.

Metodi

AsyncProcessMessage(IMessage, IMessageSink)

Implementa l'interfaccia IMessageSink.
Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetReplyMessage()

Ottiene il messaggio di risposta per la chiamata asincrona.
GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
SetMessageCtrl(IMessageCtrl)

Imposta un oggetto IMessageCtrl per la chiamata corrente al metodo remoto, che consente di controllare i messaggi asincroni dopo il loro invio.
SyncProcessMessage(IMessage)

Elabora in modo sincrono il messaggio di risposta restituito da una chiamata di metodo su un oggetto remoto.
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)

Si applica a

Vedi anche