Instantiate Local Variable By Value?

Question

I sort of understand why this is happening, but not entirely. I have a base class with a Shared (Static) variable, declared like so:

Public Shared myVar As New MyObject(arg1, arg2)

In a method of a derived class, I set a local variable like so:

Dim myLocalVar As MyObject = myVar

Now when I do something like myLocalVar.Property1 += value, the value in Property1 persists to the next call of that method! I suppose I get why it would be happening; myVar is being set by reference instead of by value, but I've never encountered anything like this before. Is there any way (other than my workaround which is to just create a new object using the property values of myVar) to create myLocalVar by value?

Answer 1

When you create myLocalVar you are creating a new reference to the same shared object. If you truly want a local copy of the shared instance you will need to create a true copy.

This is done by either cloning the instance or with a copy constructor on the type that allows you to create a copy of the instance. This is not as simple as it sounds, however, due to the differences between deep and shallow copying and a cloned or copied instance could create similar problems for you if the property you are accessing is simply a shallow-copied reference to the same instance that the property on the original instance is referencing.

The best thing I to do in this case is to create a local copy of only the parts of the shared instance that you need, rather than copying the entire object graph. This means create a local copy of whatever type Property1 is and using that.

Answer 2

An interesting side note: In modern languages starting with C++ pointers were replaced by objects. Prior to that (eg in C and Pascal), you had to manipulate the pointers (to what were basically objects) yourself. Because objects are actually pointers to data they "contain" they are always references. Object based languages try to shield you from this reality but sometimes, like in this case, the reality shines through.

If you had ever had to implement a pointer heavy program in C or Pascal the reality of the underlying manipulation would be much clearer. For better or worse, most programmers these days have not had that experience.