TPL Archives - 5 중 3 번째 페이지

[C#/TPL] Task 클래스 : 일정 주기 반복 태스크 시작하기

■ Task 클래스를 사용해 일정 주기 반복 태스크를 시작하는 방법을 보여준다. ▶ Program.cs


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

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

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

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        /// <param name="argumentArray">인자 배열</param>
        private static void Main(string[] argumentArray)
        {
            Action action = () =>
            {
                Console.WriteLine(DateTime.Now.ToString("HH:mm:ss"));
            };

            StartPeriodicTask(action, 1000, 0, CancellationToken.None);

            Console.ReadKey(false);
        }

        #endregion
        #region 일정 주기 반복 태스크 시작하기 - StartPeriodicTask(action, interval, delay, token)

        /// <summary>
        /// 일정 주기 반복 태스크 시작하기
        /// </summary>
        /// <param name="action"></param>
        /// <param name="interval">간격 (단위 : 밀리초)</param>
        /// <param name="delay">지연 (단위 : 밀리초)</param>
        /// <param name="token">취소 토큰</param>
        /// <returns>태스크</returns>
        private static Task StartPeriodicTask(Action action, int interval, int delay, CancellationToken token)
        {
            Action wrapperAction = () =>
            {
                if(token.IsCancellationRequested)
                {
                    return;
                }

                action();
            };

            Action mainAction = () =>
            {
                TaskCreationOptions options = TaskCreationOptions.AttachedToParent;

                if(token.IsCancellationRequested)
                {
                    return;
                }

                if(delay > 0)
                {
                    Thread.Sleep(delay);
                }

                while(true)
                {
                    if(token.IsCancellationRequested)
                    {
                        break;
                    }

                    Task.Factory.StartNew(wrapperAction, token, options, TaskScheduler.Current);

                    if(token.IsCancellationRequested || interval == Timeout.Infinite)
                    {
                        break;
                    }

                    Thread.Sleep(interval);
                }
            };

            return Task.Factory.StartNew(mainAction, token);
        }

        #endregion
    }
}

using System;

using System.Threading;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

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

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

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

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

/// <param name="argumentArray">인자 배열</param>

private static void Main(string[] argumentArray)

{

Action action = () =>

{

Console.WriteLine(DateTime.Now.ToString("HH:mm:ss"));

};

StartPeriodicTask(action, 1000, 0, CancellationToken.None);

Console.ReadKey(false);

}

#endregion

#region 일정 주기 반복 태스크 시작하기 - StartPeriodicTask(action, interval, delay, token)

/// <summary>

/// 일정 주기 반복 태스크 시작하기

/// </summary>

/// <param name="action"></param>

/// <param name="interval">간격 (단위 : 밀리초)</param>

/// <param name="delay">지연 (단위 : 밀리초)</param>

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

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

private static Task StartPeriodicTask(Action action, int interval, int delay, CancellationToken token)

{

Action wrapperAction = () =>

{

if(token.IsCancellationRequested)

{

return;

}

action();

};

Action mainAction = () =>

{

TaskCreationOptions options = TaskCreationOptions.AttachedToParent;

if(token.IsCancellationRequested)

{

return;

}

if(delay > 0)

{

Thread.Sleep(delay);

}

while(true)

{

if(token.IsCancellationRequested)

{

break;

}

Task.Factory.StartNew(wrapperAction, token, options, TaskScheduler.Current);

if(token.IsCancellationRequested || interval == Timeout.Infinite)

{

break;

}

Thread.Sleep(interval);

}

};

return Task.Factory.StartNew(mainAction, token);

}

#endregion

}

TestProject.zip

[C#/TPL] Task 클래스 : 태스크 완료시/에러시 처리하기

■ Task 클래스를 사용해 태스크 완료시/에러시 처리하는 방법을 보여준다. ▶ TaskExtension.cs


using System;
using System.Threading.Tasks;

namespace TestProject
{
    /// <summary>
    /// 태스크 확장
    /// </summary>
    public static class TaskExtension
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 대기하기 - Await(task, completedAction, errorAction)

        /// <summary>
        /// 대기하기
        /// </summary>
        /// <param name="task">태스크</param>
        /// <param name="completedAction">완료시 액션</param>
        /// <param name="errorAction">에러 액션</param>
        public async static void Await(this Task task, Action completedAction, Action<Exception> errorAction)
        {
            try
            {
                await task;

                completedAction?.Invoke();
            }
            catch(Exception exception)
            {
                errorAction?.Invoke(exception);
            }
        }

        #endregion
    }
}

using System;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 태스크 확장

/// </summary>

public static class TaskExtension

{

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

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

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

#region 대기하기 - Await(task, completedAction, errorAction)

/// <summary>

/// 대기하기

/// </summary>

/// <param name="task">태스크</param>

/// <param name="completedAction">완료시 액션</param>

/// <param name="errorAction">에러 액션</param>

public async static void Await(this Task task, Action completedAction, Action<Exception> errorAction)

{

try

{

await task;

completedAction?.Invoke();

}

catch(Exception exception)

{

errorAction?.Invoke(exception);

}

#endregion

}

▶ MainWindow.xaml


<Window x:Class="TestProject.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Width="800"
    Height="600"
    Title="Task 클래스 : 태스크 완료시/에러시 처리하기"
    FontFamily="나눔고딕코딩"
    FontSize="16">
    <Grid>
        <TextBlock Name="textBlock"
            HorizontalAlignment="Center"
            VerticalAlignment="Center"
            FontSize="32" />
    </Grid>
</Window>

<Window x:Class="TestProject.MainWindow"

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

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

Width="800"

Height="600"

Title="Task 클래스 : 태스크 완료시/에러시 처리하기"

FontFamily="나눔고딕코딩"

FontSize="16">

<Grid>

<TextBlock Name="textBlock"

HorizontalAlignment="Center"

VerticalAlignment="Center"

FontSize="32" />

</Grid>

</Window>

▶ MainWindow.xaml.cs


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

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

        #region 생성자 - MainWindow()

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

            Loaded += Window_Loaded;
        }

        #endregion

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

        #region 윈도우 로드시 처리하기 - Window_Loaded(sender, e)

        /// <summary>
        /// 윈도우 로드시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            this.textBlock.Text = "기본 값";

            ProcessTask().Await(ProcessCompleted, ProcessError);
        }

        #endregion

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

        #region 태스크 처리하기 - ProcessTask()

        /// <summary>
        /// 태스크 처리하기
        /// </summary>
        /// <returns>태스크</returns>
        private async Task ProcessTask()
        {
            await Task.Delay(3000);

            //throw new Exception("에러 발생");
        }

        #endregion
        #region 완료시 처리하기 - ProcessCompleted()

        /// <summary>
        /// 완료시 처리하기
        /// </summary>
        private void ProcessCompleted()
        {
            this.textBlock.Text = "작업 완료";
        }

        #endregion
        #region 에러시 처리하기 - ProcessError(e)

        /// <summary>
        /// 에러시 처리하기
        /// </summary>
        /// <param name="e">이벤트 인자</param>
        private void ProcessError(Exception e)
        {
            this.textBlock.Text = e.Message;
        }

        #endregion
    }
}

using System;

using System.Threading.Tasks;

using System.Windows;

namespace TestProject

