Static Functions and Thread Safety. How does it work?

1. Will each call get its own stack?
Of course, each time you call a method (no matter if static, virtual,
regular) a new stack frame is created. so as I said above if you use no
instance from outside the method you are ok
2. How simultaneous calls are processed?

Hello,
It might seem like a stupid question to some. But I need to put this issue
to rest once and for all, since it keeps coming up in code reviews every
now
and then.
There's a static function in business logic class invoked by a Web
multi-user application. Each request calls this static function passing in
one unique ID, and XML serialized object (as out param), function
deserializes XML to object, creates new instances of DB Access object and
makes calls to database based on ID, modifies object's properties and
serializes it back to be returned as out param.
Now there are concerns coming from some developers that it's not
thread-safe, that static function might cause race-conditions, if
simultaneous calls are made to the static function there will be
"detrimenta l
consequences".

Are the any real thread safety/race conditions issues with static
functions?
Can someone tell me or point to a good link "behind the scenes" how static
function get invoked:
1. Will each call get its own stack?
2. How simultaneous calls are processed?

I think ignacio answered this properly, but I wanted to re-iterate.

Local variables declared INSIDE a static function aren't static (unless you
declare them so).

For example:

public void static DoSomething()
{
int i = 0;
++i;
}

Each call to DoSoemthing (even if they happen at exactly the same time) will
create their own i. If you declare i as static/shared also, then it's a
different story (but that's true whether or not the method itself is
static).

<"Karl Seguin [MVP]" <karl REMOVE @ REMOVE openmymind REMOVEMETOO .
ANDME net>> wrote:

I think ignacio answered this properly, but I wanted to re-iterate.

Local variables declared INSIDE a static function aren't static (unless
you
declare them so).

For example:

public void static DoSomething()
{
int i = 0;
++i;
}

Each call to DoSoemthing (even if they happen at exactly the same time)
will
create their own i. If you declare i as static/shared also, then it's a
different story (but that's true whether or not the method itself is
static).

You can't declare local variables as static in C# anyway...

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

I think ignacio answered this properly, but I wanted to re-iterate.

Local variables declared INSIDE a static function aren't static (unless
you declare them so).

For example:

public void static DoSomething()
{
int i = 0;
++i;
}

Each call to DoSoemthing (even if they happen at exactly the same time)
will create their own i. If you declare i as static/shared also, then it's
a different story (but that's true whether or not the method itself is
static).