AsyncResult 类

项目
08/17/2007

封装异步委托上的异步操作的结果。

**命名空间:**System.Runtime.Remoting.Messaging
**程序集:**mscorlib（在 mscorlib.dll 中）

语法

声明
<ComVisibleAttribute(True)> _
Public Class AsyncResult
    Implements IAsyncResult, IMessageSink
用法
Dim instance As AsyncResult

[ComVisibleAttribute(true)] 
public class AsyncResult : IAsyncResult, IMessageSink

[ComVisibleAttribute(true)] 
public ref class AsyncResult : IAsyncResult, IMessageSink

/** @attribute ComVisibleAttribute(true) */ 
public class AsyncResult implements IAsyncResult, IMessageSink

ComVisibleAttribute(true) 
public class AsyncResult implements IAsyncResult, IMessageSink

备注

AsyncResult 类与异步委托一起使用。从该委托的 BeginInvoke 方法返回的 IAsyncResult 可以强制转换为 AsyncResult。AsyncResult 具有 AsyncDelegate 属性，该属性保存在其上调用异步调用的委托对象。

有关 BeginInvoke 和异步委托的更多信息，请参见使用委托进行异步编程。

示例

下面的代码示例说明如何使用 AsyncResult 类检索异步委托上的异步操作的结果。

Imports System
Imports System.Threading
Imports System.Runtime.Remoting
Imports System.Runtime.Remoting.Contexts
Imports System.Runtime.Remoting.Messaging


' Context-bound type with the Synchronization context attribute.
<Synchronization()> Public Class SampleSyncronized
   Inherits ContextBoundObject
   
   ' A method that does some work, and returns the square of the given number.
   Public Function Square(i As Integer) As Integer
      
      Console.Write("The hash of the thread executing ")
      Console.WriteLine("SampleSyncronized.Square is: {0}", Thread.CurrentThread.GetHashCode())
      Return i * i
   End Function 'Square

End Class 'SampleSyncronized

' The async delegate used to call a method with this signature asynchronously.
Delegate Function SampSyncSqrDelegate(i As Integer) As Integer


Public Class AsyncResultSample
   
   ' Asynchronous Callback method.
   Public Shared Sub MyCallback(ar As IAsyncResult)
      ' Obtains the last parameter of the delegate call.
      Dim value As Integer = Convert.ToInt32(ar.AsyncState)
      
      ' Obtains return value from the delegate call using EndInvoke.
      Dim aResult As AsyncResult = CType(ar, AsyncResult)
      Dim temp As SampSyncSqrDelegate = CType(aResult.AsyncDelegate, SampSyncSqrDelegate)
      Dim result As Integer = temp.EndInvoke(ar)
      
      Console.Write("Simple.SomeMethod (AsyncCallback): Result of ")
      Console.WriteLine("{0} in SampleSynchronized.Square is {1} ", value, result)
   End Sub 'MyCallback  

   Public Shared Sub Main()
      
      Dim result As Integer
      Dim param As Integer
      
      ' Creates an instance of a context-bound type SampleSynchronized.
      Dim sampSyncObj As New SampleSyncronized()
      
      ' Checks whether the object is a proxy, since it is context-bound.
      If RemotingServices.IsTransparentProxy(sampSyncObj) Then
         Console.WriteLine("sampSyncObj is a proxy.")
      Else
         Console.WriteLine("sampSyncObj is NOT a proxy.")
      End If 

      param = 10
      
      Console.WriteLine("")
      Console.WriteLine("Making a synchronous call on the context-bound object:")
      
      result = sampSyncObj.Square(param)
      Console.Write("The result of calling sampSyncObj.Square with ")
      Console.WriteLine("{0} is {1}.", param, result)
      Console.WriteLine("")     

      Dim sampleDelegate As New SampSyncSqrDelegate(AddressOf sampSyncObj.Square)
      param = 8
      
      Console.WriteLine("Making a single asynchronous call on the context-bound object:")
      
      Dim ar1 As IAsyncResult = sampleDelegate.BeginInvoke(param, New AsyncCallback(AddressOf AsyncResultSample.MyCallback), param)
      
      Console.WriteLine("Waiting for the asynchronous call to complete...")
      Dim wh As WaitHandle = ar1.AsyncWaitHandle
      wh.WaitOne()
      
      Console.WriteLine("")
      Console.WriteLine("Waiting for the AsyncCallback to complete...")
      Thread.Sleep(1000)
   End Sub 'Main 
End Class 'AsyncResultSample

using System;
using System.Threading;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Contexts;
using System.Runtime.Remoting.Messaging;

// Context-bound type with the Synchronization context attribute.
[Synchronization()]
public class SampleSyncronized : ContextBoundObject {

