Comment puis-je utiliser un BackgroundWorker avec un timer tick?

Dans ce cas, il est préférable d'utiliser deux System.Le filetage.Timer et d'exécuter votre cpu-intensive des opérations dans ces deux threads. Veuillez noter que vous doit des contrôles d'accès avec BeginInvoke. Vous pouvez encapsuler ces accès dans les propriétés setter ou encore mieux les tirer hors de vue de la classe du modèle.

public class MyForm : Form
{
private System.Threading.Timer gpuUpdateTimer;
private System.Threading.Timer cpuUpdateTimer;
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
if (!DesignMode)
{
gpuUpdateTimer = new System.Threading.Timer(UpdateGpuView, null, 0, 1000);
cpuUpdateTimer = new System.Threading.Timer(UpdateCpuView, null, 0, 100);
}
}
private string GpuText
{
set
{
if (InvokeRequired)
{
BeginInvoke(new Action(() => gpuLabel.Text = value), null);
}
}
}
private string TemperatureLabel
{
set
{
if (InvokeRequired)
{
BeginInvoke(new Action(() => temperatureLabel.Text = value), null);
}
}
}
private void UpdateCpuView(object state)
{
//do your stuff here
//
//do not access control directly, use BeginInvoke!
TemperatureLabel = sensor.Value.ToString() + "c" //whatever
}
private void UpdateGpuView(object state)
{
//do your stuff here
//
//do not access control directly, use BeginInvoke!
GpuText = sensor.Value.ToString() + "c";  //whatever
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (cpuTimer != null)
{
cpuTimer.Dispose();
}
if (gpuTimer != null)
{
gpuTimer.Dispose();
}
}
base.Dispose(disposing);
}

D'abord assurez-vous d'obtenir votre tête autour de multithreathing et il y a des problèmes (en particulier des éléments d'INTERFACE utilisateur).

Ensuite, vous pouvez utiliser somethink comme

public class Program
{
public static void Main(string[] args)
{
Timer myTimer = new Timer(TimerTick, //the callback function
new object(), //some parameter to pass
0, //the time to wait before the timer starts it's first tick
1000); //the tick intervall
}
private static void TimerTick(object state)
{
//less then .NET 4.0
Thread newThread = new Thread(CallTheBackgroundFunctions);
newThread.Start();
//.NET 4.0 or higher
Task.Factory.StartNew(CallTheBackgroundFunctions);
}
private static void CallTheBackgroundFunctions()
{
cpuView();
gpuView();
}
}

Veuillez garder à l'esprit (comme Jean Koerner dit vous) votre cpuView() et gpuView() ne fonctionnera pas comme il est.

Je pense que BackgroundWorker est trop complexe chose pour le cas; avec Timer il est difficile de mettre en œuvre la garantie de s'arrêter.

Je tiens à vous recommander à l'aide de travailleur Thread avec la boucle qui attend à l'annulation ManualResetEvent pour l'intervalle que vous avez besoin de:

• Si l'annulation de l'événement est définie, alors le travailleur quitte la boucle.
• Si il y a un délai d'attente (intervalle de temps que vous devez dépasse) puis effectuer la surveillance du système.

Ici est la projet de version du code. Veuillez noter je ne l'ai pas testé, mais il pourrait vous montrer l'idée.

public class HardwareMonitor
{
private readonly object _locker = new object();
private readonly TimeSpan _monitoringInterval;
private readonly Thread _thread;
private readonly ManualResetEvent _stoppingEvent = new ManualResetEvent(false);
private readonly ManualResetEvent _stoppedEvent = new ManualResetEvent(false);
public HardwareMonitor(TimeSpan monitoringInterval)
{
_monitoringInterval = monitoringInterval;
_thread = new Thread(ThreadFunc)
{
IsBackground = true
};
}
public void Start()
{
lock (_locker)
{
if (!_stoppedEvent.WaitOne(0))
throw new InvalidOperationException("Already running");
_stoppingEvent.Reset();
_stoppedEvent.Reset();
_thread.Start();
}
}
public void Stop()
{
lock (_locker)
{
_stoppingEvent.Set();
}
_stoppedEvent.WaitOne();
}
private void ThreadFunc()
{
try
{
while (true)
{
//Wait for time interval or cancellation event.
if (_stoppingEvent.WaitOne(_monitoringInterval))
break;
//Monitoring...
//NOTE: update UI elements using Invoke()/BeginInvoke() if required.
}
}
finally
{
_stoppedEvent.Set();
}
}
}