MICROSOFT Archives - 4 중 2 번째 페이지

[C#/TPL/.NET5] Task 클래스 : Delay 정적 메소드를 사용해 타임아웃시 취소 가능한 태스크 생성하기

■ Task 클래스의 Delay 정적 메소드를 사용해 타임아웃시 취소 가능한 태스크를 생성하는 방법을 보여준다. ▶ Program.cs


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

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

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

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

            string html = DownloadStringAsync(client, "https://www.daum.net").GetAwaiter().GetResult();

            Console.WriteLine(html);
        }

        #endregion

        #region 문자열 다운로드하기 (비동기) - DownloadStringAsync(httpClient, uri)

        /// <summary>
        /// 문자열 다운로드하기 (비동기)
        /// </summary>
        /// <param name="httpClient">HTTP 클라이언트</param>
        /// <param name="uri">URI</param>
        /// <returns>문자열 태스크</returns>
        private static async Task<string> DownloadStringAsync(HttpClient httpClient, string uri)
        {
            using CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(3));

            Task<string> downloadTask = httpClient.GetStringAsync(uri);

            Task timeoutTask = Task.Delay(Timeout.InfiniteTimeSpan, cancellationTokenSource.Token);

            Task completedTask = await Task.WhenAny(downloadTask, timeoutTask);

            if(completedTask == timeoutTask)
            {
                return null;
            }

            return await downloadTask;
        }

        #endregion
    }
}

using System;

using System.Net.Http;

using System.Threading;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

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

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

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

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

HttpClient client = new HttpClient();

string html = DownloadStringAsync(client, "https://www.daum.net").GetAwaiter().GetResult();

Console.WriteLine(html);

}

#endregion

#region 문자열 다운로드하기 (비동기) - DownloadStringAsync(httpClient, uri)

/// <summary>

/// 문자열 다운로드하기 (비동기)

/// </summary>

/// <param name="httpClient">HTTP 클라이언트</param>

/// <param name="uri">URI</param>

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

private static async Task<string> DownloadStringAsync(HttpClient httpClient, string uri)

{

using CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(3));

Task<string> downloadTask = httpClient.GetStringAsync(uri);

Task timeoutTask = Task.Delay(Timeout.InfiniteTimeSpan, cancellationTokenSource.Token);

Task completedTask = await Task.WhenAny(downloadTask, timeoutTask);

if(completedTask == timeoutTask)

{

return null;

}

return await downloadTask;

}

#endregion

}

TestProject.zip

[C#/TPL/.NET5] Task 클래스 : WhenAny 정적 메소드를 사용해 타임아웃시 작업 취소하기

■ Task 클래스의 WhenAny 정적 메소드를 사용해 타임아웃시 작업을 취소하는 방법을 보여준다. ▶ Program.cs


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

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

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

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

            string html = DownloadStringAsync(client, "https://www.daum.net").GetAwaiter().GetResult();

            Console.WriteLine(html);
        }

        #endregion

        #region 문자열 다운로드하기 (비동기) - DownloadStringAsync(httpClient, uri)

        /// <summary>
        /// 문자열 다운로드하기 (비동기)
        /// </summary>
        /// <param name="httpClient">HTTP 클라이언트</param>
        /// <param name="uri">URI</param>
        /// <returns>문자열 태스크</returns>
        private static async Task<string> DownloadStringAsync(HttpClient httpClient, string uri)
        {
            using CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(3));

            Task<string> downloadTask = httpClient.GetStringAsync(uri);

            Task timeoutTask = Task.Delay(Timeout.InfiniteTimeSpan, cancellationTokenSource.Token);

            Task completedTask = await Task.WhenAny(downloadTask, timeoutTask);

            if(completedTask == timeoutTask)
            {
                return null;
            }

            return await downloadTask;
        }

        #endregion
    }
}

using System;

using System.Net.Http;

using System.Threading;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

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

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

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

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

HttpClient client = new HttpClient();

string html = DownloadStringAsync(client, "https://www.daum.net").GetAwaiter().GetResult();

Console.WriteLine(html);

}

#endregion

#region 문자열 다운로드하기 (비동기) - DownloadStringAsync(httpClient, uri)

