AsyncCallback 委托

定义

引用在相应异步操作完成时调用的方法。

public delegate void AsyncCallback(IAsyncResult ^ ar);
public delegate void AsyncCallback(IAsyncResult ar);
[System.Serializable]
public delegate void AsyncCallback(IAsyncResult ar);
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public delegate void AsyncCallback(IAsyncResult ar);
type AsyncCallback = delegate of IAsyncResult -> unit
[<System.Serializable>]
type AsyncCallback = delegate of IAsyncResult -> unit
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type AsyncCallback = delegate of IAsyncResult -> unit
Public Delegate Sub AsyncCallback(ar As IAsyncResult)

参数

ar
IAsyncResult

异步操作的结果。

属性

示例

下面的代码示例展示了如何使用 Dns 类中的异步方法,检索用户指定计算机的域名系统 (DNS) 信息。 此示例创建引用 ProcessDnsInformation 方法的 AsyncCallback 委托。 每次异步请求获取 DNS 信息,都会调用一次此方法。

/*
The following example demonstrates using asynchronous methods to
get Domain Name System information for the specified host computers.
This example uses a delegate to obtain the results of each asynchronous
operation.
*/

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Collections.Specialized;
using System.Collections;

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    public class UseDelegateForAsyncCallback
    {
        static int requestCounter;
        static ArrayList hostData = new ArrayList();
        static StringCollection hostNames = new StringCollection();
        static void UpdateUserInterface()
        {
            // Print a message to indicate that the application
            // is still working on the remaining requests.
            Console.WriteLine("{0} requests remaining.", requestCounter);
        }
        public static void Main()
        {
            // Create the delegate that will process the results of the
            // asynchronous request.
            AsyncCallback callBack = new AsyncCallback(ProcessDnsInformation);
            string host;
            do
            {
                Console.Write(" Enter the name of a host computer or <enter> to finish: ");
                host = Console.ReadLine();
                if (host.Length > 0)
                {
                    // Increment the request counter in a thread safe manner.
                    Interlocked.Increment(ref requestCounter);
                    // Start the asynchronous request for DNS information.
                    Dns.BeginGetHostEntry(host, callBack, host);
                 }
            } while (host.Length > 0);
            // The user has entered all of the host names for lookup.
            // Now wait until the threads complete.
            while (requestCounter > 0)
            {
                UpdateUserInterface();
            }
            // Display the results.
            for (int i = 0; i< hostNames.Count; i++)
            {
                object data = hostData [i];
                string message = data as string;
                // A SocketException was thrown.
                if (message != null)
                {
                    Console.WriteLine("Request for {0} returned message: {1}",
                        hostNames[i], message);
                    continue;
                }
                // Get the results.
                IPHostEntry h = (IPHostEntry) data;
                string[] aliases = h.Aliases;
                IPAddress[] addresses = h.AddressList;
                if (aliases.Length > 0)
                {
                    Console.WriteLine("Aliases for {0}", hostNames[i]);
                    for (int j = 0; j < aliases.Length; j++)
                    {
                        Console.WriteLine("{0}", aliases[j]);
                    }
                }
                if (addresses.Length > 0)
                {
                    Console.WriteLine("Addresses for {0}", hostNames[i]);
                    for (int k = 0; k < addresses.Length; k++)
                    {
                        Console.WriteLine("{0}",addresses[k].ToString());
                    }
                }
            }
       }

        // The following method is called when each asynchronous operation completes.
        static void ProcessDnsInformation(IAsyncResult result)
        {
            string hostName = (string) result.AsyncState;
            hostNames.Add(hostName);
            try
            {
                // Get the results.
                IPHostEntry host = Dns.EndGetHostEntry(result);
                hostData.Add(host);
            }
            // Store the exception message.
            catch (SocketException e)
            {
                hostData.Add(e.Message);
            }
            finally
            {
                // Decrement the request counter in a thread-safe manner.
                Interlocked.Decrement(ref requestCounter);
            }
        }
    }
}
// The following example demonstrates using asynchronous methods to
// get Domain Name System information for the specified host computers.
// This example uses a delegate to obtain the results of each asynchronous
// operation.

open System
open System.Net
open System.Net.Sockets
open System.Threading
open System.Collections.Specialized

let mutable requestCounter = 0
let hostData = ResizeArray<Result<IPHostEntry, string>>()
let hostNames = StringCollection()

let updateUserInterface () =
    // Print a message to indicate that the application
    // is still working on the remaining requests.
    printfn $"{requestCounter} requests remaining."

// The following function is called when each asynchronous operation completes.
let processDnsInformation (result: IAsyncResult) =
    string result.AsyncState
    |> hostNames.Add 
    |> ignore
    try
        try
            // Get the results.
            Dns.EndGetHostEntry result
            |> Ok
            |> hostData.Add
        // Store the exception message.
        with :? SocketException as e ->
            Error e.Message
            |> hostData.Add 
    finally
        // Decrement the request counter in a thread-safe manner.
        Interlocked.Decrement &requestCounter 
        |> ignore

// Create the delegate that will process the results of the asynchronous request.
let callBack = AsyncCallback processDnsInformation

