为什么我的对象是指针？

Question

My question concerns the use of objects in C#. I think I understand what's happening, but I want to understand why. For reasons I won't go into, I want to create a temporary copy of an object with its current data (current state). So I thought I could create a new object, assign it the original object, then change the original object. At that point I would have two objects in different states. But what happens is that the copied object ends up looking exactly like the first. Here is some code to illustrate:

Order o1 = new Order();
o1.property1 = "test 1";

Order o2 = new Order();
o2 = o1;

o1.property1 = "test 2";

But at the end of this code, both o1 and o2 have property1 set to "test 2". I think I realize that all objects are just pointers, so if you change one it changes another, but I can't understand why this is, or why it is useful. Is there some fundamental thing I'm missing here? Also, what would be the best way to accomplish what I want to do? Which is: store the state of the object, make changes, then revert if necessary. Hopefully this makes sense.

Answer 1

An object variable in C# is a reference (not a pointer) to a specific object in memory. When you declare

Order o2 = new Order();

you are creating a new Order object in the heap, and allocating a reference to that object to your o2 variable. When you then state

o2 = o1;

you are telling the compiler to make o2 a reference to o1. At this point, the reference to the original o2 object is lost, and the memory for that object will be removed during the next garbage collection sweep.

Henceforth, both o1 and o2 both reference the same object in memory. To copy information from one object to another, you will need to implement a procedure to instantiate a new destination object and copy all of the data from one object to the other. See the MSDN docs on ICloneable for more info.

Answer 2

What you are referring to is the difference between value types and reference types. Apparently your Order object is a reference type, I would assume it is a class.

Classes are reference types meaning they are "pointers". One of the reasons for this is performance as you do not want to copy huge amounts of data every time you assign a variable.

Structures are value types and would be copied in memory when you assign them.

You have 2 solutions :

• Use a struct instead of class
• Clone your object using either MemberwiseClone if it is very simple, or use your own method if you need to perform a deep clone.

Answer 3

This is by Design. If you want to clone and keep the clone independent i would recommend to Implement a "cloning" mechanism on your types. This can be ICloneable or even just a constructor that takes an instance and copies values from it.

Answer 4

Regarding your question

what would be the best way to accomplish what I want to do? Which is: store the state of the object, make changes, then revert if necessary

A simple method is to simply serialize the object, eg using XMLSerializer . Then if you want to throw away your changes, just deserialize the original object and replace the modified object with the original version.

Answer 5

Use Structures to accomplish your task, Classes are reference type and Structs are Value type. Classes are stored on memory heap Structs are stored on stack. for more info search Structs vs Classes and learn differences

Answer 6

Objects are, by definition, a 'pointer'; they hold a reference to your data, and not the actual data itself. You can assign it a value type though and it will give the appearance of holding the data.

As was mentioned above, understanding Value types vs. Reference types is key.

Answer 7

Java has no concept of any non-primitive data type other than an object reference; since almost anything one can do with an object reference involves acting upon the object referred to thereby, the . operator in Java . Although .net does have non-primitive value types, most .net languages maintain the convention (different from C and C++, which use -> to access a member of a pointed-to object and . to access a member of a structure) that the same . operator is used for both "dereference and access member" and "access value-type member".

Personally, I dislike Java's "everything is an object reference" design, and .net's decision to have value types and reference types use the same . operator to mean very different things doesn't help, but it is what it is.