We Keep Coding

C# multithreaded throbber form

Working on a C# project which I would like to implement a "waiting" (throbber) indicator in a separate form. After much research and trial and error it appears as the suggested method of doing this is to load a form using a separate thread from the one from the current form/thread.
The reason I went with this method was because initially using the Show() method on the throbber form produced a transparent form. I cannot use ShowDialog because I need to run some code after the throbber is displayed, after which that completes I would like to close the throbber form.
Anyway .. after trying many different methods to load the throbber form in a separate thread I still get an error about trying to access it from a thread which is different from the one it was created in. Here is a skelton version of the project code that should shed some light on my issue:
the example I was working off of for multithreading was this popular link for creating your own spashscreen in a separate thread ... http://www.codeproject.com/Articles/5454/A-Pretty-Good-Splash-Screen-in-C
public class Main
{
public void CheckData()
{
try
{
ProgressBar pb = new ProgressBar();
pb.ShowProgressBar();
//do data checking here
pb.CloseForm()
}
catch(Exception e)
{
}
}
}
public partial class ProgressBar : Form
{
static Thread ms_oThread = null;
public bool shouldStop = false;
static ProgressBar ms_ProgBar = null;
public ProgressBar()
{
InitializeComponent();
//DoWork();
}
public void ShowForm()
{
ms_ProgBar = new ProgressBar();
Application.Run(ms_ProgBar);
}
public void CloseForm()
{
ms_ProgBar.Close();
}
public void ShowProgressBar()
{
// Make sure it is only launched once.
if (ms_ProgBar != null)
return;
ms_oThread = new Thread(new ThreadStart(ShowForm));
ms_oThread.IsBackground = true;
ms_oThread.SetApartmentState(ApartmentState.STA);
ms_oThread.Start();
while (ms_ProgBar == null || ms_ProgBar.IsHandleCreated == false)
{
System.Threading.Thread.Sleep(1000);
}
}
}

You are creating your ProgressBar twice. Once in your main function, and once in your new thread. You are also calling your CloseWindow method from your main function (and on the window that is never shown), rather than on your new thread window.
You only want to create ProgressBar and show it using your new thread. Make your static ProgressBar field public so you can call close on it directly from Main, but make sure to use Invoke to do it since it's not on that Window's GUI thread.
Also, ShowProgressBar should be static.
Here's a rewrite attempt:
public class Main
{
public void CheckData()
{
try
{
ProgressBar.ShowProgressBar();
//do data checking here
ProgressBar.CloseForm();
}
catch(Exception e)
{
}
}
}
public partial class ProgressBar : Form
{
static ProgressBar _progressBarInstance;
public ProgressBar()
{
InitializeComponent();
//DoWork();
}
static void ShowForm()
{
_progressBarInstance = new ProgressBar();
Application.Run(ms_ProgressBar);
}
public static void CloseForm()
{
_progressBarInstance.Invoke(new Action(_progressBarInstance.Close));
_progressBarInstance= null;
}
public static void ShowProgressBar()
{
// Make sure it is only launched once.
if (_progressBarInstance != null)
return;
var ms_oThread = new Thread(new ThreadStart(ShowForm));
ms_oThread.IsBackground = true;
ms_oThread.SetApartmentState(ApartmentState.STA);
ms_oThread.Start();
}
}

Infinite loop between main program and thread