let mutable host = " "
while host.Length > 0 do
    printf " Enter the name of a host computer or <enter> to finish: "
    host <- stdin.ReadLine()
    if host.Length > 0 then
        // Increment the request counter in a thread safe manner.
        Interlocked.Increment &requestCounter |> ignore
        // Start the asynchronous request for DNS information.
        Dns.BeginGetHostEntry(host, callBack, host) |> ignore

// The user has entered all of the host names for lookup.
// Now wait until the threads complete.
while requestCounter > 0 do
    updateUserInterface ()

// Display the results.
for i = 0 to hostNames.Count - 1 do
    match hostData[i] with 
    | Error message ->
        // A SocketException was thrown.
        printfn $"Request for {hostNames[i]} returned message: {message}"
    | Ok entry ->    
        // Get the results.
        let aliases = entry.Aliases
        let addresses = entry.AddressList
        if aliases.Length > 0 then
            printfn $"Aliases for {hostNames[i]}"
            for alias in aliases do
                printfn $"{alias}"

        if addresses.Length > 0 then
            printfn $"Addresses for {hostNames[i]}"
            for address in addresses do
                printfn $"{address}"

'The following example demonstrates using asynchronous methods to
'get Domain Name System information for the specified host computers.
'This example uses a delegate to obtain the results of each asynchronous 
'operation.

Imports System.Net
Imports System.Net.Sockets
Imports System.Threading
Imports System.Collections.Specialized
Imports System.Collections

Namespace Examples.AdvancedProgramming.AsynchronousOperations

    Public Class UseDelegateForAsyncCallback
    
        Dim Shared requestCounter as Integer
        Dim Shared hostData as ArrayList = new ArrayList()
        Dim Shared hostNames as StringCollection = new StringCollection()
        Shared Sub UpdateUserInterface()
        
            ' Print a message to indicate that the application
            ' is still working on the remaining requests.
            Console.WriteLine("{0} requests remaining.", requestCounter)
        End Sub
        Public Shared Sub Main()
            ' Create the delegate that will process the results of the 
            ' asynchronous request.
            Dim callBack as AsyncCallback
            Dim host as string
            Dim i, j, k as Integer
            callback = AddressOf ProcessDnsInformation
            Do
                Console.Write(" Enter the name of a host computer or <enter> to finish: ")
                host = Console.ReadLine()
                If host.Length > 0
                    ' Increment the request counter in a thread safe manner.
                    Interlocked.Increment(requestCounter)
                    ' Start the asynchronous request for DNS information.
                    Dns.BeginGetHostEntry(host, callBack, host)
                End If
            Loop While (host.Length > 0)
            
            ' The user has entered all of the host names for lookup.
            ' Now wait until the threads complete.
            Do While requestCounter > 0
            
                UpdateUserInterface()
            Loop
            
            ' Display the results.
            For i = 0 To hostNames.Count -1
                Dim dataObject as Object = hostData (i)
                Dim message as String 
                
                ' Was a SocketException was thrown?
                If TypeOf dataObject is String
                    message = CType(dataObject, String)
                    Console.WriteLine("Request for {0} returned message: {1}", _ 
                        hostNames(i), message)
                Else
                    ' Get the results.
                    Dim h as IPHostEntry = CType(dataObject, IPHostEntry) 
                    Dim aliases() as String = h.Aliases
                    Dim addresses() as IPAddress = h.AddressList
                    If aliases.Length > 0
                        Console.WriteLine("Aliases for 0}", hostNames(i))
                        For j = 0 To aliases.Length -1
                            Console.WriteLine("{0}", aliases(j))
                        Next j
                    End If
                    If addresses.Length > 0
                        Console.WriteLine("Addresses for {0}", hostNames(i))
                        For k = 0 To addresses.Length -1
                            Console.WriteLine("{0}",addresses(k).ToString())
                        Next k
                    End If
                End If
            Next i
       End Sub

        ' The following method is called when each asynchronous operation completes.
        Shared Sub ProcessDnsInformation(result as IAsyncResult)
        
            Dim hostName as String = CType(result.AsyncState, String)
            hostNames.Add(hostName)
            Try 
                ' Get the results.
                Dim host as IPHostEntry = Dns.EndGetHostEntry(result)
                hostData.Add(host)
            ' Store the exception message.
            Catch e as SocketException
                hostData.Add(e.Message)
            Finally 
                ' Decrement the request counter in a thread-safe manner.
                Interlocked.Decrement(requestCounter)
            End Try
        End Sub
    End Class
End Namespace

注解

AsyncCallback使用委托在单独的线程中处理异步操作的结果。 委托 AsyncCallback 表示异步操作完成时调用的回调方法。 回调方法采用 IAsyncResult 参数,该参数随后用于获取异步操作的结果。

有关异步编程的详细信息,请参阅使用 AsyncCallback 委托结束异步操作和在基于事件的异步模式中使用 AsyncCallback 委托和状态对象 (EAP) 。

扩展方法

GetMethodInfo(Delegate)

获取指示指定委托表示的方法的对象。

适用于

另请参阅