System.Thread and multiple method calls

"Paul Schwann" <pa**********@g mail.comwrote in message
news:66******** *************** ***********@e23 g2000prf.google groups.com...

Hi group,

I am relatively new to C# (although I have a lot of programming
excperience in other languages like Java and C). Currently I am
searching for a solution to this problem:

Suppose you have 3 methods A, B and C. All of them shall be run
threaded (I/O tasks) and one after another. I can create a thread and
schedule one method just like:

Thread t = new Thread(A);

But how do I add the other 2 methods? Can this be done somehow with
the .NET Library classes or do I have to create my own "Thread-Method-
Manager" for this purpose? I also would like to add and remove the
methods being executed dynamically.

Thansk for your ideas!

Regards,
Paul

Hi Paul,

Not so sure about Java and C, but in every language I've ever worked in a
thread has a single starting point and linear execution path, just like the
"main" program thread. So, in your case, if you want to execute methods A,
B, and C, you would need to create a new method D that calls A, B, and C and
use method D as your thread proc. You can, of course, pass parameters to
method D to identify which other methods to be executed.

I suppose you *could* implement some sort of message pump (like the "main"
program thread usually has) and dynamically execute methods based on
messages, but that seems like it may be overkill, depending on what you are
trying to accomplish.

Scott

Hi Scott,

thanks for your reply! Implementing such a method D by myself is what
I more or less will do now. I just thought how nice it would be based
on some kind of delegates... Like

Thread t = new Thread();
t.executeThis += A;
t.start();
....
t.executeThis += B;
....
t.executeThis += C;
....
t.executeThis -= A;

.... You get the idea... :-)

Regards,
Paul

Scott Roberts <sr******@no.sp am.here-webworks-software.comwro te:

Not so sure about Java and C, but in every language I've ever worked in a
thread has a single starting point and linear execution path, just like the
"main" program thread. So, in your case, if you want to execute methods A,
B, and C, you would need to create a new method D that calls A, B, and C and
use method D as your thread proc. You can, of course, pass parameters to
method D to identify which other methods to be executed.

Yup. One "wrinkle" to .NET is that what you pass in when you create a
thread is a delegate - and delegates can have multiple targets. I've
*never* used ThreadStart in this way before, but it will work. It's
pretty odd...

using System;
using System.Threadin g;

class Test
{
static void Main()
{
ThreadStart start = null;

start += A;
start += B;
start += C;

new Thread(start).S tart();
}

static void A()
{
Console.WriteLi ne ("A");
}

static void B()
{
Console.WriteLi ne ("B");
}

static void C()
{
Console.WriteLi ne ("C");
}
}

Note that you can't add to the list of methods to execute after you've
started the thread though.

I suppose you *could* implement some sort of message pump (like the "main"
program thread usually has) and dynamically execute methods based on
messages, but that seems like it may be overkill, depending on what you are
trying to accomplish.

Again, I agree. Fortunately if the OP *does* need to do this, it's not
too hard to do with a producer/consumer queue.

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
World class .NET training in the UK: http://iterativetraining.co.uk

Paul Schwann <pa**********@g mail.comwrote:

thanks for your reply! Implementing such a method D by myself is what
I more or less will do now. I just thought how nice it would be based
on some kind of delegates... Like

<snip>

Yup, see my recent post for a complete example. You should probably
comment this in your code, however - it's not a common pattern. (Quite
a neat one though.)

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
World class .NET training in the UK: http://iterativetraining.co.uk

Hi,
You are saying that the 3 methods needs to be run one after the other, what
if you create a new method (can be anonymous) that call the 3 methods?

void DoIt()
{
A();
B();
C();
}
and then is that method the one that you start the thread with?
--
Ignacio Machin
http://www.laceupsolutions.com
Mobile & warehouse Solutions.
"Scott Roberts" <sr******@no.sp am.here-webworks-software.comwro te in
message news:%2******** ********@TK2MSF TNGP05.phx.gbl. ..

>
"Paul Schwann" <pa**********@g mail.comwrote in message
news:66******** *************** ***********@e23 g2000prf.google groups.com...

>Hi group,

I am relatively new to C# (although I have a lot of programming
excperience in other languages like Java and C). Currently I am
searching for a solution to this problem:

Suppose you have 3 methods A, B and C. All of them shall be run
threaded (I/O tasks) and one after another. I can create a thread and
schedule one method just like:

Thread t = new Thread(A);

But how do I add the other 2 methods? Can this be done somehow with
the .NET Library classes or do I have to create my own "Thread-Method-
Manager" for this purpose? I also would like to add and remove the
methods being executed dynamically.

Thansk for your ideas!

Regards,
Paul

Hi Paul,

Not so sure about Java and C, but in every language I've ever worked in a
thread has a single starting point and linear execution path, just like
the "main" program thread. So, in your case, if you want to execute
methods A, B, and C, you would need to create a new method D that calls A,
B, and C and use method D as your thread proc. You can, of course, pass
parameters to method D to identify which other methods to be executed.

I suppose you *could* implement some sort of message pump (like the "main"
program thread usually has) and dynamically execute methods based on
messages, but that seems like it may be overkill, depending on what you
are trying to accomplish.

Scott

Hi,
--
Ignacio Machin
http://www.laceupsolutions.com
Mobile & warehouse Solutions.
"Jon Skeet [C# MVP]" <sk***@pobox.co mwrote in message
news:MP******** *************@m snews.microsoft .com...

Yup. One "wrinkle" to .NET is that what you pass in when you create a
thread is a delegate - and delegates can have multiple targets. I've
*never* used ThreadStart in this way before, but it will work. It's
pretty odd...

I have never though of this. Of course as ThreadStart is a delegate you can
do it. I wander what would happen if one method throw an exception ....

"Jon Skeet [C# MVP]" <sk***@pobox.co mwrote in message
news:MP******** *************@m snews.microsoft .com...

[Side point - Ignacio, all your posts end up with a signature before
all of the quoted text. That means when I start to reply, all I end up
with is "Hi". Could you either remove the signature separator or make
sure it ends up after the body?]

Sorry for that, no idea why OE place the signature at the top instead of at
the botton of the message. Will have to dig around to see if I can change it
somewhere.

Ignacio Machin
http://www.laceupsolutions.com
Mobile & warehouse Solutions.

Hi Ignacio,

basically, you are right:

>
You are saying that the 3 methods needs to be run one after the other, what
if you create a new method (can be anonymous) that call the 3 methods?

void DoIt()
{
* * A();
* * B();
* * C();

}

But I need a way t configure the "three" methods such that I can say
when (and when not) they run. I want to select them during runtime and
thus, need something more dynamic than just a function D().

If you have any ideas how to do this nicely, please let me know!

Regards,
Paul

Hi Pete and all the others,

thanks a lot for your valuable input! Although Jon's solution is
almost perfect, it does'nt work for me. I have to be able to add and
remove any of the A, B, C, ... functions form the delegate while the
thread is *already running*. I think I will implement my own way of
doing this. Here is my first idea (sort of Java/Pseudo code):

class MyThreadManager extends Thread {
List<Runnableex ecuteThis;

public void run() {
for (runnable in executeThis) {
runnable.run();
}
}

synchronized addExecutable(R unnable r) {...}
synchronized removeExecutabl e(Runnable r) {...}
}

Just an idea.... :-)

Regards,
Paul