    // A method that does some work, and returns the square of the given number.
    public int Square(int i)  {

        Console.Write("The hash of the thread executing ");
        Console.WriteLine("SampleSyncronized.Square is: {0}", 
                             Thread.CurrentThread.GetHashCode());
        return i*i;
    }
}

// The async delegate used to call a method with this signature asynchronously.
public delegate int SampSyncSqrDelegate(int i);

public class AsyncResultSample {

    // Asynchronous Callback method.
    public static void MyCallback(IAsyncResult ar) {

        // Obtains the last parameter of the delegate call.
        int value = Convert.ToInt32(ar.AsyncState);

        // Obtains return value from the delegate call using EndInvoke.
        AsyncResult aResult = (AsyncResult)ar;
        SampSyncSqrDelegate temp = (SampSyncSqrDelegate)aResult.AsyncDelegate;
        int result = temp.EndInvoke(ar);

        Console.Write("Simple.SomeMethod (AsyncCallback): Result of ");
        Console.WriteLine("{0} in SampleSynchronized.Square is {1} ", value, result);
    }

    public static void Main() {

        int result;
        int param;

        // Creates an instance of a context-bound type SampleSynchronized.
        SampleSyncronized sampSyncObj = new SampleSyncronized();

        // Checks whether the object is a proxy, since it is context-bound.
        if (RemotingServices.IsTransparentProxy(sampSyncObj))
            Console.WriteLine("sampSyncObj is a proxy.");
        else
            Console.WriteLine("sampSyncObj is NOT a proxy.");

        param = 10;

        Console.WriteLine("");
        Console.WriteLine("Making a synchronous call on the context-bound object:");

        result = sampSyncObj.Square(param);
        Console.Write("The result of calling sampSyncObj.Square with ");
        Console.WriteLine("{0} is {1}.", param, result);
        Console.WriteLine("");

        SampSyncSqrDelegate sampleDelegate = new SampSyncSqrDelegate(sampSyncObj.Square);
        param = 8;

        Console.WriteLine("Making a single asynchronous call on the context-bound object:");

        IAsyncResult ar1 = sampleDelegate.BeginInvoke( param, 
                              new AsyncCallback(AsyncResultSample.MyCallback), 
                              param);

        Console.WriteLine("Waiting for the asynchronous call to complete...");
        WaitHandle wh = ar1.AsyncWaitHandle;
        wh.WaitOne();

        Console.WriteLine("");
        Console.WriteLine("Waiting for the AsyncCallback to complete...");
        Thread.Sleep(1000);
    }
}

using namespace System;
using namespace System::Threading;
using namespace System::Runtime::Remoting;
using namespace System::Runtime::Remoting::Contexts;
using namespace System::Runtime::Remoting::Messaging;

// Context-bound type with the Synchronization context attribute.

[Synchronization]
public ref class SampleSyncronized: public ContextBoundObject
{
public:

   // A method that does some work, and returns the square of the given number.
   int Square( int i )
   {
      Console::Write( "The hash of the thread executing " );
      Console::WriteLine( "SampleSyncronized::Square is: {0}", Thread::CurrentThread->GetHashCode() );
      return i * i;
   }

};

// The async delegate used to call a method with this signature asynchronously.
int i );
public ref class AsyncResultSample
{
public:

   // Asynchronous Callback method.
   static void MyCallback( IAsyncResult^ ar )
   {
      
      // Obtains the last parameter of the delegate call.
      int value = Convert::ToInt32( ar->AsyncState );
      
      // Obtains return value from the delegate call using EndInvoke.
      AsyncResult^ aResult = dynamic_cast<AsyncResult^>(ar);
      SampSyncSqrDelegate^ temp = static_cast<SampSyncSqrDelegate^>(aResult->AsyncDelegate);
      int result = temp->EndInvoke( ar );
      Console::Write( "Simple::SomeMethod (AsyncCallback): Result of " );
      Console::WriteLine( " {0} in SampleSynchronized::Square is {1} ", value, result );
   }

};

int main()
{
   int result;
   int param;
   
   // Creates an instance of a context-bound type SampleSynchronized.
   SampleSyncronized^ sampSyncObj = gcnew SampleSyncronized;
   
   // Checks whether the Object* is a proxy, since it is context-bound.
   if ( RemotingServices::IsTransparentProxy( sampSyncObj ) )
      Console::WriteLine( "sampSyncObj is a proxy." );
   else
      Console::WriteLine( "sampSyncObj is NOT a proxy." );

   
   param = 10;
   Console::WriteLine( "" );
   Console::WriteLine( "Making a synchronous call on the context-bound Object*:" );
   result = sampSyncObj->Square( param );
   Console::Write( "The result of calling sampSyncObj.Square with " );
   Console::WriteLine( " {0} is {1}.", param, result );
   Console::WriteLine( "" );
   
   SampSyncSqrDelegate^ sampleDelegate = gcnew SampSyncSqrDelegate( sampSyncObj, &SampleSyncronized::Square );
   param = 8;
   Console::WriteLine( "Making a single asynchronous call on the context-bound Object*:" );
   IAsyncResult^ ar1 = sampleDelegate->BeginInvoke( param, gcnew AsyncCallback( AsyncResultSample::MyCallback ), param );
   Console::WriteLine( "Waiting for the asynchronous call to complete..." );
   WaitHandle^ wh = ar1->AsyncWaitHandle;
   wh->WaitOne();
   Console::WriteLine( "" );
   Console::WriteLine( "Waiting for the AsyncCallback to complete..." );
   Thread::Sleep( 1000 );
   return 0;
   
}