{

/// <summary>

/// 메인 윈도우

/// </summary>

public partial class MainWindow : Window

{

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

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

#region 생성자 - MainWindow()

/// <summary>

/// 생성자

/// </summary>

public MainWindow()

{

InitializeComponent();

Loaded += Window_Loaded;

}

#endregion

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

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

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

#region 윈도우 로드시 처리하기 - Window_Loaded(sender, e)

/// <summary>

/// 윈도우 로드시 처리하기

/// </summary>

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

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

private void Window_Loaded(object sender, RoutedEventArgs e)

{

this.textBlock.Text = "기본 값";

ProcessTask().Await(ProcessCompleted, ProcessError);

}

#endregion

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

#region 태스크 처리하기 - ProcessTask()

/// <summary>

/// 태스크 처리하기

/// </summary>

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

private async Task ProcessTask()

{

await Task.Delay(3000);

//throw new Exception("에러 발생");

}

#endregion

#region 완료시 처리하기 - ProcessCompleted()

/// <summary>

/// 완료시 처리하기

/// </summary>

private void ProcessCompleted()

{

this.textBlock.Text = "작업 완료";

}

#endregion

#region 에러시 처리하기 - ProcessError(e)

/// <summary>

/// 에러시 처리하기

/// </summary>

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

private void ProcessError(Exception e)

{

this.textBlock.Text = e.Message;

}

#endregion

}

TestProject.zip

[C#/TPL] Task 클래스 : 변환 함수를 사용해 비동기 변환하기

■ Task<T> 클래스에서 변환 함수를 사용해 비동기 변환하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Threading.Tasks;

#region 변환하기 - Convert<TSource, TTarget>(sourceTask, convertFunction)

/// <summary>
/// 변환하기
/// </summary>
/// <typeparam name="TSource">소스 타입</typeparam>
/// <typeparam name="TTarget">타겟 타입</typeparam>
/// <param name="sourceTask">소스 태스크</param>
/// <param name="convertFunction">변환 함수</param>
/// <returns>타겟 태스크</returns>
public async Task<TTarget> Convert<TSource, TTarget>
(
    Task<TSource>                sourceTask,
    Func<TSource, Task<TTarget>> convertFunction
)
{
    TSource source = await sourceTask;

    Task<TTarget> resultTask = convertFunction(source);

    return await resultTask;
}

#endregion

using System;

using System.Threading.Tasks;

#region 변환하기 - Convert<TSource, TTarget>(sourceTask, convertFunction)

/// <summary>

/// 변환하기

/// </summary>

/// <typeparam name="TSource">소스 타입</typeparam>

/// <typeparam name="TTarget">타겟 타입</typeparam>

/// <param name="sourceTask">소스 태스크</param>

/// <param name="convertFunction">변환 함수</param>

/// <returns>타겟 태스크</returns>

public async Task<TTarget> Convert<TSource, TTarget>

(

Task<TSource> sourceTask,

Func<TSource, Task<TTarget>> convertFunction

)

{

TSource source = await sourceTask;

Task<TTarget> resultTask = convertFunction(source);

return await resultTask;

}

#endregion

[C#/TPL] 함수형 확장 사용하기

■ 함수형 확장을 사용하는 방법을 보여준다. ▶ FunctionalExtension.cs


using System;
using System.Threading.Tasks;

namespace TestProject
{
    /// <summary>
    /// 함수형 확장
    /// </summary>
    public static class FunctionalExtension
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 함수 실행하기 - ExecuteFunction<TSource, TResult>(sourceTask, function)

        /// <summary>
        /// 함수 실행하기
        /// </summary>
        /// <typeparam name="TSource">소스 타입</typeparam>
        /// <typeparam name="TResult">결과 타입</typeparam>
        /// <param name="sourceTask">소스 태스크</param>
        /// <param name="function">함수</param>
        /// <returns>태스크</returns>
        public static async Task<TResult> ExecuteFunction<TSource, TResult>
        (
            this Task<TSource>           sourceTask,
            Func<TSource, Task<TResult>> function
        )
        => await function(await sourceTask);

        #endregion
    }
}

using System;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 함수형 확장

/// </summary>

public static class FunctionalExtension

{

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

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

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

#region 함수 실행하기 - ExecuteFunction<TSource, TResult>(sourceTask, function)

/// <summary>

/// 함수 실행하기

/// </summary>

/// <typeparam name="TSource">소스 타입</typeparam>

/// <typeparam name="TResult">결과 타입</typeparam>

/// <param name="sourceTask">소스 태스크</param>

/// <param name="function">함수</param>

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

public static async Task<TResult> ExecuteFunction<TSource, TResult>

(

this Task<TSource> sourceTask,

Func<TSource, Task<TResult>> function

)

=> await function(await sourceTask);

#endregion

}

▶ Program.cs


using System;
using System.Threading.Tasks;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    public class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region A 곱하기 (비동기) - MultiplyAAsync(a)

        /// <summary>
        /// A 곱하기 (비동기)
        /// </summary>
        /// <param name="a">A</param>
        /// <returns>곱셈 결과</returns>
        private async static Task<int> MultiplyAAsync(int a) => await Task.FromResult(a * 1);

        #endregion
        #region B 곱하기 (비동기) - MultiplyBAsync(b)

        /// <summary>
        /// B 곱하기 (비동기)
        /// </summary>
        /// <param name="b">B</param>
        /// <returns>곱셈 결과</returns>
        private async static Task<int> MultiplyBAsync(int b) => await Task.FromResult(b * 2);

        #endregion
        #region C 곱하기 (비동기) - MultiplyCAsync(c)

        /// <summary>
        /// C 곱하기 (비동기)
        /// </summary>
        /// <param name="c">C</param>
        /// <returns>곱셈 결과</returns>
        private async static Task<int> MultiplyCAsync(int c) => await Task.FromResult(c * 3);

        #endregion
        #region 곱하기 - Multiply()

        /// <summary>
        /// 곱하기
        /// </summary>
        public async static void Multiply()
        {
            int result = await MultiplyAAsync(10)
                .ExecuteFunction(MultiplyBAsync)
                .ExecuteFunction(MultiplyCAsync);

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

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

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            Multiply();
        }

        #endregion
    }
}

using System;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

public class Program

{

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

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

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

#region A 곱하기 (비동기) - MultiplyAAsync(a)

/// <summary>

/// A 곱하기 (비동기)

/// </summary>

/// <param name="a">A</param>

/// <returns>곱셈 결과</returns>

private async static Task<int> MultiplyAAsync(int a) => await Task.FromResult(a * 1);

#endregion

#region B 곱하기 (비동기) - MultiplyBAsync(b)

/// <summary>

/// B 곱하기 (비동기)

/// </summary>

/// <param name="b">B</param>

/// <returns>곱셈 결과</returns>

private async static Task<int> MultiplyBAsync(int b) => await Task.FromResult(b * 2);

#endregion

#region C 곱하기 (비동기) - MultiplyCAsync(c)

/// <summary>

/// C 곱하기 (비동기)

/// </summary>

/// <param name="c">C</param>

/// <returns>곱셈 결과</returns>

private async static Task<int> MultiplyCAsync(int c) => await Task.FromResult(c * 3);

#endregion

#region 곱하기 - Multiply()

/// <summary>

/// 곱하기

/// </summary>

public async static void Multiply()

{

int result = await MultiplyAAsync(10)

.ExecuteFunction(MultiplyBAsync)

.ExecuteFunction(MultiplyCAsync);

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

}

#endregion

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

Multiply();

}

#endregion

}

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

■ async … await 키워드를 사용하는 방법을 보여준다. ▶ Program.cs


using System;
using System.IO;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// 완료 여부
        /// </summary>
        static bool _isCompleted;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 파일 읽기 (비동기) - ReadFileAsync()

        /// <summary>
        /// 파일 읽기 (비동기)
        /// </summary>
        public static async void ReadFileAsync()
        {
            FileStream fileStream = File.OpenRead("d:\\source.txt");

            byte[] bufferByteArray = new byte[fileStream.Length];

            int byteCount = await fileStream.ReadAsync(bufferByteArray, 0, (int)fileStream.Length);

            Console.WriteLine("바이트 수 : {0}", byteCount);

            _isCompleted = true;

            fileStream.Dispose();
        }

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

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            _isCompleted = false;

            ReadFileAsync();

            int i = 0;

            do
            {
                Console.WriteLine("타이머 카운터 : {0}", ++i);
            }
            while(!_isCompleted);
        }

        #endregion
    }
}

using System;

using System.IO;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

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

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

#region Field

/// <summary>

/// 완료 여부

/// </summary>

static bool _isCompleted;

#endregion

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

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

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

#region 파일 읽기 (비동기) - ReadFileAsync()

/// <summary>

/// 파일 읽기 (비동기)

/// </summary>

public static async void ReadFileAsync()

{

FileStream fileStream = File.OpenRead("d:\\source.txt");

byte[] bufferByteArray = new byte[fileStream.Length];

int byteCount = await fileStream.ReadAsync(bufferByteArray, 0, (int)fileStream.Length);

Console.WriteLine("바이트 수 : {0}", byteCount);

_isCompleted = true;

fileStream.Dispose();

}

#endregion

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

_isCompleted = false;

ReadFileAsync();

int i = 0;

{

Console.WriteLine("타이머 카운터 : {0}", ++i);

}

while(!_isCompleted);

}

#endregion

}

[C#/TPL] CancellationToken 클래스 : 태스크 실행 취소하기

■ CancellationToken 클래스를 사용해 태스크 실행을 취소하는 방법을 보여준다. ▶ Program.cs


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

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

        #region 파일 읽기 (비동기) - ReadFileAsync(filePath)

        /// <summary>
        /// 파일 읽기 (비동기)
        /// </summary>
        /// <param name="filePath">파일 경로</param>
        /// <returns>태스크</returns>
        private static Task<int> ReadFileAsync(string filePath)
        {
            FileStream fileStream = File.OpenRead(filePath);

            byte[] bufferByteArray = new byte[fileStream.Length];

            Task<int> task = Task.Factory.FromAsync
            (
                (Func<byte[], int, int, AsyncCallback, object, IAsyncResult>)fileStream.BeginRead,
                (Func<IAsyncResult, int>)fileStream.EndRead,
                bufferByteArray,
                0,
                (int)fileStream.Length,
                null
            );

            task.ContinueWith
            (
                task =>
                {
                    if(task.Status == TaskStatus.RanToCompletion)
                    {
                        Console.WriteLine("파일명 : {0}, 바이트 수 : {1}", filePath, task.Result);
                    }

                    fileStream.Dispose();
                }
            );

            return task;
        }

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

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            bool isCompleted = false;

            CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
            CancellationToken       cancellationToken       = cancellationTokenSource.Token;

            Task task1 = ReadFileAsync("d:\\source1.txt");
            Task task2 = ReadFileAsync("d:\\source2.txt");

            Task.WhenAll(task1, task2).ContinueWith
            (
                task =>
                {
                    isCompleted = true;

                    Console.WriteLine("모든 파일 읽기를 성공적으로 완료했습니다.");
                },
                cancellationToken
            );

            int i = 0;

            do
            {
                Console.WriteLine("타이머 카운터 : {0}", ++i);

                if(i > 10)
                {
                    cancellationTokenSource.Cancel();

                    Console.WriteLine($"{i}번째 카운터에서 모든 작업을 취소했습니다.");

                    break;
                }
            }
            while(!isCompleted);
        }

        #endregion
    }
}

