AsyncResult AsyncResult AsyncResult AsyncResult Class

Definición

Encapsula los resultados de una operación asincrónica en un delegado.Encapsulates the results of an asynchronous operation on a delegate.

public ref 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
Public Class AsyncResult
Implements IAsyncResult, IMessageSink
Herencia
AsyncResultAsyncResultAsyncResultAsyncResult
Atributos
Implementaciones

Ejemplos

En el ejemplo siguiente se muestra cómo usar el AsyncWaitHandle propiedad va a obtener un WaitHandley cómo esperar una llamada asincrónica en un delegado.The following example demonstrates how to use the AsyncWaitHandle property to get a WaitHandle, and how to wait for an asynchronous call on a delegate. WaitHandle se señaliza cuando finaliza la llamada asincrónica y puede esperar a que termine llamando al método WaitOne .The WaitHandle is signaled when the asynchronous call completes, and you can wait for it by calling the WaitOne method.

El ejemplo consta de dos clases, la clase que contiene el método que se llama de forma asincrónica, y la clase que contiene el Main método que realiza la llamada.The example consists of two classes, the class that contains the method which is called asynchronously, and the class that contains the Main method that makes the call.

Para obtener más información y más ejemplos de llamar a métodos de forma asincrónica mediante delegados, vea Calling Synchronous Methods Asynchronously.For more information and more examples of calling methods asynchronously by using delegates, see Calling Synchronous Methods Asynchronously.

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
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
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.".

Comentarios

La AsyncResult clase se utiliza en combinación con llamadas a métodos asincrónicos realizadas mediante delegados.The AsyncResult class is used in conjunction with asynchronous method calls made using delegates. El IAsyncResult devuelto desde el delegado BeginInvoke método puede convertirse en un AsyncResult.The IAsyncResult returned from the delegate's BeginInvoke method can be cast to an AsyncResult. El AsyncResult tiene la AsyncDelegate objeto de propiedad que contiene el delegado que se ha invocado la llamada asincrónica.The AsyncResult has the AsyncDelegate property that holds the delegate object on which the asynchronous call was invoked.

Para obtener más información acerca de BeginInvoke y llamadas asincrónicas mediante delegados, vea Asynchronous Programming Using Delegates.For more information about BeginInvoke and asynchronous calls using delegates, see Asynchronous Programming Using Delegates.

Propiedades

AsyncDelegate AsyncDelegate AsyncDelegate AsyncDelegate

Obtiene el objeto delegado en el que se ha invocado la llamada asincrónica.Gets the delegate object on which the asynchronous call was invoked.

AsyncState AsyncState AsyncState AsyncState

Obtiene el objeto proporcionado como el último parámetro de una llamada al método BeginInvoke.Gets the object provided as the last parameter of a BeginInvoke method call.

AsyncWaitHandle AsyncWaitHandle AsyncWaitHandle AsyncWaitHandle

Obtiene un WaitHandle que encapsula identificadores de sincronización Win32, y permite la implementación de varios esquemas de sincronización.Gets a WaitHandle that encapsulates Win32 synchronization handles, and allows the implementation of various synchronization schemes.

CompletedSynchronously CompletedSynchronously CompletedSynchronously CompletedSynchronously

Obtiene un valor que indica si la llamada de BeginInvoke ha finalizado de forma sincrónica.Gets a value indicating whether the BeginInvoke call completed synchronously.

EndInvokeCalled EndInvokeCalled EndInvokeCalled EndInvokeCalled

Obtiene o establece un valor que indica si se ha llamado a EndInvoke en el AsyncResult actual.Gets or sets a value indicating whether EndInvoke has been called on the current AsyncResult.

IsCompleted IsCompleted IsCompleted IsCompleted

Obtiene un valor que indica si el servidor ha completado la llamada.Gets a value indicating whether the server has completed the call.

NextSink NextSink NextSink NextSink

Obtiene el siguiente receptor de mensajes en la cadena de receptores.Gets the next message sink in the sink chain.

Métodos

AsyncProcessMessage(IMessage, IMessageSink) AsyncProcessMessage(IMessage, IMessageSink) AsyncProcessMessage(IMessage, IMessageSink) AsyncProcessMessage(IMessage, IMessageSink)

Implementa la interfaz IMessageSink.Implements the IMessageSink interface.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Inherited from Object)
GetReplyMessage() GetReplyMessage() GetReplyMessage() GetReplyMessage()

Obtiene el mensaje de respuesta para la llamada asincrónica.Gets the response message for the asynchronous call.

GetType() GetType() GetType() GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

(Inherited from Object)
SetMessageCtrl(IMessageCtrl) SetMessageCtrl(IMessageCtrl) SetMessageCtrl(IMessageCtrl) SetMessageCtrl(IMessageCtrl)

Establece IMessageCtrl para la llamada a método remoto actual, que proporciona una manera de controlar los mensajes asincrónicos una vez enviados.Sets an IMessageCtrl for the current remote method call, which provides a way to control asynchronous messages after they have been dispatched.

SyncProcessMessage(IMessage) SyncProcessMessage(IMessage) SyncProcessMessage(IMessage) SyncProcessMessage(IMessage)

Procesa sincrónicamente un mensaje de respuesta devuelto por una llamada a método en un objeto remoto.Synchronously processes a response message returned by a method call on a remote object.

ToString() ToString() ToString() ToString()

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Inherited from Object)

Se aplica a

Consulte también: