La création de BackgroundWorker avec la File d'attente

J'ai besoin de créer une file d'attente et l'utiliser avec BackgroundWorker. Donc, je peux les opérations d'ajout et quand on se fait suivant commence en arrière-plan. J'ai trouvé ce code par google:

public class QueuedBackgroundWorker<T>
{
public void QueueWorkItem(
Queue queue,
T inputArgument,
Func<T> doWork,
Action workerCompleted)
{
if (queue == null) throw new ArgumentNullException("queue");
BackgroundWorker bw = new BackgroundWorker();
bw.WorkerReportsProgress = false;
bw.WorkerSupportsCancellation = false;
bw.DoWork += (sender, args) =>
{
if (doWork != null)
{
args.Result = doWork(new DoWorkArgument<T>((T)args.Argument));
}
};
bw.RunWorkerCompleted += (sender, args) =>
{
if (workerCompleted != null)
{
workerCompleted(new WorkerResult<T>((T)args.Result, args.Error));
}
queue.Dequeue();
if (queue.Count > 0)
{
QueueItem<T> nextItem = queue.Peek() as QueueItem<T>;
nextItem.BackgroundWorker.RunWorkerAsync(nextItem.Argument);
}
};
queue.Enqueue(new QueueItem<T>(bw, inputArgument));
if (queue.Count == 1)
{
QueueItem<T> nextItem = queue.Peek() as QueueItem<T>;
nextItem.BackgroundWorker.RunWorkerAsync(nextItem.Argument);
}
}
}
public class DoWorkArgument<T>
{
public DoWorkArgument(T argument)
{
this.Argument = argument;
}
public T Argument { get; private set; }
}
public class WorkerResult<T>
{
public WorkerResult(T result, Exception error)
{
this.Result = result;
this.Error = error;
}
public T Result { get; private set; }
public Exception Error { get; private set; }
}
public class QueueItem<T>
{
public QueueItem(BackgroundWorker backgroundWorker, T argument)
{
this.BackgroundWorker = backgroundWorker;
this.Argument = argument;
}
public T Argument { get; private set; }
public BackgroundWorker BackgroundWorker { get; private set; }
}

Mais j'ai un problème avec doWork et workerCompleted. J'obtiens l'erreur:

Délégué 'Func' ne prend pas 1 arguments

Comment puis-je résoudre ce problème? Comment dois-je changer les paramètres? Grâce

  • Au moins indiquer sur la ligne. Et peut-être seulement après que ligne. TL;DR
InformationsquelleAutor Libor Zapletal | 2013-02-27
  1. 30

    Ici est beaucoup plus rapide méthode qui fait ce que vous voulez:

    public class BackgroundQueue
{
private Task previousTask = Task.FromResult(true);
private object key = new object();
public Task QueueTask(Action action)
{
lock (key)
{
previousTask = previousTask.ContinueWith(t => action()
, CancellationToken.None
, TaskContinuationOptions.None
, TaskScheduler.Default);
return previousTask;
}
}
public Task<T> QueueTask<T>(Func<T> work)
{
lock (key)
{
var task = previousTask.ContinueWith(t => work()
, CancellationToken.None
, TaskContinuationOptions.None
, TaskScheduler.Default);
previousTask = task;
return task;
}
}
}

    En ajoutant à chaque nouvelle action comme une continuation de la précédente vous assurer qu'un seul est travaillé sur un temps, comme l'élément suivant ne démarre pas jusqu'à ce que l'élément précédent est terminé, vous vous assurez qu'il n'y a pas de fil assis autour de la marche au ralenti quand il n'y a rien à être travaillé, et vous assurer qu'ils sont tous fait dans l'ordre.

    Notez également que si vous ne croyez jamais que vous aurez besoin d'une file d'attente, et pas de n'importe quel nombre, vous pourriez faire de tous les membres static, mais c'est à vous de voir.

    • Regarde mieux, merci pour cette. Maintenant je l'utilise comme ceci: bgQueue.QueueTask(() => CreateConvertingProccess(item.FullName));. Pouvez-vous m'aider comment puis-je appeler la méthode lorsqu'une tâche est terminée? Devrait je l'ai ajouté après le verrouillage? Je veux dire, quand je veux ajouter une méthode qui, je voudrais ajouter RunWorkerCompleted.
    • Merci beaucoup, Ça fonctionne. Je dois apprendre sur le travail à la Tâche.
    • Pouvez-vous m'aider une fois de plus, s'il vous plaît. Comment puis-je savoir si la file d'attente est vide?
    • public bool IsEmpty() { return previousTask.IsCompleted; }
    • Vous avez fait ce que je pensais impossible, un rêve viennent vrai. Je vous remercie pour cette.
    • Ce qui est intéressant... Pourriez-vous donner un exemple de la façon dont il peut être mis à quelque chose comme le traitement d'une liste de fichiers (fichier donné chemins)?
    • Il n'a pas d'importance ce les tâches sont en train de faire. C'est l'ensemble de point. Vous construisez une file d'attente et fournir des méthodes, et ils vont tous être exécutées de manière séquentielle, de manière asynchrone. Ce qu'ils font n'est pas pertinent à la file d'attente.

    InformationsquelleAutor Servy
  2. 1

    Il semble que vous êtes absent le deuxième paramètre générique - Tout;

    Le code suivant doit prendre soin d'elle:

    using System;