/// <summary>

/// 문자열 다운로드하기 (비동기)

/// </summary>

/// <param name="httpClient">HTTP 클라이언트</param>

/// <param name="uri">URI</param>

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

private static async Task<string> DownloadStringAsync(HttpClient httpClient, string uri)

{

using CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(3));

Task<string> downloadTask = httpClient.GetStringAsync(uri);

Task timeoutTask = Task.Delay(Timeout.InfiniteTimeSpan, cancellationTokenSource.Token);

Task completedTask = await Task.WhenAny(downloadTask, timeoutTask);

if(completedTask == timeoutTask)

{

return null;

}

return await downloadTask;

}

#endregion

}

TestProject.zip

[C#/TPL/.NET5] Task 클래스 : Delay 정적 메소드를 사용해 재시도시 지연 시간 증가시키기

■ Task 클래스의 Delay 정적 메소드를 사용해 재시도시 지연 시간을 증가시키는 방법을 보여준다. ▶ 예제 코드 (C#)


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

#region 문자열 다운로드하기 (비동기) - DownloadStringAsync(httpClient, uri)

/// <summary>
/// 문자열 다운로드하기 (비동기)
/// </summary>
/// <param name="httpClient">HTTP 클라이언트</param>
/// <param name="uri">URI</param>
/// <returns>문자열 태스크</returns>
public async Task<string> DownloadStringAsync(HttpClient httpClient, string uri)
{
    TimeSpan delayTimeSpan = TimeSpan.FromSeconds(1);

    for(int i = 0; i < 3; i++)
    {
        try
        {
            return await httpClient.GetStringAsync(uri);
        }
        catch
        {
        }

        await Task.Delay(delayTimeSpan);

        delayTimeSpan = delayTimeSpan + delayTimeSpan;
    }

    return await httpClient.GetStringAsync(uri);
}

#endregion

using System;

using System.Net.Http;

using System.Threading.Tasks;

#region 문자열 다운로드하기 (비동기) - DownloadStringAsync(httpClient, uri)

/// <summary>

/// 문자열 다운로드하기 (비동기)

/// </summary>

/// <param name="httpClient">HTTP 클라이언트</param>

/// <param name="uri">URI</param>

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

public async Task<string> DownloadStringAsync(HttpClient httpClient, string uri)

{

TimeSpan delayTimeSpan = TimeSpan.FromSeconds(1);

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

{

try

{

return await httpClient.GetStringAsync(uri);

}

catch

{

}

await Task.Delay(delayTimeSpan);

delayTimeSpan = delayTimeSpan + delayTimeSpan;

}

return await httpClient.GetStringAsync(uri);

}

#endregion

[C#/TPL/.NET5] TransformBlock 클래스 사용하기

■ TransformBlock<TInput, TOutput> 클래스를 사용하는 방법을 보여준다. ▶ Program.cs


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

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

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

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            try
            {
                TransformBlock<int, int> multiplyBlock = new TransformBlock<int, int>
                (
                    async item =>
                    {
                        int result = item * 2;

                        Console.WriteLine($"MULTIPLY : {item} -> {result}");

                        await Task.Delay(300);

                        return result;
                    }
                );

                TransformBlock<int, int> subtractBlock = new TransformBlock<int, int>
                (
                    async item =>
                    {
                        int result = item - 2;

                        Console.WriteLine($"SUBTRACT : {item} -> {result}");

                        await Task.Delay(300);

                        return result;
                    }
                );

                multiplyBlock.LinkTo(subtractBlock, new DataflowLinkOptions { PropagateCompletion = true });

                multiplyBlock.Post(2);
                multiplyBlock.Post(4);
                multiplyBlock.Post(6);

                multiplyBlock.Complete();

                multiplyBlock.Completion.Wait();

                Console.WriteLine("COMPLETED");
            }
            catch(AggregateException exception)
            {
                Console.WriteLine(exception.Flatten().InnerException);
            }
        }

        #endregion
    }
}

using System;

using System.Threading.Tasks;

using System.Threading.Tasks.Dataflow;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

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

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

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

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

try

