Visual Studio 2008, C# 3.0.
I have a method below which calls an event handler. I would like to pass the two arguments received by the method to the event handler.
I would like to do something like this:
wc.DownloadDataCompleted += wc.DownloadedDataCompleted(strtitle, placeid);
Is this even possible, if yes, how would I go about doing it ?
Code Snippet:
public void downloadphoto(string struri,string strtitle,string placeid)
{
using (WebClient wc = new WebClient())
{
wc.DownloadDataCompleted += wc_DownloadDataCompleted;
wc.DownloadDataAsync(new Uri(struri));
}
}
The easiest way to do this is to use an anonymous function (an anonymous method or a lambda expression) to subscribe to the event, then make your method have just the parameters you want:
public void downloadphoto(string struri, string strtitle, string placeid)
{
using (WebClient wc = new WebClient())
{
wc.DownloadDataCompleted += (sender, args) =>
DownloadDataCompleted(strtitle, placeid, args);
wc.DownloadDataAsync(new Uri(struri));
}
}
// Please rename the method to say what it does rather than where it's used :)
private void DownloadDataCompleted(string title, string id,
DownloadDataCompletedEventArgs args)
{
// Do stuff here
}
DownloadDataAsync has an overload which takes an object:
DownloadDataAsync(uri, object)
That object can be any arbitrary thing you want that gets passed into the DownloadDataCompleted handler:
public void downloadphoto(string struri,string strtitle,string placeid)
{
using (WebClient wc = new WebClient())
{
string[] data = new string[2] { strtitle, placeid };
wc.DownloadDataCompleted += wc_DownloadDataCompleted;
wc.DownloadDataAsync(new Uri(struri), data);
}
}
void wc_DownloadDataCompleted(object sender, DownloadDataCompletedEventArgs e)
{
string[] data = (string[])e.UserToken;
string strtitle = data[0];
string placeid = data[1];
}
You could create a private class and place the handler in there. E.g.
public void downloadphoto(string struri, string strtitle, string placeid)
{
using (WebClient wc = new WebClient())
{
wcHandler handler = new wcHandler() { Strtitle = strtitle, Placeid = placeid };
wc.DownloadDataCompleted += handler.wc_DownloadDataCompleted;
wc.DownloadDataAsync(new Uri(struri));
}
}
private class wcHandler
{
public string Strtitle { get; set; }
public string Placeid { get; set; }
public void wc_DownloadDataCompleted(object sender, DownloadDataCompletedEventArgs e)
{
// Do Stuff
}
}
Although, given the elegance of Jon's answer would probably use that!
Jon Skeet already answered this, showing how to use a lamda expression, but I was still unclear about it. I still needed some more examples, and eventually found this simple case using a button: http://social.msdn.microsoft.com/Forums/en-US/csharpgeneral/thread/74d03fe0-0fa5-438d-80e0-cf54fa15af0e
void A()
{
Popup parameter = new Popup();
buttonClose.Click += (sender, e) => { buttonClose_Click(sender, e, parameter); };
}
static void buttonClose_Click(object sender, EventArgs e, Popup parameter)
{
MakeSomethingWithPopupParameter(parameter);
}
In my case, I was using a context menu for a TreeView control, which ended up looking like this:
private void TreeViewCreateContextMenu(TreeNode node)
{
ContextMenuStrip contextMenu = new ContextMenuStrip();
// create the menu items
ToolStripMenuItem newMenuItem = new ToolStripMenuItem();
newMenuItem.Text = "New...";
// add the menu items to the menu
contextMenu.Items.AddRange(new ToolStripMenuItem[] { newMenuItem });
// add its event handler using a lambda expression, passing
// the additional parameter "myData"
string myData = "This is the extra parameter.";
newMenuItem.Click += (sender, e) => { newMenuItem_Click(sender, e, myData); };
// finally, set the node's context menu
node.ContextMenuStrip = contextMenu;
}
// the custom event handler, with "extraData":
private void newMenuItem_Click(object sender, EventArgs e, string extraData)
{
// do something with "extraData"
}
Related
Let's say I want to pass some extra data when assigning an event handler. Consider the following code:
private void setup(string someData)
{
Object.assignHandler(evHandler);
}
public void evHandler(Object sender)
{
// need someData here!!!
}
How would I go about getting someData into my evHandler method?
private void setup(string someData)
{
Object.assignHandler((sender) => evHandler(sender,someData));
}
public void evHandler(Object sender, string someData)
{
// need someData here!!!
}
I had a hard time figuring out #spender's example above especially with: Object.assignHandler((sender) => evHandler(sender,someData)); because there's no such thing as Object.assignHandler in the literal sense. So I did a little more Googling and found this example. The answer by Peter Duniho was the one that clicked in my head (this is not my work):
snip
The usual approach is to use an anonymous method with an event handler
that has your modified signature. For example:
void Onbutton_click(object sender, EventArgs e, int i) { ... }
button.Click += delegate(object sender, EventArgs e)
{ Onbutton_click(sender, e, 172); };
Of course, you don't have to pass in 172, or even make the third parameter
an int. :)
/snip
Using that example I was able to pass in two custom ComboBoxItem objects to a Timer.Elapsed event using lambda notation:
simulatorTimer.Elapsed +=
(sender, e) => onTimedEvent(sender, e,
(ComboBoxItem) cbPressureSetting.SelectedItem,
(ComboBoxItem) cbTemperatureSetting.SelectedItem);
and then into it's handler:
static void onTimedEvent(object sender, EventArgs e, ComboBoxItem pressure, ComboBoxItem temperature)
{
Console.WriteLine("Requested pressure: {0} PSIA\nRequested temperature: {1}° C", pressure, temperature);
}
This isn't any new code from the examples above, but it does demonstrate how to interpret them. Hopefully someone like me finds it instructive & useful so they don't spend hours trying to understand the concept like I did.
This code works in my project (except for a non-thread-safe exception with the ComboBoxItem objects that I don't believe changes how the example works). I'm figuring that out now.
Captured variables:
private void setup(string someData)
{
Object.assignHandler((sender,args) => {
evHandler(sender, someData);
});
}
public void evHandler(Object sender, string someData)
{
// use someData here
}
Or (C# 2.0 alternative):
Object.assignHandler((EventHandler)delegate(object sender,EventArgs args) {
evHandler(sender, someData);
});
you can try doing this:
string yourObject;
theClassWithTheEvent.myEvent += (sender, model) =>
{
yourObject = "somthing";
}
My question that was similar was marked a duplicate so thought I'd add an answer here since it won't let me on my question.
class Program
{
delegate void ComponentEventHandler(params dynamic[] args);
event ComponentEventHandler onTest;
static void Main(string[] args)
{
Program prg = new Program();
// can be bound to event and called that way
prg.onTest += prg.Test;
prg.onTest.Invoke("What", 5, 12.0);
Console.ReadKey();
}
public void Test(params dynamic[] values)
{
// assign our params to variables
string name = values[0];
int age = values[1];
double value = values[2];
Console.WriteLine(name);
Console.WriteLine(age);
Console.WriteLine(value);
}
}
Well, the simplest method id to make someData a member variable like so:
public class MyClass
{
private string _eventData;
private void setup(string someData)
{
_eventData = someData;
Object.assignHandler(evHandler);
}
public void evHandler()
{
// do something with _eventData here
}
}
I'm not sure that's the best way to do it, but it really depends on the event type, the object, etc.
You could create a custom object having additional properties based on Object:
class CustomObject : Object
{
public string SomeData;
}
private void setup(string someData)
{
CustomObject customObject = new CustomObject { SomeData = someData };
CustomObject.assignHandler(evHandler);
}
public void evHandler(Object sender)
{
string someData = ((CustomObject)sender).SomeData;
}
If the data should not be changed anymore after initialization, you could also add a custom constructor, for example.
Here is my one-line solution that pass extra parameters to a timer handler.
private void OnFailed(uint errorCode, string message)
{
ThreadPoolTimer.CreateTimer((timer) => {
UI.ErrorMessage = string.Format("Error: 0x{0:X} {1}", errorCode, message);
}, System.TimeSpan.FromMilliseconds(100));
}
This solution offers a way to pass extra parameters to an event handler while still allowing to unsubscibe:
Within the Subscribe() function of my example I create an Action that invokes a lambda function that supplies my event handler with the event args and my extra parameter. I then store this Action in a dictionary. When I want to unsubscribe, I can use the stored Actions to do so.
This works, I read the length of listeners before and after unsubscribing and it did decrease - you can unsubscribe again without problems.
public class Player
{
public Action<JumpInfo> OnJump;
}
public class PlayerJumpListener
{
public List<Player> MyPlayerList;
private Dictionary<Player, Action<JumpInfo>> _jumpActionsByPlayer = new Dictionary<Player, Action<JumpInfo>>();
private void Subscribe()
{
foreach (Player player in MyPlayerList)
{
Action<JumpInfo> playerJumpAction = (jumpInfo) => HandlePlayerJump(jumpInfo, player);
player.OnJump += playerJumpAction;
_jumpActionsByPlayer.Add(player, playerJumpAction);
}
}
private void Unsubscibe()
{
foreach (KeyValuePair<Player, Action<JumpInfo>> kvp in _jumpActionsByPlayer)
{
kvp.Key.OnJump -= kvp.Value;
}
}
private void HandlePlayerJump(JumpInfo jumpInfo, Player player)
{
// player jumped
}
}
I scoured the internet before a coworker kindly helped me, and boy I felt dumb. Brackets is the solution for the EventHandler.
Ex.
event EventHandler<(int, bool)> EventName;
and then pick it up with:
private void Delegate_EventName(object sender, (int, bool) e)
you can then access the info:
var temp = e.Item1;<br>
var temp2 = e.Item2;<br>
or you can add names as you would expect for parameters and call them via e:
private void Delegate_EventName(object sender, (int num, bool val) e)
you can then access the info:
var temp = e.num;
var temp2 = e.val;
I am trying to create a tray icon in C#/.NET and so far I have this code that works:
....
Icon i = new Icon("favicon.ico");
ContextMenu cm = new ContextMenu();
ni.Icon = i;
MenuItem delMi = new MenuItem("Delete stuff");
MenuItem closeMi = new MenuItem("Close");
MenuItem testMi = new MenuItem("Test");
cm.MenuItems.Add(testMi);
cm.MenuItems.Add(delMi);
cm.MenuItems.Add(closeMi);
testMi.Click += TestMi_Click;
delMi.Click += DelMi_Click;
closeMi.Click += CloseMi_Click;
ni.ContextMenu = cm;
}
private void TestMi_Click(object sender, EventArgs e)
{
// Test event here
}
private void CloseMi_Click(object sender, EventArgs e)
{
// Close event here
}
private void DelMi_Click(object sender, EventArgs e)
{
// Delete event here
}
But I am trying to separate the code by having a function that returns an array of MenuItem instances, and having a loop that adds them to the ContextMenu, but I'm not sure how to add the click event handlers to the MenuItem instances in the loop:
....
Icon i = new Icon("favicon.ico");
ContextMenu cm = new ContextMenu();
ni.Icon = i;
MenuItem[] miArray = getArrayMI();
foreach(MenuItem mi in miArray)
{
cm.MenuItems.Add(mi);
//Not sure what to do here
mi.Click += mi
}
// How do I put this section into the loop instead
// of adding the event handlers one by one?
testMi.Click += TestMi_Click;
delMi.Click += DelMi_Click;
closeMi.Click += CloseMi_Click;
ni.ContextMenu = cm;
}
private MenuItem[] getArrayMI( )
{
MenuItem[] miArray = { new MenuItem("Delete stuff"), new MenuItem("Close"), new MenuItem("Test") };
return miArray;
}
private void TestMi_Click(object sender, EventArgs e)
{
// Test event here
}
private void CloseMi_Click(object sender, EventArgs e)
{
// Close event here
}
private void DelMi_Click(object sender, EventArgs e)
{
// Delete event here
}
The only thing I could think of would be to do something like this:
foreach(MenuItem mi in miArray)
{
cm.MenuItems.Add(mi);
mi.Click += mi.ToString() + "_Click";
}
I don't think it's a bad idea to abstract your original code, but I'd suggest looking at the abstraction in a different way. I'd recommend implementing some kind of separation of the view from the model - MVC, MVP, MVVM, etc. In this way, the code that actually happens when the click occurs is abstracted away from the view, into another layer of code.
For example, consider something like this (writing without an IDE so please forgive typos):
public interface IContextAction
{
string DisplayName { get; }
Action Invoke { get; }
}
public class WindowViewModel
{
public IEnumerable<IContextAction> ContextActions { get; private set; }
/* ... */
}
/* ... */
ContextMenu cm = new ContextMenu();
foreach (IContextAction action in viewModel.ContextActions)
{
MenuItem item = new MenuItem(action.DisplayName);
cm.MenuItems.Add(item);
item.Click += (sender,args) => action.Invoke();
}
I agree with the comment that suggests that, at least for the code example you posted, there is no need to "improve" the code. It's already a reasonable way to implement that particular logic. Furthermore, it is my preference to avoid relying on naming conventions to tie specific code to specific run-time objects. Doing so results in a fragile (i.e. easily broken) implementation, and restricts your ability to change the name of the code (e.g. to address some unrelated aspect of naming which would otherwise provide for more readable code).
That said, if you really want to do this, you can. Here is a Minimal, Complete, and Verifiable code example that illustrates how to create a delegate instance for an event handler based on the name of the object, and subscribe to the object's event:
class Program
{
static void Main(string[] args)
{
Class[] classInstances =
{
new Class("A"),
new Class("B"),
new Class("C"),
};
foreach (Class c in classInstances)
{
string methodName = c.Name + "_Event";
MethodInfo mi = typeof(Program).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Static);
EventHandler handler = (EventHandler)Delegate.CreateDelegate(typeof(EventHandler), mi);
c.Event += handler;
}
foreach (Class c in classInstances)
{
c.RaiseEvent();
}
}
static void A_Event(object sender, EventArgs e) { Console.WriteLine("A_Event handler"); }
static void B_Event(object sender, EventArgs e) { Console.WriteLine("B_Event handler"); }
static void C_Event(object sender, EventArgs e) { Console.WriteLine("C_Event handler"); }
}
class Class
{
public string Name { get; }
public Class(string name)
{
Name = name;
}
public event EventHandler Event;
public void RaiseEvent()
{
Event?.Invoke(this, EventArgs.Empty);
}
}
Personally, I prefer a more explicit approach. That is, if there's really a need to encapsulate the assignment of handler to object in an abstracted way, to put this in explicit code. For example, provide a single event handler method to subscribe to all controls, and then have that method dispatch to the appropriate method by name:
static void Main(string[] args)
{
Class[] classInstances =
{
new Class("A"),
new Class("B"),
new Class("C"),
};
foreach (Class c in classInstances)
{
c.Event += All_Event;
}
foreach (Class c in classInstances)
{
c.RaiseEvent();
}
}
static void All_Event(object sender, EventArgs e)
{
switch (((Class)sender).Name)
{
case "A":
A_Event(sender, e);
break;
case "B":
B_Event(sender, e);
break;
case "C":
C_Event(sender, e);
break;
}
}
Alternatively, you can use a dictionary to represent the mapping from name to method:
static void Main(string[] args)
{
Class[] classInstances =
{
new Class("A"),
new Class("B"),
new Class("C"),
};
Dictionary<string, EventHandler> nameToHandler = new Dictionary<string, EventHandler>()
{
{ "A", A_Event },
{ "B", B_Event },
{ "C", C_Event },
};
foreach (Class c in classInstances)
{
c.Event += nameToHandler[c.Name];
}
foreach (Class c in classInstances)
{
c.RaiseEvent();
}
}
In both of those examples, you don't save any typing (the switch-based approach is particularly verbose), but it does move the object-to-handler relationship into its own area of the code, allowing it to be maintained more easily without having to deal with the event subscription itself.
If you really want a fully dynamic, reflection-based approach, I would opt for something more explicit and less fragile that relying on the method name. For example, you can create a custom attribute for the event handler methods, used to define what method goes with what object. This provides for a reasonably minimal amount of typing, but disconnects the method name from the mapping, so that you can go ahead and refactor the code to your heart's content without worrying about the event-handling aspect.
That would look something like this:
class Program
{
static void Main(string[] args)
{
Class[] classInstances =
{
new Class("A"),
new Class("B"),
new Class("C"),
};
Dictionary<string, EventHandler> nameToHandler =
(from mi in typeof(Program).GetMethods(BindingFlags.NonPublic | BindingFlags.Static)
let attribute = (Handler)mi.GetCustomAttribute(typeof(Handler))
where attribute != null
select new { attribute.Target, mi })
.ToDictionary(x => x.Target, x => (EventHandler)Delegate.CreateDelegate(typeof(EventHandler), x.mi));
foreach (Class c in classInstances)
{
c.Event += nameToHandler[c.Name];
}
foreach (Class c in classInstances)
{
c.RaiseEvent();
}
}
[Handler("A")]
static void A_Event(object sender, EventArgs e) { Console.WriteLine("A_Event handler"); }
[Handler("B")]
static void B_Event(object sender, EventArgs e) { Console.WriteLine("B_Event handler"); }
[Handler("C")]
static void C_Event(object sender, EventArgs e) { Console.WriteLine("C_Event handler"); }
}
class Handler : Attribute
{
public string Target { get; }
public Handler(string target)
{
Target = target;
}
}
Good evening,
I try to create an own EventHandler on the base of the DownloadProgressChangedEventHandler.
The reason is, I want to give the Callback function an extra parameter (fileName).
This is my EventHandler:
public class MyDownloadProgressChangedEventHandler : DownloadProgressChangedEventHandler
{
public object Sender { get; set; }
public DownloadProgressChangedEventArgs E { get; set; }
public string FileName { get; set; }
public MyDownloadProgressChangedEventHandler(object sender, DownloadProgressChangedEventArgs e, string fileName)
{
this.Sender = sender;
this.E = e;
this.FileName = fileName;
}
}
And this is my attempt:
WebClient client = new WebClient();
client.DownloadProgressChanged += new MyDownloadProgressChangedEventhandler(DownloadProgressChanged);
client.DownloadFileAsync(new Uri(String.Format("{0}/key={1}", srv, file)), localName);
Console.WriteLine(String.Format("Download of file {0} started.", localName));
Console.ReadLine();
But VS says that a conversation from MyDownloadProgressChangedEventHandler to the DownloadProgressChangedEventHandler is not possible.
Is this even possible like how I think?
Thanks in advance.
How should the WebClient know what to put inside your defined variable? (it can't)
Instead, wrap the handler you got inside another one:
string fileName = new Uri(String.Format("{0}/key={1}", srv, file));
client.DownloadProgressChanged +=
(sender, e) =>
DownloadProgressChanged(sender, e, fileName);
client.DownloadFileAsync(fileName);
Lambda expressions are always fun to use in these situations!
I'm using silverlight to access a webservice to request some data. This call is asynchronous. I (think I) have to put this data in a class member after doing some operations on it, so I can access it later.
public class CardPrinter
{
// The card to be printed
private UIElement printCard;
public void PrintStaffCard(string p_persoons)
{
Debug.WriteLine(p_persoons);
foreach (string persoon in p_persoons.Split(','))
{
int p_persoon = Convert.ToInt32(persoon.Trim());
this.GetStaffData(p_persoon);
}
}
private void GetStaffData(int p_persoon)
{
PictureServiceClient proxy = new PictureServiceClient();
proxy.GetPersonelCardInfoCompleted += this.Proxy_GetPersonelCardInfoCompleted;
proxy.GetPersonelCardInfoAsync(p_persoon);
}
private void Proxy_GetPersonelCardInfoCompleted(object sender, GetPersonelCardInfoCompletedEventArgs e)
{
if (e.Error != null)
{
Debug.WriteLine(e.Error.Message);
}
else
{
this.SendStaffCardToPrinter(e.Result);
}
}
private void SendStaffCardToPrinter(CardInfo.CardInfo card)
{
Canvas canvas = new Canvas()
//Do some stuff
this.printCard = canvas;
PrintDocument pd = new PrintDocument();
pd.PrintPage += new EventHandler<PrintPageEventArgs>(this.Pd_PrintPage);
pd.Print(card.accountNr, null, true);
}
private void Pd_PrintPage(object sender, PrintPageEventArgs e)
{
e.PageVisual = this.printCard;
}
}
The problem is in the printCard variable. Sometimes it still contains the data from a previous async call in the foreach.
If I could make sure that the call in the foreach is compeletely finished there would not be a problem, but not sure how to do this and if this is the correct way to handle this.
What is the best way to handle a situation like this?
You can make the code easier to use by using TaskCompletionSource to convert the asynchronous methods from event based to task based. Then you can get rid of the variable and usage of the methods becomes much like using a synchronous method.
I haven't tested this, but it should be close to what you need. You may also find the following article useful. And also the following post Nested Asynchronous function in Silverlight
public class CardPrinter
{
public void PrintStaffCard(string p_persoons)
{
Debug.WriteLine(p_persoons);
foreach (string persoon in p_persoons.Split(','))
{
int p_persoon = Convert.ToInt32(persoon.Trim());
var cardInfo = await this.GetStaffDataAsync(p_persoon);
await this.SendStaffCardToPrinterAsync(cardInfo);
}
}
private Task<CardInfo.CardInfo> GetStaffDataAsync(int p_persoon)
{
var tcs = new TaskCompletionSource<CardInfo.CardInfo>();
PictureServiceClient proxy = new PictureServiceClient();
proxy.GetPersonelCardInfoCompleted += (s, e) =>
{
if (e.Error != null)
{
Debug.WriteLine(e.Error.Message);
tcs.SetException(e.Error);
}
else
{
tcs.SetResult(e.Result);
}
};
proxy.GetPersonelCardInfoAsync(p_persoon);
return tcs.Task;
}
private Task SendStaffCardToPrinterAsync(CardInfo.CardInfo card)
{
Canvas canvas = new Canvas();
//Do some stuff
var tcs = new TaskCompletionSource<object>();
PrintDocument pd = new PrintDocument();
pd.PrintPage += (s, e) =>
{
e.PageVisual = canvas;
tcs.SetResult(null);
};
pd.Print(card.accountNr, null, true);
return tcs.Task;
}
}
The GetPersonalCardInfoAsync method should have an overload where you can pass a UserState argument. You can pass your printCard there when you're making the call and access it later in your Proxy_GetPersonelCardInfoCompleted.
private void GetStaffData(int p_persoon, UIElement printCard)
{
PictureServiceClient proxy = new PictureServiceClient();
proxy.GetPersonelCardInfoCompleted += this.Proxy_GetPersonelCardInfoCompleted;
proxy.GetPersonelCardInfoAsync(p_persoon, printCard);
}
private void Proxy_GetPersonelCardInfoCompleted(object sender, GetPersonelCardInfoCompletedEventArgs e)
{
UIElement printCard = (UIElement)e.UserState;
// do stuff
}
The BackgroundWorker object allows us to pass a single argument into the 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;
...
}
To pass multiple arguments, I must wrap them in an object, like this poor string array:
// 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];
}
Is there another object or pattern that allows us pass multiple arguments nicely, or ideally, write our own signature?
You could use a closure (Lambda):
backgroundWorker.DoWork += (s, e) => MyWorkMethod(userName, targetNumber);
Or with delegate (anonymous method) syntax:
backgroundWorker.DoWork +=
delegate(object sender, DoWorkEventArgs e)
{
MyWorkMethod(userName, targetNumber);
};
What's wrong with using a typed object?
internal class UserArgs
{
internal string UserName { get; set; }
internal string TargetNumber { get; set; }
}
var args = new UserArgs() {UserName="Me", TargetNumber="123" };
startCallWorker.RunWorkerAsync(args);
instead of a typed object. C# 4.0 provides us with tuple. We could use a tuple to hold multiple args. Then there is no need to declare a new class.
Object can be a list or array or some such. Just make your object a container of some sort, then cast within the BackgroundWorker. You need to make sure you're always passing in the same type though.
Maybe pass a lambda function as your object? Then you'd call it in the DoWork handler.
endCallWorker.RunWorkerAsync(new Action( () => DelegatedCallTarget(userName, targetNumber) ));
Create a class that holds all your 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;
}
Why not have the "one" object passed be an array of parameters? You only need to cast it back to array inside the method from the object parameter.