namespace MP3_speler.Threading
{
public class thread : MainWindow
{
public thread()
{
StartThreading();
}
public void StartThreading()
{
Thread thread = new Thread(new ThreadStart(WorkThreadFunction));
thread.Priority = ThreadPriority.BelowNormal;
thread.Start();
}
public void WorkThreadFunction()
{
try
{
UpdateMyDelegatedelegate UpdateMyDelegate = new UpdateMyDelegatedelegate(UpdateMyDelegateLabel);
timelabel.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal, UpdateMyDelegate, (Convert.ToInt32(mp3FileReader.Position / 10000)));
Thread.Sleep(500);
}
catch
{
}
}
private void UpdateMyDelegateLabel(int i)
{
double timeseconds = (double)mp3FileReader.Position / (double)176000;
TimeSpan t = TimeSpan.FromSeconds(timeseconds);
string answer = string.Format("{0:D2}:{1:D2}:{2:D2}",
t.Hours,
t.Minutes,
t.Seconds
);
timelabel.Content = answer;
if (waveOut.PlaybackState != PlaybackState.Paused) Slider2.Value = mp3FileReader.Position;
}
}
}
Code Mainprogram:
public partial class MainWindow : Window
{
public IWavePlayer waveOut;
public Mp3FileReader mp3FileReader;
public delegate void UpdateMyDelegatedelegate(int i);
public MainWindow()
{
InitializeComponent();
//Create a thread
thread thread = new thread();
//Setting up notifyicon
notifyCenter notify = new notifyCenter(this);
//giving values to bars
Slider1.Value = 5;
volumelabel.Content = 50;
}
This code generates an infinite loop and goes back to Initializecomponent all the time.
Maybe the problem is that I made the Thread class inherit the MainWindow but would like to know what the problem is.

Yes, the fact that thread derives from MainWindow is causing the infinite loop.
In MainWindow's constructor, it creates a new thread object. However, because thread derives from MainWindow, it then re-invokes MainWindow's constructor, when creates a thread, repeat ad infinitum.
Remember that when deriving, your constructor will always invoke the base class default constructor unless you explicitly instruct to use a different one.
As an aside, there are no use cases I can think of for ever deriving from MainWindow and this certainly isn't one. You will need to rethink your design.

How to call sibling objects from a foreign thread

I have a WPF application with lots of user controls. One of these controls also uses a 3rd party DLL that watches an external system and produces events. I subscribe to those events and handle them with something like this:
public class ControlClassD
{
private 3rdPartyEventSource _3rdPartyEventSource = new 3rdPartyEventSource();
public ControlClassD()
{
_3rdPartyEventSource.NewEvent += _3rdPartyEventSource_NewEvent;
_3rdPartyEventSource.StartMakingEventsWhenSomethingHappens();
}
private void _3rdPartyEventSource_NewEvent(object o)
{
InstanceOfControlClassA.doSomethingWith(o);
InstanceOfControlClassB.doSomethingWith(o);
InstanceOfControlClassC.doSomethingWith(o);
}
}
All of the InstanceOfControlClassx were instantiated by whatever thread runs the _Loaded event handler in the MainWindow class at startup.
The thread executing the handler is one created by the 3rdPartyEventSource and has no access to all these things (as demonstrated by error messages of that nature)
What I would like to do is let the thread delivered by the 3rdPartyEventSource go back and have HandleNewEvent executed by the thread that created all of those instances (CreatorThread). Like:
private void _3rdPartyEventSource_NewEvent(object o)
{
SomehowInvokeCreatorThread(new Action(() => HandleNewEvent(o)));
}
private void HandleNewEvent(object o)
{
InstanceOfControlClassA.doSomethingWith(o);
InstanceOfControlClassB.doSomethingWith(o);
InstanceOfControlClassC.doSomethingWith(o); //which may access this
}
How can I do that?

There are many ways of doing this, but the following one might be the simplest. Just create your own wrapper event which will be fired on the UI thread:
public class ControlClassD
{
public class WrapperEventArgs: EventArgs { public object Arg { get; set; } }
public event EventHandler<WrapperEventArgs> WrapperEvent = delegate { };
private 3rdPartyEventSource _3rdPartyEventSource = new 3rdPartyEventSource();
public ControlClassD()
{
var dispatcher = Dispatcher.CurrentDispatcher;
_3rdPartyEventSource.NewEvent += obj =>
dispatcher.BeginInvoke(new Action(() =>
this.WrapperEvent(this, new WrapperEventArgs { Arg = obj })));
this.WrapperEvent += ControlClassD_WrapperEventHandler;
_3rdPartyEventSource.StartMakingEventsWhenSomethingHappens();
}
private void ControlClassD_WrapperEventHandler(
object sender, WrapperEventArgs args)
{
InstanceOfControlClassA.doSomethingWith(args.Arg);
InstanceOfControlClassB.doSomethingWith(args.Arg);
InstanceOfControlClassC.doSomethingWith(args.Arg);
}
}

Refresh Progressbar UI using Thread

I have a FTP proccess that run without UI. and have a winform that use this ftp control. in that window I have a progressbar that show the ftp upload progress. The progress arrives to the window via interfase that is updated on the underliying presenter (I'm using MVP pattern).
My problem is when try to update the progress, it allways throw me this exception.
Through threads illegal operation: control 'prgProgresoSubido' is accessed from a thread other than that in which you created it.
That problem persists even if I use a BackGroundWorker in the Form.
// This is a delegated on presenter when a File finish to upload
void client_FileUploadCompletedHandler(object sender, FileUploadCompletedEventArgs e)
{
string log = string.Format("{0} Upload from {1} to {2} is completed. Length: {3}. ",
DateTime.Now, e.LocalFile.FullName, e.ServerPath, e.LocalFile.Length);
archivosSubidos += 1;
_Publicacion.ProgresoSubida = (int)((archivosSubidos / archivosXSubir) * 100);
//this.lstLog.Items.Add(log);
//this.lstLog.SelectedIndex = this.lstLog.Items.Count - 1;
}
// This is My interfase
public interface IPublicacion
{
...
int ProgresoSubida { set; }
}
/// And Here is the implementartion of the interfase on the form
public partial class PublicarForm : Form ,IPublicacion
{
//Credenciales para conectarse al servicio FTP
public FTPClientManager client = null;
public XmlDocument conf = new XmlDocument();
public string workingDir = null;
public webTalk wt = new webTalk();
private readonly PublicacionesWebBL _Publicador;
public PublicarForm()
{
InitializeComponent();
String[] laPath = { System.AppDomain.CurrentDomain.BaseDirectory};
String lcPath = System.IO.Path.Combine(laPath);
_Publicador = new PublicacionesWebBL(this, lcPath);
}
public int ProgresoSubida
{
set
{
// This is my prograss bar, here it throw the exception.
prgProgresoSubido.Value = value;
}
}
}
How can I do to avoid this problem ?

In general, all updates to the User Interface and Controls has to be done from the main thread (event dispatcher). If you attempt to modify the properties of a control from a different thread you will get an exception.
You must call Control.Invoke to invoke on the event dispatcher the method that updates your UI
Control.Invoke
Here, place a button and a label on a form, then try this
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
Thread t = new Thread(new ThreadStart(TestThread));
t.Start();
}
private void TestThread()
{
for (int i = 0; i < 10; i++)
{
UpdateCounter(i);
Thread.Sleep(1000);
}
}
private void UpdateCounter(int i)
{
if (label1.InvokeRequired)
{
label1.Invoke(new ThreadStart(delegate { UpdateCounter(i); }));
}
else
{
label1.Text = i.ToString();
}
}
}
Realize, that if you are firing an event from a thread, that the event will be on the same Thread. Therefore, if that thread is not the event dispatcher, you'll need to invoke.
Also, there may be mechanisms that BackgroundWorker gives you (As the commentator said) that simplify this for you, but I've never used it before so I'll leave that up to you to investigate.

