Comments by Member 11709930 (Top 15 by date)

Thats what I've gathered...
Found I can add a timeout so I've altered the Wait routine so it won't just sit there forever -
public void Wait()
{
bool finished = thread.Join(5000);
if (!finished)
thread.Abort();
}

And with Daves suggestion below, I've added a process kill into the Main so the app will die for me.
Process currentProcess = Process.GetCurrentProcess();
if (!currentProcess.HasExited)
currentProcess.Kill();

I realise its not ideal but will do until I can understand the myriad of threads this thing uses.

I have this in the main loop-
ConsoleKeyInfo cki;
cki = Console.ReadKey();
if ((cki.Modifiers & ConsoleModifiers.Control) != 0)
{
if (cki.Key == ConsoleKey.D)
// do stuff
{}
}

however this seems to be absorbing the windows message as it never fires the ctrlBreak handler whilst this is in place.

I didn't write the original app but I believe console was used for outright speed. This thing runs a heap of multithreading in a real time stock market application.

Thanks Jochen
So CTRL_BREAK_EVENT, becomes CTRL_BREAK_EVENT=1, by default. Didn't know that and explains things nicely.

Seems there is a line limit hence clipped response. Here's the rest-

public void Wait()
{
thread.Join();
}

Ok, hope some of that makes sense.
It seems there is a problem with thread.Join() for one of the threads. When this is reached, stepping is dumped and the console window sits there with a blinking cursor. I tried surrounding it with a Try/Catch but nothing is caught and the code does not step to the lines below.
If I now hit CTL_C again, the app exits immediately.

Think my question now is, how do I debug thread.join ?

It would start again via Windows Scheduler.
Your assumptions are basically correct. I tried heading off the loop but the problems seem to lie in some of the threads not closing.
I've put more time into stepping through the code and there is CTL_C and CTL_BREAK handling in place-

private static bool TermHandlerRoutine(CtrlTypes dwCtrlType)
{
switch (dwCtrlType)
{ //no break so all close events handled same
case CtrlTypes.CTRL_CLOSE_EVENT:
case CtrlTypes.CTRL_BREAK_EVENT:
case CtrlTypes.CTRL_SHUTDOWN_EVENT:
case CtrlTypes.CTRL_C_EVENT:
terminated = true;
return true;
}
return false;
}

'terminated = true;' is detected by the loop which then fires this to close off process console handlers -

public static void Exit()
{
if (!initialized)
{
return;
}

// Unregister each callback delegate that the list contains
for (int i = 0; i < callbacks.Count; i++)
{
SetConsoleCtrlHandler(callbacks[i], false);
}

callbacks.Clear();

initialized = false;
terminated = true;
}

That gets us out of the loop where we initiate a thread cleanup -
private void Cleanup()
{
// Stop SessionClients
foreach (var item in sessionClients)
{
if (item.Value != null)
{
item.Value.Stop();
}
}

// Wait for SessionClients to terminate
foreach (var item in sessionClients)
{
if (item.Value != null)
{
try
{
item.Value.Wait();
}
catch (System.Exception ex)
{
Console.Write(ex);
}
}
}

sessionClients.Clear();

if (appLoggerMonitor != null)
{
appLoggerMonitor.Destroy();
appLoggerMonitor = null;
}

if (appLogger != null)
{
appLogger.Release();
appLogger = null;
}

if (eventQueue != null)
{
while (eventQueue.HasActiveEventStreams)
{
eventQueue.Dispatch(-1);
}

eventQueue.Destroy();
eventQueue = null;
}

if (rfaConfigDB != null)
{
rfaConfigDB.Release();
rfaConfigDB = null;
}

if (appConfigDB != null)
{
appConfigDB.Release();
appConfigDB = null;
}


// Uninitialise Context
if (!Context.Uninitialize() && Context.InitializedCount == 0)
{
// report problem if and ONLY if Context.Uninitialize() returned false
// AND Context.InitializedCount returns zero;
// if Context.InitializedCount returns more than zero, RFA did not attempt to uninitialize its context
Utils.ReportError("Application", configClient.ConfigurationClientName, "RFA Context fails to uninitialize ... ");
}

AppUtil.CleanupLog();
eventQueueSemaphore.Release();
eventQueueSemaphore = null;
}


From this, item.Value.Stop() and item.Value.Wait() fire these-

public void Stop()
{
try
{
stopping = true;
thread.Abort();
}
catch (System.Exception)
{
}
}

public void Wait()
{

As I said, C is not my thing and I do not have the luxury of time at this point to do things properly.
I need something that will dump the app in the same way that clicking the X does. That makes the boss happy and buys me the time to understand whats going on in this thing and do it properly.

Thanks, This app never completes. Runs 24/7 until manually closed. I've updated the original description to try and explain things better.

Garth, I've updated the original question to try and explain some of this.
I guess "terminate it with extreme predjudice !" is what I need for now until I can understand the threads involved and shut down nicely.

Not sure what you mean?
The chart type is 'area'
chart1.Series["Change"].ChartType = SeriesChartType.Area;

This the MS Chart Controls for dot net.
http://www.microsoft.com/en-us/download/details.aspx?id=14422
I'll have read of the links, thanks