c# - varias - runworkerasync

¿Alternativa a BackgroundWorker que acepta más de un argumento?

Question

El objeto BackgroundWorker nos permite pasar un solo argumento al 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;
...
}

Para pasar múltiples argumentos, debo envolverlos en un objeto, como esta matriz de cadena pobre:

// 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];
}

¿Hay algún otro objeto o patrón que nos permita pasar varios argumentos muy bien o, idealmente, escribir nuestra propia firma?

Answer 1

¿Por qué no hacer pasar el objeto "uno" a una matriz de parámetros? Solo necesita devolverlo a la matriz dentro del método desde el parámetro del objeto.

Answer 2

¿Qué pasa con el uso de un objeto tipado?

internal class UserArgs
{
internal string UserName { get; set; }
internal string TargetNumber { get; set; }
}
var args = new UserArgs() {UserName="Me", TargetNumber="123" };
startCallWorker.RunWorkerAsync(args);

Answer 3

Crea una clase que contenga todos tus argumentos

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;
}

Answer 4

El objeto puede ser una lista o matriz o algo así. Simplemente haga que su objeto sea un contenedor de algún tipo, luego colóquelo en BackgroundWorker. Sin embargo, debes asegurarte de que siempre pasas el mismo tipo.

Answer 5

Podría usar un cierre (Lambda):

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

O con la sintaxis de delegado (método anónimo):

backgroundWorker.DoWork +=
delegate(object sender, DoWorkEventArgs e)
{
MyWorkMethod(userName, targetNumber);
};

Answer 6

Tal vez pasar una función lambda como su objeto? Entonces lo llamarías en el controlador DoWork.

endCallWorker.RunWorkerAsync(new Action( () => DelegatedCallTarget(userName, targetNumber) ));

Answer 7

en lugar de un objeto tipeado C # 4.0 nos proporciona tupla. Podríamos usar una tupla para contener múltiples args. Entonces no hay necesidad de declarar una nueva clase.