// 스레드 생성, 시작, 대기
class Program
{
	static void Main(string[] args)
	{
		Thread t = new Thread(threadFunc); // 스레드 생성
		t.IsBackground = true; // 배경 스레드로 변경
		t.Start(); // t 스레드 시작            

		t.Join(); // t 스레드가 종료할 때 까지 현재 스레드를 무한 대기
		Console.WriteLine("주 스레드 종료");
	}
	
	static void threadFunc()
	{
		Console.WriteLine("60초 후에 프로그램 종료");
		Thread.Sleep(1000 * 60); // 60초 동안 실행 중지
		Console.WriteLine("스레드 종료!");
	}
}

// 60초 후에 프로그램 종료
// 스레드 종료!
// 주 스레드 종료!

class Program
{
    int number = 0;
    static void Main(string[] args)
    {
        Thread t = new Thread(threadFunc); 
        t.Start();          
    }
    static void threadFunc(object inst)
    {
        Program pg = inst as Program;

        for (int i = 0; i < 100000; i++)
        {
            // Monitor 클래스를 이용한 동기화
            Monitor.Enter(pg);

            try
            {
                pg.number = pg.number + 1;
            }
            finally
            {
                Monitor.Exit(pg);
            }

            // lock 예약어를 이용한 동기화 간편 표기
            lock (pg)
            {
                pg.number = pg.number + 1;
            } 
        }
    }
}

TheadPool.QueueUserWorkItem(threadFunc, data);

public class Calc
{
    public static long Cumsum(int start, int end)
    {
        long sum = 0;
        for (int i = start; i <= end; i++)
        {
            sum += i;
        }

        return sum;
    }
}
class Program
{
    public delegate long CalcMethod(int start, int end);

    static void Main(string[] args)
    {
        CalcMethod calc = new CalcMethod(Calc.Cumsum);

        IAsyncResult ar = calc.BeginInvoke(1, 100, null, null);
        ar.AsyncWaitHandle.WaitOne();

        long result = calc.EndInvoke(ar);

        Console.WriteLine(result);
    }
}

class Program
{
   static void Main(string[] args)
   {
       AwaitRead();
       Console.ReadLine();
   }

   private static async void AwaitRead()
   {
       using (FileStream fs = new FileStream(@"C:\windows\system32\drivers\etc\HOSTS", FileMode.Open))
       {
           byte[] buf = new byte[fs.Length];
           await fs.ReadAsync(buf, 0, buf.Length);

           // ReadAsync 메서드가 완료된 후에 아래 코드가 호출된다.
           string txt = Encoding.UTF8.GetString(buf);
           Console.WriteLine(txt);
       }
   }
}

class Program
{
	static void Main(string[] args)
	{
		// WebClinet 타입
		AwaitDownloadString();
		Console.ReadLine();

		// TCP 통신
		TcpListener listener = new TcpListener(IPAddress.Any, 11200);
		listener.Start();

		while (true)
		{
			var client = listener.AcceptTcpClient();
			ProcessTcpClient(client);
		}
	}

	private static async void AwaitDownloadString()
	{
		WebClient wc = new WebClient();
		wc.Encoding = Encoding.UTF8;
		string text = await wc.DownloadStringTaskAsync("http://www.naver.com");
		Console.WriteLine(text);
	}

	private static async void ProcessTcpClient(TcpClient client)
	{
		NetworkStream ns = client.GetStream();

		byte[] buffer = new byte[1024];
		int received = await ns.ReadAsync(buffer, 0, buffer.Length);

		string txt = Encoding.UTF8.GetString(buffer, 0, received);

		byte[] sendBuffer = Encoding.UTF8.GetBytes("Hello:" + txt);
		await ns.WriteAsync(sendBuffer, 0, sendBuffer.Length);
		ns.Close();
	}
}

