References vs Copies

[mehdi_mousavi]

Hi folks,
Consider the following line of code:

Address addr = ei.Address;

where ei is an instance of a class that has got a property of Address
type.

The question is that what is happening in the above assignment? Unlike
the C/C++, it seems that the above code instructs the compiler to point
the addr variable to the same location where ei.Address already
resides, i.e, it's somehow a pointer to the ei.Address. Therefore, any
modification on addr variable is instantly applied to the ei.Address.

Well, is this right? or, am I missing something?

Any help would be highly appreciated,
Cheers,
Mehdi

[Marc Gravell]

Yes, that is exactly what is happening - classes have reference-type
semantics, so your "variable" (address) is preceisly that: a (managed)
pointer to an object on the (managed) heap.

If you want value-type semantics (i.e. instances cloned at the blink of an
eye) then "struct" can be useful, although to be honest an address "feels"
like a class to me. Perhaps look at the ICloneable interface? i.e.

public class Address : ICloneable {
public Address Clone() { // your explicit copy code goes here
}
object ICloneable.Clon e() {return this.Clone();} // non-typesafe version
usually done via an explicit implementation
}

then you can call:
Address addr = ei.Address.Clon e();

[Ignacio Machin \( .NET/ C# MVP \)]

Hi,

"mehdi_mous avi" <me***********@ gmail.comwrote in message
news:11******** **************@ b28g2000cwb.goo glegroups.com.. .

The question is that what is happening in the above assignment? Unlike
the C/C++, it seems that the above code instructs the compiler to point
the addr variable to the same location where ei.Address already
resides, i.e, it's somehow a pointer to the ei.Address. Therefore, any
modification on addr variable is instantly applied to the ei.Address.

Well, is this right? or, am I missing something?

In managed world it's called reference but yes, that's pretty much what
happens IF Address IS A class ; in your post you especify that ei is an
instance of a class, you say nothing about Address.

If Address is not a class but a struct the above is not true.
--
--
Ignacio Machin,
ignacio.machin AT dot.state.fl.us
Florida Department Of Transportation

[Kevin Spencer]

There are 2 distinct ways to reference data in .Net: By value, and by
reference. This is why the .Net platform defines reference types and value
types. Value types, such as integers and structures, are passed "by value,"
meaning that a copy of the data in the type is passed when an instance of
that type is referenced. Reference types, which constitute most of the .Net
types, are passed "by reference," meaning that a managed pointer to the
instance is passed when an instance of that type is referenced.

To pass a copy of a reference type, the instance must be copied, or Cloned.

--
HTH,

Kevin Spencer
Microsoft MVP
Chicken Salad Surgery

What You Seek Is What You Get.

"mehdi_mous avi" <me***********@ gmail.comwrote in message
news:11******** **************@ b28g2000cwb.goo glegroups.com.. .

Hi folks,
Consider the following line of code:

Address addr = ei.Address;

where ei is an instance of a class that has got a property of Address
type.

The question is that what is happening in the above assignment? Unlike
the C/C++, it seems that the above code instructs the compiler to point
the addr variable to the same location where ei.Address already
resides, i.e, it's somehow a pointer to the ei.Address. Therefore, any
modification on addr variable is instantly applied to the ei.Address.

Well, is this right? or, am I missing something?

Any help would be highly appreciated,
Cheers,
Mehdi

[David Anton]

No - value types can be passed by value or by reference and reference types
can be passed by value or by reference.

--
David Anton
www.tangiblesoftwaresolutions.com
Instant C#: VB to C# converter
Instant VB: C# to VB converter
Instant C++: C#/VB to C++ converter
C# Code Metrics: Quick metrics for C#
"Kevin Spencer" wrote:

There are 2 distinct ways to reference data in .Net: By value, and by
reference. This is why the .Net platform defines reference types and value
types. Value types, such as integers and structures, are passed "by value,"
meaning that a copy of the data in the type is passed when an instance of
that type is referenced. Reference types, which constitute most of the .Net
types, are passed "by reference," meaning that a managed pointer to the
instance is passed when an instance of that type is referenced.

To pass a copy of a reference type, the instance must be copied, or Cloned.

--
HTH,

Kevin Spencer
Microsoft MVP
Chicken Salad Surgery

What You Seek Is What You Get.

"mehdi_mous avi" <me***********@ gmail.comwrote in message
news:11******** **************@ b28g2000cwb.goo glegroups.com.. .

Hi folks,
Consider the following line of code:

Address addr = ei.Address;

where ei is an instance of a class that has got a property of Address
type.

The question is that what is happening in the above assignment? Unlike
the C/C++, it seems that the above code instructs the compiler to point
the addr variable to the same location where ei.Address already
resides, i.e, it's somehow a pointer to the ei.Address. Therefore, any
modification on addr variable is instantly applied to the ei.Address.

Well, is this right? or, am I missing something?

Any help would be highly appreciated,
Cheers,
Mehdi

[Hans Kesting]

Hi folks,

Consider the following line of code:

Address addr = ei.Address;

where ei is an instance of a class that has got a property of Address
type.

The question is that what is happening in the above assignment? Unlike
the C/C++, it seems that the above code instructs the compiler to point
the addr variable to the same location where ei.Address already
resides, i.e, it's somehow a pointer to the ei.Address. Therefore, any
modification on addr variable is instantly applied to the ei.Address.

Well, is this right? or, am I missing something?

Any help would be highly appreciated,
Cheers,
Mehdi

See http://www.yoda.arachsys.com/csharp/parameters.html

[Kevin Spencer]

"No?" No to what?

If I told you that 1 + 1 = 2, would you say "No - 2 + 0 = 2"?

The fact that 2 statements concerning anything state different things
doesn't imply that one of the 2 statements is wrong.

In fact, the only wrong statement so far has been your "No".

--
HTH,

Kevin Spencer
Microsoft MVP
Chicken Salad Surgery

What You Seek Is What You Get.

"David Anton" <Da********@dis cussions.micros oft.comwrote in message
news:3F******** *************** ***********@mic rosoft.com...

No - value types can be passed by value or by reference and reference
types
can be passed by value or by reference.

--
David Anton
www.tangiblesoftwaresolutions.com
Instant C#: VB to C# converter
Instant VB: C# to VB converter
Instant C++: C#/VB to C++ converter
C# Code Metrics: Quick metrics for C#
"Kevin Spencer" wrote:

>There are 2 distinct ways to reference data in .Net: By value, and by
reference. This is why the .Net platform defines reference types and
value
types. Value types, such as integers and structures, are passed "by
value,"
meaning that a copy of the data in the type is passed when an instance of
that type is referenced. Reference types, which constitute most of the
.Net
types, are passed "by reference," meaning that a managed pointer to the
instance is passed when an instance of that type is referenced.

To pass a copy of a reference type, the instance must be copied, or
Cloned.

--
HTH,

Kevin Spencer
Microsoft MVP
Chicken Salad Surgery

What You Seek Is What You Get.

"mehdi_mousavi " <me***********@ gmail.comwrote in message
news:11******* *************** @b28g2000cwb.go oglegroups.com. ..

Hi folks,
Consider the following line of code:

Address addr = ei.Address;

where ei is an instance of a class that has got a property of Address
type.

The question is that what is happening in the above assignment? Unlike
the C/C++, it seems that the above code instructs the compiler to point
the addr variable to the same location where ei.Address already
resides, i.e, it's somehow a pointer to the ei.Address. Therefore, any
modification on addr variable is instantly applied to the ei.Address.

Well, is this right? or, am I missing something?

Any help would be highly appreciated,
Cheers,
Mehdi

[David Anton]

You had said that value types are passed by value and reference types are
passed by reference. This is the part that is obviously not correct.
To be clear, you could have said that value types *can* be passed by value
and that reference types *can* be passed by reference, but from your post, it
was pretty obvious that this isn't what you intended.
--
David Anton
www.tangiblesoftwaresolutions.com
Instant C#: VB to C# converter
Instant VB: C# to VB converter
Instant C++: C#/VB to C++ converter
C# Code Metrics: Quick metrics for C#
"Kevin Spencer" wrote:

"No?" No to what?

If I told you that 1 + 1 = 2, would you say "No - 2 + 0 = 2"?

The fact that 2 statements concerning anything state different things
doesn't imply that one of the 2 statements is wrong.

In fact, the only wrong statement so far has been your "No".

--
HTH,

Kevin Spencer
Microsoft MVP
Chicken Salad Surgery

What You Seek Is What You Get.

"David Anton" <Da********@dis cussions.micros oft.comwrote in message
news:3F******** *************** ***********@mic rosoft.com...

No - value types can be passed by value or by reference and reference
types
can be passed by value or by reference.

--
David Anton
www.tangiblesoftwaresolutions.com
Instant C#: VB to C# converter
Instant VB: C# to VB converter
Instant C++: C#/VB to C++ converter
C# Code Metrics: Quick metrics for C#
"Kevin Spencer" wrote:

There are 2 distinct ways to reference data in .Net: By value, and by
reference. This is why the .Net platform defines reference types and
value
types. Value types, such as integers and structures, are passed "by
value,"
meaning that a copy of the data in the type is passed when an instance of
that type is referenced. Reference types, which constitute most of the
.Net
types, are passed "by reference," meaning that a managed pointer to the
instance is passed when an instance of that type is referenced.

To pass a copy of a reference type, the instance must be copied, or
Cloned.

--
HTH,

Kevin Spencer
Microsoft MVP
Chicken Salad Surgery

What You Seek Is What You Get.

"mehdi_mous avi" <me***********@ gmail.comwrote in message
news:11******** **************@ b28g2000cwb.goo glegroups.com.. .
Hi folks,
Consider the following line of code:

Address addr = ei.Address;

where ei is an instance of a class that has got a property of Address
type.

The question is that what is happening in the above assignment? Unlike
the C/C++, it seems that the above code instructs the compiler to point
the addr variable to the same location where ei.Address already
resides, i.e, it's somehow a pointer to the ei.Address. Therefore, any
modification on addr variable is instantly applied to the ei.Address.

Well, is this right? or, am I missing something?

Any help would be highly appreciated,
Cheers,
Mehdi

[Bruce Wood]

mehdi_mousavi wrote:

Hi folks,
Consider the following line of code:

Address addr = ei.Address;

where ei is an instance of a class that has got a property of Address
type.

The question is that what is happening in the above assignment? Unlike
the C/C++, it seems that the above code instructs the compiler to point
the addr variable to the same location where ei.Address already
resides, i.e, it's somehow a pointer to the ei.Address.

You say "unlike C/C++", but this is not necessarily so. In C, if the
Address field of ei is a pointer, then in fact addr will contain the
same pointer and any modifications to addr->Blah will also change
ei.Address->Blah.

Others here have given good answers, but I wanted to adapt them to your
situation. What will happen in this situation depends upon two things:

1) Whether the type Address is a class or a struct.
2) Whether the Address member of ei is a field, a property that returns
a reference that is part of the state of ei, or a property that returns
a clone of the Address held by ei.

