CONCURRENCY Archives - 15 중 13 번째 페이지

[C#/COMMON] 프로세스 메모리 크기 구하기

■ 프로세스의 메모리 크기를 구하는 방법을 보여준다. ▶ 프로세스 메모리 크기 구하기 예제 (C#)


using System;
using System.Diagnostics;

Process process = Process.GetCurrentProcess();

long processMemorySize = GetProcessMemorySize(process.ProcessName);

string processMemorySizeString = GetMemorySizeString(processMemorySize); // '메모리 크기 문자열 구하기' 참조

Console.WriteLine("프로세스 메모리 크기 : " + processMemorySizeString);

using System;

using System.Diagnostics;

Process process = Process.GetCurrentProcess();

long processMemorySize = GetProcessMemorySize(process.ProcessName);

string processMemorySizeString = GetMemorySizeString(processMemorySize); // '메모리 크기 문자열 구하기' 참조

Console.WriteLine("프로세스 메모리 크기 : " + processMemorySizeString);

▶ 프로세스 메모리 크기 구하기 (C#)


using System;
using System.Diagnostics;

#region 프로세스 메모리 크기 구하기 - GetProcessMemorySize(processName)

/// <summary>
/// 프로세스 메모리 크기 구하기
/// </summary>
/// <param name="processName">프로세스명</param>
/// <returns>프로세스 메모리 크기</returns>
public long GetProcessMemorySize(string processName)
{
    PerformanceCounter performanceCounter = new PerformanceCounter("Process", "Working Set - Private", processName);

    long memorySize = performanceCounter.RawValue;

    return memorySize;
}

#endregion

using System;

using System.Diagnostics;

#region 프로세스 메모리 크기 구하기 - GetProcessMemorySize(processName)

/// <summary>

/// 프로세스 메모리 크기 구하기

/// </summary>

/// <param name="processName">프로세스명</param>

/// <returns>프로세스 메모리 크기</returns>

public long GetProcessMemorySize(string processName)

{

PerformanceCounter performanceCounter = new PerformanceCounter("Process", "Working Set - Private", processName);

long memorySize = performanceCounter.RawValue;

return memorySize;

}

#endregion

[C#/COMMON] Thread 클래스 사용하기

■ Thread 클래스를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Threading;

namespace TestThread
{
    /// <summary>
    /// 프로그램
    /// </summary>
    class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            Thread thread = new Thread(ProcessWork);

            thread.Start();

            for(int i = 0; i < 3; i++)
            {
                Console.WriteLine("주 스레드 카운터 : {0}", i);

                Thread.Sleep(5);
            }

            thread.Join();

            Console.WriteLine("스레드가 종료됩니다.");
        }

        #endregion
        #region 작업 처리하기 - ProcessWork()

        /// <summary>
        /// 작업 처리하기
        /// </summary>
        private static void ProcessWork()
        {
            for(int i = 0; i < 10; i++)
            {
                Console.WriteLine("외부 스레드 카운터 : {0}", i);

                Thread.Sleep(5);
            }
        }

        #endregion
    }
}

using System;

using System.Threading;

namespace TestThread

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

Thread thread = new Thread(ProcessWork);

thread.Start();

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

{

Console.WriteLine("주 스레드 카운터 : {0}", i);

Thread.Sleep(5);

}

thread.Join();

Console.WriteLine("스레드가 종료됩니다.");

}

#endregion

#region 작업 처리하기 - ProcessWork()

/// <summary>

/// 작업 처리하기

/// </summary>

private static void ProcessWork()

{

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

{

Console.WriteLine("외부 스레드 카운터 : {0}", i);

Thread.Sleep(5);

}

#endregion

}

[C#/COMMON] Process 클래스 : 인터넷 익스플로러 실행하기

■ Process 클래스를 사용해 인터넷 익스플로러를 실행하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Diagnostics;

ProcessStartInfo processStartInfo = new ProcessStartInfo("IExplore.exe");

processStartInfo.Arguments = "http://www.naver.com";

Process process = new Process();

process.StartInfo = processStartInfo;

process.Start();

process.WaitForExit();

using System.Diagnostics;

ProcessStartInfo processStartInfo = new ProcessStartInfo("IExplore.exe");

processStartInfo.Arguments = "http://www.naver.com";

Process process = new Process();

process.StartInfo = processStartInfo;

process.Start();

process.WaitForExit();

[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#/WPF] UI 스레드에서 태스크 비동기 처리하기

■ UI 스레드에서 태스크를 비동기 처리하는 방법을 보여준다. ▶ MainWindow.xaml


<Window x:Class="MainProject.TestWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="TestProject"
    Width="600"
    Height="450"
    FontFamily="나눔고딕코딩"
    FontSize="16">
    <StackPanel>
        <TextBlock x:Name="messageTextBlock"
            Margin="10 50 10 50"
            HorizontalAlignment="Center"
            Height="40" />
        <Button
            Content="Async Test"
            Width="100"
            Height="30"
            Click="asyncTestButton_Click" />
    </StackPanel>
</Window>

<Window x:Class="MainProject.TestWindow"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Title="TestProject"

Width="600"

Height="450"

FontFamily="나눔고딕코딩"

FontSize="16">

<TextBlock x:Name="messageTextBlock"

Margin="10 50 10 50"

HorizontalAlignment="Center"

Height="40" />

<Button

Content="Async Test"

Width="100"

Height="30"

Click="asyncTestButton_Click" />

</StackPanel>

</Window>

▶ MainWindow.xaml.cs


using System;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;

namespace TestProject
{
    /// <summary>
    /// 메인 윈도우
    /// </summary>
    public partial class MainWindow : Window
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainWindow()

        /// <summary>
        /// 생성자
        /// </summary>
        public MainWindow()
        {
            InitializeComponent();
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private
        //////////////////////////////////////////////////////////////////////////////// Event

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

        /// <summary>
        /// Async Test 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void asyncTestButton_Click(object sender, RoutedEventArgs e)
        {
            this.messageTextBlock.Text = string.Empty;

            Mouse.OverrideCursor = Cursors.Wait;

            Task<string> task = Test(TaskScheduler.FromCurrentSynchronizationContext());

            task.ContinueWith
            (
                t => Mouse.OverrideCursor = null,
                CancellationToken.None,
                TaskContinuationOptions.None,
                TaskScheduler.FromCurrentSynchronizationContext()
            );
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////// Function

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

        /// <summary>
        /// 테스트 처리하기
        /// </summary>
        /// <param name="taskScheduler">태스크 스케줄러</param>
        /// <returns>태스크</returns>
        private Task<string> Test(TaskScheduler taskScheduler)
        {
            Task task = Task.Delay(TimeSpan.FromSeconds(5));

            return task.ContinueWith
            (
                t =>
                {
                    string text = string.Format
                    (
                        "[{0} 스레드 ] 스레드 풀 스레드 여부 : {1}",
                        Thread.CurrentThread.ManagedThreadId,
                        Thread.CurrentThread.IsThreadPoolThread
                    );

                    this.messageTextBlock.Text = text;

                    return text;
                },
                taskScheduler
            );
        }

        #endregion
    }
}

using System;

using System.Threading;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Input;

namespace TestProject

{

/// <summary>

/// 메인 윈도우

/// </summary>

public partial class MainWindow : Window

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainWindow()

/// <summary>

/// 생성자

/// </summary>

public MainWindow()

{

InitializeComponent();

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Private

//////////////////////////////////////////////////////////////////////////////// Event

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

/// <summary>

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

/// </summary>

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

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

private void asyncTestButton_Click(object sender, RoutedEventArgs e)

{

this.messageTextBlock.Text = string.Empty;

Mouse.OverrideCursor = Cursors.Wait;

Task<string> task = Test(TaskScheduler.FromCurrentSynchronizationContext());

task.ContinueWith

(

t => Mouse.OverrideCursor = null,

CancellationToken.None,

TaskContinuationOptions.None,

TaskScheduler.FromCurrentSynchronizationContext()

);

}

#endregion

//////////////////////////////////////////////////////////////////////////////// Function

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

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <param name="taskScheduler">태스크 스케줄러</param>

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

private Task<string> Test(TaskScheduler taskScheduler)

{

Task task = Task.Delay(TimeSpan.FromSeconds(5));

return task.ContinueWith

(

t =>

{

string text = string.Format

(

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

Thread.CurrentThread.ManagedThreadId,

Thread.CurrentThread.IsThreadPoolThread

);

this.messageTextBlock.Text = text;

return text;

taskScheduler

);

}

#endregion

}

[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#/COMMON] Process 클래스 : 프로세스 리스트 구하기

■ Process 클래스를 사용해 프로세스 리스트를 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Collections.Generic;
using System.Diagnostics;

#region 프로세스 리스트 구하기 - GetProcessList(filePath)

/// <summary>
/// 프로세스 리스트 구하기
/// </summary>
/// <param name="filePath">파일 경로</param>
/// <returns>프로세스 리스트</returns>
public List<Process> GetProcessList(string filePath)
{
    List<Process> processList = new List<Process>();

    foreach(Process process in Process.GetProcesses())
    {
        try
        {
            if(process.MainModule.FileName.Equals(filePath))
            {
                processList.Add(process);
            }
        }
        catch
        {
        }
    }

    return processList;
}

#endregion
#region 프로세스 리스트 구하기 - GetProcessList()

/// <summary>
/// 프로세스 리스트 구하기
/// </summary>
/// <returns>프로세스 리스트</returns>
public List<Process> GetProcessList()
{
    string fileName = Process.GetCurrentProcess().MainModule.FileName;

    return GetProcessList(fileName);
}

#endregion

using System.Collections.Generic;

using System.Diagnostics;

#region 프로세스 리스트 구하기 - GetProcessList(filePath)

/// <summary>

/// 프로세스 리스트 구하기

/// </summary>

/// <param name="filePath">파일 경로</param>

/// <returns>프로세스 리스트</returns>

public List<Process> GetProcessList(string filePath)

{

List<Process> processList = new List<Process>();

foreach(Process process in Process.GetProcesses())

{

try

{

if(process.MainModule.FileName.Equals(filePath))

{

processList.Add(process);

}

catch

{

}

return processList;

}

#endregion

#region 프로세스 리스트 구하기 - GetProcessList()

/// <summary>

/// 프로세스 리스트 구하기

/// </summary>

/// <returns>프로세스 리스트</returns>

public List<Process> GetProcessList()

{

string fileName = Process.GetCurrentProcess().MainModule.FileName;

return GetProcessList(fileName);

}

#endregion

[C#/COMMON] 쓰기/읽기 작업을 비동기 순차 처리하기

■ 쓰기/읽기 작업을 비동기 순차 처리하는 방법을 보여준다. 작업 조건이 아래와 같은 경우를 위한 비동기 순차 처리 코드이다. . 1번 쓰기 작업

[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("작업을 완료했습니다.");