100

101

102

103

104

105

using System;

using System.IO;

using System.Threading;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

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

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

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

#region 파일 읽기 (비동기) - ReadFileAsync(filePath)

/// <summary>

/// 파일 읽기 (비동기)

/// </summary>

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

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

private static Task<int> ReadFileAsync(string filePath)

{

FileStream fileStream = File.OpenRead(filePath);

byte[] bufferByteArray = new byte[fileStream.Length];

Task<int> task = Task.Factory.FromAsync

(

(Func<byte[], int, int, AsyncCallback, object, IAsyncResult>)fileStream.BeginRead,

(Func<IAsyncResult, int>)fileStream.EndRead,

bufferByteArray,

(int)fileStream.Length,

null

);

task.ContinueWith

(

task =>

{

if(task.Status == TaskStatus.RanToCompletion)

{

Console.WriteLine("파일명 : {0}, 바이트 수 : {1}", filePath, task.Result);

}

fileStream.Dispose();

}

);

return task;

}

#endregion

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

bool isCompleted = false;

CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();

CancellationToken cancellationToken = cancellationTokenSource.Token;

Task task1 = ReadFileAsync("d:\\source1.txt");

Task task2 = ReadFileAsync("d:\\source2.txt");

Task.WhenAll(task1, task2).ContinueWith

(

task =>

{

isCompleted = true;

Console.WriteLine("모든 파일 읽기를 성공적으로 완료했습니다.");

cancellationToken

);

int i = 0;

{

Console.WriteLine("타이머 카운터 : {0}", ++i);

if(i > 10)

{

cancellationTokenSource.Cancel();

Console.WriteLine($"{i}번째 카운터에서 모든 작업을 취소했습니다.");

break;

}

while(!isCompleted);

}

#endregion

}

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

■ Task 클래스의 WhenAll 정적 메소드를 사용하는 방법을 보여준다. ▶ Program.cs


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

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

        #region 파일 읽기 (비동기) - ReadFileAsync(filePath)

        /// <summary>
        /// 파일 읽기 (비동기)
        /// </summary>
        /// <param name="filePath">파일 경로</param>
        /// <returns>태스크</returns>
        private static Task<int> ReadFileAsync(string filePath)
        {
            FileStream fileStream = File.OpenRead(filePath);

            byte[] bufferByteArray = new byte[fileStream.Length];

            Task<int> task = Task.Factory.FromAsync
            (
                (Func<byte[], int, int, AsyncCallback, object, IAsyncResult>)fileStream.BeginRead,
                (Func<IAsyncResult, int>)fileStream.EndRead,
                bufferByteArray,
                0,
                (int)fileStream.Length,
                null
            );

            task.ContinueWith
            (
                task =>
                {
                    if(task.Status == TaskStatus.RanToCompletion)
                    {
                        Console.WriteLine("파일명 : {0}, 바이트 수 : {1}", filePath, task.Result);
                    }

                    fileStream.Dispose();
                }
            );

            return task;
        }

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

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            bool isCompleted = false;

            Task task1 = ReadFileAsync("d:\\source1.txt");
            Task task2 = ReadFileAsync("d:\\source2.txt");

            Task.WhenAll(task1, task2).ContinueWith
            (
                task =>
                {
                    isCompleted = true;

                    Console.WriteLine("모든 파일 읽기를 성공적으로 완료했습니다.");
                }
            );

            int i = 0;

            do
            {
                Console.WriteLine("타이머 카운터 : {0}", ++i);
            }
            while(!isCompleted);
        }

        #endregion
    }
}

using System;

using System.IO;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

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

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

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

#region 파일 읽기 (비동기) - ReadFileAsync(filePath)

/// <summary>

/// 파일 읽기 (비동기)

/// </summary>

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

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

private static Task<int> ReadFileAsync(string filePath)

{

FileStream fileStream = File.OpenRead(filePath);

byte[] bufferByteArray = new byte[fileStream.Length];

Task<int> task = Task.Factory.FromAsync

(

(Func<byte[], int, int, AsyncCallback, object, IAsyncResult>)fileStream.BeginRead,

(Func<IAsyncResult, int>)fileStream.EndRead,

bufferByteArray,

(int)fileStream.Length,

null

);

task.ContinueWith

(

task =>

{

if(task.Status == TaskStatus.RanToCompletion)

{

Console.WriteLine("파일명 : {0}, 바이트 수 : {1}", filePath, task.Result);

}

fileStream.Dispose();

}

);

return task;

}

#endregion

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

bool isCompleted = false;

Task task1 = ReadFileAsync("d:\\source1.txt");

Task task2 = ReadFileAsync("d:\\source2.txt");

Task.WhenAll(task1, task2).ContinueWith

(

task =>

{

isCompleted = true;

Console.WriteLine("모든 파일 읽기를 성공적으로 완료했습니다.");

}

);

int i = 0;

{

Console.WriteLine("타이머 카운터 : {0}", ++i);

}

while(!isCompleted);

}

#endregion

}

[C#/TPL] TaskFactory 클래스 : FromAsync 메소드를 사용해 비동기 프로그래밍 모델 실행하기

■ TaskFactory 클래스의 FromAsync 메소드를 사용해 비동기 프로그래밍 모델을 실행하는 방법을 보여준다. ▶ Program.cs


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

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// 완료 여부
        /// </summary>
        private static bool _isCompleted;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 파일 읽기 (비동기) - ReadFileAsync(filePath)

        /// <summary>
        /// 파일 읽기 (비동기)
        /// </summary>
        /// <param name="filePath">파일 경로</param>
        /// <returns>태스크</returns>
        private static Task<int> ReadFileAsync(string filePath)
        {
            FileStream fileStream = File.OpenRead(filePath);

            byte[] bufferByteArray = new Byte[fileStream.Length];

            Task<int> task = Task.Factory.FromAsync
            (
                (Func<byte[], int, int, AsyncCallback, object, IAsyncResult>)fileStream.BeginRead,
                (Func<IAsyncResult, int>)fileStream.EndRead,
                bufferByteArray,
                0,
                (int)fileStream.Length,
                null
            );

            task.ContinueWith
            (
                task =>
                {
                    if(task.Status == TaskStatus.RanToCompletion)
                    {
                        _isCompleted = true;

                        Console.WriteLine("파일명 : {0}, 바이트 수 : {1}", filePath, task.Result);
                    }

                    fileStream.Dispose();
                }
            );

            return task;
        }

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

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            _isCompleted = false;

            ReadFileAsync("d:\\source.txt");

            int i = 0;

            do
            {
                Console.WriteLine("타이머 카운터 : {0}", ++i);
            }
            while(!_isCompleted);
        }

        #endregion
    }
}

using System;

using System.IO;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

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

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

#region Field

/// <summary>

/// 완료 여부

/// </summary>

private static bool _isCompleted;

#endregion

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

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

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

#region 파일 읽기 (비동기) - ReadFileAsync(filePath)

/// <summary>

/// 파일 읽기 (비동기)

/// </summary>

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

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

private static Task<int> ReadFileAsync(string filePath)

{

FileStream fileStream = File.OpenRead(filePath);

byte[] bufferByteArray = new Byte[fileStream.Length];

Task<int> task = Task.Factory.FromAsync

(

(Func<byte[], int, int, AsyncCallback, object, IAsyncResult>)fileStream.BeginRead,

(Func<IAsyncResult, int>)fileStream.EndRead,

bufferByteArray,

(int)fileStream.Length,

null

);

task.ContinueWith

(

task =>

{

if(task.Status == TaskStatus.RanToCompletion)

{

_isCompleted = true;

Console.WriteLine("파일명 : {0}, 바이트 수 : {1}", filePath, task.Result);

}

fileStream.Dispose();

}

);

return task;

}

#endregion

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

_isCompleted = false;

ReadFileAsync("d:\\source.txt");

int i = 0;

{

Console.WriteLine("타이머 카운터 : {0}", ++i);

}

