我有一个叫做MyStruct的结构体，其中包含一个私有成员变量private bool[] boolArray;和一个方法ChangeBoolValue(int index, bool Value)。
我还有一个类MyClass，它有一个字段public MyStruct bools { get; private set; }
当我从一个现有的MyStruct对象创建一个新对象，然后应用ChangeBoolValue()方法时，由于复制的是引用而不是被引用的内容，所以两个对象中的bool数组都会改变。例如：
MyStruct A = new MyStruct();
MyStruct B = A; //Copy of A made
B.ChangeBoolValue(0,true);
//Now A.BoolArr[0] == B.BoolArr[0] == true
Clone 方法或复制构造函数，但无法强制使用它们。一种简单的制作(深层)副本方法，虽然不是最快的方法(因为它使用反射)，但可以使用BinaryFormatter将原始对象序列化到一个MemoryStream中，然后从那个MemoryStream反序列化到一个新的MyStruct中。
static public T DeepCopy<T>(T obj)
{
BinaryFormatter s = new BinaryFormatter();
using (MemoryStream ms = new MemoryStream())
{
s.Serialize(ms, obj);
ms.Position = 0;
T t = (T)s.Deserialize(ms);
return t;
}
}
适用于类和结构体。
MyStruct的消费者在传递实例时调用DeepCopy方法。我认为3Pi正在询问如何在运行时复制结构体时自动执行深度复制。 - Chris Sinclairobject.ReferenceEquals(A, B) 为 true），因此仅使用赋值运算符将无法实现他所要求的功能。除非使用（扩展）方法，否则我不确定是否有其他方法可以解决这个问题。 - Eric J.MyStruct的使用，那么应该没问题，只需要注意其使用情况即可。 - Chris Sinclair作为一种解决方法，我将实现以下内容。
结构体中有两种方法可以修改BoolArray的内容。与其在复制结构体时创建数组，当调用更改函数时，将新创建BoolArray，如下所示：
public void ChangeBoolValue(int index, int value)
{
bool[] Copy = new bool[4];
BoolArray.CopyTo(Copy, 0);
BoolArray = Copy;
BoolArray[index] = value;
}
当更新可能具有高度的特殊集中性，但命中太多元素以至于无法完全适应结构时，另一种方法是保留对“主”数组的引用，以及一个“更新”数组和一个整数，指示“更新”数组表示主数组的哪个部分。更新通常需要重新生成“更新”数组，但它可以比主数组小得多；如果“更新”数组变得太大，则可以重新生成主数组，并将“更新”数组所代表的更改合并到其中。
任何这些方法的最大问题是，虽然可以通过工程化的方式设计struct，以呈现一致的值类型语义，同时允许高效的复制，但是一眼看去，结构体的代码很难显而易见（与普通数据结构不同，普通数据结构具有名为Foo的公共字段，使得Foo的行为非常清晰明了）。
当传递结构体时，它会被复制，对吗？所以：
public static class StructExts
{
public static T Clone<T> ( this T val ) where T : struct => val;
}
使用方法：
var clone = new AnyStruct ().Clone ();
unsafe struct MyStruct{///add unsafe
private fixed bool boolArray[100];///set to fixed array
public void ChangeBoolValue(int index, bool Value) {
boolArray[index] = Value;
}
}
MyStruct copyMyStruct(MyStruct copy){
return copy;
}
项目->属性->构建->允许不安全代码 = 已选中
项目->属性->构建->优化代码 = 未选中
MyStruct A = new MyStruct();
MyStruct B = copyMyStruct(A);//Copy of A made
B.ChangeBoolValue(0,true);//B.BoolArr[0] == true , A.BoolArr[0] == false
我曾思考过一个与值类型相关的类似问题，并找到了一个“解决方案”。你看，在C#中，你无法像在C++中那样更改默认的复制构造函数，因为它旨在轻量级且无副作用。然而，你可以等到实际访问结构体时再检查是否已复制。
问题在于，与引用类型不同，结构体没有真正的身份；只有按值相等性。但是，它们仍然必须存储在某个内存位置，并且该地址可以用于识别（尽管是暂时的）值类型。GC在这里是一个问题，因为它可以移动对象，从而更改结构体所在的地址，因此你必须能够应对这种情况（例如使结构体的数据私有化）。
实际上，如果是值类型，结构体的地址可以从this引用中获取，因为它是一个简单的ref T。我将获得从我的库的引用中获取地址的方法留给您自己去探索，但是发出自定义CIL也很简单。在这个例子中，我创建了一个类似于按值传递数组的东西。public struct ByValArray<T>
{
//Backup field for cloning from.
T[] array;
public ByValArray(int size)
{
array = new T[size];
//Updating the instance is really not necessary until we access it.
}
private void Update()
{
//This should be called from any public method on this struct.
T[] inst = FindInstance(ref this);
if(inst != array)
{
//A new array was cloned for this address.
array = inst;
}
}
//I suppose a GCHandle would be better than WeakReference,
//but this is sufficient for illustration.
static readonly Dictionary<IntPtr, WeakReference<T[]>> Cache = new Dictionary<IntPtr, WeakReference<T[]>>();
static T[] FindInstance(ref ByValArray<T> arr)
{
T[] orig = arr.array;
return UnsafeTools.GetPointer(
//Obtain the address from the reference.
//It uses a lambda to minimize the chance of the reference
//being moved around by the GC.
out arr,
ptr => {
WeakReference<T[]> wref;
T[] inst;
if(Cache.TryGetValue(ptr, out wref) && wref.TryGetTarget(out inst))
{
//An object is found on this address.
if(inst != orig)
{
//This address was overwritten with a new value,
//clone the instance.
inst = (T[])orig.Clone();
Cache[ptr] = new WeakReference<T[]>(inst);
}
return inst;
}else{
//No object was found on this address,
//clone the instance.
inst = (T[])orig.Clone();
Cache[ptr] = new WeakReference<T[]>(inst);
return inst;
}
}
);
}
//All subsequent methods should always update the state first.
public T this[int index]
{
get{
Update();
return array[index];
}
set{
Update();
array[index] = value;
}
}
public int Length{
get{
Update();
return array.Length;
}
}
public override bool Equals(object obj)
{
Update();
return base.Equals(obj);
}
public override int GetHashCode()
{
Update();
return base.GetHashCode();
}
public override string ToString()
{
Update();
return base.ToString();
}
}
var a = new ByValArray<int>(10);
a[5] = 11;
Console.WriteLine(a[5]); //11
var b = a;
b[5]++;
Console.WriteLine(b[5]); //12
Console.WriteLine(a[5]); //11
var c = a;
a = b;
Console.WriteLine(a[5]); //12
Console.WriteLine(c[5]); //11
正如您所看到的，这个值类型的行为就像每次复制对数组的引用时都将基础数组复制到新位置一样。
警告!!! 仅在自己的风险下使用此代码，并且最好永远不要在生产代码中使用。这种技术在许多层面上都是错误和邪恶的，因为它假定了某些不应该具有的身份。虽然这试图为这个结构体“强制执行”值类型语义（“目的证明手段”），但在几乎任何情况下，肯定有更好的解决方案来解决真正的问题。另请注意，尽管我已经尝试预见到这个类型可能会出现的任何可预见的问题，但仍可能存在这种类型会显示出相当意外行为的情况。