{

TransformBlock<int, int> multiplyBlock = new TransformBlock<int, int>

(

async item =>

{

int result = item * 2;

Console.WriteLine($"MULTIPLY : {item} -> {result}");

await Task.Delay(300);

return result;

}

);

TransformBlock<int, int> subtractBlock = new TransformBlock<int, int>

(

async item =>

{

int result = item - 2;

Console.WriteLine($"SUBTRACT : {item} -> {result}");

await Task.Delay(300);

return result;

}

);

multiplyBlock.LinkTo(subtractBlock, new DataflowLinkOptions { PropagateCompletion = true });

multiplyBlock.Post(2);

multiplyBlock.Post(4);

multiplyBlock.Post(6);

multiplyBlock.Complete();

multiplyBlock.Completion.Wait();

Console.WriteLine("COMPLETED");

}

catch(AggregateException exception)

{

Console.WriteLine(exception.Flatten().InnerException);

}

#endregion

}

TestProject.zip

[C#/TPL/.NET5] AggregateException 클래스 : Handle 메소드를 사용해 예외 처리하기

■ AggregateException 클래스의 Handle 메소드를 사용해 예외를 처리하는 방법을 보여준다. ▶ 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()
        {
            try
            {
                Parallel.Invoke
                (
                    () => { throw new Exception(); },
                    () => { throw new Exception(); }
                );
            }
            catch(AggregateException exception)
            {
                exception.Handle
                (
                    e =>
                    {
                        Console.WriteLine(e);

                        return true;
                    }
                );
            }

            Console.ReadKey(false);
        }

        #endregion
    }
}

using System;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

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

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

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

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

try

{

Parallel.Invoke

(

() => { throw new Exception(); },

() => { throw new Exception(); }

);

}

catch(AggregateException exception)

{

exception.Handle

(

e =>

{

Console.WriteLine(e);

return true;

}

);

}

Console.ReadKey(false);

}

#endregion

}

TestProject.zip

[C#/TPL/.NET5] Parallel 클래스 : Invoke 정적 메소드를 사용해 병렬 작업 처리하기

■ Parallel 클래스의 Invoke 정적 메소드를 사용해 병렬 작업을 처리하는 방법을 보여준다. ▶ Program.cs


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

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

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

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            double[] array = new double[] { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };

            Calculate(array);

            Console.ReadKey(false);
        }

        #endregion

        #region 계산하기 - Calculate(array, startIndex, endIndex)

        /// <summary>
        /// 계산하기
        /// </summary>
        /// <param name="array">배열</param>
        /// <param name="startIndex">시작 인덱스</param>
        /// <param name="endIndex">종료 인덱스</param>
        private static void Calculate(double[] array, int startIndex, int endIndex)
        {
            for(int i = startIndex; i <= endIndex; i++)
            {
                Console.WriteLine(array[i]);

                Thread.Sleep(300);
            }
        }

        #endregion
        #region 계산하기 - Calculate(array)

        /// <summary>
        /// 계산하기
        /// </summary>
        /// <param name="array">배열</param>
        private static void Calculate(double[] array)
        {
            Parallel.Invoke
            (
                () => Calculate(array, 0                   , array.Length / 2 - 1),
                () => Calculate(array, array.Length / 2 - 1, array.Length - 1    )
            );
        }

        #endregion
    }
}

using System;

using System.Threading;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

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

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

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

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

double[] array = new double[] { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };

Calculate(array);

Console.ReadKey(false);

}

#endregion

#region 계산하기 - Calculate(array, startIndex, endIndex)

/// <summary>

/// 계산하기

/// </summary>

/// <param name="array">배열</param>

/// <param name="startIndex">시작 인덱스</param>

/// <param name="endIndex">종료 인덱스</param>

private static void Calculate(double[] array, int startIndex, int endIndex)

{

for(int i = startIndex; i <= endIndex; i++)

{

Console.WriteLine(array[i]);

Thread.Sleep(300);

}

#endregion

#region 계산하기 - Calculate(array)

/// <summary>

/// 계산하기

/// </summary>

/// <param name="array">배열</param>

private static void Calculate(double[] array)

{

Parallel.Invoke

(

() => Calculate(array, 0 , array.Length / 2 - 1),

() => Calculate(array, array.Length / 2 - 1, array.Length - 1 )

);

}

#endregion

}

