다음을 통해 공유


TaskExtensions.Unwrap 메서드

정의

오버로드

Unwrap(Task<Task>)

Task<Task>(C#) 또는 Task (Of Task)(Visual Basic)의 비동기 작업을 나타내는 프록시 Task를 만듭니다.

Unwrap<TResult>(Task<Task<TResult>>)

Task<Task<T>>(C#) 또는 Task (Of Task(Of T))(Visual Basic)의 비동기 작업을 나타내는 프록시 Task를 만듭니다.

Unwrap(Task<Task>)

Task<Task>(C#) 또는 Task (Of Task)(Visual Basic)의 비동기 작업을 나타내는 프록시 Task를 만듭니다.

public:
[System::Runtime::CompilerServices::Extension]
 static System::Threading::Tasks::Task ^ Unwrap(System::Threading::Tasks::Task<System::Threading::Tasks::Task ^> ^ task);
public static System.Threading.Tasks.Task Unwrap (this System.Threading.Tasks.Task<System.Threading.Tasks.Task> task);
static member Unwrap : System.Threading.Tasks.Task<System.Threading.Tasks.Task> -> System.Threading.Tasks.Task
<Extension()>
Public Function Unwrap (task As Task(Of Task)) As Task

매개 변수

task
Task<Task>

래핑을 해제할 Task<Task>(C#) 또는 Task (Of Task)(Visual Basic)입니다.

반환

Task

제공된 System.Threading.Tasks.Task(Of Task)의 비동기 작업을 나타내는 작업입니다.

예외

task 인수가 null인 경우 throw되는 예외입니다.

예제

다음 예제에서는 태스크 래이프를 해제하는 방법을 보여줍니다.

using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

class UnWrapDemo
{
     // Demonstrated features:
        //		Task.Unwrap()
        // 		Task.Factory.StartNew()
        //		Task.ContinueWith()
        // Expected results:
        // 		Indicates that continuation chains can be set up virtually instantaneously using Unwrap(), and then left to run on their own.
        //      The results of the RemoteIncrement(0) chain and the RemoteIncrement(4) chain may be intermixed with each other.
        //		The results of the sequence that starts with RemoteIncrement(4) are in strict order.
        // Documentation:
        //		http://msdn.microsoft.com/library/dd781129(VS.100).aspx
        // More information:
        //		http://blogs.msdn.com/pfxteam/archive/2009/11/04/9917581.aspx
        // Other notes:
        //		The combination of Task<T>, ContinueWith() and Unwrap() can be particularly useful for setting up a chain of long-running
        //      tasks where each task uses the results of its predecessor.
        static void Main()
        {
            // Invoking individual tasks is straightforward
            Task<int> t1 = RemoteIncrement(0);
            Console.WriteLine("Started RemoteIncrement(0)");

            // Chain together the results of (simulated) remote operations.
            // The use of Unwrap() instead of .Result below prevents this thread from blocking while setting up this continuation chain.
            Task<int> t2 = RemoteIncrement(4)
                .ContinueWith(t => RemoteIncrement(t.Result))			// RemoteIncrement() returns Task<int> so no unwrapping is needed for the first continuation.
                .Unwrap().ContinueWith(t => RemoteIncrement(t.Result))	// ContinueWith() returns Task<Task<int>>. Therefore unwrapping is needed.
                .Unwrap().ContinueWith(t => RemoteIncrement(t.Result))	// and on it goes...
                .Unwrap();
            Console.WriteLine("Started RemoteIncrement(...(RemoteIncrement(RemoteIncrement(4))...)");

            try
            {
                t1.Wait();
                Console.WriteLine("Finished RemoteIncrement(0)\n");

                t2.Wait();
                Console.WriteLine("Finished RemoteIncrement(...(RemoteIncrement(RemoteIncrement(4))...)");
            }
            catch (AggregateException e)
            {
                Console.WriteLine("A task has thrown the following (unexpected) exception:\n{0}", e);
            }
        }
        // This method represents a remote API.
        static Task<int> RemoteIncrement(int n)
        {
            return Task<int>.Factory.StartNew(
                (obj) =>
                {
                    // Simulate a slow operation
                    Thread.Sleep(1 * 1000);

                    int x = (int)obj;
                    Console.WriteLine("Thread={0}, Next={1}", Thread.CurrentThread.ManagedThreadId, ++x);
                    return x;
                },
                n);
        }
}
Imports System.Threading
Imports System.Threading.Tasks

Module UnwrapDemo
    ' Demonstrated features:
    '   Task.Unwrap()
    '    Task.Factory.StartNew()
    '   Task.ContinueWith()
    ' Expected results:
    ' 	Indicates that continuation chains can be set up virtually instantaneously using Unwrap(), and then left to run on their own.
    '   The results of the RemoteIncrement(0) chain and the RemoteIncrement(4) chain may be intermixed with each other.
    '   The results of the sequence that starts with RemoteIncrement(4) are in strict order.
    ' Documentation:
    '   http://msdn.microsoft.com/library/dd781129(VS.100).aspx
    ' More information:
    '   http://blogs.msdn.com/pfxteam/archive/2009/11/04/9917581.aspx
    ' Other notes:
    '   The combination of Task<T>, ContinueWith() and Unwrap() can be particularly useful for setting up a chain of long-running
    '   tasks where each task uses the results of its predecessor.

    Sub Main()
        ' Invoking individual tasks is straightforward
        Dim t1 As Task(Of Integer) = RemoteIncrement(0)
        Console.WriteLine("Started RemoteIncrement(0)")

        ' Chain together the results of (simulated) remote operations.
        ' The use of Unwrap() instead of .Result below prevents this thread from blocking while setting up this continuation chain.
        ' RemoteIncrement() returns Task<int> so no unwrapping is needed for the first continuation.
        ' ContinueWith() here returns Task<Task<int>>. Therefore unwrapping is needed.
        ' and on it goes...
        Dim t2 As Task(Of Integer) = RemoteIncrement(4).ContinueWith(Function(t) RemoteIncrement(t.Result)).Unwrap().ContinueWith(Function(t) RemoteIncrement(t.Result)).Unwrap().ContinueWith(Function(t) RemoteIncrement(t.Result)).Unwrap()
        Console.WriteLine("Started RemoteIncrement(...(RemoteIncrement(RemoteIncrement(4))...)")

        Try
            t1.Wait()
            Console.WriteLine("Finished RemoteIncrement(0)" & vbLf)

            t2.Wait()
            Console.WriteLine("Finished RemoteIncrement(...(RemoteIncrement(RemoteIncrement(4))...)")
        Catch e As AggregateException
            Console.WriteLine("A task has thrown the following (unexpected) exception:" & vbLf & "{0}", e)

        End Try
    End Sub

    ' This method represents a remote API.
    Function RemoteIncrement(ByVal n As Integer) As Task(Of Integer)
        Return Task(Of Integer).Factory.StartNew(Function(obj)
                                                     ' Simulate a slow operation
                                                     Thread.Sleep(1 * 1000)

                                                     Dim x As Integer = CInt(obj)
                                                     Console.WriteLine("Thread={0}, Next={1}", Thread.CurrentThread.ManagedThreadId, System.Threading.Interlocked.Increment(x))
                                                     Return x
                                                 End Function, n)
    End Function


End Module

설명

내부 태스크가 외부Task<TResult>의 일부로 수행된 작업을 나타내는 작업에서 Task<TResult>작업을 반환할 수 있는 경우가 많습니다. 그러나 이렇게 Task<Task> 하면 (C#) 또는 Task (Of Task) (Visual Basic)가 발생하며, 신중하게 처리하지 않으면 예기치 않은 동작이 발생할 수 있습니다. 래프 해제는 이러한 작업의 전체 비동기 작업을 나타내는 프록시 작업을 만들어 이 문제를 해결합니다.

추가 정보

적용 대상

Unwrap<TResult>(Task<Task<TResult>>)

Task<Task<T>>(C#) 또는 Task (Of Task(Of T))(Visual Basic)의 비동기 작업을 나타내는 프록시 Task를 만듭니다.

public:
generic <typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Threading::Tasks::Task<TResult> ^ Unwrap(System::Threading::Tasks::Task<System::Threading::Tasks::Task<TResult> ^> ^ task);
public static System.Threading.Tasks.Task<TResult> Unwrap<TResult> (this System.Threading.Tasks.Task<System.Threading.Tasks.Task<TResult>> task);
static member Unwrap : System.Threading.Tasks.Task<System.Threading.Tasks.Task<'Result>> -> System.Threading.Tasks.Task<'Result>
<Extension()>
Public Function Unwrap(Of TResult) (task As Task(Of Task(Of TResult))) As Task(Of TResult)

형식 매개 변수

TResult

작업 결과의 형식입니다.

매개 변수

task
Task<Task<TResult>>

래핑을 해제할 Task<Task<T>>(C#) 또는 Task (Of Task(Of T))(Visual Basic)입니다.

반환

Task<TResult>

제공된 Task<Task<T>>(C#) 또는 Task (Of Task(Of T))(Visual Basic)의 비동기 작업을 나타내는 Task입니다.

예외

task 인수가 null인 경우 throw되는 예외입니다.

설명

내부 Task 가 외부Task의 일부로 수행된 작업을 나타내는 위치에서 Task반환 Task 할 수 있는 것이 유용한 경우가 많습니다. 그러나 이렇게 Task<Task<T>> 하면 (C#) 또는 Task (Of Task(Of T)) (Visual Basic)가 발생하며, 신중하게 처리하지 않으면 예기치 않은 동작이 발생할 수 있습니다. 래핑 해제는 이러한 (C#) 또는 Task (Of Task(Of T)) (Visual Basic)의 전체 비동기 작업을 나타내는 프록시 Task<TResult>Task<Task<T>> 만들어 이 문제를 해결합니다.

추가 정보

적용 대상