As Alan has just pointed out, you must do all operations with UI controls in UI thread.
Just modify your property like this:
public int ProgresoSubida
{
set
{
MethodInvoker invoker = delegate
{
prgProgresoSubido.Value = value;
}
if (this.InvokeRequired)
{
Invoke(invoker);
}
else
{
invoker();
}
}
}

Return feedback from an event which is being waited on

In it's simplicity what I am trying to do is handle "Doing Something" by firing off a process on a seperate thread to do what I need to do and waiting for an event to be raised to say "I have finished doing what I need to do". In the EventArgs though I will have a property for any errors which may be encountered during the process. Here is a simplified example of my situation.
public class MessageHandler
{
private AutoResetEvent MessageHasSent = new AutoResetEvent(false);
public void SendMessage()
{
MessageSender ms = new MessageSender();
ms.MessageSent += new EventHandler<MessageSentEventArgs>(MessageHandler_MessageSent);
Thread t = new Thread(ms.Send());
t.Start();
MessageHasSent.WaitOne();
//Do some check here
//Same again but for "Message recieved"
}
void MessageHandler_MessageSent(object sender, MessageSentEventArgs e)
{
if (e.Errors.Count != 0)
{
//What can I do here to return to the next step after waitone?
}
else
MessageHasSent.Set();
}
}
public class MessageSender
{
public event EventHandler<MessageSentEventArgs> MessageSent;
public void Send()
{
//Do some method which could potentiallialy return a List<Error>
MessageSent(this, new MessageSentEventArgs() { Errors = new List<Error>() });
}
}
public class Error { }
public class MessageSentEventArgs : EventArgs
{
public List<Error> Errors;
}
Essentially once the event has been raised from Send the code will continute, however I want some way of the event giving feedback, potentially using the MessageHasSent. I have tried different methods, I thought if I called Close instead of Set it would perhaps allow me to access something such as IsClosed. You could throw an exception or set a flag outside of the scope of the event to check but I feel like this is dirty.
Any suggestions?
Using the TPL isn't applicable in my case as I am using .NET 3.5.

Since it seems that this entire section of code is already running in a background thread, and you're doing nothing more than starting up a new thread just so that you can wait for it to finish, you'd be better off just calling Send directly, rather than asynchronously.
You don't need to fire off an event when you're completed.
You don't need to signal the main thread when it needs to continue.
You don't need to log the exceptions in a List, you can just throw them and catch them in SendMessage with a try/catch block.

This will do what you want:
public class MessageHandler
{
private AutoResetEvent MessageHasSent = new AutoResetEvent(false);
private bool IsSuccess = false;
public void SendMessage()
{
MessageSender ms = new MessageSender();
ms.MessageSent += new EventHandler<MessageSentEventArgs>(MessageHandler_MessageSent);
Thread t = new Thread(ms.Send());
t.Start();
MessageHasSent.WaitOne();
if(IsSuccess)
//wohooo
else
//oh crap
//Same again but for "Message recieved"
}
void MessageHandler_MessageSent(object sender, MessageSentEventArgs e)
{
IsSuccess = e.Errors.Count == 0;
MessageHasSent.Set();
}
}
public class MessageSender
{
public event EventHandler<MessageSentEventArgs> MessageSent;
public void Send()
{
//Do some method which could potentiallialy return a List<Error>
MessageSent(this, new MessageSentEventArgs() { Errors = new List<Error>() });
}
}
public class Error { }
public class MessageSentEventArgs : EventArgs
{
public List<Error> Errors;
}