TestProject.zip

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

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


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

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

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

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            IEnumerable<int> enumerable = new List<int> { 10, 20, 30, 40, 50 };

            Parallel.ForEach(enumerable, value => Calculate(value));

            Console.ReadKey(false);
        }

        #endregion

        #region 계산하기 - Calculate(value)

        /// <summary>
        /// 계산하기
        /// </summary>
        /// <param name="value">값</param>
        private static void Calculate(int value)
        {
            Console.WriteLine(value * 2);
        }

        #endregion
    }
}

using System;

using System.Collections.Generic;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

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

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

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

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

IEnumerable<int> enumerable = new List<int> { 10, 20, 30, 40, 50 };

Parallel.ForEach(enumerable, value => Calculate(value));

Console.ReadKey(false);

}

#endregion

#region 계산하기 - Calculate(value)

/// <summary>

/// 계산하기

/// </summary>

/// <param name="value">값</param>

private static void Calculate(int value)

{

Console.WriteLine(value * 2);

}

#endregion

}

TestProject.zip

[C#/TPL] Task 클래스 : Wait 메소드 사용하기 (교착 상태 발생)

■ Task 클래스의 Wait 메소드를 사용하는 방법을 보여준다. (교착 상태 발생) ▶ MainForm.cs


using System;
using System.Diagnostics;
using System.Threading;
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.executeButton.Click += executeButton_Click;
        }

        #endregion

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

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

        /// <summary>
        /// 실행 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private async void executeButton_Click(object sender, EventArgs e)
        {
            Trace.WriteLine("BEGIN EXECUTE BUTTON CLICK");

            Trace.WriteLine($"현재 스레드 : {Thread.CurrentThread.ManagedThreadId}");

            Task task = ExecuteAsync();

            Trace.WriteLine($"현재 스레드 : {Thread.CurrentThread.ManagedThreadId}");

            task.Wait(); // 교착 상태가 된다.

            Trace.WriteLine("END EXECUTE BUTTON CLICK");
        }

        #endregion

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

        #region 실행하기 (비동기) - ExecuteAsync()

        /// <summary>
        /// 실행하기 (비동기)
        /// </summary>
        /// <returns>태스크</returns>
        private async Task ExecuteAsync()
        {
            Trace.WriteLine("BEGIN EXECUTE ASYNC FUNCTION");

            Trace.WriteLine($"ExecuteAsync 현재 스레드 : {Thread.CurrentThread.ManagedThreadId}");

            await Task.Delay(TimeSpan.FromSeconds(1));
          //await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false); // 교착 상태를 회피한다.

            Trace.WriteLine($"ExecuteAsync 현재 스레드 : {Thread.CurrentThread.ManagedThreadId}");

            Trace.WriteLine("END EXECUTE ASYNC FUNCTION");
        }

        #endregion
    }
}

using System;

using System.Diagnostics;

using System.Threading;

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.executeButton.Click += executeButton_Click;

}

#endregion

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

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

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

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

/// <summary>

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

/// </summary>

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

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

private async void executeButton_Click(object sender, EventArgs e)

{

Trace.WriteLine("BEGIN EXECUTE BUTTON CLICK");

Trace.WriteLine($"현재 스레드 : {Thread.CurrentThread.ManagedThreadId}");

Task task = ExecuteAsync();

Trace.WriteLine($"현재 스레드 : {Thread.CurrentThread.ManagedThreadId}");

task.Wait(); // 교착 상태가 된다.

Trace.WriteLine("END EXECUTE BUTTON CLICK");

}

#endregion

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

#region 실행하기 (비동기) - ExecuteAsync()

/// <summary>

/// 실행하기 (비동기)

/// </summary>

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

private async Task ExecuteAsync()

{

Trace.WriteLine("BEGIN EXECUTE ASYNC FUNCTION");

Trace.WriteLine($"ExecuteAsync 현재 스레드 : {Thread.CurrentThread.ManagedThreadId}");

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

//await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false); // 교착 상태를 회피한다.

Trace.WriteLine($"ExecuteAsync 현재 스레드 : {Thread.CurrentThread.ManagedThreadId}");

Trace.WriteLine("END EXECUTE ASYNC FUNCTION");

}