Most here have talked about point #1. Specifically, if the Address type
is a struct--that is, a value type--then assignment and/or returning an
Address from a method implies copying it.

public struct Address
{ ... }

So, if this were the case then changes to the Address held by addr
would not affect the Address held by ei. This is regardless of point #2
above.

If the Address type is a class, then point #2 comes into play: is
ei.Address a field, or is a property. If it's a property, does it
return a reference held by ei or return a clone?

If the Address type is a class and ei.Address is a field:

public class Address
{ ... }

public class EiType
{
public Address Address;
}

then yes, addr will refer to the same object instance as does
ei.Address, and changes to one will be visible when referring to that
same object via the other reference. In effect the "two" will appear to
change in synch, because in reality there's only one.

Similarly, if the field is wrapped in a property that just returns the
object reference, the same applies:

public class Address
{ ... }

public class EiType
{
private Address _address;

public Address Address { get { return this._address; } }
}

However, if ei.Address is a property that returns a clone:

public class Address : ICloneable
{
public override object Clone() { ... }
}

public class EiType
{
private Address _address;

public Address Address { get { return
(Address)this._ address.Clone() ; } }
}

then the reference assigned to addr will be to a different object
instance than the one held by ei._address, and changes to one will not
be reflected in the other.

[Kevin Spencer]

