IAsyncResult.AsyncState Propriedade

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Obtém um objeto definido pelo usuário que qualifica ou contém informações sobre uma operação assíncrona.

C#

public object AsyncState { get; }

C#

public object? AsyncState { get; }

Valor da propriedade

Object

Um objeto definido pelo usuário que qualifica ou contém informações sobre uma operação assíncrona.

Exemplos

O exemplo de código a seguir demonstra como a AsyncState propriedade é usada para passar informações para um método de retorno de chamada. O último parâmetro da chamada de BeginInvoke método é uma cadeia de caracteres de formato, que o método de retorno de chamada usa para formatar uma mensagem de saída.

O exemplo consiste em duas classes: a classe que contém o método que é chamado de forma assíncrona e a classe que contém o método Main que faz a chamada.

Para obter mais informações sobre como esse exemplo de retorno de chamada funciona e mais exemplos de métodos de chamada de forma assíncrona usando delegados, consulte Chamando métodos síncronos de forma assíncrona.

C#

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);
}

C#

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

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    public class AsyncMain
    {
        static void Main()
        {
            // Create an instance of the test class.
            AsyncDemo ad = new AsyncDemo();

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

            // The threadId parameter of TestMethod is an out parameter, so
            // its input value is never used by TestMethod. Therefore, a dummy
            // variable can be passed to the BeginInvoke call. If the threadId
            // parameter were a ref parameter, it would have to be a class-
            // level field so that it could be passed to both BeginInvoke and
            // EndInvoke.
            int dummy = 0;

            // Initiate the asynchronous call, passing three seconds (3000 ms)
            // for the callDuration parameter of TestMethod; a dummy variable
            // for the out parameter (threadId); the callback delegate; and
            // state information that can be retrieved by the callback method.
            // In this case, the state information is a string that can be used
            // to format a console message.
            IAsyncResult result = caller.BeginInvoke(3000,
                out dummy,
                new AsyncCallback(CallbackMethod),
                "The call executed on thread {0}, with return value \"{1}\".");

            Console.WriteLine("The main thread {0} continues to execute...",
                Thread.CurrentThread.ManagedThreadId);

            // The callback is made on a ThreadPool thread. ThreadPool threads
            // are background threads, which do not keep the application running
            // if the main thread ends. Comment out the next line to demonstrate
            // this.
            Thread.Sleep(4000);

            Console.WriteLine("The main thread ends.");
        }

        // The callback method must have the same signature as the
        // AsyncCallback delegate.
        static void CallbackMethod(IAsyncResult ar)
        {
            // Retrieve the delegate.
            AsyncResult result = (AsyncResult) ar;
            AsyncMethodCaller caller = (AsyncMethodCaller) result.AsyncDelegate;

            // Retrieve the format string that was passed as state
            // information.
            string formatString = (string) ar.AsyncState;

            // Define a variable to receive the value of the out parameter.
            // If the parameter were ref rather than out then it would have to
            // be a class-level field so it could also be passed to BeginInvoke.
            int threadId = 0;

            // Call EndInvoke to retrieve the results.
            string returnValue = caller.EndInvoke(out threadId, ar);

            // Use the format string to format the output message.
            Console.WriteLine(formatString, threadId, returnValue);
        }
    }
}

/* This example produces output similar to the following:

The main thread 1 continues to execute...
Test method begins.
The call executed on thread 3, with return value "My call time was 3000.".
The main thread ends.
 */

Comentários

Essa propriedade retorna o objeto que é o último parâmetro do método que inicia uma operação assíncrona.

Notas aos Implementadores

Implemente essa propriedade para permitir que o chamador de uma operação assíncrona obtenha um objeto definido pelo aplicativo especificado no início da operação.

Notas aos Chamadores

Esse objeto pode ser usado para passar informações de estado para a operação assíncrona para uma AsyncCallback que você fornece.

Aplica-se a

Confira também

• AsyncCallback