MICROSOFT Archives - 4 중 4 번째 페이지

[C#/TPL] TaskFactory 클래스 : StartNew 메소드를 사용해 비동기 실행하기

■ TaskFactory 클래스의 StartNew 메소드를 사용해 비동기로 실행하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

#region 테스트 하기 - Test(taskName)

/// <summary>
/// 테스트 하기
/// </summary>
/// <param name="taskName">태스크명</param>
private void Test(string taskName)
{
    Console.WriteLine
    (
        "태스크명 : {0}, 스레드 ID : {1}, 스레드 풀 사용 여부 : {2}",
        taskName,
        Thread.CurrentThread.ManagedThreadId,
        Thread.CurrentThread.IsThreadPoolThread
    );
}

#endregion

Task.Factory.StartNew(() => Test("Task #1"));

using System;

using System.Threading;

using System.Threading.Tasks;

#region 테스트 하기 - Test(taskName)

/// <summary>

/// 테스트 하기

/// </summary>

/// <param name="taskName">태스크명</param>

private void Test(string taskName)

{

Console.WriteLine

(

"태스크명 : {0}, 스레드 ID : {1}, 스레드 풀 사용 여부 : {2}",

taskName,

Thread.CurrentThread.ManagedThreadId,

Thread.CurrentThread.IsThreadPoolThread

);

}

#endregion

Task.Factory.StartNew(() => Test("Task #1"));

[C#/TPL] Task 클래스 : Run 정적 메소드를 사용해 비동기 실행하기

■ Task 클래스의 Run 정적 메소드를 사용해 비동기로 실행하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

#region 테스트 하기 - Test(taskName)

/// <summary>
/// 테스트 하기
/// </summary>
/// <param name="taskName">태스크명</param>
private void Test(string taskName)
{
    Console.WriteLine
    (
        "태스크명 : {0}, 스레드 ID : {1}, 스레드 풀 사용 여부 : {2}",
        taskName,
        Thread.CurrentThread.ManagedThreadId,
        Thread.CurrentThread.IsThreadPoolThread
    );
}

#endregion

Task.Run(() => Test("Task #1"));

using System;

using System.Threading;

using System.Threading.Tasks;

#region 테스트 하기 - Test(taskName)

/// <summary>

/// 테스트 하기

/// </summary>

/// <param name="taskName">태스크명</param>

private void Test(string taskName)

{

Console.WriteLine

(

"태스크명 : {0}, 스레드 ID : {1}, 스레드 풀 사용 여부 : {2}",

taskName,

Thread.CurrentThread.ManagedThreadId,

Thread.CurrentThread.IsThreadPoolThread

);

}

#endregion

Task.Run(() => Test("Task #1"));

[C#/TPL] Task 클래스 : Start 메소드를 사용해 비동기 실행하기

■ Task 클래스의 Start 메소드를 사용해 비동기로 실행하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

#region 테스트 하기 - Test(taskName)

/// <summary>
/// 테스트 하기
/// </summary>
/// <param name="taskName">태스크명</param>
private void Test(string taskName)
{
    Console.WriteLine
    (
        "태스크명 : {0}, 스레드 ID : {1}, 스레드 풀 사용 여부 : {2}",
        taskName,
        Thread.CurrentThread.ManagedThreadId,
        Thread.CurrentThread.IsThreadPoolThread
    );
}

#endregion

Task task = new Task(() => Test("Task #1"));

task.Start();

using System;

using System.Threading;

using System.Threading.Tasks;

#region 테스트 하기 - Test(taskName)

/// <summary>

/// 테스트 하기

/// </summary>

/// <param name="taskName">태스크명</param>

private void Test(string taskName)

{

Console.WriteLine

(

"태스크명 : {0}, 스레드 ID : {1}, 스레드 풀 사용 여부 : {2}",

taskName,

Thread.CurrentThread.ManagedThreadId,

Thread.CurrentThread.IsThreadPoolThread

);

}

#endregion

Task task = new Task(() => Test("Task #1"));

task.Start();

[C#/TPL] 비동기 연산에서 예외 처리하기

■ 비동기 연산에서 예외를 처리하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Threading.Tasks;
using System.Collections.ObjectModel;

...

#region 테스트 처리하기 - Test(taskName, secondCount)

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="secondCount">초 카운트</param>
/// <returns>태스크</returns>
private async Task<string> Test(string taskName, int secondCount)
{
    await Task.Delay(TimeSpan.FromSeconds(secondCount));

    throw new Exception(string.Format("{0}에서 예외가 발생했습니다.", taskName));
}

#endregion
#region 테스트 처리하기 - Test()

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <returns>태스크</returns>
private async Task Test()
{
    Task<string> task1 = Test("작업 1", 3);
    Task<string> task2 = Test("작업 2", 2);

    Task<string[]> task3 = Task.WhenAll(task1, task2);

    try
    {
        string[] resultArray = await task3;

        Console.WriteLine(resultArray.Length);
    }
    catch
    {
        AggregateException aggregateException = task3.Exception.Flatten();

        ReadOnlyCollection<Exception> exceptionCollection = aggregateException.InnerExceptions;

        Console.WriteLine("예외 카운트 : {0}", exceptionCollection.Count);

        foreach(Exception exception in exceptionCollection)
        {
            Console.WriteLine(exception);
            Console.WriteLine();
        }
    }
}

#endregion

...

Task task = Test();

task.Wait();

using System;

using System.Threading.Tasks;

using System.Collections.ObjectModel;

...

#region 테스트 처리하기 - Test(taskName, secondCount)

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <param name="taskName">태스크명</param>

/// <param name="secondCount">초 카운트</param>

/// <returns>태스크</returns>

private async Task<string> Test(string taskName, int secondCount)

{

await Task.Delay(TimeSpan.FromSeconds(secondCount));

throw new Exception(string.Format("{0}에서 예외가 발생했습니다.", taskName));

}

#endregion

#region 테스트 처리하기 - Test()

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <returns>태스크</returns>

private async Task Test()

{

Task<string> task1 = Test("작업 1", 3);

Task<string> task2 = Test("작업 2", 2);

Task<string[]> task3 = Task.WhenAll(task1, task2);

try

{

string[] resultArray = await task3;

Console.WriteLine(resultArray.Length);

}

catch

{

AggregateException aggregateException = task3.Exception.Flatten();

ReadOnlyCollection<Exception> exceptionCollection = aggregateException.InnerExceptions;

Console.WriteLine("예외 카운트 : {0}", exceptionCollection.Count);

foreach(Exception exception in exceptionCollection)

{

Console.WriteLine(exception);

Console.WriteLine();

}

#endregion

...

Task task = Test();

task.Wait();

[C#/TPL] 비동기 연산에서 예외 처리하기

■ 비동기 연산에서 예외를 처리하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Threading.Tasks;

...

#region 테스트 처리하기 - Test(taskName, secondCount)

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="secondCount">초 카운트</param>
/// <returns>태스크</returns>
private async Task<string> Test(string taskName, int secondCount)
{
    await Task.Delay(TimeSpan.FromSeconds(secondCount));

    throw new Exception(string.Format("{0}에서 예외가 발생했습니다.", taskName));
}

#endregion
#region 테스트 처리하기 - Test()

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <returns>태스크</returns>
private async Task Test()
{
    Task<string> task1 = Test("작업 1", 3);
    Task<string> task2 = Test("작업 2", 2);

    try
    {
        string[] resultArray = await Task.WhenAll(task1, task2);

        Console.WriteLine(resultArray.Length);
    }
    catch(Exception exception)
    {
        Console.WriteLine(exception);
    }
}

#endregion

...

Task task = Test();

task.Wait();

using System;

using System.Threading.Tasks;

...

#region 테스트 처리하기 - Test(taskName, secondCount)

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <param name="taskName">태스크명</param>

/// <param name="secondCount">초 카운트</param>

/// <returns>태스크</returns>

private async Task<string> Test(string taskName, int secondCount)

{

await Task.Delay(TimeSpan.FromSeconds(secondCount));

throw new Exception(string.Format("{0}에서 예외가 발생했습니다.", taskName));

}

#endregion

#region 테스트 처리하기 - Test()

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <returns>태스크</returns>

private async Task Test()

{

Task<string> task1 = Test("작업 1", 3);

Task<string> task2 = Test("작업 2", 2);

try

{

string[] resultArray = await Task.WhenAll(task1, task2);

Console.WriteLine(resultArray.Length);

}

catch(Exception exception)

{

Console.WriteLine(exception);

}

#endregion

...

Task task = Test();

task.Wait();

[C#/TPL] 비동기 연산에서 예외 처리하기

■ 비동기 연산에서 예외를 처리하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Threading.Tasks;

...

#region 테스트 처리하기 - Test(taskName, secondCount)

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="secondCount">초 카운트</param>
/// <returns>태스크</returns>
private async Task<string> Test(string taskName, int secondCount)
{
    await Task.Delay(TimeSpan.FromSeconds(secondCount));

    throw new Exception(string.Format("{0}에서 예외가 발생했습니다.", taskName));
}

#endregion
#region 테스트 처리하기 - Test()

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <returns>태스크</returns>
private async Task Test()
{
    try
    {
        string result = await Test("작업 1", 2);

        Console.WriteLine(result);
    }
    catch(Exception exception)
    {
        Console.WriteLine(exception);
    }
}

#endregion

...

Task task = Test();

task.Wait();

using System;

using System.Threading.Tasks;

...

#region 테스트 처리하기 - Test(taskName, secondCount)

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <param name="taskName">태스크명</param>

/// <param name="secondCount">초 카운트</param>

/// <returns>태스크</returns>

private async Task<string> Test(string taskName, int secondCount)

{

await Task.Delay(TimeSpan.FromSeconds(secondCount));

throw new Exception(string.Format("{0}에서 예외가 발생했습니다.", taskName));

}

#endregion

#region 테스트 처리하기 - Test()

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <returns>태스크</returns>

private async Task Test()

{

try

{

string result = await Test("작업 1", 2);

Console.WriteLine(result);

}

catch(Exception exception)

{

Console.WriteLine(exception);

}

#endregion

...

Task task = Test();

task.Wait();

[C#/TPL] 병렬 비동기 태스크에 await 연산자 사용하기

■ 병렬 비동기 태스크에 await 연산자를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

...

#region 테스트 처리하기 - Test(taskName, secondCount)

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="secondCount">초 카운트</param>
/// <returns>태스크</returns>
private async Task<string> Test(string taskName, int secondCount)
{
    await Task.Delay(TimeSpan.FromSeconds(secondCount));
  //await Task.Run(() => Thread.Sleep(TimeSpan.FromSeconds(secondCount)));

    return string.Format
    (
        "[{0} 스레드] 실행 태스크 : {1}, 스레드 풀 스레드 여부 : {2}",
        Thread.CurrentThread.ManagedThreadId,
        taskName,
        Thread.CurrentThread.IsThreadPoolThread
    );
}

#endregion
#region 테스트 처리하기 - Test()

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <returns>태스크</returns>
private async Task Test()
{
    Task<string> task1 = Test("Task 1", 3);
    Task<string> task2 = Test("Task 2", 5);

    string[] resultArray = await Task.WhenAll(task1, task2);

    foreach(string result in resultArray)
    {
        Console.WriteLine(result);
    }
}

#endregion

...

Task task = Test();

task.Wait();

using System;

using System.Threading;

using System.Threading.Tasks;

...

#region 테스트 처리하기 - Test(taskName, secondCount)

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <param name="taskName">태스크명</param>

/// <param name="secondCount">초 카운트</param>

/// <returns>태스크</returns>

private async Task<string> Test(string taskName, int secondCount)

{

await Task.Delay(TimeSpan.FromSeconds(secondCount));

//await Task.Run(() => Thread.Sleep(TimeSpan.FromSeconds(secondCount)));

return string.Format

(

"[{0} 스레드] 실행 태스크 : {1}, 스레드 풀 스레드 여부 : {2}",

Thread.CurrentThread.ManagedThreadId,

taskName,

Thread.CurrentThread.IsThreadPoolThread

);

}

#endregion

#region 테스트 처리하기 - Test()

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <returns>태스크</returns>

private async Task Test()

{

Task<string> task1 = Test("Task 1", 3);

Task<string> task2 = Test("Task 2", 5);

string[] resultArray = await Task.WhenAll(task1, task2);

foreach(string result in resultArray)

{

Console.WriteLine(result);

}

#endregion

...

Task task = Test();

task.Wait();

[C#/TPL] 연속 비동기 태스크에 await 연산자 사용하기

■ 병렬 비동기 태스크에 await 연산자를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

...

#region 테스트 처리하기 - Test(taskName)

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <returns>태스크</returns>
private async Task<string> Test(string taskName)
{
    Console.WriteLine("{0} 태스크가 시작되었습니다.", taskName);

    await Task.Delay(TimeSpan.FromSeconds(2));

    //if(taskName == "Task 2")
    //{
    //    throw new Exception("예외가 발생했습니다!");
    //}

    return string.Format
    (
        "[{0} 스레드] 실행 태스크 : {1}, 스레드 풀 스레드 여부 : {2}",
        Thread.CurrentThread.ManagedThreadId,
        taskName,
        Thread.CurrentThread.IsThreadPoolThread
    );
}

#endregion
#region 테스트 처리하기 - Test()

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <returns>태스크</returns>
private Task Test()
{
    Task containerTask = new Task
    (
        () =>
        {
            Task<string> task1 = Test("Task 1");

            task1.ContinueWith
            (
                task =>
                {
                    Console.WriteLine(task1.Result);

                    Task<string> task2 = Test("Task 2");

                    task2.ContinueWith
                    (
                        innerTask => Console.WriteLine(innerTask.Result),
                        TaskContinuationOptions.NotOnFaulted | TaskContinuationOptions.AttachedToParent
                    );

                    task2.ContinueWith
                    (
                        innerTask => Console.WriteLine(innerTask.Exception.InnerException),
                        TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.AttachedToParent
                    );
                },
                TaskContinuationOptions.NotOnFaulted | TaskContinuationOptions.AttachedToParent
            );

            task1.ContinueWith
            (
                task => Console.WriteLine(task1.Exception.InnerException),
                TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.AttachedToParent
            );
        }
    );

    containerTask.Start();

    return containerTask;
}

#endregion

...

Task task = Test();

task.Wait();

using System;

using System.Threading;

using System.Threading.Tasks;

...

#region 테스트 처리하기 - Test(taskName)

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <param name="taskName">태스크명</param>

/// <returns>태스크</returns>

private async Task<string> Test(string taskName)

{

Console.WriteLine("{0} 태스크가 시작되었습니다.", taskName);

await Task.Delay(TimeSpan.FromSeconds(2));

//if(taskName == "Task 2")

//{

// throw new Exception("예외가 발생했습니다!");

//}

return string.Format

(

"[{0} 스레드] 실행 태스크 : {1}, 스레드 풀 스레드 여부 : {2}",

Thread.CurrentThread.ManagedThreadId,

taskName,

Thread.CurrentThread.IsThreadPoolThread

);

}

#endregion

#region 테스트 처리하기 - Test()

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <returns>태스크</returns>

private Task Test()

{

Task containerTask = new Task

(

() =>

{

Task<string> task1 = Test("Task 1");

task1.ContinueWith

(

task =>

{

Console.WriteLine(task1.Result);

Task<string> task2 = Test("Task 2");

task2.ContinueWith

(

innerTask => Console.WriteLine(innerTask.Result),

TaskContinuationOptions.NotOnFaulted | TaskContinuationOptions.AttachedToParent

);

task2.ContinueWith

(

innerTask => Console.WriteLine(innerTask.Exception.InnerException),

TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.AttachedToParent

);

TaskContinuationOptions.NotOnFaulted | TaskContinuationOptions.AttachedToParent

);

task1.ContinueWith

(

task => Console.WriteLine(task1.Exception.InnerException),

TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.AttachedToParent

);

}

);

containerTask.Start();

return containerTask;

}

#endregion

...

Task task = Test();

task.Wait();

[C#/TPL] 연속 비동기 태스크에 await 연산자 사용하기

■ 병렬 비동기 태스크에 await 연산자를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

...

#region 테스트 처리하기 - Test(taskName)

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <returns>태스크</returns>
private async Task<string> Test(string taskName)
{
    Console.WriteLine("{0} 태스크가 시작되었습니다.", taskName);

    await Task.Delay(TimeSpan.FromSeconds(2));

    //if(taskName == "Task 2")
    //{
    //    throw new Exception("예외가 발생했습니다!");
    //}

    return string.Format
    (
        "[{0} 스레드] 실행 태스크 : {1}, 스레드 풀 스레드 여부 : {2}",
        Thread.CurrentThread.ManagedThreadId,
        taskName,
        Thread.CurrentThread.IsThreadPoolThread
    );
}

#endregion
#region 테스트 처리하기 - Test()

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <returns>태스크</returns>
private async Task Test()
{
    try
    {
        string result = await Test("Task 1");

        Console.WriteLine(result);

        result = await Test("Task 2");

        Console.WriteLine(result);
    }
    catch(Exception exception)
    {
        Console.WriteLine(exception);
    }
}

#endregion

...

Task task = Test();

task.Wait();

using System;

using System.Threading;

using System.Threading.Tasks;

...

#region 테스트 처리하기 - Test(taskName)

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <param name="taskName">태스크명</param>

/// <returns>태스크</returns>

private async Task<string> Test(string taskName)

{

Console.WriteLine("{0} 태스크가 시작되었습니다.", taskName);

await Task.Delay(TimeSpan.FromSeconds(2));

//if(taskName == "Task 2")

//{

// throw new Exception("예외가 발생했습니다!");

//}

return string.Format

(

"[{0} 스레드] 실행 태스크 : {1}, 스레드 풀 스레드 여부 : {2}",

Thread.CurrentThread.ManagedThreadId,

taskName,

Thread.CurrentThread.IsThreadPoolThread

);

}

#endregion

#region 테스트 처리하기 - Test()

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <returns>태스크</returns>

private async Task Test()

{

try

{

string result = await Test("Task 1");

Console.WriteLine(result);

result = await Test("Task 2");

Console.WriteLine(result);

}

catch(Exception exception)

{

Console.WriteLine(exception);

}

#endregion

...

Task task = Test();

task.Wait();

[C#/TPL] 람다식에서 await 연산자 사용하기

■ 람다식에서 await 연산자를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

...

#region 테스트 처리하기 - Test()

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <returns>태스크</returns>
private async Task Test()
{
    Func<string, Task<string>> func = async taskName =>
    {
        await Task.Delay(TimeSpan.FromSeconds(2));

        return string.Format
        (
            "[{0} 스레드] 실행 태스크 : {1}, 스레드 풀 스레드 여부 : {2}",
            Thread.CurrentThread.ManagedThreadId,
            taskName,
            Thread.CurrentThread.IsThreadPoolThread
        );
    };

    string result = await func("태스크 1");

    Console.WriteLine(result);
}

#endregion

...

Task task = Test();

task.Wait();

using System;

using System.Threading;

using System.Threading.Tasks;

...

#region 테스트 처리하기 - Test()

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <returns>태스크</returns>

private async Task Test()

{

Func<string, Task<string>> func = async taskName =>

{

await Task.Delay(TimeSpan.FromSeconds(2));

return string.Format

(

"[{0} 스레드] 실행 태스크 : {1}, 스레드 풀 스레드 여부 : {2}",

Thread.CurrentThread.ManagedThreadId,

taskName,

Thread.CurrentThread.IsThreadPoolThread

);

};

string result = await func("태스크 1");

Console.WriteLine(result);

}

#endregion

...

Task task = Test();

task.Wait();

[C#/TPL] 태스크 병렬 실행하기

■ 태스크를 병렬 실행하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

...

#region 테스트 처리하기 - Test(taskName, secondCount)

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="secondCount">초 카운트</param>
/// <returns>처리 결과</returns>
private int Test(string taskName, int secondCount)
{
    Console.WriteLine
    (
        "[{0} 스레드] 실행 태스크 : {1}, 스레드 풀 스레드 여부 : {2}",
        Thread.CurrentThread.ManagedThreadId,
        taskName,
        Thread.CurrentThread.IsThreadPoolThread
    );

    Thread.Sleep(TimeSpan.FromSeconds(secondCount));

    return secondCount;
}

#endregion

...

Task<int>   task1 = new Task<int>(() => Test("태스크 1", 3));
Task<int>   task2 = new Task<int>(() => Test("태스크 2", 2));
Task<int[]> task3 = Task.WhenAll(task1, task2);

task3.ContinueWith
(
    t => Console.WriteLine("첫번째 태스크 결과 : {0}, 두번째 태스크 결과 : {1}", t.Result[0], t.Result[1]),
    TaskContinuationOptions.OnlyOnRanToCompletion
);

task1.Start();
task2.Start();

Thread.Sleep(TimeSpan.FromSeconds(4));

Console.WriteLine();
Console.WriteLine();
Console.WriteLine();

List<Task<int>> taskList = new List<Task<int>>();

for(int i = 1; i < 4; i++)
{
    int count = i;

    Task<int> task = new Task<int>(() => Test(string.Format("태스크 {0}", count), count));

    taskList.Add(task);

    task.Start();
}

while(taskList.Count > 0)
{
    Task<int> completedTask = Task.WhenAny(taskList).Result;

    taskList.Remove(completedTask);

    Console.WriteLine("완료된 태스크 결과 : {0}.", completedTask.Result);
}

Thread.Sleep(TimeSpan.FromSeconds(1));

using System;

using System.Collections.Generic;

using System.Threading;

using System.Threading.Tasks;

...

#region 테스트 처리하기 - Test(taskName, secondCount)

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <param name="taskName">태스크명</param>

/// <param name="secondCount">초 카운트</param>

/// <returns>처리 결과</returns>

private int Test(string taskName, int secondCount)

{

Console.WriteLine

(

"[{0} 스레드] 실행 태스크 : {1}, 스레드 풀 스레드 여부 : {2}",

Thread.CurrentThread.ManagedThreadId,

taskName,

Thread.CurrentThread.IsThreadPoolThread

);

Thread.Sleep(TimeSpan.FromSeconds(secondCount));

return secondCount;

}

#endregion

...

Task<int> task1 = new Task<int>(() => Test("태스크 1", 3));

Task<int> task2 = new Task<int>(() => Test("태스크 2", 2));

Task<int[]> task3 = Task.WhenAll(task1, task2);

task3.ContinueWith

(

t => Console.WriteLine("첫번째 태스크 결과 : {0}, 두번째 태스크 결과 : {1}", t.Result[0], t.Result[1]),

TaskContinuationOptions.OnlyOnRanToCompletion

);

task1.Start();

task2.Start();

Thread.Sleep(TimeSpan.FromSeconds(4));

Console.WriteLine();

List<Task<int>> taskList = new List<Task<int>>();

for(int i = 1; i < 4; i++)

{

int count = i;

Task<int> task = new Task<int>(() => Test(string.Format("태스크 {0}", count), count));

taskList.Add(task);

task.Start();

}

while(taskList.Count > 0)

{

Task<int> completedTask = Task.WhenAny(taskList).Result;

taskList.Remove(completedTask);

Console.WriteLine("완료된 태스크 결과 : {0}.", completedTask.Result);

}

Thread.Sleep(TimeSpan.FromSeconds(1));

[C#/TPL] 태스크 예외 처리하기

■ 태스크 예외를 처리하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

...

#region 테스트 처리하기 - Test(taskName, secondCount)

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="secondCount">초 카운트</param>
/// <returns>처리 결과</returns>
private static int Test(string taskName, int secondCount)
{
    Console.WriteLine
    (
        "[{0} 스레드] 실행 태스크 : {1}, 스레드 풀 스레드 여부 : {2}",
        Thread.CurrentThread.ManagedThreadId,
        taskName,
        Thread.CurrentThread.IsThreadPoolThread
    );

    Thread.Sleep(TimeSpan.FromSeconds(secondCount));

    throw new Exception("고의적인 예외");

    // 실행되지 않는다.
    return secondCount;
}

#endregion

...

Task<int> task;

try
{
    task = Task.Run(() => Test("태스크 1", 2));

    int result = task.Result;

    Console.WriteLine("태스크 결과 : {0}", result);
}
catch(Exception exception)
{
    Console.WriteLine("발생 예외 :");
    Console.WriteLine("--------------------------------------------------");
    Console.WriteLine("Exception caught : {0}", exception);
    Console.WriteLine("--------------------------------------------------");
}

Console.WriteLine();
Console.WriteLine();
Console.WriteLine();

try
{
    task = Task.Run(() => Test("태스크 2", 2));

    int result = task.GetAwaiter().GetResult();

    Console.WriteLine("태스크 결과 : {0}", result);
}
catch(Exception exception)
{
    Console.WriteLine("발생 예외 :");
    Console.WriteLine("--------------------------------------------------");
    Console.WriteLine("Exception caught : {0}", exception);
    Console.WriteLine("--------------------------------------------------");
}

Console.WriteLine();
Console.WriteLine();
Console.WriteLine();

Task<int> task3 = new Task<int>(() => Test("태스크 3", 3));
Task<int> task4 = new Task<int>(() => Test("태스크 4", 2));

Task<int[]> task5 = Task.WhenAll(task3, task4);

Task task6 = task5.ContinueWith
(
    t =>
    {
        Console.WriteLine("발생 예외 :");
        Console.WriteLine("--------------------------------------------------");
        Console.WriteLine("Exception caught : {0}", t.Exception);
        Console.WriteLine("--------------------------------------------------");
    },
    TaskContinuationOptions.OnlyOnFaulted
);

task3.Start();
task4.Start();

Thread.Sleep(TimeSpan.FromSeconds(5));

100

101

using System;

using System.Threading;

using System.Threading.Tasks;

...

#region 테스트 처리하기 - Test(taskName, secondCount)

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <param name="taskName">태스크명</param>

/// <param name="secondCount">초 카운트</param>

/// <returns>처리 결과</returns>

private static int Test(string taskName, int secondCount)

{

Console.WriteLine

(

"[{0} 스레드] 실행 태스크 : {1}, 스레드 풀 스레드 여부 : {2}",

Thread.CurrentThread.ManagedThreadId,

taskName,

Thread.CurrentThread.IsThreadPoolThread

);

Thread.Sleep(TimeSpan.FromSeconds(secondCount));

throw new Exception("고의적인 예외");

// 실행되지 않는다.

return secondCount;

}

#endregion

...

Task<int> task;

try

{

task = Task.Run(() => Test("태스크 1", 2));

int result = task.Result;

Console.WriteLine("태스크 결과 : {0}", result);

}

catch(Exception exception)

{

Console.WriteLine("발생 예외 :");

Console.WriteLine("--------------------------------------------------");

Console.WriteLine("Exception caught : {0}", exception);

Console.WriteLine("--------------------------------------------------");

}

Console.WriteLine();

try

{

task = Task.Run(() => Test("태스크 2", 2));

int result = task.GetAwaiter().GetResult();

Console.WriteLine("태스크 결과 : {0}", result);

}

catch(Exception exception)

{

Console.WriteLine("발생 예외 :");

Console.WriteLine("--------------------------------------------------");

Console.WriteLine("Exception caught : {0}", exception);

Console.WriteLine("--------------------------------------------------");

}

Console.WriteLine();

Task<int> task3 = new Task<int>(() => Test("태스크 3", 3));

Task<int> task4 = new Task<int>(() => Test("태스크 4", 2));

Task<int[]> task5 = Task.WhenAll(task3, task4);

Task task6 = task5.ContinueWith

(

t =>

{

Console.WriteLine("발생 예외 :");

Console.WriteLine("--------------------------------------------------");

Console.WriteLine("Exception caught : {0}", t.Exception);

Console.WriteLine("--------------------------------------------------");

TaskContinuationOptions.OnlyOnFaulted

);

task3.Start();

task4.Start();

Thread.Sleep(TimeSpan.FromSeconds(5));

[C#/TPL] 태스크 취소 옵션 사용하기

■ 태스크 취소 옵션을 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

...

#region 테스트 처리하기 - Test(taskName, secondCount, cancellationToken)

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="secondCount">초 카운트</param>
/// <param name="cancellationToken">취소 토큰</param>
/// <returns>처리 결과</returns>
private int Test(string taskName, int secondCount, CancellationToken cancellationToken)
{
    Console.WriteLine
    (
        "[{0} 스레드] 태스크명 : {1}, 스레드 풀 스레드 여부 : {2}",
        Thread.CurrentThread.ManagedThreadId,
        taskName,
        Thread.CurrentThread.IsThreadPoolThread
    );

    for(int i = 0; i < secondCount; i ++)
    {
        Thread.Sleep(TimeSpan.FromSeconds(1));

        if(cancellationToken.IsCancellationRequested)
        {
            return -1;
        }
    }

    return secondCount;
}

#endregion

...

CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();

Task<int> task = new Task<int>(() => Test("태스크 1", 10, cancellationTokenSource.Token), cancellationTokenSource.Token);

Console.WriteLine("태스크 상태 : {0}", task.Status);

cancellationTokenSource.Cancel();

Console.WriteLine("태스트 상태 : {0}", task.Status);

Console.WriteLine("첫번째 태스크가 실행 전 취소되었습니다.");

cancellationTokenSource = new CancellationTokenSource();

task = new Task<int>(() => Test("태스크 2", 10, cancellationTokenSource.Token), cancellationTokenSource.Token);

task.Start();

for(int i = 0; i < 5; i++ )
{
    Thread.Sleep(TimeSpan.FromSeconds(0.5));

    Console.WriteLine(task.Status);
}

cancellationTokenSource.Cancel();

for(int i = 0; i < 5; i++)
{
    Thread.Sleep(TimeSpan.FromSeconds(0.5));

    Console.WriteLine(task.Status);
}

Console.WriteLine("태스크가 완료되었습니다 : {0}.", task.Result);

using System;

using System.Threading;

using System.Threading.Tasks;

...

#region 테스트 처리하기 - Test(taskName, secondCount, cancellationToken)

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <param name="taskName">태스크명</param>

/// <param name="secondCount">초 카운트</param>

/// <param name="cancellationToken">취소 토큰</param>

/// <returns>처리 결과</returns>

private int Test(string taskName, int secondCount, CancellationToken cancellationToken)

{

Console.WriteLine

(

"[{0} 스레드] 태스크명 : {1}, 스레드 풀 스레드 여부 : {2}",

Thread.CurrentThread.ManagedThreadId,

taskName,

Thread.CurrentThread.IsThreadPoolThread

);

for(int i = 0; i < secondCount; i ++)

{

Thread.Sleep(TimeSpan.FromSeconds(1));

if(cancellationToken.IsCancellationRequested)

{

return -1;

}

return secondCount;

}

#endregion

...

CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();

Task<int> task = new Task<int>(() => Test("태스크 1", 10, cancellationTokenSource.Token), cancellationTokenSource.Token);

Console.WriteLine("태스크 상태 : {0}", task.Status);

cancellationTokenSource.Cancel();

Console.WriteLine("태스트 상태 : {0}", task.Status);

Console.WriteLine("첫번째 태스크가 실행 전 취소되었습니다.");

cancellationTokenSource = new CancellationTokenSource();

task = new Task<int>(() => Test("태스크 2", 10, cancellationTokenSource.Token), cancellationTokenSource.Token);

task.Start();

for(int i = 0; i < 5; i++ )

{

Thread.Sleep(TimeSpan.FromSeconds(0.5));

Console.WriteLine(task.Status);

}

cancellationTokenSource.Cancel();

for(int i = 0; i < 5; i++)

{

Thread.Sleep(TimeSpan.FromSeconds(0.5));

Console.WriteLine(task.Status);

}

Console.WriteLine("태스크가 완료되었습니다 : {0}.", task.Result);

[C#/TPL] EAP 패턴을 태스크로 변환하기

■ EAP 패턴을 태스크로 변환하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.ComponentModel;
using System.Threading;
using System.Threading.Tasks;

...

#region 테스트 처리하기 - Test(name, secondCount)

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <param name="name">명칭</param>
/// <param name="secondCount">초 카운트</param>
/// <returns>처리 결과</returns>
private int Test(string name, int secondCount)
{
    Console.WriteLine
    (
        "[{0} 스레드] 처리명 {1}, 스레드 풀 스레드 여부 : {2}",
        Thread.CurrentThread.ManagedThreadId,
        name,
        Thread.CurrentThread.IsThreadPoolThread
    );

    Thread.Sleep(TimeSpan.FromSeconds(secondCount));

    return secondCount;
}

#endregion

...

TaskCompletionSource<int> taskCompletionSource = new TaskCompletionSource<int>();

BackgroundWorker backgroundWorker = new BackgroundWorker();

backgroundWorker.DoWork += (sender, e) => { e.Result = Test("백그라운드 작업자", 5); };

backgroundWorker.RunWorkerCompleted += (sender, e) =>
{
    if(e.Error != null)
    {
        taskCompletionSource.SetException(e.Error);
    }
    else if(e.Cancelled)
    {
        taskCompletionSource.SetCanceled();
    }
    else
    {
        taskCompletionSource.SetResult((int)e.Result);
    }
};

backgroundWorker.RunWorkerAsync();

int result = taskCompletionSource.Task.Result;

Console.WriteLine("처리 결과 : {0}", result);

using System;

using System.ComponentModel;

using System.Threading;

using System.Threading.Tasks;

...

#region 테스트 처리하기 - Test(name, secondCount)

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <param name="name">명칭</param>

/// <param name="secondCount">초 카운트</param>

/// <returns>처리 결과</returns>

private int Test(string name, int secondCount)

{

Console.WriteLine

(

"[{0} 스레드] 처리명 {1}, 스레드 풀 스레드 여부 : {2}",

Thread.CurrentThread.ManagedThreadId,

name,

Thread.CurrentThread.IsThreadPoolThread

);

Thread.Sleep(TimeSpan.FromSeconds(secondCount));

return secondCount;

}

#endregion

...

TaskCompletionSource<int> taskCompletionSource = new TaskCompletionSource<int>();

BackgroundWorker backgroundWorker = new BackgroundWorker();

backgroundWorker.DoWork += (sender, e) => { e.Result = Test("백그라운드 작업자", 5); };

backgroundWorker.RunWorkerCompleted += (sender, e) =>

{

if(e.Error != null)

{

taskCompletionSource.SetException(e.Error);

}

else if(e.Cancelled)

{

taskCompletionSource.SetCanceled();

}

else

{

taskCompletionSource.SetResult((int)e.Result);

}

};

backgroundWorker.RunWorkerAsync();

int result = taskCompletionSource.Task.Result;

Console.WriteLine("처리 결과 : {0}", result);

[C#/TPL] APM 패턴을 태스크로 변환하기

■ APM 패턴을 태스크로 변환하는 방법을 보여준다. ▶ 예제 코드 (C#)


#region 테스트 1 대리자 - Test1Delegate(threadID)

/// <summary>
/// 테스트 1 대리자
/// </summary>
/// <param name="threadID">스레드 ID</param>
/// <returns>처리 결과</returns>
private delegate string Test1Delegate(out int threadID);

#endregion
#region 콜백 처리하기 - Callback(asyncResult)

/// <summary>
/// 콜백 처리하기
/// </summary>
/// <param name="asyncResult">비동기 결과</param>
private void Callback(IAsyncResult asyncResult)
{
    int  threadID           = Thread.CurrentThread.ManagedThreadId;
    bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

    Console.WriteLine("[{0} 스레드] 콜백 처리를 시작합니다...", threadID);

    Console.WriteLine("[{0} 스레드] 콜백 전달 상태 값 : {1}", threadID, asyncResult.AsyncState);

    Console.WriteLine("[{0} 스레드] 스레드 풀 스레드 여부 : {1}", threadID, isThreadPoolThread);

    Console.WriteLine("[{0} 스레드] 콜백 처리를 종료합니다...", threadID);
}

#endregion
#region 테스트 1 처리하기 - Test1(threadID)

/// <summary>
/// 테스트 1 처리하기
/// </summary>
/// <param name="threadID">스레드 ID</param>
/// <returns>처리 결과</returns>
private string Test1(out int threadID)
{
    threadID = Thread.CurrentThread.ManagedThreadId;

    bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

    Console.WriteLine("[{0} 스레드] 테스트 1 처리를 시작합니다...", threadID);

    Console.WriteLine("[{0} 스레드] 스레드 풀 스레드 여부 : {1}", threadID, isThreadPoolThread);

    Thread.Sleep(TimeSpan.FromSeconds(2));

    Console.WriteLine("[{0} 스레드] 테스트 1 처리를 종료합니다...", threadID);

    return threadID.ToString();
}

#endregion
#region 테스트 2 처리하기 - Test2(precedingTask)

/// <summary>
/// 테스트 2 처리하기
/// </summary>
/// <param name="precedingTask">선행 태스크</param>
private void Test2(Task<string> precedingTask)
{
    int  threadID           = Thread.CurrentThread.ManagedThreadId;
    bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

    Console.WriteLine("[{0} 스레드] 테스트 2 처리를 시작합니다...", threadID);

    Console.WriteLine("[{0} 스레드] 선행 태스크 결과 : {1}", threadID, precedingTask.Result);

    Console.WriteLine("[{0} 스레드] 테스트 2 처리를 종료합니다...", threadID);
}

#endregion

...

int threadID;

Test1Delegate test1Delegate = Test1;

IAsyncResult asyncResult = test1Delegate.BeginInvoke(out threadID, Callback, "상태값 #1");

Task<string> task = Task<string>.Factory.FromAsync
(
    asyncResult,
    _ => test1Delegate.EndInvoke(out threadID, asyncResult)
);

task.ContinueWith(precedingTask => Test2(precedingTask));

while(!task.IsCompleted)
{
    Console.WriteLine(task.Status);

    Thread.Sleep(TimeSpan.FromSeconds(0.5));
}

Console.WriteLine(task.Status);

Thread.Sleep(TimeSpan.FromSeconds(1));

100

101

102

103

104

#region 테스트 1 대리자 - Test1Delegate(threadID)

/// <summary>

/// 테스트 1 대리자

/// </summary>

/// <param name="threadID">스레드 ID</param>

/// <returns>처리 결과</returns>

private delegate string Test1Delegate(out int threadID);

#endregion

#region 콜백 처리하기 - Callback(asyncResult)

/// <summary>

/// 콜백 처리하기

/// </summary>

/// <param name="asyncResult">비동기 결과</param>

private void Callback(IAsyncResult asyncResult)

{

int threadID = Thread.CurrentThread.ManagedThreadId;

bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

Console.WriteLine("[{0} 스레드] 콜백 처리를 시작합니다...", threadID);

Console.WriteLine("[{0} 스레드] 콜백 전달 상태 값 : {1}", threadID, asyncResult.AsyncState);

Console.WriteLine("[{0} 스레드] 스레드 풀 스레드 여부 : {1}", threadID, isThreadPoolThread);

Console.WriteLine("[{0} 스레드] 콜백 처리를 종료합니다...", threadID);

}

#endregion

#region 테스트 1 처리하기 - Test1(threadID)

/// <summary>

/// 테스트 1 처리하기

/// </summary>

/// <param name="threadID">스레드 ID</param>

/// <returns>처리 결과</returns>

private string Test1(out int threadID)

{

threadID = Thread.CurrentThread.ManagedThreadId;

bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

Console.WriteLine("[{0} 스레드] 테스트 1 처리를 시작합니다...", threadID);

Console.WriteLine("[{0} 스레드] 스레드 풀 스레드 여부 : {1}", threadID, isThreadPoolThread);

Thread.Sleep(TimeSpan.FromSeconds(2));

Console.WriteLine("[{0} 스레드] 테스트 1 처리를 종료합니다...", threadID);

return threadID.ToString();

}

#endregion

#region 테스트 2 처리하기 - Test2(precedingTask)

/// <summary>

/// 테스트 2 처리하기

/// </summary>

/// <param name="precedingTask">선행 태스크</param>

private void Test2(Task<string> precedingTask)

{

int threadID = Thread.CurrentThread.ManagedThreadId;

bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

Console.WriteLine("[{0} 스레드] 테스트 2 처리를 시작합니다...", threadID);

Console.WriteLine("[{0} 스레드] 선행 태스크 결과 : {1}", threadID, precedingTask.Result);

Console.WriteLine("[{0} 스레드] 테스트 2 처리를 종료합니다...", threadID);

}

#endregion

...

int threadID;

Test1Delegate test1Delegate = Test1;

IAsyncResult asyncResult = test1Delegate.BeginInvoke(out threadID, Callback, "상태값 #1");

Task<string> task = Task<string>.Factory.FromAsync

(

asyncResult,

_ => test1Delegate.EndInvoke(out threadID, asyncResult)

);

task.ContinueWith(precedingTask => Test2(precedingTask));

while(!task.IsCompleted)

{

Console.WriteLine(task.Status);

Thread.Sleep(TimeSpan.FromSeconds(0.5));

}

Console.WriteLine(task.Status);

Thread.Sleep(TimeSpan.FromSeconds(1));

[C#/TPL] APM 패턴을 태스크로 변환하기

■ APM 패턴을 태스크로 변환하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

...

#region 테스트 1 대리자 - Test1Delegate(threadName)

/// <summary>
/// 테스트 1 대리자
/// </summary>
/// <param name="threadName">스레드명</param>
/// <returns>처리 결과</returns>
private delegate string Test1Delegate(string threadName);

#endregion
#region 테스트 1 처리하기 - Test1(threadName)

/// <summary>
/// 테스트 1 처리하기
/// </summary>
/// <param name="threadName">스레드명</param>
/// <returns>처리 결과</returns>
private string Test1(string threadName)
{
    int  threadID           = Thread.CurrentThread.ManagedThreadId;
    bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

    Console.WriteLine("[{0} 스레드] 테스트 1 처리를 시작합니다...", threadID);

    Console.WriteLine("[{0} 스레드] 스레드 풀 스레드 여부 : {1}", threadID, isThreadPoolThread);

    Thread.Sleep(TimeSpan.FromSeconds(2));

    Thread.CurrentThread.Name = threadName;

    Console.WriteLine("[{0} 스레드] 테스트 1 처리를 종료합니다...", threadID);

    return Thread.CurrentThread.Name;
}

#endregion
#region 테스트 2 처리하기 - Test2(precedingTask)

/// <summary>
/// 테스트 2 처리하기
/// </summary>
/// <param name="precedingTask">선행 태스크</param>
private void Test2(Task<string> precedingTask)
{
    int  threadID           = Thread.CurrentThread.ManagedThreadId;
    bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

    Console.WriteLine("[{0} 스레드] 테스트 2 처리를 시작합니다...", threadID);

    Console.WriteLine("[{0} 스레드] 선행 태스크 결과 : {1}", threadID, precedingTask.Result);

    Console.WriteLine("[{0} 스레드] 테스트 2 처리를 종료합니다...", threadID);
}

#endregion

...

Test1Delegate test1Delegate = Test1;

Task<string> task = Task<string>.Factory.FromAsync
(
    test1Delegate.BeginInvoke,
    test1Delegate.EndInvoke,
    "thread1",
    "상태값 #1"
);

task.ContinueWith(precedingTask => Test2(precedingTask));

while(!task.IsCompleted)
{
    Console.WriteLine(task.Status);

    Thread.Sleep(TimeSpan.FromSeconds(0.5));
}

Console.WriteLine(task.Status);

Thread.Sleep(TimeSpan.FromSeconds(1));

using System;

using System.Threading;

using System.Threading.Tasks;

...

#region 테스트 1 대리자 - Test1Delegate(threadName)

/// <summary>

/// 테스트 1 대리자

/// </summary>

/// <param name="threadName">스레드명</param>

/// <returns>처리 결과</returns>

private delegate string Test1Delegate(string threadName);

#endregion

#region 테스트 1 처리하기 - Test1(threadName)

/// <summary>

/// 테스트 1 처리하기

/// </summary>

/// <param name="threadName">스레드명</param>

/// <returns>처리 결과</returns>

private string Test1(string threadName)

{

int threadID = Thread.CurrentThread.ManagedThreadId;

bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

Console.WriteLine("[{0} 스레드] 테스트 1 처리를 시작합니다...", threadID);

Console.WriteLine("[{0} 스레드] 스레드 풀 스레드 여부 : {1}", threadID, isThreadPoolThread);

Thread.Sleep(TimeSpan.FromSeconds(2));

Thread.CurrentThread.Name = threadName;

Console.WriteLine("[{0} 스레드] 테스트 1 처리를 종료합니다...", threadID);

return Thread.CurrentThread.Name;

}

#endregion

#region 테스트 2 처리하기 - Test2(precedingTask)

/// <summary>

/// 테스트 2 처리하기

/// </summary>

/// <param name="precedingTask">선행 태스크</param>

private void Test2(Task<string> precedingTask)

{

int threadID = Thread.CurrentThread.ManagedThreadId;

bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

Console.WriteLine("[{0} 스레드] 테스트 2 처리를 시작합니다...", threadID);

Console.WriteLine("[{0} 스레드] 선행 태스크 결과 : {1}", threadID, precedingTask.Result);

Console.WriteLine("[{0} 스레드] 테스트 2 처리를 종료합니다...", threadID);

}

#endregion

...

Test1Delegate test1Delegate = Test1;

Task<string> task = Task<string>.Factory.FromAsync

(

test1Delegate.BeginInvoke,

test1Delegate.EndInvoke,

"thread1",

"상태값 #1"

);

task.ContinueWith(precedingTask => Test2(precedingTask));

while(!task.IsCompleted)

{

Console.WriteLine(task.Status);

Thread.Sleep(TimeSpan.FromSeconds(0.5));

}

Console.WriteLine(task.Status);

Thread.Sleep(TimeSpan.FromSeconds(1));

[C#/TPL] APM 패턴을 태스크로 변환하기

■ APM 패턴을 태스크로 변환하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

...

#region 테스트 1 대리자 - Test1Delegate(threadName)

/// <summary>
/// 테스트 1 대리자
/// </summary>
/// <param name="threadName">스레드명</param>
/// <returns>처리 결과</returns>
private delegate string Test1Delegate(string threadName);

#endregion
#region 콜백 처리하기 - Callback(asyncResult)

/// <summary>
/// 콜백 처리하기
/// </summary>
/// <param name="asyncResult">비동기 결과</param>
private void Callback(IAsyncResult asyncResult)
{
    int  threadID           = Thread.CurrentThread.ManagedThreadId;
    bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

    Console.WriteLine("[{0} 스레드] 콜백 처리를 시작합니다...", threadID);

    Console.WriteLine("[{0} 스레드] 콜백 전달 상태 값 : {1}", threadID, asyncResult.AsyncState);

    Console.WriteLine("[{0} 스레드] 스레드 풀 스레드 여부 : {1}", threadID, isThreadPoolThread);

    Console.WriteLine("[{0} 스레드] 콜백 처리를 종료합니다...", threadID);
}

#endregion
#region 테스트 1 처리하기 - Test1(threadName)

/// <summary>
/// 테스트 1 처리하기
/// </summary>
/// <param name="threadName">스레드명</param>
/// <returns>처리 결과</returns>
private string Test1(string threadName)
{
    int  threadID           = Thread.CurrentThread.ManagedThreadId;
    bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

    Console.WriteLine("[{0} 스레드] 테스트 1 처리를 시작합니다...", threadID);

    Console.WriteLine("[{0} 스레드] 스레드 풀 스레드 여부 : {1}", threadID, isThreadPoolThread);

    Thread.Sleep(TimeSpan.FromSeconds(2));

    Thread.CurrentThread.Name = threadName;

    Console.WriteLine("[{0} 스레드] 테스트 1 처리를 종료합니다...", threadID);

    return Thread.CurrentThread.Name;
}

#endregion
#region 테스트 2 처리하기 - Test2(precedingTask)

/// <summary>
/// 테스트 2 처리하기
/// </summary>
/// <param name="precedingTask">선행 태스크</param>
private void Test2(Task<string> precedingTask)
{
    int  threadID           = Thread.CurrentThread.ManagedThreadId;
    bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

    Console.WriteLine("[{0} 스레드] 테스트 2 처리를 시작합니다...", threadID);

    Console.WriteLine("[{0} 스레드] 선행 태스크 결과 : {1}", threadID, precedingTask.Result);

    Console.WriteLine("[{0} 스레드] 테스트 2 처리를 종료합니다...", threadID);
}

#endregion

...

Test1Delegate test1Delegate = Test1;

Task<string> task = Task<string>.Factory.FromAsync
(
    test1Delegate.BeginInvoke("thread1", Callback, "상태값 #1"),
    test1Delegate.EndInvoke
);

task.ContinueWith(precedingTask => Test2(precedingTask));

while(!task.IsCompleted)
{
    Console.WriteLine(task.Status);

    Thread.Sleep(TimeSpan.FromSeconds(0.5));
}

Console.WriteLine(task.Status);

Thread.Sleep(TimeSpan.FromSeconds(1));

100

101

102

103

104

105

106

107

using System;

using System.Threading;

using System.Threading.Tasks;

...

#region 테스트 1 대리자 - Test1Delegate(threadName)

/// <summary>

/// 테스트 1 대리자

/// </summary>

/// <param name="threadName">스레드명</param>

/// <returns>처리 결과</returns>

private delegate string Test1Delegate(string threadName);

#endregion

#region 콜백 처리하기 - Callback(asyncResult)

/// <summary>

/// 콜백 처리하기

/// </summary>

/// <param name="asyncResult">비동기 결과</param>

private void Callback(IAsyncResult asyncResult)

{

int threadID = Thread.CurrentThread.ManagedThreadId;

bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

Console.WriteLine("[{0} 스레드] 콜백 처리를 시작합니다...", threadID);

Console.WriteLine("[{0} 스레드] 콜백 전달 상태 값 : {1}", threadID, asyncResult.AsyncState);

Console.WriteLine("[{0} 스레드] 스레드 풀 스레드 여부 : {1}", threadID, isThreadPoolThread);

Console.WriteLine("[{0} 스레드] 콜백 처리를 종료합니다...", threadID);

}

#endregion

#region 테스트 1 처리하기 - Test1(threadName)

/// <summary>

/// 테스트 1 처리하기

/// </summary>

/// <param name="threadName">스레드명</param>

/// <returns>처리 결과</returns>

private string Test1(string threadName)

{

int threadID = Thread.CurrentThread.ManagedThreadId;

bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

Console.WriteLine("[{0} 스레드] 테스트 1 처리를 시작합니다...", threadID);

Console.WriteLine("[{0} 스레드] 스레드 풀 스레드 여부 : {1}", threadID, isThreadPoolThread);

Thread.Sleep(TimeSpan.FromSeconds(2));

Thread.CurrentThread.Name = threadName;

Console.WriteLine("[{0} 스레드] 테스트 1 처리를 종료합니다...", threadID);

return Thread.CurrentThread.Name;

}

#endregion

#region 테스트 2 처리하기 - Test2(precedingTask)

/// <summary>

/// 테스트 2 처리하기

/// </summary>

/// <param name="precedingTask">선행 태스크</param>

private void Test2(Task<string> precedingTask)

{

int threadID = Thread.CurrentThread.ManagedThreadId;

bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

Console.WriteLine("[{0} 스레드] 테스트 2 처리를 시작합니다...", threadID);

Console.WriteLine("[{0} 스레드] 선행 태스크 결과 : {1}", threadID, precedingTask.Result);

Console.WriteLine("[{0} 스레드] 테스트 2 처리를 종료합니다...", threadID);

}

#endregion

...

Test1Delegate test1Delegate = Test1;

Task<string> task = Task<string>.Factory.FromAsync

(

test1Delegate.BeginInvoke("thread1", Callback, "상태값 #1"),

test1Delegate.EndInvoke

);

task.ContinueWith(precedingTask => Test2(precedingTask));

while(!task.IsCompleted)

{

Console.WriteLine(task.Status);

Thread.Sleep(TimeSpan.FromSeconds(0.5));

}

Console.WriteLine(task.Status);

Thread.Sleep(TimeSpan.FromSeconds(1));

[C#/TPL] Task 클래스 : 자식 태스크 실행하기

■ Task<T> 클래스를 사용해 자식 태스크를 실행하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

...

#region 테스트 처리하기 - Test(taskName, secondCount)

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="secondCount">초 카운트</param>
/// <returns>스레드 ID</returns>
private static int Test(string taskName, int secondCount)
{
    int  threadID           = Thread.CurrentThread.ManagedThreadId;
    bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

    Console.WriteLine
    (
        "[{0}] 스레드 ID : {1}, 스레드 풀 스레드 여부 : {2}",
        taskName,
        threadID,
        isThreadPoolThread
    );

    Thread.Sleep(TimeSpan.FromSeconds(secondCount));

    return threadID;
}

#endregion

...

Task<int> parentTask = new Task<int>
(
    () =>
    {
        Task<int> childTask = Task.Factory.StartNew
        (
            () => Test("자식 태스크 #1", 5),
            TaskCreationOptions.AttachedToParent
        );

        childTask.ContinueWith
        (
            t => Test("자식 태스크 #2", 2),
            TaskContinuationOptions.AttachedToParent
        );

        return Test("부모 태스크", 2);
    }
);

parentTask.Start();

while(!parentTask.IsCompleted)
{
    Console.WriteLine("[부모 태스크] 상태 : {0}", parentTask.Status);

    Thread.Sleep(TimeSpan.FromSeconds(0.5));
}

Console.WriteLine("[부모 태스크] 상태 : {0}", parentTask.Status);

Thread.Sleep(TimeSpan.FromSeconds(10));

using System;

using System.Threading;

using System.Threading.Tasks;

...

#region 테스트 처리하기 - Test(taskName, secondCount)

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <param name="taskName">태스크명</param>

/// <param name="secondCount">초 카운트</param>

/// <returns>스레드 ID</returns>

private static int Test(string taskName, int secondCount)

{

int threadID = Thread.CurrentThread.ManagedThreadId;

bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

Console.WriteLine

(

"[{0}] 스레드 ID : {1}, 스레드 풀 스레드 여부 : {2}",

taskName,

threadID,

isThreadPoolThread

);

Thread.Sleep(TimeSpan.FromSeconds(secondCount));

return threadID;

}

#endregion

...

Task<int> parentTask = new Task<int>

(

() =>

{

Task<int> childTask = Task.Factory.StartNew

(

() => Test("자식 태스크 #1", 5),

TaskCreationOptions.AttachedToParent

);

childTask.ContinueWith

(

t => Test("자식 태스크 #2", 2),

TaskContinuationOptions.AttachedToParent

);

return Test("부모 태스크", 2);

}

);

parentTask.Start();

while(!parentTask.IsCompleted)

{

Console.WriteLine("[부모 태스크] 상태 : {0}", parentTask.Status);

Thread.Sleep(TimeSpan.FromSeconds(0.5));

}

Console.WriteLine("[부모 태스크] 상태 : {0}", parentTask.Status);

Thread.Sleep(TimeSpan.FromSeconds(10));

[C#/TPL] Task 클래스 : ContinueWith 메소드 사용하기

■ Task<T> 클래스의 ContinueWith 메소드를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

...

#region 테스트 1 처리하기 - Test1(taskName, secondCount)

/// <summary>
/// 테스트 1 처리하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="secondCount">초 카운트</param>
/// <returns>스레드 ID</returns>
private static int Test1(string taskName, int secondCount)
{
    int  threadID           = Thread.CurrentThread.ManagedThreadId;
    bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

    Console.WriteLine
    (
        "[{0}] 스레드 ID : {1}, 스레드 풀 스레드 여부 : {2}",
        taskName,
        threadID,
        isThreadPoolThread
    );

    Thread.Sleep(TimeSpan.FromSeconds(secondCount));

    return threadID;
}

#endregion
#region 테스트 2 처리하기 - Test2(taskName, precedingTask)

/// <summary>
/// 테스트 2 처리하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="precedingTask">선행 태스크</param>
private static void Test2(string taskName, Task<int> precedingTask)
{
    int  threadID           = Thread.CurrentThread.ManagedThreadId;
    bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

    Console.WriteLine
    (
        "[{0}] 선행 태스크 스레드 ID : {1}, 스레드 ID : {2}, 스레드 풀 스레드 여부 : {3}",
        taskName,
        precedingTask.Result,
        threadID,
        isThreadPoolThread
    );
}

#endregion
#region 테스트 3 처리하기 - Test3(taskName, precedingTaskName)

/// <summary>
/// 테스트 3 처리하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="precedingTaskName">선행 태스크명</param>
private static void Test3(string taskName, string precedingTaskName)
{
    int  threadID           = Thread.CurrentThread.ManagedThreadId;
    bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

    Console.WriteLine
    (
        "[{0}] 선행 태스크명 : {1}, 스레드 ID : {2}, 스레드 풀 스레드 여부 : {3}",
        taskName,
        precedingTaskName,
        threadID,
        isThreadPoolThread
    );
}

#endregion

...

Task<int> task1 = new Task<int>(() => Test1("태스크 #1", 3));

task1.Start();

Thread.Sleep(TimeSpan.FromSeconds(4));

Task task2 = task1.ContinueWith
(
    precedingTask => Test2("태스크 #2", precedingTask),
    TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.ExecuteSynchronously
);

task2.GetAwaiter().OnCompleted(() => Test3("태스크 #3", "태스트 #2"));

Thread.Sleep(TimeSpan.FromSeconds(2));

Console.WriteLine("작업을 완료했습니다.");

100

101

using System;

using System.Threading;

using System.Threading.Tasks;

...

#region 테스트 1 처리하기 - Test1(taskName, secondCount)

/// <summary>

/// 테스트 1 처리하기

/// </summary>

/// <param name="taskName">태스크명</param>

/// <param name="secondCount">초 카운트</param>

/// <returns>스레드 ID</returns>

private static int Test1(string taskName, int secondCount)

{

int threadID = Thread.CurrentThread.ManagedThreadId;

bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

Console.WriteLine

(

"[{0}] 스레드 ID : {1}, 스레드 풀 스레드 여부 : {2}",

taskName,

threadID,

isThreadPoolThread

);

Thread.Sleep(TimeSpan.FromSeconds(secondCount));

return threadID;

}

#endregion

#region 테스트 2 처리하기 - Test2(taskName, precedingTask)

/// <summary>

/// 테스트 2 처리하기

/// </summary>

/// <param name="taskName">태스크명</param>

/// <param name="precedingTask">선행 태스크</param>

private static void Test2(string taskName, Task<int> precedingTask)

{

int threadID = Thread.CurrentThread.ManagedThreadId;

bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

Console.WriteLine

(

"[{0}] 선행 태스크 스레드 ID : {1}, 스레드 ID : {2}, 스레드 풀 스레드 여부 : {3}",

taskName,

precedingTask.Result,

threadID,

isThreadPoolThread

);

}

#endregion

#region 테스트 3 처리하기 - Test3(taskName, precedingTaskName)

/// <summary>

/// 테스트 3 처리하기

/// </summary>

/// <param name="taskName">태스크명</param>

/// <param name="precedingTaskName">선행 태스크명</param>

private static void Test3(string taskName, string precedingTaskName)

{

int threadID = Thread.CurrentThread.ManagedThreadId;

bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

Console.WriteLine

(

"[{0}] 선행 태스크명 : {1}, 스레드 ID : {2}, 스레드 풀 스레드 여부 : {3}",

taskName,

precedingTaskName,

threadID,

isThreadPoolThread

);

}

#endregion

...

Task<int> task1 = new Task<int>(() => Test1("태스크 #1", 3));

task1.Start();

Thread.Sleep(TimeSpan.FromSeconds(4));

Task task2 = task1.ContinueWith

(

precedingTask => Test2("태스크 #2", precedingTask),

TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.ExecuteSynchronously

);

task2.GetAwaiter().OnCompleted(() => Test3("태스크 #3", "태스트 #2"));

Thread.Sleep(TimeSpan.FromSeconds(2));

Console.WriteLine("작업을 완료했습니다.");

[C#/TPL] Task 클래스 : ContinueWith 메소드 사용하기

■ Task<T> 클래스의 ContinueWith 메소드를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

...

#region 테스트 1 처리하기 - Test1(taskName, secondCount)

/// <summary>
/// 테스트 1 처리하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="secondCount">초 카운트</param>
/// <returns>스레드 ID</returns>
private static int Test1(string taskName, int secondCount)
{
    int  threadID           = Thread.CurrentThread.ManagedThreadId;
    bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

    Console.WriteLine
    (
        "[{0}] 스레드 ID : {1}, 스레드 풀 스레드 여부 : {2}",
        taskName,
        threadID,
        isThreadPoolThread
    );

    Thread.Sleep(TimeSpan.FromSeconds(secondCount));

    return threadID;
}

#endregion
#region 테스트 2 처리하기 - Test2(taskName, precedingTask)

/// <summary>
/// 테스트 2 처리하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="precedingTask">선행 태스크</param>
private static void Test2(string taskName, Task<int> precedingTask)
{
    int  threadID           = Thread.CurrentThread.ManagedThreadId;
    bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

    Console.WriteLine
    (
        "[{0}] 선행 태스크 스레드 ID : {1}, 스레드 ID : {2}, 스레드 풀 스레드 여부 : {3}",
        taskName,
        precedingTask.Result,
        threadID,
        isThreadPoolThread
    );
}

#endregion

...

Task<int> task1 = new Task<int>(() => Test1("태스크 #1", 3));
Task<int> task2 = new Task<int>(() => Test1("태스크 #2", 2));

task1.ContinueWith(t => Test2("태스크 #3", t), TaskContinuationOptions.OnlyOnRanToCompletion);
task2.ContinueWith(t => Test2("태스크 #4", t), TaskContinuationOptions.OnlyOnRanToCompletion);

task1.Start();
task2.Start();

Thread.Sleep(TimeSpan.FromSeconds(4));

Console.WriteLine("작업을 완료했습니다.");

using System;

using System.Threading;

using System.Threading.Tasks;

...

#region 테스트 1 처리하기 - Test1(taskName, secondCount)

/// <summary>

/// 테스트 1 처리하기

/// </summary>

/// <param name="taskName">태스크명</param>

/// <param name="secondCount">초 카운트</param>

/// <returns>스레드 ID</returns>

private static int Test1(string taskName, int secondCount)

{

int threadID = Thread.CurrentThread.ManagedThreadId;

bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

Console.WriteLine

(

"[{0}] 스레드 ID : {1}, 스레드 풀 스레드 여부 : {2}",

taskName,

threadID,

isThreadPoolThread

);

Thread.Sleep(TimeSpan.FromSeconds(secondCount));

return threadID;

}

#endregion

#region 테스트 2 처리하기 - Test2(taskName, precedingTask)

/// <summary>

/// 테스트 2 처리하기

/// </summary>

/// <param name="taskName">태스크명</param>

/// <param name="precedingTask">선행 태스크</param>

private static void Test2(string taskName, Task<int> precedingTask)

{

int threadID = Thread.CurrentThread.ManagedThreadId;

bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

Console.WriteLine

(

"[{0}] 선행 태스크 스레드 ID : {1}, 스레드 ID : {2}, 스레드 풀 스레드 여부 : {3}",

taskName,

precedingTask.Result,

threadID,

isThreadPoolThread

);

}

#endregion

...

Task<int> task1 = new Task<int>(() => Test1("태스크 #1", 3));

Task<int> task2 = new Task<int>(() => Test1("태스크 #2", 2));

task1.ContinueWith(t => Test2("태스크 #3", t), TaskContinuationOptions.OnlyOnRanToCompletion);

task2.ContinueWith(t => Test2("태스크 #4", t), TaskContinuationOptions.OnlyOnRanToCompletion);

task1.Start();

task2.Start();

Thread.Sleep(TimeSpan.FromSeconds(4));

Console.WriteLine("작업을 완료했습니다.");

[C#/TPL] Task 클래스 : RunSynchronously 메소드를 사용해 태스크 실행하기

■ Task<T> 클래스의 RunSynchronously 메소드를 사용해 태스크를 실행하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

...

#region 테스트 처리하기 - Test(taskName)

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <returns>처리 결과</returns>
private int Test(string taskName)
{
    int  threadID           = Thread.CurrentThread.ManagedThreadId;
    bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

    Console.WriteLine("[{0}] 스레드 ID : {1}, 스레드 풀 여부 : {2}", taskName, threadID, isThreadPoolThread);

    Thread.Sleep(TimeSpan.FromSeconds(2));

    return DateTime.Now.Millisecond;
}

#endregion

...

Task<int> task = new Task<int>(() => Test("태스크 #1"));

task.RunSynchronously();

Console.WriteLine("[태스크 #1] 처리 결과 : {0}", task.Result);

Console.WriteLine("작업을 완료했습니다.");

using System;

using System.Threading;

using System.Threading.Tasks;

...

#region 테스트 처리하기 - Test(taskName)

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <param name="taskName">태스크명</param>

/// <returns>처리 결과</returns>

private int Test(string taskName)

{

int threadID = Thread.CurrentThread.ManagedThreadId;

bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

Console.WriteLine("[{0}] 스레드 ID : {1}, 스레드 풀 여부 : {2}", taskName, threadID, isThreadPoolThread);

Thread.Sleep(TimeSpan.FromSeconds(2));

return DateTime.Now.Millisecond;

}

#endregion

...

Task<int> task = new Task<int>(() => Test("태스크 #1"));

task.RunSynchronously();

Console.WriteLine("[태스크 #1] 처리 결과 : {0}", task.Result);

Console.WriteLine("작업을 완료했습니다.");

[C#/TPL] Task 클래스 : Start 메소드를 사용해 태스크 실행하기

■ Task<T> 클래스의 Start 메소드를 사용해 태스크를 실행하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

...

#region 테스트 처리하기 - Test(taskName)

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <returns>처리 결과</returns>
private int Test(string taskName)
{
    int  threadID           = Thread.CurrentThread.ManagedThreadId;
    bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

    Console.WriteLine("[{0}] 스레드 ID : {1}, 스레드 풀 여부 : {2}", taskName, threadID, isThreadPoolThread);

    Thread.Sleep(TimeSpan.FromSeconds(2));

    return DateTime.Now.Millisecond;
}

#endregion

...

Task<int> task = new Task<int>(() => Test("태스크 #1"));

task.Start();

// 아래 문장에서 task.Result를 참조하기 때문에 메인 스레드가 봉쇄 상태에서 기다린다.
Console.WriteLine("[태스크 #1] 처리 결과 : {0}", task.Result);

Console.WriteLine("작업을 완료했습니다.");

using System;

using System.Threading;

using System.Threading.Tasks;

...

#region 테스트 처리하기 - Test(taskName)

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <param name="taskName">태스크명</param>

/// <returns>처리 결과</returns>

private int Test(string taskName)

{

int threadID = Thread.CurrentThread.ManagedThreadId;

bool isThreadPoolThread = Thread.CurrentThread.IsThreadPoolThread;

Console.WriteLine("[{0}] 스레드 ID : {1}, 스레드 풀 여부 : {2}", taskName, threadID, isThreadPoolThread);

Thread.Sleep(TimeSpan.FromSeconds(2));

return DateTime.Now.Millisecond;

}

#endregion

...

Task<int> task = new Task<int>(() => Test("태스크 #1"));

task.Start();

// 아래 문장에서 task.Result를 참조하기 때문에 메인 스레드가 봉쇄 상태에서 기다린다.

Console.WriteLine("[태스크 #1] 처리 결과 : {0}", task.Result);

Console.WriteLine("작업을 완료했습니다.");

[C#/TPL] async … await 키워드 사용하기

■ async … await 키워드를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

...

private ListBox listBox;
private TextBox textBox;

...

#region 버튼 클릭시 처리하기 - button_Click(sender, e)

/// <summary>
/// 버튼 클릭시 처리하기
/// </summary>
/// <param name="sender">이벤트 발생자</param>
/// <param name="e">이벤트 인자</param>
async private void button_Click(object sender, EventArgs e)
{
    await AddItemAsync(this.textBox.Text, 10);
}

#endregion

#region 항목 비동기 추가하기 - AddItemAsync(message, count)

/// <summary>
/// 항목 비동기 추가하기
/// </summary>
/// <param name="message">메시지</param>
/// <param name="count">카운트</param>
/// <returns>태스크</returns>
private Task AddItemAsync(string message, int count)
{
    return Task.Run(() =>
    {
        for(int i = 0; i < count; i++)
        {
            this.listBox.Items.Add(message + ", " + i.ToString());

            Thread.Sleep(500);
        }
    });
}

#endregion

using System;

using System.Threading;

using System.Threading.Tasks;

using System.Windows.Forms;

...

private ListBox listBox;

private TextBox textBox;

...

#region 버튼 클릭시 처리하기 - button_Click(sender, e)

/// <summary>

/// 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

async private void button_Click(object sender, EventArgs e)

{

await AddItemAsync(this.textBox.Text, 10);

}

#endregion

#region 항목 비동기 추가하기 - AddItemAsync(message, count)

/// <summary>

/// 항목 비동기 추가하기

/// </summary>

/// <param name="message">메시지</param>

/// <param name="count">카운트</param>

/// <returns>태스크</returns>

private Task AddItemAsync(string message, int count)

{

return Task.Run(() =>

{

for(int i = 0; i < count; i++)

{

this.listBox.Items.Add(message + ", " + i.ToString());

Thread.Sleep(500);

}

});

}

#endregion

[C#/TPL] async … await 키워드 사용하기

■ async … await 키워드를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

...

private ListBox listBox;
private TextBox textBox;

...

#region 버튼 클릭시 처리하기 - button_Click(sender, e)

/// <summary>
/// 버튼 클릭시 처리하기
/// </summary>
/// <param name="sender">이벤트 발생자</param>
/// <param name="e">이벤트 인자</param>
async private void button_Click(object sender, EventArgs e)
{
    await AddItemAsync(this.textBox.Text, 10);
}

#endregion

#region 항목 비동기 추가하기 - AddItemAsync(message, count)

/// <summary>
/// 항목 비동기 추가하기
/// </summary>
/// <param name="message">메시지</param>
/// <param name="count">카운트</param>
/// <returns>태스크</returns>
private Task AddItemAsync(string message, int count)
{
    Action action = delegate()
    {
        for(int i = 0; i < count; i++)
        {
            this.listBox.Items.Add(message +", " + i.ToString());

            Thread.Sleep(500);
        }
    };

    Task task = new Task(action);

    task.Start();

    return task;
}

#endregion

using System;

using System.Threading;

using System.Threading.Tasks;

using System.Windows.Forms;

...

private ListBox listBox;

private TextBox textBox;

...

#region 버튼 클릭시 처리하기 - button_Click(sender, e)

/// <summary>

/// 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

async private void button_Click(object sender, EventArgs e)

{

await AddItemAsync(this.textBox.Text, 10);

}

#endregion

#region 항목 비동기 추가하기 - AddItemAsync(message, count)

/// <summary>

/// 항목 비동기 추가하기

/// </summary>

/// <param name="message">메시지</param>

/// <param name="count">카운트</param>

/// <returns>태스크</returns>

private Task AddItemAsync(string message, int count)

{

Action action = delegate()

{

for(int i = 0; i < count; i++)

{

this.listBox.Items.Add(message +", " + i.ToString());

Thread.Sleep(500);

}

};

Task task = new Task(action);

task.Start();

return task;

}

#endregion

[C#/TPL] async … await 키워드 사용하기

■ async … await 키워드를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

...

private ListBox listBox;
private TextBox textBox;

...

#region 버튼 클릭시 처리하기 - button_Click(sender, e)

/// <summary>
/// 버튼 클릭시 처리하기
/// </summary>
/// <param name="sender">이벤트 발생자</param>
/// <param name="e">이벤트 인자</param>
async private void button_Click(object sender, EventArgs e)
{
    await Task.Run(() =>
    {
            for(int i = 0; i < 10; i++)
            {
                this.listBox.Items.Add(this.textBox.Text + ", " + i.ToString());

                Thread.Sleep(500);
            }
    });
}

#endregion

using System;

using System.Threading;

using System.Threading.Tasks;

using System.Windows.Forms;

...

private ListBox listBox;

private TextBox textBox;

...

#region 버튼 클릭시 처리하기 - button_Click(sender, e)

/// <summary>

/// 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

async private void button_Click(object sender, EventArgs e)

{

await Task.Run(() =>

{

for(int i = 0; i < 10; i++)

{

this.listBox.Items.Add(this.textBox.Text + ", " + i.ToString());

Thread.Sleep(500);

}

});

}

#endregion