while(!_isCompleted);

}

#endregion

}

[C#/TPL] TaskCompletionSource 클래스 : 동기 방식을 비동기식으로 구현하기

■ TaskCompletionSource 클래스를 사용해 동기 방식을 비동기식으로 구현하는 방법을 보여준다. ▶ TestClass.cs


using System;
using System.Threading.Tasks;

namespace TestProject
{
    /// <summary>
    /// 테스트 클래스
    /// </summary>
    public class TestClass
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 비동기 호출하기 - CallAsync()

        /// <summary>
        /// 비동기 호출하기
        /// </summary>
        /// <returns>문자열 태스크</returns>
        public Task<string> CallAsync()
        {
            TaskCompletionSource<string> source = new TaskCompletionSource<string>();

            try
            {
                string text = "비동기 호출!";

                source.SetResult(text);
            }
            catch(Exception exception)
            {
                source.SetException(exception);
            }

            return source.Task;
        }

        #endregion
    }
}

using System;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 테스트 클래스

/// </summary>

public class TestClass

{

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

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

#region 비동기 호출하기 - CallAsync()

/// <summary>

/// 비동기 호출하기

/// </summary>

/// <returns>문자열 태스크</returns>

public Task<string> CallAsync()

{

TaskCompletionSource<string> source = new TaskCompletionSource<string>();

try

{

string text = "비동기 호출!";

source.SetResult(text);

}

catch(Exception exception)

{

source.SetException(exception);

}

return source.Task;

}

#endregion

}

▶ Program.cs


using System;
using System.Threading.Tasks;

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

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

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        /// <returns>태스크</returns>
        private static async Task Main()
        {
            Console.Title = "TaskCompletionSource 클래스 : 동기 방식을 비동기식으로 구현하기";

            string text = await new TestClass().CallAsync();

            Console.WriteLine(text);
        }

        #endregion
    }
}

using System;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

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

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

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

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

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

private static async Task Main()

{

Console.Title = "TaskCompletionSource 클래스 : 동기 방식을 비동기식으로 구현하기";

string text = await new TestClass().CallAsync();

Console.WriteLine(text);

}

#endregion

}

※ Main 함수에서 async를 사용하기 위해서

[C#/TPL] Task 클래스 : 비동기 처리하기

■ Task 클래스를 사용해 비동기 처리하는 방법을 보여준다. ▶ Program.cs


using System;
using System.Threading.Tasks;

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

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

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        /// <returns>태스크</returns>
        private static async Task Main()
        {
            Console.Title = "Task 클래스 : 비동기 처리하기";

            Program program = new Program();

            await program.CallAsync();
        }

        #endregion

        #region 비동기 텍스트 구하기 - GetTextAsync()

        /// <summary>
        /// 비동기 텍스트 구하기
        /// </summary>
        /// <returns>문자열 태스크</returns>
        private async Task<string> GetTextAsync()
        {
            Task<string> task = new TaskFactory().StartNew(() => { return "TEST"; });

            string result = await task;

            return result;
        }

        #endregion
        #region 비동기 호출하기 - CallAsync()

        /// <summary>
        /// 비동기 호출하기
        /// </summary>
        /// <returns>태스크</returns>
        private async Task CallAsync()
        {
            string currentTime = DateTime.Now.ToString();

            string text = await GetTextAsync();

            Console.WriteLine(currentTime + " : " + text);
        }

        #endregion
    }
}

using System;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

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

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

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

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

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

private static async Task Main()

{

Console.Title = "Task 클래스 : 비동기 처리하기";

Program program = new Program();

await program.CallAsync();

}

#endregion

#region 비동기 텍스트 구하기 - GetTextAsync()

/// <summary>

/// 비동기 텍스트 구하기

/// </summary>

/// <returns>문자열 태스크</returns>

private async Task<string> GetTextAsync()

{

Task<string> task = new TaskFactory().StartNew(() => { return "TEST"; });

string result = await task;

return result;

}

#endregion

#region 비동기 호출하기 - CallAsync()

/// <summary>

/// 비동기 호출하기

/// </summary>

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

private async Task CallAsync()

{

string currentTime = DateTime.Now.ToString();

string text = await GetTextAsync();

Console.WriteLine(currentTime + " : " + text);

}

#endregion

}

※ Main 함수에서 async를 사용하기 위해서 프로젝트 [속성]의 [빌드] 탭에서 [고급]

[C#/TPL] Parallel 클래스 : For 정적 메소드를 사용해 비트맵 처리하기

■ Parallel 클래스의 For 정적 메소드를 사용해 비트맵을 처리하는 방법을 보여준다. ▶ MainForm.cs


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

namespace TestProject
{
    /// <summary>
    /// 메인 폼
    /// </summary>
    public partial class MainForm : Form
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

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

            Bitmap sourceBitmap = Bitmap.FromFile("image.jpg") as Bitmap;

            Bitmap targetBitmap = sourceBitmap.Clone() as Bitmap;

            ProcessBitmap(targetBitmap);

            this.sourcePictureBox.Image = sourceBitmap;
            this.targetPictureBox.Image = targetBitmap;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region 비트맵 처리하기 - ProcessBitmap(targetBitmap)

        /// <summary>
        /// 비트맵 처리하기
        /// </summary>
        /// <param name="targetBitmap">타겟 비트맵</param>
        private void ProcessBitmap(Bitmap targetBitmap)
        {
            int targetBitmapWidth  = targetBitmap.Width;
            int targetBitmapHeight = targetBitmap.Height;

            BitmapData targetBitmapData = targetBitmap.LockBits
            (
                new Rectangle(0, 0, targetBitmapWidth, targetBitmapHeight),
                ImageLockMode.ReadWrite,
                PixelFormat.Format24bppRgb
            );

            int targetBitmapStride = targetBitmapData.Stride;

            IntPtr scan0Handle = targetBitmapData.Scan0;

            unsafe
            {
                byte* pointer = (byte*)(void*)scan0Handle;

                Parallel.For
                (
                    0,
                    targetBitmapHeight,
                    y => {

                        Parallel.For
                        (
                            0,
                            targetBitmapWidth,
                            x => {

                                int position = y * targetBitmapStride + x * 3;

                                pointer[position + 2] = 0;
                            }
                        );
                    }
                );
            }

            targetBitmap.UnlockBits(targetBitmapData);
        }

        #endregion
    }
}

using System;

using System.Drawing;

using System.Drawing.Imaging;

using System.Threading.Tasks;

using System.Windows.Forms;

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

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

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

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

Bitmap sourceBitmap = Bitmap.FromFile("image.jpg") as Bitmap;

Bitmap targetBitmap = sourceBitmap.Clone() as Bitmap;

ProcessBitmap(targetBitmap);

this.sourcePictureBox.Image = sourceBitmap;

this.targetPictureBox.Image = targetBitmap;

}

#endregion

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

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

#region 비트맵 처리하기 - ProcessBitmap(targetBitmap)

/// <summary>

/// 비트맵 처리하기

/// </summary>

/// <param name="targetBitmap">타겟 비트맵</param>

private void ProcessBitmap(Bitmap targetBitmap)

{

int targetBitmapWidth = targetBitmap.Width;

int targetBitmapHeight = targetBitmap.Height;

BitmapData targetBitmapData = targetBitmap.LockBits

(

new Rectangle(0, 0, targetBitmapWidth, targetBitmapHeight),

ImageLockMode.ReadWrite,

PixelFormat.Format24bppRgb

);

int targetBitmapStride = targetBitmapData.Stride;

IntPtr scan0Handle = targetBitmapData.Scan0;

unsafe

{

byte* pointer = (byte*)(void*)scan0Handle;

Parallel.For

(

targetBitmapHeight,

y => {

Parallel.For

(

targetBitmapWidth,

x => {

int position = y * targetBitmapStride + x * 3;

pointer[position + 2] = 0;

}

);

}

);

}

targetBitmap.UnlockBits(targetBitmapData);

}

#endregion

}

※ 비트맵 처리 연산량이 많을수록 병렬 처리 효과가

