A question about passing an object by reference

[Abe Frohnman]

Hello all,

I'm passing a reference to a class into the constructor of a form, like
so: public MyForm(int count, ref Area myArea) {...}

How can I use myArea outside the constructor? Should I create another
Area and assign myArea to it (ie: Area foo = myArea;) or is there a
better way?

~AF

[Bruno Jouhier [MVP]]

Jon,

You are right. The reference is passed by value, which is different from
passing by reference. I went back to my reference book on the subject (The
study of programming language -- Ryan Stansifer) and it confirms what you
say and what you write in your HTML document (and what the .NET
documentation says).

But rather than say, "no" when people says that objects are passed by
reference, I think that you should say "almost" or "not quite", because they
don't always grasp the difference between "passed by reference" and
"reference passed by value", and then, they get confused.

The most important point, as far as objects are concerned, is that the
reference is being passed around, and that the objects are never copied. So,
people don't need to use the "ref" keyword most of the time when they pass
an object because the reference is passed anyway (by value). The "ref"
keyword is only useful if they want the method to "return" a result (another
reference) through the parameter, which is not the usual case.

Bruno.
"Jon Skeet" <sk***@pobox.co m> a écrit dans le message de
news:MP******** *************** *@news.microsof t.com...

Ming Chen [.NET MVP] <qq******@yahoo .com> wrote:

I'm not getting the context of the discussion. Here is just what I think
about your questions.
Generally speaking, ValueTypes are passed by value, while Reference types are passed by reference by default.

No they are not. With reference types, the reference is passed by
value, which is a different thing to passing by reference.
See http://www.pobox.com/~skeet/csharp/parameters.html (again!)

For value types, it makes a lot sense to pass them by ref. Cause that's the only way to change the parameter object value in a function.
For reference types, it still gives some bonus to pass them by ref.

... which suggests that you *must* be wrong above, as if they are
passed by reference to start with, how could passing them by reference
give them some bonus?

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

[Jon Skeet]

Bruno Jouhier [MVP] <bj******@clu b-internet.fr> wrote:

You are right. The reference is passed by value, which is different from
passing by reference. I went back to my reference book on the subject (The
study of programming language -- Ryan Stansifer) and it confirms what you
say and what you write in your HTML document (and what the .NET
documentation says).

But rather than say, "no" when people says that objects are passed by
reference, I think that you should say "almost" or "not quite", because they
don't always grasp the difference between "passed by reference" and
"reference passed by value", and then, they get confused.
To be fair, I *always* now give the URL to the more detailed
explanation. I'm trying to make the point that it really is quite a
sharp distinction in theoretical terms, even if a lot of the time they
end up having similar effects.
The most important point, as far as objects are concerned, is that the
reference is being passed around, and that the objects are never copied. So,
people don't need to use the "ref" keyword most of the time when they pass
an object because the reference is passed anyway (by value). The "ref"
keyword is only useful if they want the method to "return" a result (another
reference) through the parameter, which is not the usual case.

Indeed. And the fact that people *think* that they want to pass things
by reference when actually they want to pass a reference by value shows
how close things are in people's minds. By posting "almost" or "not
quite" there's an implication (IMO) that they really *are* quite close
together, whereas I'm trying to stress how different they are.

I'll think about it a bit more though, and maybe a bit less harsh :)

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

[Andre]

Ming Chen [.NET MVP] wrote:

I'm not getting the context of the discussion. Here is just what I think
about your questions.
Generally speaking, ValueTypes are passed by value, while Reference types
are passed by reference by default.
No.. that's politically (and logically) incorrect. Reference types are
passed by value.. since reference type vars hold the reference to the
object, their reference is copied accross.
-Andre

For value types, it makes a lot sense to pass them by ref. Cause that's the
only way to change the parameter object value in a function.
For reference types, it still gives some bonus to pass them by ref. For
example:
void foo1(object o) {
o = new Object(); //foo1(myo); this won't effect the original
"o" (myo).
}
void foo2(ref object o) {
o = new Object(); //foo2(myo); this does assign a new object to
the calling object (myo).
}

Just my 2 cents. Hope it helps.
Ming Chen

"G" <gl****@bigfoot .com> wrote in message
news:bg******** **@sparta.btint ernet.com...

So what is the outcome of this?
Objects are always passed by reference or value?

[Andre]

Ahh.. you guys already got to it :) I was hoping you would.

-Andre

Jon Skeet wrote:

Bruno Jouhier [MVP] <bj******@clu b-internet.fr> wrote:

You are right. The reference is passed by value, which is different from
passing by reference. I went back to my reference book on the subject (The
study of programming language -- Ryan Stansifer) and it confirms what you
say and what you write in your HTML document (and what the .NET
documentati on says).

But rather than say, "no" when people says that objects are passed by
reference, I think that you should say "almost" or "not quite", because they
don't always grasp the difference between "passed by reference" and
"reference passed by value", and then, they get confused.

To be fair, I *always* now give the URL to the more detailed
explanation. I'm trying to make the point that it really is quite a
sharp distinction in theoretical terms, even if a lot of the time they
end up having similar effects.

The most important point, as far as objects are concerned, is that the
reference is being passed around, and that the objects are never copied. So,
people don't need to use the "ref" keyword most of the time when they pass
an object because the reference is passed anyway (by value). The "ref"
keyword is only useful if they want the method to "return" a result (another
reference) through the parameter, which is not the usual case.

Indeed. And the fact that people *think* that they want to pass things
by reference when actually they want to pass a reference by value shows
how close things are in people's minds. By posting "almost" or "not
quite" there's an implication (IMO) that they really *are* quite close
together, whereas I'm trying to stress how different they are.

I'll think about it a bit more though, and maybe a bit less harsh :)