Does C# have static local variables like C++?

[Zytan]

I see that static is more restricted in C# than in C++. It appears
usable only on classes and methods, and data members, but cannot be
created within a method itself. Surely this is possible in C# in some
way? Or maybe no, because it is similar to a global variable (with its
scope restricted) which C# is dead against?

Zytan

[Mattias Sjögren]

>Surely this is possible in C# in some way?

Nope, you have to make it a class member instead.
Mattias

--
Mattias Sjögren [C# MVP] mattias @ mvps.org
http://www.msjogren.net/dotnet/ | http://www.dotnetinterop.com
Please reply only to the newsgroup.

[Jon Skeet [C# MVP]]

Zytan <zy**********@y ahoo.comwrote:

I see that static is more restricted in C# than in C++. It appears
usable only on classes and methods, and data members, but cannot be
created within a method itself. Surely this is possible in C# in some
way? Or maybe no, because it is similar to a global variable (with its
scope restricted) which C# is dead against?

No - methods only have "temporary" storage, and types/instances have
"longer term" storage. I've found that to lead to better encapsulation.
If you find methods which need state which isn't logically part of the
state of the object, you might consider moving the method to a
different class.

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

[Zytan]

Nope, you have to make it a class member instead.

Ok, thanks, Mattias

Zytan

[Zytan]

No - methods only have "temporary" storage, and types/instances have

"longer term" storage. I've found that to lead to better encapsulation.

Yes, I can see that.

If you find methods which need state which isn't logically part of the
state of the object, you might consider moving the method to a
different class.

I was just using it for testing some code. In practice, I don't find
much use for static vars, but they are nice to throw something
together really quick. But i respect c#'s attempt to keep things
proper.

Zytan

[Paul Werkowitz]

Am Tue, 27 Feb 2007 20:52:54 -0000 schrieb Jon Skeet [C# MVP]:

Zytan <zy**********@y ahoo.comwrote:

>I see that static is more restricted in C# than in C++. It appears
usable only on classes and methods, and data members, but cannot be
created within a method itself. Surely this is possible in C# in some
way? Or maybe no, because it is similar to a global variable (with its
scope restricted) which C# is dead against?

No - methods only have "temporary" storage, and types/instances have
"longer term" storage. I've found that to lead to better encapsulation.
If you find methods which need state which isn't logically part of the
state of the object, you might consider moving the method to a
different class.

Now, how would you then write something like this in C#?

void f()
{
static int count;
if ( count 0 )
Debug.Writeline ( "recursion level" + count.ToString( ) );
count++;

// -- the internals of f

count--
}

IMHO, count is only interesting within the scope of f, and therefore should
be defined in f, and nowhere else. But C# forces me to define such
variables at class level, which is stupid.

(OK, its only a minor nuisance, and other things are much worse. But
sometimes I wonder how language designers come to their results).

My 2 cents...
Paule

[Zytan]

Now, how would you then write something like this in C#?

>
void f()
{
static int count;
if ( count 0 )
Debug.Writeline ( "recursion level" + count.ToString( ) );
count++;

// -- the internals of f

count--
}

IMHO, count is only interesting within the scope of f, and therefore should
be defined in f, and nowhere else. But C# forces me to define such
variables at class level, which is stupid.

Paule, you raise an interesting point. Normally, I only need the
above for quick testing code, not for production code. So, maybe the
designers thought that anything needing a C++ static local variable is
bad. But, like you said, it's only visible inside the function. But,
of course, via pass by reference, anything can be made visible to
anything.

Certainly the fact that you must declare it at the class level is
WORSE than at the method level, I agree.

Zytan

[debiprasadghosh]

On Feb 28, 5:18 am, Paul Werkowitz <newsgro...@pri maprogramm.de>
wrote:

Am Tue, 27 Feb 2007 20:52:54 -0000 schrieb Jon Skeet [C#MVP]:

Zytan <zytanlith...@y ahoo.comwrote:

I see that static is more restricted inC#than in C++. It appears
usable only on classes and methods, and data members, but cannot be
created within a method itself. Surely this is possible inC#in some
way? Or maybe no, because it is similar to a global variable (with its
scope restricted) whichC#is dead against?

No - methods only have "temporary" storage, and types/instances have
"longer term" storage. I've found that to lead to better encapsulation.
If you find methods which need state which isn't logically part of the
state of the object, you might consider moving the method to a
different class.

Now, how would you then write something like this inC#?

void f()
{
static int count;
if ( count 0 )
Debug.Writeline ( "recursion level" + count.ToString( ) );
count++;

// -- the internals of f

count--
}

IMHO, count is only interesting within the scope of f, and therefore should
be defined in f, and nowhere else. ButC#forces me to define such
variables at class level, which is stupid.

(OK, its only a minor nuisance, and other things are much worse. But
sometimes I wonder how language designers come to their results).

My 2 cents...
Paule

Some where I read (may be "FAQ in C++"), even in C++ this kind of
local static variable is not safe for multi threaded applications. So,
better use functionoid.
Debi

[William Stacey [C# MVP]]

| Now, how would you then write something like this in C#?
|
| void f()
| {
| static int count;
| if ( count 0 )
| Debug.Writeline ( "recursion level" + count.ToString( ) );
| count++;
|
| // -- the internals of f
|
| count--
| }

IMO, if f() is not using any class state, then the method should probably be
a static anyway. In which case "count" would be a static member var.
Moreover, I normally find I end up wanting "count" in class scope anyway as
many times you end up wanting to enumerate it for debug, statistics, or
other flow control in other parts of the class. I have wrote and read lots
of classes, and I never really come up with much need for local static
scope. I can think of one time similar to above, but the fix is easy and
probably not worth the change to the language. However, if I had to bet, I
would guess they add it at some point.

--
William Stacey [C# MVP]
PCR concurrency library: www.codeplex.com/pcr
PSH Scripts Project www.codeplex.com/psobject

[Willy Denoyette [MVP]]

"Paul Werkowitz" <ne********@pri maprogramm.dewr ote in message
news:1i******** *************** ********@40tude .net...

Am Tue, 27 Feb 2007 20:52:54 -0000 schrieb Jon Skeet [C# MVP]:

>Zytan <zy**********@y ahoo.comwrote:

>>I see that static is more restricted in C# than in C++. It appears
usable only on classes and methods, and data members, but cannot be
created within a method itself. Surely this is possible in C# in some
way? Or maybe no, because it is similar to a global variable (with its
scope restricted) which C# is dead against?

No - methods only have "temporary" storage, and types/instances have
"longer term" storage. I've found that to lead to better encapsulation.
If you find methods which need state which isn't logically part of the
state of the object, you might consider moving the method to a
different class.

Now, how would you then write something like this in C#?

void f()
{
static int count;
if ( count 0 )
Debug.Writeline ( "recursion level" + count.ToString( ) );
count++;

// -- the internals of f

count--
}

IMHO, count is only interesting within the scope of f, and therefore should
be defined in f, and nowhere else. But C# forces me to define such
variables at class level, which is stupid.

(OK, its only a minor nuisance, and other things are much worse. But
sometimes I wonder how language designers come to their results).

My 2 cents...
Paule

count has no function 'scope', it's a static after all, it has function 'visibility'.

Willy.