[C#/TPL] Parallel 클래스 : For 정적 메소드 사용하기

■ Parallel 클래스의 For 정적 메소드를 사용하는 방법을 보여준다. ▶ Program.cs


using System;
using System.Threading.Tasks;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// 시작 시간
        /// </summary>
        private static DateTime _startTime;

        /// <summary>
        /// 종료 시간
        /// </summary>
        private static DateTime _endTime;

        /// <summary>
        /// 카운트
        /// </summary>
        private static int _count = 100000000; // 1억

        /// <summary>
        /// 동기 객체
        /// </summary>
        private static object _syncObject = new object();

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

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

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            Console.Title = "Parallel 클래스 : For 정적 메소드 사용하기";

            Console.WriteLine("FOR 루프 처리하기");

            SetStartTime();

            ProcessForLoop();

            SetEndTime();

            PrintEllapseTime();

            Console.WriteLine();

            Console.WriteLine("단순 Parallel.For 사용하기");

            SetStartTime();

            ProcessSimpleParallelFor();

            SetEndTime();

            PrintEllapseTime();

            Console.WriteLine();

            Console.WriteLine("Parallel.For 사용하기");

            SetStartTime();

            ProcessParallelFor();

            SetEndTime();

            PrintEllapseTime();
        }

        #endregion

        #region 시작 시간 설정하기 - SetStartTime()

        /// <summary>
        /// 시작 시간 설정하기
        /// </summary>
        private static void SetStartTime()
        {
            _startTime = DateTime.Now;

            Console.WriteLine("시작 시간 : " + _startTime);
        }

        #endregion
        #region 종료 시간 설정하기 - SetEndTime()

        /// <summary>
        /// 종료 시간 설정하기
        /// </summary>
        private static void SetEndTime()
        {
            _endTime = DateTime.Now;

            Console.WriteLine("종료 시간 : " + _endTime);
        }

        #endregion
        #region 경과 시간 출력하기 - PrintEllapseTime()

        /// <summary>
        /// 경과 시간 출력하기
        /// </summary>
        private static void PrintEllapseTime()
        {
            Console.WriteLine("경과 시간 : " + (_endTime - _startTime));
        }

        #endregion

        #region FOR 루프 처리하기 - ProcessForLoop()

        /// <summary>
        /// FOR 루프 처리하기
        /// </summary>
        private static void ProcessForLoop()
        {
            double summary = 0.0;
            double step    = 1.0 / _count;

            for(var i = 0; i < _count; i++)
            {
                double x = (i + 0.5) * step;

                summary += 4.0 / (1.0 + x * x);
            }

            Console.WriteLine("연산 결과 : " + summary);
        }

        #endregion
        #region 단순 Parallel.For문 처리하기 - ProcessSimpleParallelFor()

        /// <summary>
        /// 단순 Parallel.For문 처리하기
        /// </summary>
        private static void ProcessSimpleParallelFor()
        {
            double summary = 0.0;
            double step    = 1.0 / _count;

            Parallel.For
            (
                0,
                _count,
                i =>
                {
                    double x = (i + 0.5) * step;
                    double y = 4.0 / (1.0 + x * x);

                    lock(_syncObject)
                    {
                        summary += y;
                    }
                }
            );

            Console.WriteLine("연산 결과 : " + summary);
        }

        #endregion
        #region Parallel.For문 처리하기 - ProcessParallelFor()

        /// <summary>
        /// Parallel.For문 처리하기
        /// </summary>
        private static void ProcessParallelFor()
        {
            double summary = 0.0;
            double step    = 1.0 / _count;

            Parallel.For
            (
                0,
                _count,
                () => 0.0,
                (i, state, local) => {

                    double x = (i + 0.5) * step;

                    return local + 4.0 / (1.0 + x * x);
                },
                local => {

                    lock(_syncObject)
                    {
                        summary += local;
                    }
                }
            );

            Console.WriteLine("연산 결과 : " + summary);
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

using System;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

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

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

#region Field

/// <summary>

/// 시작 시간

/// </summary>

private static DateTime _startTime;

/// <summary>

/// 종료 시간

/// </summary>

private static DateTime _endTime;

/// <summary>

/// 카운트

/// </summary>

private static int _count = 100000000; // 1억

/// <summary>

/// 동기 객체

/// </summary>

private static object _syncObject = new object();

#endregion

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

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

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

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

Console.Title = "Parallel 클래스 : For 정적 메소드 사용하기";

Console.WriteLine("FOR 루프 처리하기");

SetStartTime();

ProcessForLoop();

SetEndTime();

PrintEllapseTime();

Console.WriteLine();

Console.WriteLine("단순 Parallel.For 사용하기");

SetStartTime();

ProcessSimpleParallelFor();

SetEndTime();

PrintEllapseTime();

Console.WriteLine();

Console.WriteLine("Parallel.For 사용하기");

SetStartTime();

ProcessParallelFor();

SetEndTime();

PrintEllapseTime();

}

#endregion

#region 시작 시간 설정하기 - SetStartTime()

/// <summary>

/// 시작 시간 설정하기

/// </summary>

private static void SetStartTime()

{

_startTime = DateTime.Now;

Console.WriteLine("시작 시간 : " + _startTime);

}

#endregion

#region 종료 시간 설정하기 - SetEndTime()

/// <summary>

/// 종료 시간 설정하기

/// </summary>

private static void SetEndTime()

{

_endTime = DateTime.Now;

Console.WriteLine("종료 시간 : " + _endTime);

}

#endregion

#region 경과 시간 출력하기 - PrintEllapseTime()

/// <summary>

/// 경과 시간 출력하기

/// </summary>

private static void PrintEllapseTime()

{

Console.WriteLine("경과 시간 : " + (_endTime - _startTime));

}

#endregion

#region FOR 루프 처리하기 - ProcessForLoop()

/// <summary>

/// FOR 루프 처리하기

/// </summary>

private static void ProcessForLoop()

{

double summary = 0.0;

double step = 1.0 / _count;

for(var i = 0; i < _count; i++)

{

double x = (i + 0.5) * step;

summary += 4.0 / (1.0 + x * x);

}

Console.WriteLine("연산 결과 : " + summary);

}

#endregion

#region 단순 Parallel.For문 처리하기 - ProcessSimpleParallelFor()

/// <summary>

/// 단순 Parallel.For문 처리하기

/// </summary>

private static void ProcessSimpleParallelFor()

{

double summary = 0.0;

double step = 1.0 / _count;

Parallel.For

(

_count,

i =>

{

double x = (i + 0.5) * step;

double y = 4.0 / (1.0 + x * x);

lock(_syncObject)

{

summary += y;

}

);

Console.WriteLine("연산 결과 : " + summary);

}

#endregion

#region Parallel.For문 처리하기 - ProcessParallelFor()

/// <summary>

/// Parallel.For문 처리하기

/// </summary>

private static void ProcessParallelFor()

{

double summary = 0.0;

double step = 1.0 / _count;

Parallel.For

(

_count,

() => 0.0,

(i, state, local) => {

double x = (i + 0.5) * step;

return local + 4.0 / (1.0 + x * x);

local => {

lock(_syncObject)

{

summary += local;

}

);

Console.WriteLine("연산 결과 : " + summary);

}

#endregion

}

TestProject.zip

[C#/TPL] Parallel 클래스 : ForEach 정적 메소드 사용하기

■ Parallel 클래스의 ForEach 정적 메소드를 사용하는 방법을 보여준다. ▶ Program.cs


using System;
using System.Threading.Tasks;

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

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

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            Console.WriteLine("BEGIN MAIN FUNCTION");

            Console.Title = "Parallel 클래스 : ForEach 정적 메소드 사용하기";

            Console.WriteLine("BEGIN GET ARRAY");

            string[] sourceArray = GetStringArray(100);

            Console.WriteLine("END GET ARRAY");

            Console.WriteLine("BEGIN PARALLEL FOREACH");

            ParallelOptions options = new ParallelOptions();

            options.MaxDegreeOfParallelism = sourceArray.Length;

            Parallel.ForEach(sourceArray, (item) => { Console.WriteLine(item); });

            Console.WriteLine("END PARALLEL FOREACH");

            Console.WriteLine("END MAIN FUNCTION");
        }

        #endregion

        #region 문자열 배열 구하기 - GetStringArray(count)

        /// <summary>
        /// 문자열 배열 구하기
        /// </summary>
        /// <param name="count">카운트</param>
        /// <returns>문자열 배열</returns>
        private static string[] GetStringArray(int count)
        {
            int countLength = count.ToString().Length;

            string[] array = new string[count];

            for(int i = 0; i < count; i++)
            {
                array[i] = "항목" + (i + 1).ToString("d" + countLength);
            }

            return array;
        }

        #endregion
    }
}

using System;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

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

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

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

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

Console.WriteLine("BEGIN MAIN FUNCTION");

Console.Title = "Parallel 클래스 : ForEach 정적 메소드 사용하기";

Console.WriteLine("BEGIN GET ARRAY");

string[] sourceArray = GetStringArray(100);

Console.WriteLine("END GET ARRAY");

Console.WriteLine("BEGIN PARALLEL FOREACH");

ParallelOptions options = new ParallelOptions();

options.MaxDegreeOfParallelism = sourceArray.Length;

Parallel.ForEach(sourceArray, (item) => { Console.WriteLine(item); });

Console.WriteLine("END PARALLEL FOREACH");

Console.WriteLine("END MAIN FUNCTION");

}

#endregion

#region 문자열 배열 구하기 - GetStringArray(count)

/// <summary>

/// 문자열 배열 구하기

/// </summary>

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

/// <returns>문자열 배열</returns>

private static string[] GetStringArray(int count)