class Program
{
	static void Main(string[] args)
	{
		// 기존 ThreadPool QueueUserWorkItem 사용
		ThreadPool.QueueUserWorkItem((obj) => { Console.WriteLine("process workitem"); }, null);

		// 닷넷 4.0 Task 타입 사용
		Task task1 = new Task(() => { Console.WriteLine("process taskitem"); });
		task1.Start();

		// Task 작업 완료 대기
		Task TaskSleep = new Task(() => { Thread.Sleep(5000); });
		TaskSleep.Start();
		TaskSleep.Wait();

		// 객체 생성없이 Task 실행
		Task.Factory.StartNew(() => { Console.WriteLine("process taskitem"); });

		// 값을 반환하는 Task 실행
		Task<int> task = new Task<int>(() => { return new Random((int)DateTime.Now.Ticks).Next(); });
		task.Start();
		task.Wait();
		Console.WriteLine("무작위 숫자 값: " + task.Result);
	}
}

class Program
{
	static void Main(string[] args)
	{
		AwaitFileRead(@"C:\windows\system32\drivers\etc\HOSTS");
		Console.ReadLine();
	}

	private static async void AwaitFileRead(string filePath)
	{
		string fileText = await ReadAllTextAsync(filePath);
		Console.WriteLine(fileText);
	}

	static Task<string> ReadAllTextAsync(string filePath)
	{
		return Task.Factory.StartNew(() => { return File.ReadAllText(filePath); });
	}
}

public class Example
{
	public static void Main()
	{
		var tasks = new List<Task<long>>(); // 난수 생성기에서 반환한 값을 저장할 리스트 생성
		for (int ctr = 1; ctr <= 10; ctr++) 
		{
			int delayInterval = 18 * ctr;
			tasks.Add(Task.Run(async () => {       // async 이용한 익명 함수를 생성하여 task를 수행
				long total = 0;
				await Task.Delay(delayInterval);   // 랜덤 시드값을 위해 delay 
				var rnd = new Random();            
				for (int n = 1; n <= 1000; n++)
					total += rnd.Next(0, 1000);    // 난수 생성

				return total;
			}));
		}

		var continuation = Task.WhenAll(tasks);    // Non-Blocking Call

		long grandTotal = 0;
		foreach (var result in continuation.Result)
		{
			grandTotal += result;
			Console.WriteLine("Mean: {0:N2}, n = 1,000", result / 1000.0);
		}

		Console.WriteLine("\nMean of Means: {0:N2}, n = 10,000", grandTotal / 10000);
	}
}

// Tuple<bool, int>을 반환하고 비동기로 수행될 메서드 선언
public async Task<Tuple<bool, int>> SendRecvCommandTimeoutAsync(string ipAddr, string cmd, int ctag, int timeoutMillis = AppConst.TimeoutDefaultResponse,
	int sessionID = AppConst.PduSessionInitial)
{
	TcpClient client = new TcpClient();
	int calla_id = -1;
	bool result = false;

	try
	{
		// SendRecvCommandAsync, Task.Delay 수행
		Task<int> cmdTask = SendRecvCommandAsync(client, ipAddr, cmd, ctag, sessionID);
		Task timeoutTask = Task.Delay(timeoutMillis);

		calla_id = -1;

		// cmdTask, timeoutTask가 완료되면 비동기로 호출 될 completedTask 등록
		result = await Task.Factory.ContinueWhenAny<bool>(new Task[] { cmdTask, timeoutTask }, (completedTask) =>
		{
			// cmdTask, timeoutTask 중 먼저 완료된 Task에 의해 아래 작업이 수행된다.
			if (completedTask == timeoutTask)
			{
				/* timeout */
				return false;
			}
			else if (completedTask == cmdTask)
			{
				calla_id = cmdTask.Result;

				// 141203.nicew Calla가 Invalid한 경우 여기서 Close 시킨다.
				int isValid = Calla.valid(calla_id);
				if (isValid != 1)
				{
					Calla.close(calla_id);
				}

				return (isValid == 1);
			}
			else
			{
				/* just ignore : timeout */
				return false;
			}
		});
	}
	catch (Exception /*ex*/)
	{
		//Trace.TraceInformation(ex.Message);
	}
	finally
	{
		client.Close();
	}

	return new Tuple<bool, int>(result, calla_id);
}

// int를 반환하고 비동기로 수행될 메서드 선언
public async Task<int> SendRecvCommandAsync(TcpClient client, string ipAddr, string cmd, int ctag, int sessionID)
{
	// 생략
}