C＃构造函数，是否通过引用？

Question

Looking at this Microsoft article How to: Write a Copy Constructor (C#) and also this Generic C# Copy Constructor , wouldn't it be best/safe to use a reference to the class instance than to use a plain copy of the instance ?

public class Myclass()
{
    private int[] row;
    public MyClass(ref MyClass @class)
    {
        for(int i = 0; i<@class.row.Length;i++)
        {
            this.row[i] = @class.row[i];
        }
    }
}

Answer 1

What ref actually means:

void Change(SomeClass instance)
{
    instance = new SomeClass();
}
void ChangeRef(ref SomeClass instance)
{
    instance = new SomeClass();
}

Later...

SomeClass instance = new SomeClass();
Change(instance);
//value of instance remains unchanged here
ChangeRef(ref instance);
//at this line, instance has been changed to a new instance because
//ref keyword imports the `instance` variable from the call-site's scope

I can't see how this functionality would be useful with respect to a copy constructor.

Answer 2

Object by nature is reference not a value type. I do not see any good reason what extra advantage you would get doing it. But yes you might get into problems because of it, consider this -

You created an object and passed it with reference to couple of classes and those classes are now having access to the address of reference itself. Now I have got all the powers to go and change the reference itself with another object's reference. If here, another class had this object it is actually working on some stale object and other classes can not see what changes are being made and you are in chaos.

I do not see any use of doing it, rather it is dangerous. It does not sounds like a OO way of writing code to me.

Answer 3

The ref keyword is used when a method should be allowed to change the location of a reference. Reference types always pass their reference into a method (but the location of the reference cannot be modified via assignment). Values types pass their value.

See: Passing Parameters

Example:

void PassingByReference(List<int> collection)
{
    // Compile error since method cannot change reference location
    // collection = new List<int>();
    collection.Add(1);
}

void ChangingAReference(ref List<int> collection)
{
    // Allow to change location of collection with ref keyword
    collection = new List<int>();
    collection.Add(2);
}

var collection = new List<int>{ 5 };

// Pass the reference of collection to PassByReference
PassingByReference(collection);

// collection new contains 1
collection.Contains(5); // true
collection.Contains(1); // true

// Copy the reference of collection to another variable
var tempCollection = collection;

// Change the location of collection via ref keyword
ChangingAReference(ref collection);

// it is not the same collection anymore
collection.Contains(5); // false
collection.Contains(1); // false

// compare the references use the default == operator
var sameCollection = collection == tempCollection; // false