#endregion

}

TestProject.zip

[C#/TPL] Task 클래스 : ConfigureAwait 메소드를 사용해 await 이후 스레드 풀 스레드에서 실행하기

■ Task 클래스의 ConfigureAwait 메소드를 사용해 await 이후 스레드 풀 스레드에서 실행하는 방법을 보여준다. ▶ MainForm.cs


using System;
using System.Diagnostics;
using System.Threading;
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.executeButton.Click += executeButton_Click;
        }

        #endregion

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

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

        /// <summary>
        /// 실행 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private async void executeButton_Click(object sender, EventArgs e)
        {
            Trace.WriteLine($"현재 스레드 : {Thread.CurrentThread.ManagedThreadId}");

            int value = 10; // UI 스레드에서 실행한다.

            await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);

            Trace.WriteLine($"현재 스레드 : {Thread.CurrentThread.ManagedThreadId}");

            value *= 2; // 스레드 풀 스레드에서 실행한다.

            await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);

            Trace.WriteLine($"현재 스레드 : {Thread.CurrentThread.ManagedThreadId}");

            Trace.WriteLine($"결과값 : {value}"); // 스레드 풀 스레드에서 실행한다.
        }

        #endregion
    }
}

using System;

using System.Diagnostics;

using System.Threading;

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.executeButton.Click += executeButton_Click;

}

#endregion

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

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

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

/// <summary>

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

/// </summary>

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

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

private async void executeButton_Click(object sender, EventArgs e)

{

Trace.WriteLine($"현재 스레드 : {Thread.CurrentThread.ManagedThreadId}");

int value = 10; // UI 스레드에서 실행한다.

await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);

Trace.WriteLine($"현재 스레드 : {Thread.CurrentThread.ManagedThreadId}");

value *= 2; // 스레드 풀 스레드에서 실행한다.

await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);

Trace.WriteLine($"현재 스레드 : {Thread.CurrentThread.ManagedThreadId}");

Trace.WriteLine($"결과값 : {value}"); // 스레드 풀 스레드에서 실행한다.

}

#endregion

}

TestProject.zip