using System.Collections.Generic;
using System.ComponentModel;
public static class QueuedBackgroundWorker
{
public static void QueueWorkItem<Tin, Tout>(
Queue<QueueItem<Tin>> queue,
Tin inputArgument,
Func<DoWorkArgument<Tin>, Tout> doWork,
Action<WorkerResult<Tout>> workerCompleted)
{
if (queue == null) throw new ArgumentNullException("queue");
BackgroundWorker bw = new BackgroundWorker();
bw.WorkerReportsProgress = false;
bw.WorkerSupportsCancellation = false;
bw.DoWork += (sender, args) =>
{
if (doWork != null)
{
args.Result = doWork(new DoWorkArgument<Tin>((Tin)args.Argument));
}
};
bw.RunWorkerCompleted += (sender, args) =>
{
if (workerCompleted != null)
{
workerCompleted(new WorkerResult<Tout>((Tout)args.Result, args.Error));
}
queue.Dequeue();
if (queue.Count > 0)
{
QueueItem<Tin> nextItem = queue.Peek(); //as QueueItem<T>;
nextItem.BackgroundWorker.RunWorkerAsync(nextItem.Argument);
}
};
queue.Enqueue(new QueueItem<Tin>(bw, inputArgument));
if (queue.Count == 1)
{
QueueItem<Tin> nextItem = queue.Peek() as QueueItem<Tin>;
nextItem.BackgroundWorker.RunWorkerAsync(nextItem.Argument);
}
}
}
public class DoWorkArgument<T>
{
public DoWorkArgument(T argument)
{
this.Argument = argument;
}
public T Argument { get; private set; }
}
public class WorkerResult<T>
{
public WorkerResult(T result, Exception error)
{
this.Result = result;
this.Error = error;
}
public T Result { get; private set; }
public Exception Error { get; private set; }
}
public class QueueItem<T>
{
public QueueItem(BackgroundWorker backgroundWorker, T argument)
{
this.BackgroundWorker = backgroundWorker;
this.Argument = argument;
}
public T Argument { get; private set; }
public BackgroundWorker BackgroundWorker { get; private set; }
}

    Et l'usage doit être:

        private readonly Queue<QueueItem<int>> _workerQueue = new Queue<QueueItem<int>>();
private int _workerId = 1;
[Test]
public void BackgroundTest()
{
QueuedBackgroundWorker.QueueWorkItem(
this._workerQueue, 
this._workerId++,
args =>  //DoWork
{
var currentTaskId = args.Argument;
var now = DateTime.Now.ToLongTimeString();
var message = string.Format("DoWork thread started at '{0}': Task Number={1}", now, currentTaskId);
return new { WorkerId = currentTaskId, Message = message };
},
args =>  //RunWorkerCompleted
{
var currentWorkerId = args.Result.WorkerId;
var msg = args.Result.Message;
var now  = DateTime.Now.ToShortTimeString();
var completeMessage = string.Format(
"RunWorkerCompleted completed at '{0}'; for Task Number={1}, DoWork Message={2}",
now,
currentWorkerId,
msg);
}
);
}
    InformationsquelleAutor Aaron