Alternative à BackgroundWorker qui accepte plus d'un argument?

Le BackgroundWorker objet nous permet de passer un seul argument dans le DoWorkEventHandler. 

//setup/init:
BackgroundWorker endCallWorker = new BackgroundWorker();
endCallWorker.DoWork += new DoWorkEventHandler(EndCallWorker_DoWork);
...
endCallWorker.RunWorkerAsync(userName);

//the handler:
private void EndCallWorker_DoWork(object sender, DoWorkEventArgs e)
{
    string userName = e.Argument as string;
    ...
}

Pour passer plusieurs arguments, je doit les envelopper d'un objet, comme ce pauvre tableau de chaînes:

//setup/init:

BackgroundWorker startCallWorker = new BackgroundWorker();
startCallWorker.DoWork += new DoWorkEventHandler(StartCallWorker_DoWork);
...
startCallWorker.RunWorkerAsync(new string[]{userName, targetNumber});


//the handler:
private void StartCallWorker_DoWork(object sender, DoWorkEventArgs e)
{
    string[] args = e.Argument as string[];
    string userName = args[0];
    string targetNumber = args[1];
}

Est là un autre objet ou un modèle qui nous permet de passer plusieurs arguments bien, ou, idéalement, d'écrire notre propre signature?

InformationsquelleAutor Jeff Meatball Yang | 2009-07-17
  1. 45

    Vous pouvez utiliser un dispositif de fermeture (Lambda):

    backgroundWorker.DoWork += (s, e) => MyWorkMethod(userName, targetNumber);

    Ou avec des délégué (méthode anonyme) syntaxe:

    backgroundWorker.DoWork += 
    delegate(object sender, DoWorkEventArgs e)
    {
        MyWorkMethod(userName, targetNumber);
    };
    • pourriez-vous expliquer comment cela fonctionne? (en particulier le "(s, e)"... pourquoi sont-ils déclarés?)
    • J'aime beaucoup - Pour mon cas d'utilisation, il fonctionne très bien, mais plus complexe des applications peuvent avoir des problèmes, c'est à dire j'ai besoin d'accéder à des valeurs de paramètre (nom d'utilisateur et targetNumber) lors de l'installation/init.
    • Un plaisir de vous aider (et un peu plus de texte).
    • Je pense que l'inconvénient de cette solution est, nous perdons la capacité de remplir le Résultat ou d'Annuler les champs dans la DoWorkEventArgs e. Si vous n'ont pas l'intention d'utiliser que de toute façon, c'est génial.
    • R ne pourriez-vous faire pour conserver le résultat: (s,e) => e.Résultat = MyWorkMethod(nom d'utilisateur,targetNumber);
    InformationsquelleAutor Ben M
  2. 12

    Quel est le problème avec l'aide d'un tapé objet?

    internal class UserArgs
{
    internal string UserName { get; set; }
    internal string TargetNumber { get; set; }
}

var args = new UserArgs() {UserName="Me", TargetNumber="123" };
startCallWorker.RunWorkerAsync(args);
    • Ce n'est plus agréable que mon string[] tableau, mais encore - je ne veux pas déclarer une autre classe juste pour passer des arguments dans ma propre fonction. Ce qui se passe dans beaucoup d'autres gestionnaires intégrés dans .NET - je suppose que je suis à la recherche d'un modèle cohérent qui ne pollue pas mon code inutile classes wrapper.
    • C# 4.0 a n-uplet qui pourrait tenir plus d'une args. Veuillez vous référer à ma réponse à cette question.
    InformationsquelleAutor Vijay Patel
  3. 4

    plutôt typé objet. C# 4.0 nous offre n-uplet. Nous pourrions utiliser un tuple d'avoir plusieurs arguments. Il n'est pas nécessaire de déclarer une nouvelle classe.

    InformationsquelleAutor Peter Long
  4. 3

    Objet peut être une liste ou un tableau ou quelque chose du genre. Faites votre objet un conteneur de quelque sorte, alors coulé dans le BackgroundWorker. Vous devez vous assurer que vous êtes en passant toujours dans le même type de bien.

    • +McAden Si la bibliothèque concepteurs manipulé deux arguments, pourquoi pas trois, quatre, etc? La solution a été de manipuler un, et que l'on peut être un objet de complexité arbitraire.
    InformationsquelleAutor McAden
  5. 2

    Peut-être passer à une fonction lambda que votre objet? Alors vous souhaitez appeler dans la DoWork gestionnaire.

    endCallWorker.RunWorkerAsync(new Action( () => DelegatedCallTarget(userName, targetNumber) ));
    • pourriez-vous me montrer comment je les déballer dans le gestionnaire?
    InformationsquelleAutor Sam Harwell
  6. 1

    Créer une classe qui contient tous vos arguments

    Class MyClass
{
     private string m_Username = string.Empty;
     private int m_Targetnumber;

     public MyClass(){}

     public string Username
     {
         get { return m_Username; }
         set { m_Username = value; }
     }

     public int TargetNumber
     {
         get { return m_TargetNumber; }
         set { m_TargetNumber = value; }
     }
 }



//setup/init:

BackgroundWorker startCallWorker = new BackgroundWorker();
startCallWorker.DoWork += new DoWorkEventHandler(StartCallWorker_DoWork);
...

MyClass thisClass = new MyClass();
thisClass.Username = "abcd";
thisClass.TargetNumber = 1234;
startCallWorker.RunWorkerAsync(thisClass);


//the handler:
private void StartCallWorker_DoWork(object sender, DoWorkEventArgs e)
{
     MyClass args = (MyClass)e.Argument;
     string userName = args.Username;
     string targetNumber = args.TargetNumber;
}
    InformationsquelleAutor Azhar Khorasany
  7. 0

    Pourquoi ne pas avoir "un" objet passé en être un tableau de paramètres? Vous avez seulement besoin de le jeter en arrière à tableau à l'intérieur de la méthode de l'objet en paramètre.

    InformationsquelleAutor Kenan E. K.