{

int countLength = count.ToString().Length;

string[] array = new string[count];

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

{

array[i] = "항목" + (i + 1).ToString("d" + countLength);

}

return array;

}

#endregion

}

TestProject.zip

[C#/TPL] Parallel 클래스 : ForEach 정적 메소드를 사용해 디렉토리 크기 구하기

■ Parallel 클래스의 ForEach 정적 메소드를 사용해 디렉토리 크기를 구하는 방법을 보여준다. ▶ Parallel 클래스 : ForEach 정적 메소드를 사용해 디렉토리 크기

[C#/TPL] Parallel 클래스 : For 정적 메소드를 사용해 디렉토리 크기 구하기

■ Parallel 클래스의 For 정적 메소드를 사용해 디렉토리 크기를 구하는 방법을 보여준다. ▶ Parallel 클래스 : For 정적 메소드를 사용해 디렉토리 크기

[C#/TPL] Task 클래스 : 스로틀링(Throttling) 처리하기

■ Task 클래스에서 스로틀링(Throttling)을 처리하는 방법을 보여준다. ▶ Program.cs


using System;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// 최대 다운로드 카운트
        /// </summary>
        private const int MAXIMUM_DOWNLOAD_COUNT = 3;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 다운로드 하기 (비동기) - DownloadAsync(urlArray)

        /// <summary>
        /// 다운로드 하기 (비동기)
        /// </summary>
        /// <param name="urlArray">URL 배열</param>
        /// <returns>태스크</returns>
        private static async Task DownloadAsync(string[] urlArray)
        {
            using(SemaphoreSlim semaphoreSlim = new SemaphoreSlim(MAXIMUM_DOWNLOAD_COUNT))
            {
                using(HttpClient httpClient = new HttpClient())
                {
                    var taskEnumerable = urlArray.Select
                    (
                        async url => {

                            await semaphoreSlim.WaitAsync();

                            try
                            {
                                string html = await httpClient.GetStringAsync(url);

                                Console.WriteLine(html);
                            }
                            finally
                            {
                                semaphoreSlim.Release();
                            }
                        }
                    );

                    await Task.WhenAll(taskEnumerable);
                }
            }
        }

        #endregion
        #region 다운로드 테스트 하기 - TestDownload()

        /// <summary>
        /// 다운로드 테스트 하기
        /// </summary>
        private async static void TestDownload()
        {
            await DownloadAsync
            (
                new string[]
                {
                    "http://www.daum.net",
                    "http://www.naver.com",
                    "http://www.daum.net",
                    "http://www.naver.com",
                    "http://www.daum.net",
                    "http://www.naver.com",
                    "http://www.daum.net",
                    "http://www.naver.com",
                    "http://www.daum.net",
                    "http://www.naver.com"
                }
            );
        }

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

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            TestDownload();

            Console.ReadKey();
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

using System;

using System.Linq;

using System.Net.Http;

using System.Threading;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

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

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

#region Field

/// <summary>

/// 최대 다운로드 카운트

/// </summary>

private const int MAXIMUM_DOWNLOAD_COUNT = 3;

#endregion

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

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

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

#region 다운로드 하기 (비동기) - DownloadAsync(urlArray)

/// <summary>

/// 다운로드 하기 (비동기)

/// </summary>

/// <param name="urlArray">URL 배열</param>

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

private static async Task DownloadAsync(string[] urlArray)

{

using(SemaphoreSlim semaphoreSlim = new SemaphoreSlim(MAXIMUM_DOWNLOAD_COUNT))

{

using(HttpClient httpClient = new HttpClient())

{

var taskEnumerable = urlArray.Select

(

async url => {

await semaphoreSlim.WaitAsync();

try

{

string html = await httpClient.GetStringAsync(url);

Console.WriteLine(html);

}

finally

{

semaphoreSlim.Release();

}

);

await Task.WhenAll(taskEnumerable);

}

#endregion

#region 다운로드 테스트 하기 - TestDownload()

/// <summary>

/// 다운로드 테스트 하기

/// </summary>

private async static void TestDownload()

{

await DownloadAsync

(

new string[]

{

"http://www.daum.net",

"http://www.naver.com",

"http://www.daum.net",

"http://www.naver.com",

"http://www.daum.net",

"http://www.naver.com",

"http://www.daum.net",

"http://www.naver.com",

"http://www.daum.net",

"http://www.naver.com"

}

);

}

#endregion

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

TestDownload();

Console.ReadKey();

}

#endregion

}

TestProject.zip

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

■ Task<T> 클래스의 Run 정적 메소드를 사용하는 방법을 보여준다. ▶ MainForm.cs


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

namespace TestProject
{
    /// <summary>
    /// 메인 폼
    /// </summary>
    public partial class MainForm : Form
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

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

            this.testButton.Click += testButton_Click;
        }

        #endregion

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

        #region 테스트 버튼 클릭시 처리하기 - testButton_Click(sender, e)

        /// <summary>
        /// 테스트 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void testButton_Click(object sender, EventArgs e)
        {
            this.testButton.Enabled = false;

            this.resultTextBox.Text = string.Empty;

            ProcessTest();
        }

        #endregion

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

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

        /// <summary>
        /// 테스트 처리하기
        /// </summary>
        private async void ProcessTest()
        {
            Task<string> task = Task<string>.Run(() =>
            {
                for(int i = 0; i < 101; i++)
                {
                    System.Threading.Thread.Sleep(10);

                    Invoke(new MethodInvoker(() =>
                    {
                        this.progressBar.Value = i;

                        this.progressBar.Update();
                    }));
                }

                return DateTime.Now.Millisecond.ToString();
            });

            string result = await task;

            this.resultTextBox.Text = result;

            this.testButton.Enabled = true;
        }

        #endregion
    }
}

using System;

using System.Threading.Tasks;

using System.Windows.Forms;

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

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

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

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

this.testButton.Click += testButton_Click;

}

#endregion

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

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

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

#region 테스트 버튼 클릭시 처리하기 - testButton_Click(sender, e)

/// <summary>

/// 테스트 버튼 클릭시 처리하기

/// </summary>

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

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

private void testButton_Click(object sender, EventArgs e)

{

this.testButton.Enabled = false;

this.resultTextBox.Text = string.Empty;

ProcessTest();

}

#endregion

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

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

/// <summary>

/// 테스트 처리하기

/// </summary>

private async void ProcessTest()

{

Task<string> task = Task<string>.Run(() =>

{

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

{

System.Threading.Thread.Sleep(10);

Invoke(new MethodInvoker(() =>

{

this.progressBar.Value = i;

this.progressBar.Update();

}));

}

return DateTime.Now.Millisecond.ToString();

});

string result = await task;

this.resultTextBox.Text = result;

this.testButton.Enabled = true;

}

#endregion

}

TestProject.zip

[C#/TPL] Task 클래스 : WhenAny 정적 메소드 사용시, 작업들 중에서 임의 비동기 실행 완료시 처리하기

■ Task 클래스의 WhenAny 정적 메소드 사용시, 작업들 중에서 임의 비동기 실행 완료시 처리하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

#region 값 구하기 - GetValue(taskName)

/// <summary>
/// 값 구하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="waitTime">대기 시간</param>
/// <returns>값</returns>
private int GetValue(string taskName, int waitTime)
{
    Console.WriteLine
    (
        "태스크명 : {0}, 스레드 ID :{1}, 스레드 풀 사용 여부 : {2}",
        taskName,
        Thread.CurrentThread.ManagedThreadId,
        Thread.CurrentThread.IsThreadPoolThread
    );

    Thread.Sleep(waitTime);

    return DateTime.Now.Millisecond;
}

#endregion

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

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

    Task<int> task = new Task<int>(() => GetValue(string.Format("Task #{0}", count), count * 1000));

    taskList.Add(task);

    task.Start();
}

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

    taskList.Remove(completedTask);

    Console.WriteLine("반환값 : {0}", completedTask.Result);
}

using System;

using System.Collections.Generic;

using System.Threading;

using System.Threading.Tasks;

#region 값 구하기 - GetValue(taskName)

/// <summary>

/// 값 구하기

/// </summary>

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

/// <param name="waitTime">대기 시간</param>

/// <returns>값</returns>

private int GetValue(string taskName, int waitTime)

{

Console.WriteLine

(

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

taskName,

Thread.CurrentThread.ManagedThreadId,

Thread.CurrentThread.IsThreadPoolThread

);

Thread.Sleep(waitTime);

return DateTime.Now.Millisecond;

}

#endregion

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

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

{

int count = i;

Task<int> task = new Task<int>(() => GetValue(string.Format("Task #{0}", count), count * 1000));

taskList.Add(task);

task.Start();

}

while(taskList.Count > 0)

{

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

taskList.Remove(completedTask);

Console.WriteLine("반환값 : {0}", completedTask.Result);

}