import System.*;
import System.Threading.*;
import System.Runtime.Remoting.*;
import System.Runtime.Remoting.Contexts.*;
import System.Runtime.Remoting.Messaging.*;

// Context-bound type with the Synchronization context attribute.
/** @attribute Synchronization()
 */
public class SampleSyncronized extends ContextBoundObject
{
    // A method that does some work, and returns the square of the given number.
    public int Square(int i)
    {
        Console.Write("The hash of the thread executing ");
        Console.WriteLine("SampleSyncronized.Square is: {0}",
            (Int32)System.Threading.Thread.get_CurrentThread().GetHashCode());
        return i * i;
    } //Square
} //SampleSyncronized

// The async delegate used to call a method with this signature asynchronously.
/** @delegate 
 */
public delegate int SampSyncSqrDelegate(int i);

public class AsyncResultSample
{
    static int value;
    // Asynchronous Callback method.
    public static void MyCallback(IAsyncResult ar)
    {
        // Obtains the last parameter of the delegate call.
        SampSyncSqrDelegate sampDelg = (SampSyncSqrDelegate)ar.get_AsyncState();
        
        // Obtains return value from the delegate call using EndInvoke.
        AsyncResult aResult = (AsyncResult)ar;
        SampSyncSqrDelegate temp =
            (SampSyncSqrDelegate)(aResult.get_AsyncDelegate());
        int threadId = AppDomain.GetCurrentThreadId();
        int result = temp.EndInvoke(ar);

        Console.Write("Simple.SomeMethod (AsyncCallback): Result of ");
        Console.WriteLine("{0} in SampleSynchronized.Square is {1} ",
            (Int32)value, (Int32)result);
    } //MyCallback

    public static void main(String[] args)
    {
        int result;
        int param;
        // Creates an instance of a context-bound type SampleSynchronized.
        SampleSyncronized sampSyncObj = new SampleSyncronized();
        // Checks whether the object is a proxy, since it is context-bound.
        if (RemotingServices.IsTransparentProxy(sampSyncObj)) {
            Console.WriteLine("sampSyncObj is a proxy.");
        }
        else {
            Console.WriteLine("sampSyncObj is NOT a proxy.");
        }

        param = 10;
        Console.WriteLine("");
        Console.WriteLine("Making a synchronous call on the context-bound "
            + "object:");
        result = sampSyncObj.Square(param);
        Console.Write("The result of calling sampSyncObj.Square with ");
        Console.WriteLine("{0} is {1}.", (Int32)param, (Int32)result);
        Console.WriteLine("");

        SampSyncSqrDelegate sampleDelegate =
            new SampSyncSqrDelegate(sampSyncObj.Square);
        param = 8;
        value = param;
        Console.WriteLine("Making a single asynchronous call on the "
            + "context-bound object:");
        IAsyncResult ar1 = sampleDelegate.BeginInvoke(param,
            new AsyncCallback(AsyncResultSample.MyCallback), sampleDelegate);

        Console.WriteLine("Waiting for the asynchronous call to complete...");
        WaitHandle wh = ar1.get_AsyncWaitHandle();

        wh.WaitOne();
        Console.WriteLine("");
        Console.WriteLine("Waiting for the AsyncCallback to complete...");
        System.Threading.Thread.Sleep(1000);
    } //main 
} //AsyncResultSample

继承层次结构

System.Object
System.Runtime.Remoting.Messaging.AsyncResult

线程安全

此类型的任何公共静态（Visual Basic 中的 Shared）成员都是线程安全的，但不保证所有实例成员都是线程安全的。

平台

Windows 98、Windows 2000 SP4、Windows Millennium Edition、Windows Server 2003、Windows XP Media Center Edition、Windows XP Professional x64 Edition、Windows XP SP2、Windows XP Starter Edition

.NET Framework 并不是对每个平台的所有版本都提供支持。有关受支持版本的列表，请参见系统要求。

Share via

AsyncResult 类

语法

备注

示例

继承层次结构

线程安全

平台

版本信息

.NET Framework

请参见

参考

其他资源

其他资源