I intended to say exactly what I said. If I had intended to say otherwise, I
would have. That is why my software works well.

Value types *are* passed by value. Passing them by reference is a (rather
rare) exception (unless the developer is unskilled), and requires
instructions that specify that it should be done that way. Same thing with
reference types, only moreso. I honestly can't think of any time I've tried
to pass a reference type by value. But hey, if it makes you feel superior to
correct people who are not wrong, by all means, do so.

--
HTH,

Kevin Spencer
Microsoft MVP
Chicken Salad Surgery

What You Seek Is What You Get.

"David Anton" <Da********@dis cussions.micros oft.comwrote in message
news:0B******** *************** ***********@mic rosoft.com...

You had said that value types are passed by value and reference types are
passed by reference. This is the part that is obviously not correct.
To be clear, you could have said that value types *can* be passed by value
and that reference types *can* be passed by reference, but from your post,
it
was pretty obvious that this isn't what you intended.
--
David Anton
www.tangiblesoftwaresolutions.com
Instant C#: VB to C# converter
Instant VB: C# to VB converter
Instant C++: C#/VB to C++ converter
C# Code Metrics: Quick metrics for C#
"Kevin Spencer" wrote:

>"No?" No to what?

If I told you that 1 + 1 = 2, would you say "No - 2 + 0 = 2"?