[C#/TPL/.NET5] Task 클래스 : 여러 작업을 실행하는 경우 각 작업 완료시 처리하기

■ Task 클래스를 사용해 여러 작업을 실행하는 경우 각 작업 완료시 처리하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

#region 작업 실행하기 (비동기) - ExecuteJobAsync(value)

/// <summary>
/// 작업 실행하기 (비동기)
/// </summary>
/// <param name="value">값</param>
/// <returns>작업 실행 결과 태스크</returns>
private async Task<int> ExecuteJobAsync(int value)
{
    await Task.Delay(TimeSpan.FromSeconds(value));

    return value;
}

#endregion

Task<int> task1 = ExecuteJobAsync(2);
Task<int> task2 = ExecuteJobAsync(3);
Task<int> taks3 = ExecuteJobAsync(1);

Task<int>[] taskArray = new[] { task1, task2, taks3 };

Task[] processingTaskArray = taskArray.Select
(
    async task =>
    {
        int result = await task;

        Console.WriteLine(result);
    }
).ToArray();

await Task.WhenAll(processingTaskArray);

using System;

using System.Linq;

using System.Threading.Tasks;

#region 작업 실행하기 (비동기) - ExecuteJobAsync(value)

/// <summary>

/// 작업 실행하기 (비동기)

/// </summary>

/// <param name="value">값</param>

/// <returns>작업 실행 결과 태스크</returns>

private async Task<int> ExecuteJobAsync(int value)

{

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

return value;

}

#endregion

Task<int> task1 = ExecuteJobAsync(2);

Task<int> task2 = ExecuteJobAsync(3);

Task<int> taks3 = ExecuteJobAsync(1);

Task<int>[] taskArray = new[] { task1, task2, taks3 };

Task[] processingTaskArray = taskArray.Select

(

async task =>

{

int result = await task;

Console.WriteLine(result);

}

).ToArray();

await Task.WhenAll(processingTaskArray);

[C#/TPL/.NET5] Task 클래스 : WhenAll 정적 메소드 사용시 예외 처리하기

■ Task 클래스의 WhenAll 정적 메소드 사용시 예외를 처리하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Threading.Tasks;

Task task1 = Task.Run(() => { throw new NotImplementedException();   });
Task task2 = Task.Run(() => { throw new InvalidOperationException(); });

Task task3 = Task.WhenAll(task1, task2);

try
{
    await task3;
}
catch
{
    AggregateException exception = task3.Exception;

    Console.WriteLine(exception.InnerExceptions.Count);
}

using System;

using System.Threading.Tasks;

Task task1 = Task.Run(() => { throw new NotImplementedException(); });

Task task2 = Task.Run(() => { throw new InvalidOperationException(); });

Task task3 = Task.WhenAll(task1, task2);

try

{

await task3;

}

catch

{

AggregateException exception = task3.Exception;

Console.WriteLine(exception.InnerExceptions.Count);

}

[C#/TPL/.NET5] Task 클래스 : WhenAll 정적 메소드 사용시 결과 구하기

■ Task 클래스의 WhenAll 정적 메소드 사용시 결과를 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Windows.Forms;

Task<int> task1 = Task.FromResult(3);
Task<int> task2 = Task.FromResult(5);
Task<int> task3 = Task.FromResult(7);

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

using System;

using System.Windows.Forms;

Task<int> task1 = Task.FromResult(3);

Task<int> task2 = Task.FromResult(5);

Task<int> task3 = Task.FromResult(7);

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

[C#/TPL/.NET5] Task 클래스 : WhenAll 정적 메소드 사용시 예외 처리하기

■ Task 클래스의 WhenAll 정적 메소드 사용시 예외를 처리하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Threading.Tasks;

Task task1 = Task.Run(() => { throw new NotImplementedException();   });
Task task2 = Task.Run(() => { throw new InvalidOperationException(); });

try
{
    await Task.WhenAll(task1, task2);
}
catch(Exception exception)
{
    Console.WriteLine(exception.ToString());
}

using System;

using System.Threading.Tasks;

Task task1 = Task.Run(() => { throw new NotImplementedException(); });

Task task2 = Task.Run(() => { throw new InvalidOperationException(); });

try

{

await Task.WhenAll(task1, task2);

}

catch(Exception exception)

{

Console.WriteLine(exception.ToString());

}

※ Task.WhenAll 정적 메소드의 첫번째 인자로

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

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


using System;
using System.Threading.Tasks;

Task task1 = Task.Delay(TimeSpan.FromSeconds(1));
Task task2 = Task.Delay(TimeSpan.FromSeconds(2));
Task task3 = Task.Delay(TimeSpan.FromSeconds(1));

await Task.WhenAll(task1, task2, task3);

using System;

using System.Threading.Tasks;

Task task1 = Task.Delay(TimeSpan.FromSeconds(1));

Task task2 = Task.Delay(TimeSpan.FromSeconds(2));

Task task3 = Task.Delay(TimeSpan.FromSeconds(1));

await Task.WhenAll(task1, task2, task3);

[C#/TPL/.NET5] Task 클래스 : CompletedTask 속성 사용하기

■ Task 클래스의 CompletedTask 속성을 사용하는 방법을 보여준다 ※ 이 코드는 사실상 아무 작업도 수행하지 않는다. ※ 이는 주로 다음과 같은 이유로

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

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


using System;
using System.Threading.Tasks;

private static void Execute(int count)
{
    for(int i = 0; i < count; i++)
    {
        Console.WriteLine(i + 1);
    }
}

private static Task ExecuteAsync(int count)
{
    try
    {
        Execute(count);

        return Task.CompletedTask;
    }
    catch(Exception exception)
    {
        return Task.FromException(exception);
    }
}

using System;

using System.Threading.Tasks;

private static void Execute(int count)

{

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

{

Console.WriteLine(i + 1);

}

private static Task ExecuteAsync(int count)

{

try

{

Execute(count);

return Task.CompletedTask;

}

catch(Exception exception)

{

return Task.FromException(exception);

}

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

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


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

public Task<int> GetValueAsync(CancellationToken cancelltationToken)
{
    if(cancelltationToken.IsCancellationRequested)
    {
        return Task.FromCanceled<int>(cancelltationToken);
    }

    return Task.FromResult(100);
}

using System;

using System.Threading;

using System.Threading.Tasks;

public Task<int> GetValueAsync(CancellationToken cancelltationToken)

{

if(cancelltationToken.IsCancellationRequested)

{

return Task.FromCanceled<int>(cancelltationToken);

}

return Task.FromResult(100);

}

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

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


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

#region 디렉토리 크기 구하기 (비동기) - GetDirectorySizeAsync(directoryPath)

/// <summary>
/// 디렉토리 크기 구하기 (비동기)
/// </summary>
/// <param name="directoryPath">디렉토리 경로</param>
/// <returns>디렉토리 크기</returns>
public Task<long> GetDirectorySizeAsync(string directoryPath)
{
    if(!Directory.Exists(directoryPath))
    {
        return Task.FromException<long>(new DirectoryNotFoundException("디렉토리가 없습니다."));
    }
    else
    {
        string[] filePathArray = Directory.GetFiles(directoryPath, "*.*", SearchOption.AllDirectories);

        if(filePathArray.Length == 0)
        {
            return Task.FromResult(0L);
        }
        else
        {
            return Task.Run
            (
                () =>
                {
                    long totalFileLength = 0;

                    Parallel.ForEach
                    (
                        filePathArray,
                        (filePath) =>
                        {
                            FileStream fileStream = new FileStream
                            (
                                filePath,
                                FileMode.Open,
                                FileAccess.Read,
                                FileShare.ReadWrite,
                                256,
                                true
                            );

                            long fileLength = fileStream.Length;

                            Interlocked.Add(ref totalFileLength, fileLength);

                            fileStream.Close();
                        }
                    );

                    return totalFileLength;
                }
            );
        }
    }
}

#endregion

using System.IO;

using System.Threading;

using System.Threading.Tasks;

#region 디렉토리 크기 구하기 (비동기) - GetDirectorySizeAsync(directoryPath)

/// <summary>

/// 디렉토리 크기 구하기 (비동기)

/// </summary>

/// <param name="directoryPath">디렉토리 경로</param>

/// <returns>디렉토리 크기</returns>

public Task<long> GetDirectorySizeAsync(string directoryPath)

{

if(!Directory.Exists(directoryPath))

{

return Task.FromException<long>(new DirectoryNotFoundException("디렉토리가 없습니다."));

}

else

{

string[] filePathArray = Directory.GetFiles(directoryPath, "*.*", SearchOption.AllDirectories);

if(filePathArray.Length == 0)

{

return Task.FromResult(0L);

}

else

{

return Task.Run

(

() =>

{

long totalFileLength = 0;

Parallel.ForEach

(

filePathArray,

(filePath) =>

{

FileStream fileStream = new FileStream

(

filePath,

FileMode.Open,

FileAccess.Read,

FileShare.ReadWrite,

256,

true

);

long fileLength = fileStream.Length;

Interlocked.Add(ref totalFileLength, fileLength);

fileStream.Close();

}

);

return totalFileLength;

}

);

}

#endregion

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

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


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

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

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

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            string[] argumentArray = Environment.GetCommandLineArgs();

            if(argumentArray.Length > 1)
            {
                List<Task<long>> taskList = new List<Task<long>>();

                for(int i = 1; i < argumentArray.Length; i++)
                {
                    taskList.Add(GetDirectorySizeAsync(argumentArray[i]));
                }

                try
                {
                    Task.WaitAll(taskList.ToArray());
                }
                catch(AggregateException)
                {
                }

                for(int i = 0 ; i < taskList.Count; i++)
                {
                    if(taskList[i].Status == TaskStatus.Faulted)
                    {
                        Console.WriteLine($"{argumentArray[i + 1]} 디렉토리가 없습니다.");
                    }
                    else
                    {
                        Console.WriteLine($"{argumentArray[i + 1]} 디렉토리 크기 : {taskList[i].Result:N0} 바이트");
                    }
                }
            }
            else
            {
                Console.WriteLine("구문 에러 : 1개 이상의 디렉토리 경로를 지정해 주시기 바랍니다.");
            }
        }

        #endregion

        #region 디렉토리 크기 구하기 (비동기) - GetDirectorySizeAsync(directoryPath)

        /// <summary>
        /// 디렉토리 크기 구하기 (비동기)
        /// </summary>
        /// <param name="directoryPath">디렉토리 경로</param>
        /// <returns>디렉토리 크기</returns>
        private static Task<long> GetDirectorySizeAsync(string directoryPath)
        {
            if(!Directory.Exists(directoryPath))
            {
                return Task.FromException<long>(new DirectoryNotFoundException("디렉토리가 없습니다."));
            }
            else
            {
                string[] filePathArray = Directory.GetFiles(directoryPath, "*.*", SearchOption.AllDirectories);

                if(filePathArray.Length == 0)
                {
                    return Task.FromResult(0L);
                }
                else
                {
                    return Task.Run
                    (
                        () =>
                        {
                            long totalFileLength = 0;

                            Parallel.ForEach
                            (
                                filePathArray,
                                (filePath) =>
                                {
                                    FileStream fileStream = new FileStream
                                    (
                                        filePath,
                                        FileMode.Open,
                                        FileAccess.Read,
                                        FileShare.ReadWrite,
                                        256,
                                        true
                                    );

                                    long fileLength = fileStream.Length;

                                    Interlocked.Add(ref totalFileLength, fileLength);

                                    fileStream.Close();
                                }
                            );

                            return totalFileLength;
                        }
                    );
                }
            }
        }

        #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

using System;

using System.Collections.Generic;

using System.IO;

using System.Threading;

using System.Threading.Tasks;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

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

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

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

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

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

string[] argumentArray = Environment.GetCommandLineArgs();

if(argumentArray.Length > 1)

{

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

for(int i = 1; i < argumentArray.Length; i++)

{

taskList.Add(GetDirectorySizeAsync(argumentArray[i]));

}

try

{

Task.WaitAll(taskList.ToArray());

}

catch(AggregateException)

{

}

for(int i = 0 ; i < taskList.Count; i++)

{

if(taskList[i].Status == TaskStatus.Faulted)

{

Console.WriteLine($"{argumentArray[i + 1]} 디렉토리가 없습니다.");

}

else

{

Console.WriteLine($"{argumentArray[i + 1]} 디렉토리 크기 : {taskList[i].Result:N0} 바이트");

}

else

{

Console.WriteLine("구문 에러 : 1개 이상의 디렉토리 경로를 지정해 주시기 바랍니다.");

}

#endregion

#region 디렉토리 크기 구하기 (비동기) - GetDirectorySizeAsync(directoryPath)

/// <summary>

/// 디렉토리 크기 구하기 (비동기)

/// </summary>

/// <param name="directoryPath">디렉토리 경로</param>

/// <returns>디렉토리 크기</returns>

private static Task<long> GetDirectorySizeAsync(string directoryPath)

{

if(!Directory.Exists(directoryPath))

{

return Task.FromException<long>(new DirectoryNotFoundException("디렉토리가 없습니다."));

}

else

{

string[] filePathArray = Directory.GetFiles(directoryPath, "*.*", SearchOption.AllDirectories);

if(filePathArray.Length == 0)

{

return Task.FromResult(0L);

}

else

{

return Task.Run

(

() =>

{

long totalFileLength = 0;

Parallel.ForEach

(

filePathArray,

(filePath) =>

{

FileStream fileStream = new FileStream

(

filePath,

FileMode.Open,

FileAccess.Read,

FileShare.ReadWrite,

256,

true

);

long fileLength = fileStream.Length;

Interlocked.Add(ref totalFileLength, fileLength);

fileStream.Close();

}

);

return totalFileLength;

}

);

}

#endregion

}

TestProject.zip

[C#/TPL] System.Threading.Tasks.Dataflow 누겟 설치하기

■ System.Threading.Tasks.Dataflow 누겟을 설치하는 방법을 보여준다. 1. Visual Studio를 실행한다. 2. [도구] / [NuGet 패키지 관리자] / [패키지 관리자 콘솔] 메뉴를 실행한다.

[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

}