ν€λ₯Ό λλ₯Ό λκΉμ§ (μ Esc: λ릴 λκΉμ§) μ½μ μμ© νλ‘κ·Έλ¨μ κ³μ μ€ννλ €λ©΄ μ΄λ»κ² ν΄μΌν©λκΉ?
while 루νλ₯Ό κ°μΈκ³ μλ€κ³ κ°μ ν©λλ€. ReadKey
ν€ λλ₯΄κΈ°λ₯Ό κ³μ λ£κ³ λ£λ κ²μ΄ μλλΌ μλμ μ°¨λ¨νκ³ ν€λ₯Ό μꡬνλ κ²μ΄ λ§μμ λ€μ§ μμ΅λλ€ .
μ΄λ»κ² ν μ μμ΅λκΉ?
λ΅λ³
μ°¨λ¨λμ§ μλλ€λ κ²μ μκ³ μμ Console.KeyAvailable
λλ§ μ ν ReadKey
ν μ μλλ‘ μ¬μ©νμμμ€ .
Console.WriteLine("Press ESC to stop");
do {
while (! Console.KeyAvailable) {
// Do something
}
} while (Console.ReadKey(true).Key != ConsoleKey.Escape);
λ΅λ³
μ κ·Ό λ°©μμ μ½κ° λ³κ²½ν μ μμ΅λλ€- Console.ReadKey()
μ±μ μ€μ§ νλ λ° μ¬μ© νμ§λ§ λ°±κ·ΈλΌμ΄λ μ€λ λμμ μμ
μ μννμμμ€.
static void Main(string[] args)
{
var myWorker = new MyWorker();
myWorker.DoStuff();
Console.WriteLine("Press any key to stop...");
Console.ReadKey();
}
μμ myWorker.DoStuff()
κΈ°λ₯μ λ€μ λ°°κ²½ μ€λ λμμ λ€λ₯Έ ν¨μλ₯Ό νΈμΆνλ κ² (μ¬μ©μ Action<>()
λλ Func<>()
κ·Έκ²μ ν μμλ μ¬μ΄ λ°©λ²μ΄λ€), μ¦μ λ°ννλ€.
λ΅λ³
κ°μ₯ μ§§μ λ°©λ² :
Console.WriteLine("Press ESC to stop");
while (!(Console.KeyAvailable && Console.ReadKey(true).Key == ConsoleKey.Escape))
{
// do something
}
Console.ReadKey()
μ°¨λ¨ κΈ°λ₯μ΄λ©° νλ‘κ·Έλ¨ μ€νμ μ€μ§νκ³ ν€ λλ¦μ κΈ°λ€λ¦½λλ€. κ·Έλ¬λ Console.KeyAvailable
λ¨Όμ νμΈ λλΆμ while
루νκ° μ°¨λ¨λμ§ μκ³ Escλ₯Ό λλ₯Ό λκΉμ§ μ€ν λ©λλ€.
λ΅λ³
Jason Curs ( http://www.pluralsight.com)μ C #μμ .NET μ½μ μμ© νλ‘κ·Έλ¨ κ΅¬μΆ λΉλμ€ μ μ£Ό
μ¬λ¬ κ°μ μ€νμ€μΈ νλ‘μΈμ€λ₯Ό κ°κΈ° μν΄ λ€μμ μν ν μ μμ΅λλ€.
static void Main(string[] args)
{
Console.CancelKeyPress += (sender, e) =>
{
Console.WriteLine("Exiting...");
Environment.Exit(0);
};
Console.WriteLine("Press ESC to Exit");
var taskKeys = new Task(ReadKeys);
var taskProcessFiles = new Task(ProcessFiles);
taskKeys.Start();
taskProcessFiles.Start();
var tasks = new[] { taskKeys };
Task.WaitAll(tasks);
}
private static void ProcessFiles()
{
var files = Enumerable.Range(1, 100).Select(n => "File" + n + ".txt");
var taskBusy = new Task(BusyIndicator);
taskBusy.Start();
foreach (var file in files)
{
Thread.Sleep(1000);
Console.WriteLine("Procesing file {0}", file);
}
}
private static void BusyIndicator()
{
var busy = new ConsoleBusyIndicator();
busy.UpdateProgress();
}
private static void ReadKeys()
{
ConsoleKeyInfo key = new ConsoleKeyInfo();
while (!Console.KeyAvailable && key.Key != ConsoleKey.Escape)
{
key = Console.ReadKey(true);
switch (key.Key)
{
case ConsoleKey.UpArrow:
Console.WriteLine("UpArrow was pressed");
break;
case ConsoleKey.DownArrow:
Console.WriteLine("DownArrow was pressed");
break;
case ConsoleKey.RightArrow:
Console.WriteLine("RightArrow was pressed");
break;
case ConsoleKey.LeftArrow:
Console.WriteLine("LeftArrow was pressed");
break;
case ConsoleKey.Escape:
break;
default:
if (Console.CapsLock && Console.NumberLock)
{
Console.WriteLine(key.KeyChar);
}
break;
}
}
}
}
internal class ConsoleBusyIndicator
{
int _currentBusySymbol;
public char[] BusySymbols { get; set; }
public ConsoleBusyIndicator()
{
BusySymbols = new[] { '|', '/', '-', '\\' };
}
public void UpdateProgress()
{
while (true)
{
Thread.Sleep(100);
var originalX = Console.CursorLeft;
var originalY = Console.CursorTop;
Console.Write(BusySymbols[_currentBusySymbol]);
_currentBusySymbol++;
if (_currentBusySymbol == BusySymbols.Length)
{
_currentBusySymbol = 0;
}
Console.SetCursorPosition(originalX, originalY);
}
}
λ΅λ³
λ€μμ λ€λ₯Έ μ€λ λμμ 무μΈκ°λ₯Ό μννκ³ λ€λ₯Έ μ€λ λμμ λλ₯Έ ν€μ μ²μ·¨λ₯Ό μμνλ λ°©λ²μ λλ€. μ€μ νλ‘μΈμ€κ° μ’ λ£λκ±°λ μ¬μ©μκ° Escν€ λ₯Ό λλ¬ νλ‘μΈμ€λ₯Ό μ’ λ£νλ©΄ μ½μμ΄ μ²λ¦¬λ₯Ό μ€μ§ν©λλ€ .
class SplitAnalyser
{
public static bool stopProcessor = false;
public static bool Terminate = false;
static void Main(string[] args)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Split Analyser starts");
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Press Esc to quit.....");
Thread MainThread = new Thread(new ThreadStart(startProcess));
Thread ConsoleKeyListener = new Thread(new ThreadStart(ListerKeyBoardEvent));
MainThread.Name = "Processor";
ConsoleKeyListener.Name = "KeyListener";
MainThread.Start();
ConsoleKeyListener.Start();
while (true)
{
if (Terminate)
{
Console.WriteLine("Terminating Process...");
MainThread.Abort();
ConsoleKeyListener.Abort();
Thread.Sleep(2000);
Thread.CurrentThread.Abort();
return;
}
if (stopProcessor)
{
Console.WriteLine("Ending Process...");
MainThread.Abort();
ConsoleKeyListener.Abort();
Thread.Sleep(2000);
Thread.CurrentThread.Abort();
return;
}
}
}
public static void ListerKeyBoardEvent()
{
do
{
if (Console.ReadKey(true).Key == ConsoleKey.Escape)
{
Terminate = true;
}
} while (true);
}
public static void startProcess()
{
int i = 0;
while (true)
{
if (!stopProcessor && !Terminate)
{
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("Processing...." + i++);
Thread.Sleep(3000);
}
if(i==10)
stopProcessor = true;
}
}
}
λ΅λ³
Visual Studioλ₯Ό μ¬μ©νλ κ²½μ° λλ²κ·Έ λ©λ΄μμ βλλ²κΉ μμ΄ μμβμ μ¬μ©ν μ μμ΅λλ€.
βκ³μνλ €λ©΄ μ무 ν€λ λλ₯΄μμμ€.βλΌκ³ μλμΌλ‘ μ°μ¬μ§λλ€. μμ© νλ‘κ·Έλ¨μ΄ μλ£λλ©΄ μ½μμ νμλλ©° ν€λ₯Ό λλ₯Ό λκΉμ§ μ½μμ΄ μ΄λ¦° μνλ‘ μ μ§λ©λλ€.
λ΅λ³
λ€λ₯Έ λ΅λ³ μ€ μΌλΆκ° μ μ²λ¦¬λμ§ μλ κ²½μ°λ₯Ό ν΄κ²°ν©λλ€.
- μλ΅ : ν€ λλ₯΄κΈ° μ²λ¦¬ μ½λμ μ§μ μ€ν; ν΄λ§ μ§μ° λλ μ§μ° μ§μ° λ°©μ§
- μ ν μ¬ν : μ μ ν€ λλ₯΄κΈ°κ° μ νλμ΄ μμ΅λλ€ . κ·Έλ μ§ μμΌλ©΄ μ±μ΄ μ μμ μΌλ‘ μ’ λ£λμ΄μΌν©λλ€
- μ°λ €μ λΆλ¦¬ : λ μΉ¨μ΅μ μΈ μ²μ·¨ μ½λ; μΌλ° μ½μ μ± μ½λμ λ 립μ μΌλ‘ μλν©λλ€.
μ΄ νμ΄μ§μ λ§μ μ루μ
μμμ λν ν΄λ§ Console.KeyAvailable
λλ μ°¨λ¨ μ΄ ν¬ν¨ λμ΄ Console.ReadKey
μμ΅λλ€. Console
μ¬κΈ° μμ .NET μ΄ λ§€μ° νμ‘°μ μ΄μ§ μλ€λ κ²μ μ¬μ€μ΄μ§λ§ Task.Run
,λ³΄λ€ νλμ μΈ Async
λ£κΈ° λͺ¨λλ‘ μ ν νλ λ° μ¬μ©ν μ μμ΅λλ€ .
μμμΌ ν μ£Όμ λ¬Έμ λ κΈ°λ³Έμ μΌλ‘ μ½μ μ€λ λκ° Async
μλνλλ‘ μ€μ λμ΄ μμ§ μλ€λ κ²μ
λλ€. μ¦, main
ν¨μ μ νλ¨μμ λ¨μ΄μ§ λ Async
μλ£λ₯Ό κΈ°λ€λ¦¬μ§ μκ³ AppDoman λ° νλ‘μΈμ€κ° μ’
λ£λ¨μ μλ―Έν©λλ€. . μ΄λ₯Ό ν΄κ²°νλ μ μ ν λ°©λ²μ Stephen Clearyμ AsyncContext λ₯Ό μ¬μ© Async
νμ¬ λ¨μΌ μ€λ λ μ½μ νλ‘κ·Έλ¨μ μμ ν μ§μνλ κ²μ
λλ€. κ·Έλ¬λ ν€ λλ¦ λκΈ°μ κ°μ κ°λ¨ν κ²½μ°μλ μ 체 νΈλ¨ν΄λ¦°μ μ€μΉνλ κ²μ΄ κ³Όλ ν μ μμ΅λλ€.
μλ μμ λ μΌμ’ μ λ°λ³΅ λ°°μΉ νμΌμ μ¬μ©λλ μ½μ νλ‘κ·Έλ¨μ λλ€. μ΄ κ²½μ° νλ‘κ·Έλ¨μ΄ μμ μΌλ‘ μλ£λλ©΄ μΌλ°μ μΌλ‘ ν€λ₯Ό λλ₯΄μ§ μμλ μ’ λ£ ν λ€μ μ νμ ν€ λλ₯΄κΈ°λ₯Ό νμ© νμ¬ μ±μ΄ μ’ λ£ λμ§ μλλ‘ ν©λλ€. μ¬μ΄ν΄μ μΌμ μ€μ§νμ¬ μ¬λ¬Όμ κ²ν νκ±°λ μ¬κ°νκ±°λ μΌμ μ€μ§λ₯Ό μλ €μ§ βμ μ΄μ βμΌλ‘ μ¬μ©νμ¬ λ°°μΉ νμΌμ μμ ν μ€λ¨ ν μ μμ΅λλ€.
static void Main(String[] args)
{
Console.WriteLine("Press any key to prevent exit...");
var tHold = Task.Run(() => Console.ReadKey(true));
// ... do your console app activity ...
if (tHold.IsCompleted)
{
#if false // For the 'hold' state, you can simply halt forever...
Console.WriteLine("Holding.");
Thread.Sleep(Timeout.Infinite);
#else // ...or allow continuing to exit
while (Console.KeyAvailable)
Console.ReadKey(true); // flush/consume any extras
Console.WriteLine("Holding. Press 'Esc' to exit.");
while (Console.ReadKey(true).Key != ConsoleKey.Escape)
;
#endif
}
}