Passing a (Generic) Stack by Reference

[Mahmoud Al-Qudsi]

Hi all,

I'm working on a C# project, and at some point I'm needing to pass the
same stack to multiple functions.

I found out the hard way that when I poss a stack by value it doesn't
actually use a copy constructor to move the contents over to a new
stack - the original stack is still modified by changes to the stack
that was passed by value.

Looking at the MSDN page (http://msdn2.microsoft.com/en-us/library/
3278tedw.aspx) I don't see anything that explicitly says it's (un)safe
to pass by reference.

My question: is there an easy way to copy this stack to a new one
without creating my own "stack copy" function?
Also: In the future, how can I tell if it is safe to pass *and modify*
a stack to a new function?

Thanks,

[Jon Skeet [C# MVP]]

Mahmoud Al-Qudsi <mq****@gmail.comwrote:

I'm working on a C# project, and at some point I'm needing to pass the
same stack to multiple functions.

I found out the hard way that when I poss a stack by value it doesn't
actually use a copy constructor to move the contents over to a new
stack - the original stack is still modified by changes to the stack
that was passed by value.

That's because it's a reference type.

See http://pobox.com/~skeet/csharp/parameters.html

Looking at the MSDN page (http://msdn2.microsoft.com/en-us/library/
3278tedw.aspx) I don't see anything that explicitly says it's (un)safe
to pass by reference.

You need to be clear about the difference between passing a reference
by value and passing a value by reference.

My question: is there an easy way to copy this stack to a new one
without creating my own "stack copy" function?

new Stack<WhateverType(oldStack) should do it.

Also: In the future, how can I tell if it is safe to pass *and modify*
a stack to a new function?

What kind of "safety" are you concerned about?

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

[Mahmoud Al-Qudsi]

On Aug 27, 12:50 pm, Jon Skeet [C# MVP] <[e-mail]:

Mahmoud Al-Qudsi <[e-mail]:

I'm working on a C# project, and at some point I'm needing to pass the
same stack to multiple functions.

I found out the hard way that when I poss a stack by value it doesn't
actually use a copy constructor to move the contents over to a new
stack - the original stack is still modified by changes to the stack
that was passed by value.

That's because it's a reference type.

Seehttp://pobox.com/~skeet/csharp/parameters.html

Looking at the MSDN page (http://msdn2.microsoft.com/en-us/library/
3278tedw.aspx) I don't see anything that explicitly says it's (un)safe
to pass by reference.

You need to be clear about the difference between passing a reference
by value and passing a value by reference.

My question: is there an easy way to copy this stack to a new one
without creating my own "stack copy" function?

new Stack<WhateverType(oldStack) should do it.

Also: In the future, how can I tell if it is safe to pass *and modify*
a stack to a new function?

What kind of "safety" are you concerned about?

--
Jon Skeet - <[e-mail]>http://www.pobox.com/~skeet Blog:http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

Thanks for your reply.

I'm clear on what (and how) it is happening (thanks to painful years
of C++ coding), just not sure how to tell beforehand if it would
happen or not.
Casting the old stack to an IEnumerable and putting that in the new
stack's constructor like you suggested has done the trick - thanks.

I'm already using a thread-safe wrapper for thread-safety, the only
other concern I had was the preservation of data when sending it to
another function - and now that is working fine too.

Thanks :)

[Nicholas Paldino [.NET/C# MVP]]

It should be noted that the copy of the stack that you make is a shallow
copy. If the elements in the stack are reference types, and you manipulate
elements in the new stack, then those changes are going to be reflected in
the original stack.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard.caspershouse.com

"Mahmoud Al-Qudsi" <mq****@gmail.comwrote in message
news:11**********************@r34g2000hsd.googlegr oups.com...

On Aug 27, 12:50 pm, Jon Skeet [C# MVP] <[e-mail]:

>Mahmoud Al-Qudsi <[e-mail]:

I'm working on a C# project, and at some point I'm needing to pass the
same stack to multiple functions.

I found out the hard way that when I poss a stack by value it doesn't
actually use a copy constructor to move the contents over to a new
stack - the original stack is still modified by changes to the stack
that was passed by value.

That's because it's a reference type.

Seehttp://pobox.com/~skeet/csharp/parameters.html

Looking at the MSDN page (http://msdn2.microsoft.com/en-us/library/
3278tedw.aspx) I don't see anything that explicitly says it's (un)safe
to pass by reference.

You need to be clear about the difference between passing a reference
by value and passing a value by reference.

My question: is there an easy way to copy this stack to a new one
without creating my own "stack copy" function?

new Stack<WhateverType(oldStack) should do it.

Also: In the future, how can I tell if it is safe to pass *and modify*
a stack to a new function?

What kind of "safety" are you concerned about?

--
Jon Skeet - <[e-mail]>http://www.pobox.com/~skeet
Blog:http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

Thanks for your reply.

I'm clear on what (and how) it is happening (thanks to painful years
of C++ coding), just not sure how to tell beforehand if it would
happen or not.
Casting the old stack to an IEnumerable and putting that in the new
stack's constructor like you suggested has done the trick - thanks.

I'm already using a thread-safe wrapper for thread-safety, the only
other concern I had was the preservation of data when sending it to
another function - and now that is working fine too.

Thanks :)

[Jon Skeet [C# MVP]]

Mahmoud Al-Qudsi <mq****@gmail.comwrote:

I'm clear on what (and how) it is happening (thanks to painful years
of C++ coding), just not sure how to tell beforehand if it would
happen or not.

You just need to know whether you're dealing with a reference type (a
class/delegate/array/interface) or a value type (a struct/enum).
--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too