The fact that 2 statements concerning anything state different things
doesn't imply that one of the 2 statements is wrong.

In fact, the only wrong statement so far has been your "No".

--
HTH,

Kevin Spencer
Microsoft MVP
Chicken Salad Surgery

What You Seek Is What You Get.

"David Anton" <Da********@dis cussions.micros oft.comwrote in message
news:3F******* *************** ************@mi crosoft.com...

No - value types can be passed by value or by reference and reference
types
can be passed by value or by reference.

--
David Anton
www.tangiblesoftwaresolutions.com
Instant C#: VB to C# converter
Instant VB: C# to VB converter
Instant C++: C#/VB to C++ converter
C# Code Metrics: Quick metrics for C#
"Kevin Spencer" wrote:

There are 2 distinct ways to reference data in .Net: By value, and by
reference. This is why the .Net platform defines reference types and
value
types. Value types, such as integers and structures, are passed "by
value,"
meaning that a copy of the data in the type is passed when an instance
of
that type is referenced. Reference types, which constitute most of the
.Net
types, are passed "by reference," meaning that a managed pointer to
the
instance is passed when an instance of that type is referenced.

To pass a copy of a reference type, the instance must be copied, or
Cloned.

--
HTH,

Kevin Spencer
Microsoft MVP
Chicken Salad Surgery

What You Seek Is What You Get.

"mehdi_mousavi " <me***********@ gmail.comwrote in message
news:11******* *************** @b28g2000cwb.go oglegroups.com. ..
Hi folks,
Consider the following line of code:

Address addr = ei.Address;

where ei is an instance of a class that has got a property of
Address
type.

The question is that what is happening in the above assignment?
Unlike
the C/C++, it seems that the above code instructs the compiler to
point
the addr variable to the same location where ei.Address already
resides, i.e, it's somehow a pointer to the ei.Address. Therefore,
any
modification on addr variable is instantly applied to the
ei.Address.

Well, is this right? or, am I missing something?

Any help would be highly appreciated,
Cheers,
Mehdi