[C#/TPL] Task 클래스 : GetAwaiter 메소드를 사용해 내부 Exception 직접 처리하기

■ Task<T> 클래스의 GetAwaiter 메소드를 사용해 내부 Exception을 직접 처리하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

#region 값 구하기 - GetValue(taskName)

/// <summary>
/// 값 구하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="waitTime">대기 시간</param>
/// <returns>값</returns>
private int GetValue(string taskName, int waitTime)
{
    Console.WriteLine
    (
        "태스크명 : {0}, 스레드 ID :{1}, 스레드 풀 사용 여부 : {2}",
        taskName,
        Thread.CurrentThread.ManagedThreadId,
        Thread.CurrentThread.IsThreadPoolThread
    );

    Thread.Sleep(waitTime);

    throw new Exception("에러가 발생했습니다!");

    return DateTime.Now.Millisecond;
}

#endregion

Task<int> task = null;

try
{
    task = Task.Run(() => GetValue("Task #1", 2000));

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

    Console.WriteLine("반환값 : {0}", value);
}
catch(Exception exception)
{
    Console.WriteLine("예외 : {0}", exception);
}

using System;

using System.Threading;

using System.Threading.Tasks;

#region 값 구하기 - GetValue(taskName)

/// <summary>

/// 값 구하기

/// </summary>

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

/// <param name="waitTime">대기 시간</param>

/// <returns>값</returns>

private int GetValue(string taskName, int waitTime)

{

Console.WriteLine

(

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

taskName,

Thread.CurrentThread.ManagedThreadId,

Thread.CurrentThread.IsThreadPoolThread

);

Thread.Sleep(waitTime);

throw new Exception("에러가 발생했습니다!");

return DateTime.Now.Millisecond;

}

#endregion

Task<int> task = null;

try

{

task = Task.Run(() => GetValue("Task #1", 2000));

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

Console.WriteLine("반환값 : {0}", value);

}

catch(Exception exception)

{

Console.WriteLine("예외 : {0}", exception);

}

[C#/TPL] Task 클래스 : AggregationException 발생시 처리하기

■ Task<T> 클래스에서 AggregationException 발생시 처리하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

#region 값 구하기 - GetValue(taskName)

/// <summary>
/// 값 구하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="waitTime">대기 시간</param>
/// <returns>값</returns>
private int GetValue(string taskName, int waitTime)
{
    Console.WriteLine
    (
        "태스크명 : {0}, 스레드 ID :{1}, 스레드 풀 사용 여부 : {2}",
        taskName,
        Thread.CurrentThread.ManagedThreadId,
        Thread.CurrentThread.IsThreadPoolThread
    );

    Thread.Sleep(waitTime);

    throw new Exception("에러가 발생했습니다!");

    return DateTime.Now.Millisecond;
}

#endregion

Task<int> task = null;

try
{
    task = Task.Run(() => GetValue("Task #1", 2000));

    int value = task.Result;

    Console.WriteLine("반환값 : {0}", value);
}
catch(Exception exception)
{
    Console.WriteLine("예외 : {0}", exception);
}

using System;

using System.Threading;

using System.Threading.Tasks;

#region 값 구하기 - GetValue(taskName)

/// <summary>

/// 값 구하기

/// </summary>

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

/// <param name="waitTime">대기 시간</param>

/// <returns>값</returns>

private int GetValue(string taskName, int waitTime)

{

Console.WriteLine

(

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

taskName,

Thread.CurrentThread.ManagedThreadId,

Thread.CurrentThread.IsThreadPoolThread

);

Thread.Sleep(waitTime);

throw new Exception("에러가 발생했습니다!");

return DateTime.Now.Millisecond;

}

#endregion

Task<int> task = null;

try

{

task = Task.Run(() => GetValue("Task #1", 2000));

int value = task.Result;

Console.WriteLine("반환값 : {0}", value);

}

catch(Exception exception)

{

Console.WriteLine("예외 : {0}", exception);

}

[C#/TPL] Task 클래스 : WhenAll 정적 메소드 사용시, 모든 작업 완료 후 처리하기

■ Task 클래스의 WhenAll 정적 메소드 사용시, 모든 작업을 완료 후 처리하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

#region 값 구하기 - GetValue(taskName)

/// <summary>
/// 값 구하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="waitTime">대기 시간</param>
/// <returns>값</returns>
private int GetValue(string taskName, int waitTime)
{
    Console.WriteLine
    (
        "태스크명 : {0}, 스레드 ID :{1}, 스레드 풀 사용 여부 : {2}",
        taskName,
        Thread.CurrentThread.ManagedThreadId,
        Thread.CurrentThread.IsThreadPoolThread
    );

    Thread.Sleep(waitTime);

    return DateTime.Now.Millisecond;
}

#endregion

Task<int> task1 = new Task<int>(() => GetValue("Task #1", 3000));
Task<int> task2 = new Task<int>(() => GetValue("Task #2", 2000));

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

Task exceptionTask = task3.ContinueWith
(
    t =>
    {
        Console.WriteLine
        (
            "첫번째 반환값 : {0}\n두번째 반환값 : {1}",
            t.Result[0],
            t.Result[1]
        );
    },
    TaskContinuationOptions.OnlyOnRanToCompletion
);

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

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

    Thread.Sleep(500);
}

Console.WriteLine(task3.Status);

Thread.Sleep(5000);

using System;

using System.Threading;

using System.Threading.Tasks;

#region 값 구하기 - GetValue(taskName)

/// <summary>

/// 값 구하기

/// </summary>

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

/// <param name="waitTime">대기 시간</param>

/// <returns>값</returns>

private int GetValue(string taskName, int waitTime)

{

Console.WriteLine

(

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

taskName,

Thread.CurrentThread.ManagedThreadId,

Thread.CurrentThread.IsThreadPoolThread

);

Thread.Sleep(waitTime);

return DateTime.Now.Millisecond;

}

#endregion

Task<int> task1 = new Task<int>(() => GetValue("Task #1", 3000));

Task<int> task2 = new Task<int>(() => GetValue("Task #2", 2000));

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

Task exceptionTask = task3.ContinueWith

(

t =>

{

Console.WriteLine

(

"첫번째 반환값 : {0}\n두번째 반환값 : {1}",

t.Result[0],

t.Result[1]

);

TaskContinuationOptions.OnlyOnRanToCompletion

);

task1.Start();

task2.Start();

while(!task3.IsCompleted)

{

Console.WriteLine(task3.Status);

Thread.Sleep(500);

}

Console.WriteLine(task3.Status);

Thread.Sleep(5000);

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

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


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

#region 값 구하기 - GetValue(taskName)

/// <summary>
/// 값 구하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="waitTime">대기 시간</param>
/// <returns>값</returns>
private int GetValue(string taskName, int waitTime)
{
    Console.WriteLine
    (
        "태스크명 : {0}, 스레드 ID :{1}, 스레드 풀 사용 여부 : {2}",
        taskName,
        Thread.CurrentThread.ManagedThreadId,
        Thread.CurrentThread.IsThreadPoolThread
    );

    Thread.Sleep(waitTime);

    return DateTime.Now.Millisecond;
}

#endregion

Task<int> parentTask = new Task<int>
(
    () =>
    {
        Task childTask = Task.Factory.StartNew
        (
            () => GetValue("Child Task #1", 5000),
            TaskCreationOptions.AttachedToParent
        );

        childTask.ContinueWith
        (
            t => GetValue("Child Task #2", 2000),
            TaskContinuationOptions.AttachedToParent
        );

        return GetValue("Parent Task", 2000);
    }
);

parentTask.Start();

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

    Thread.Sleep(500);
}

Console.WriteLine(parentTask.Status);

int value = parentTask.Result;

Console.WriteLine("반환값 : {0}", value);

Thread.Sleep(10000);

using System;

using System.Threading;

using System.Threading.Tasks;

#region 값 구하기 - GetValue(taskName)

/// <summary>

/// 값 구하기

/// </summary>

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

/// <param name="waitTime">대기 시간</param>

/// <returns>값</returns>

private int GetValue(string taskName, int waitTime)

{

Console.WriteLine

(

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

taskName,

Thread.CurrentThread.ManagedThreadId,

Thread.CurrentThread.IsThreadPoolThread

);

Thread.Sleep(waitTime);

return DateTime.Now.Millisecond;

}

#endregion

Task<int> parentTask = new Task<int>

(

() =>

{

Task childTask = Task.Factory.StartNew

(

() => GetValue("Child Task #1", 5000),

TaskCreationOptions.AttachedToParent

);

childTask.ContinueWith

(

t => GetValue("Child Task #2", 2000),

TaskContinuationOptions.AttachedToParent

);

return GetValue("Parent Task", 2000);

}

);

parentTask.Start();

while(!parentTask.IsCompleted)

{

Console.WriteLine(parentTask.Status);

Thread.Sleep(500);

}

Console.WriteLine(parentTask.Status);

int value = parentTask.Result;

Console.WriteLine("반환값 : {0}", value);

Thread.Sleep(10000);

[C#/TPL] Task 클래스 : WhenAll 정적 메소드 사용시, 모든 작업 완료 후 에러 발생시 처리하기

■ Task 클래스의 WhenAll 정적 메소드 사용시, 모든 작업 완료 후 에러 발생시 처리하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

#region 값 구하기 - GetValue(taskName)

/// <summary>
/// 값 구하기
/// </summary>
/// <param name="taskName">태스크명</param>
/// <param name="waitTime">대기 시간</param>
/// <returns>값</returns>
private int GetValue(string taskName, int waitTime)
{
    Console.WriteLine
    (
        "태스크명 : {0}, 스레드 ID :{1}, 스레드 풀 사용 여부 : {2}",
        taskName,
        Thread.CurrentThread.ManagedThreadId,
        Thread.CurrentThread.IsThreadPoolThread
    );

    Thread.Sleep(waitTime);

    throw new Exception("에러가 발생했습니다!");

    return DateTime.Now.Millisecond;
}

#endregion

Task<int> task1 = new Task<int>(() => GetValue("Task #1", 3000));
Task<int> task2 = new Task<int>(() => GetValue("Task #2", 2000));

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

Task exceptionTask = task3.ContinueWith
(
    t =>
    {
        Console.WriteLine
        (
            "첫번째 에러 : {0}\n\n두번째 에러 : {1}",
            t.Exception.InnerExceptions[0],
            t.Exception.InnerExceptions[1]
        );
    },
    TaskContinuationOptions.OnlyOnFaulted
);

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

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

    Thread.Sleep(500);
}

Console.WriteLine(task3.Status);

Thread.Sleep(5000);

using System;

using System.Threading;

using System.Threading.Tasks;

#region 값 구하기 - GetValue(taskName)

/// <summary>

/// 값 구하기

/// </summary>

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

/// <param name="waitTime">대기 시간</param>

/// <returns>값</returns>

private int GetValue(string taskName, int waitTime)

{

Console.WriteLine

(

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

taskName,

Thread.CurrentThread.ManagedThreadId,

Thread.CurrentThread.IsThreadPoolThread

);

Thread.Sleep(waitTime);

throw new Exception("에러가 발생했습니다!");

return DateTime.Now.Millisecond;

}

#endregion

Task<int> task1 = new Task<int>(() => GetValue("Task #1", 3000));

Task<int> task2 = new Task<int>(() => GetValue("Task #2", 2000));

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

Task exceptionTask = task3.ContinueWith

(

t =>

{

Console.WriteLine

(

"첫번째 에러 : {0}\n\n두번째 에러 : {1}",

t.Exception.InnerExceptions[0],

t.Exception.InnerExceptions[1]

);

TaskContinuationOptions.OnlyOnFaulted

);

task1.Start();

task2.Start();

while(!task3.IsCompleted)

{

Console.WriteLine(task3.Status);

Thread.Sleep(500);

}

Console.WriteLine(task3.Status);

Thread.Sleep(5000);

[C#/TPL] TaskAwaiter 클래스 : OnCompleted 메소드를 사용해 연속(Continuation) 완료시 처리하기

■ TaskAwaiter 클래스의 OnCompleted 메소드를 사용해 연속(Continuation) 완료시 처리하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

#region 값 구하기 - GetValue(taskName)

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

    Thread.Sleep(2000);

    return DateTime.Now.Millisecond;
}

#endregion

Task<int> task = new Task<int>(() => GetValue("Task #1"));

Task continuation = task.ContinueWith
(
    t =>
    {
        Console.WriteLine
        (
            "반환값 : {0}, 스레드 ID : {1}, 스레드 풀 사용 여부 : {2}",
            t.Result,
            Thread.CurrentThread.ManagedThreadId,
            Thread.CurrentThread.IsThreadPoolThread
        );
    },
    TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.ExecuteSynchronously
); // TaskContinuationOptions.ExecuteSynchronously 옵션이 설정되었으나 선행 태스크와 동일한 스레드에서 실행된다.

continuation.GetAwaiter().OnCompleted
(
    () =>
    {
        Console.WriteLine
        (
            "연속 태스크가 완료되었습니다.\n스레드 ID : {0}, 스레드 풀 사용 여부 : {1}",
            Thread.CurrentThread.ManagedThreadId,
            Thread.CurrentThread.IsThreadPoolThread
        );
    }
);

task.Start();

Thread.Sleep(4000);

using System;

using System.Threading;

using System.Threading.Tasks;

#region 값 구하기 - GetValue(taskName)

/// <summary>

/// 값 구하기

/// </summary>

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

/// <returns>값</returns>

private int GetValue(string taskName)

{

Console.WriteLine

(

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

taskName,

Thread.CurrentThread.ManagedThreadId,

Thread.CurrentThread.IsThreadPoolThread

);

Thread.Sleep(2000);

return DateTime.Now.Millisecond;

}

#endregion

Task<int> task = new Task<int>(() => GetValue("Task #1"));

Task continuation = task.ContinueWith

(

t =>

{

Console.WriteLine

(

"반환값 : {0}, 스레드 ID : {1}, 스레드 풀 사용 여부 : {2}",

t.Result,

Thread.CurrentThread.ManagedThreadId,

Thread.CurrentThread.IsThreadPoolThread

);

TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.ExecuteSynchronously

); // TaskContinuationOptions.ExecuteSynchronously 옵션이 설정되었으나 선행 태스크와 동일한 스레드에서 실행된다.

continuation.GetAwaiter().OnCompleted

(

() =>

{

Console.WriteLine

(

"연속 태스크가 완료되었습니다.\n스레드 ID : {0}, 스레드 풀 사용 여부 : {1}",

Thread.CurrentThread.ManagedThreadId,

Thread.CurrentThread.IsThreadPoolThread

);

}

);

task.Start();

Thread.Sleep(4000);

※ TaskAwaiter : System.Runtime.CompilerServices.TaskAwaiter 클래스

[C#/TPL] TaskAwaiter 클래스 : OnCompleted 메소드를 사용해 연속(Continuation) 완료시 처리하기

■ TaskAwaiter 클래스의 OnCompleted 메소드를 사용해 연속(Continuation) 완료시 처리하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

#region 값 구하기 - GetValue(taskName)

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

    Thread.Sleep(2000);

    return DateTime.Now.Millisecond;
}

#endregion

Task<int> task = new Task<int>(() => GetValue("Task #1"));

task.Start();

Thread.Sleep(4000);

Task continuation = task.ContinueWith
(
    t =>
    {
        Console.WriteLine
        (
            "반환값 : {0}, 스레드 ID : {1}, 스레드 풀 사용 여부 : {2}",
            t.Result,
            Thread.CurrentThread.ManagedThreadId,
            Thread.CurrentThread.IsThreadPoolThread
        );
    },
    TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.ExecuteSynchronously
); // TaskContinuationOptions.ExecuteSynchronously 옵션 설정으로 메인 스레드에서 실행된다.

continuation.GetAwaiter().OnCompleted
(
    () =>
    {
        Console.WriteLine
        (
            "연속 태스크가 완료되었습니다.\n스레드 ID : {0}, 스레드 풀 사용 여부 : {1}",
            Thread.CurrentThread.ManagedThreadId,
            Thread.CurrentThread.IsThreadPoolThread
        );
    }
);

Thread.Sleep(1000);

using System;

using System.Threading;

using System.Threading.Tasks;

#region 값 구하기 - GetValue(taskName)

/// <summary>

/// 값 구하기

/// </summary>

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

/// <returns>값</returns>

private int GetValue(string taskName)

{

Console.WriteLine

(

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

taskName,

Thread.CurrentThread.ManagedThreadId,

Thread.CurrentThread.IsThreadPoolThread

);

Thread.Sleep(2000);

return DateTime.Now.Millisecond;

}

#endregion

Task<int> task = new Task<int>(() => GetValue("Task #1"));

task.Start();

Thread.Sleep(4000);

Task continuation = task.ContinueWith

(

t =>

{

Console.WriteLine

(

"반환값 : {0}, 스레드 ID : {1}, 스레드 풀 사용 여부 : {2}",

t.Result,

Thread.CurrentThread.ManagedThreadId,

Thread.CurrentThread.IsThreadPoolThread

);

TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.ExecuteSynchronously

); // TaskContinuationOptions.ExecuteSynchronously 옵션 설정으로 메인 스레드에서 실행된다.

continuation.GetAwaiter().OnCompleted

(

() =>

{

Console.WriteLine

(

"연속 태스크가 완료되었습니다.\n스레드 ID : {0}, 스레드 풀 사용 여부 : {1}",

Thread.CurrentThread.ManagedThreadId,

Thread.CurrentThread.IsThreadPoolThread

);

}

);

Thread.Sleep(1000);

※ TaskAwaiter : System.Runtime.CompilerServices.TaskAwaiter 클래스