Casting error in VS2005

JeremyJ wrote:

The two blocks of code do the same thing.  I can do the equivilent in other languages and it works just fine (yes I have tested this).

They don't do entirely the same thing. What you want to do would actually be equivalent to this (sort of):
Recipient data;
Contact contact = data;
FetchContact(ref contact, row);
data = (Recipient)contact;

It's the final line that makes the difference. Let's look at the following example:

class Base { }
class Child1 : Base { }
class Child2 : Base { }

void FetchBase(ref Base base)
{
   /* Omitted: do something with original value of base. */

  base = new Child2();
}

Now if you do what you're describing above, it'd look like this:
Child1 c = new Child1();
FetchBase(ref (Base)c);

You'd end up trying to assign a Child2 object to a Child1 variable! It can't be done.

That's what Amotif was getting at.

JeremyJ wrote:

The only difference between the two blocks of code is the fact that I am creating a second pointer and passing that in. The Contact contact = ( Contact )data; is doing a shallow copy and not a deep copy.

No, the difference is that when FetchContact changes the value of the ref parameter, it's assigning to a variable of type Contact, whereas your first version would assign to a variable of type Recipient while it thinks it's assigning to one of type Contact.

And there's no copying done at all, besides the reference. A shallow copy would be a new Recipient object but with the same members; and where they are references, the new object gets the same reference (a deep copy would also clone the referenced objects from the members).

JeremyJ wrote:

The last line you added to the code isn't needed.
data = (Recipient)contact;

contact is already pointing to data so data gets updated automatically.  I tested that in the code to verify it was correct.

Wait, so the parameter reference value isn't being changed? Then why is it a ref parameter? That last list is definitely needed if you use ref parameters for their intended purpose.

JeremyJ wrote:

As for changing the derived type in the function, you are correct, there is no one stopping anyone from writing bad code.  Not sure what that had to do with the question though.

There's two ways to deal with this.
1. Don't allow it.
2. Throw an InvalidCastException at run time when such an invalid assignment occurs.

The C# team chose the former. That's the problem you're hitting and that's why it was relevant.

JeremyJ wrote:

The parameter reference is being changed. 
The contact variable is pointing to data.  So when contact is changed data is changed.  That is just the way pointers work.  Give it a try and you will see what I am talking about.

No. All reference types in .Net are passed by reference anyway. Only when you want to return a different reference through the parameter is a ref parameter required.

void Foo(Bar b)
{
   b.Baz = 5;
}
If Bar is a class (and not a struct), no ref parameter is required for this, and Foo's caller will still see the change in Baz.

void Foo(ref Bar b)
{
   b = new Bar();
}
That's what a ref parameter is for (and actually, since I'm not using the value passed in, I should use an out parameter).

The C++ equivalent would look like this:
void Foo(Bar *b)
{
   b->Baz = 5;
}

void Foo(Bar *&b)
{
   b = new Bar();
}

When dealing with reference types, you're already passing a pointer even without ref, so you can change the instance (but not the pointer itself). With ref, you're actually passing a reference to a pointer. This is only necessary when you want to change the pointer itself.