This program is not being stop after pressing c - c#-4.0

Question

This program is not being stop after pressing c.
This program should stop after pressing c but it is not.
I am searching .dll file in given directory. After that I am searching given method name and property
by user.
class Program
{
static void Main(string[] args)
{
char choice;
Console.WriteLine(AppConst.Messages.UserChoice);
Console.WriteLine(AppConst.Messages.Star);
choice = GetResponse();
string name = string.Empty;
if (choice == 'M')
{
Console.WriteLine(AppConst.Messages.InputMethodName);
name = Console.ReadLine();
}
if (choice == 'P')
{
Console.WriteLine(AppConst.Messages.InputPropertyName);
name = Console.ReadLine();
}
CancellationTokenSource cancellationToken = new CancellationTokenSource();
// Use ParallelOptions instance to store the CancellationToken.
ParallelOptions parallelOption = new ParallelOptions();
parallelOption.CancellationToken = cancellationToken.Token;
parallelOption.MaxDegreeOfParallelism = 10;
Console.WriteLine(AppConst.Messages.StartSearchingMessage);
Console.ReadKey();
//Console.WriteLine();
// Run a task so that we can cancel another thread.
Task.Factory.StartNew(() =>
{
while (Console.ReadKey().Key != ConsoleKey.C) ;
cancellationToken.Cancel();
});
int countClass = 0;
string[] files = Directory.GetFiles(#"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETCore\v4.5", "*.dll");
try
{
Parallel.ForEach(files, parallelOption, (file) =>
{
parallelOption.CancellationToken.ThrowIfCancellationRequested();
try
{
var asm = Assembly.LoadFile(file);
foreach (var type in asm.GetTypes())
{
if (choice == 'M')
{
try
{
MethodInfo methodInfo = type.GetMethod(name);
if (methodInfo != null)
{
countClass++;
Console.WriteLine(AppConst.Messages.Star);
Console.WriteLine(AppConst.Messages.
PrintFileName, Path.GetFileName(file));
Console.WriteLine(AppConst.Messages.
PrintCalssName, type.Name);
}
}
catch (AmbiguousMatchException ex)
{
Console.WriteLine("\n{0}\n{1}", ex.GetType().
FullName, ex.Message);
}
}
if (choice == 'P')
{
try
{
PropertyInfo propertyInfo = type.GetProperty(name);
if (propertyInfo != null)
{
countClass++;
Console.WriteLine(AppConst.Messages.Star);
Console.WriteLine(AppConst.Messages.
PrintFileName, Path.GetFileName(file));
Console.WriteLine(AppConst.Messages.
PrintCalssName, type.Name);
}
}
catch (NullReferenceException e)
{
Console.WriteLine(AppConst.Messages.
PropertyNotExist + e.Message);
}
}
}
}
catch (BadImageFormatException e)
{
Console.WriteLine(AppConst.Messages.UnableTOLoad,
Path.GetFileName(file));
Console.WriteLine(e.Message.Substring(0, e.Message.IndexOf(".") + 1));
}
//parallelOption.CancellationToken.ThrowIfCancellationRequested();
});
}
catch (OperationCanceledException e)
{
Console.WriteLine(e.Message);
}
catch (Exception e)
{
Console.WriteLine();
Console.ReadLine();
}
if (countClass == 0)
{
Console.WriteLine(AppConst.Messages.NotExistMessage);
}
Console.ReadKey();
}
private static char GetResponse()
{
char response;
while (true)
{
//Checking for entered input is M or P.
if (Char.TryParse(Console.ReadLine().ToUpper(), out response)
&& (response == 'M' || response == 'P'))
break;
//AppConst.Messages.InvalidChoice is string message.
Console.WriteLine(AppConst.Messages.InvalidChoice);
}
return response;
}
}

Answer 1

It seems to me that the main problem in your code is that you only check for cancellation once, right when a thread starts. If you want an exception, or any other type of cancellation for that matter, you need to actually check the CancellationToken somehow while you're running the task.
It looks to me as though you would want to put the parallelOption.CancellationToken.ThrowIfCancellationRequested(); line in the loop block for the foreach (var type in asm.GetTypes()) loop, probably as the first statement in the block.
Here is a simple example demonstrating correct use of CancellationToken in a way that is similar to what you seem to want:
CancellationTokenSource tokenSource = new CancellationTokenSource();
Thread thread = new Thread(() =>
{
while (Console.ReadKey().Key != ConsoleKey.C) { }
tokenSource.Cancel();
});
thread.IsBackground = true;
thread.Start();
TimeSpan[] timeSpans = new TimeSpan[10];
int completedCount = 0;
timeSpans[0] = TimeSpan.FromSeconds(4);
for (int i = 1; i < timeSpans.Length; i++)
{
timeSpans[i] = timeSpans[i - 1] + TimeSpan.FromSeconds(2);
}
try
{
Parallel.ForEach(timeSpans, timeSpan =>
{
Stopwatch sw = Stopwatch.StartNew();
while (sw.Elapsed < timeSpan)
{
Thread.Sleep(100);
tokenSource.Token.ThrowIfCancellationRequested();
}
Console.WriteLine("Completed {0} threads (thread time: {1})",
Interlocked.Increment(ref completedCount), sw.Elapsed);
});
}
catch (AggregateException e)
{
Console.WriteLine("Exception: " + e);
}
Console.WriteLine("All threads completed");
Note that the exception actually seen in the main thread is an AggregateException. This contains the individual exception information for each thread that was cancelled.