C# Automatique de la copie en profondeur de struct

Le runtime effectue une rapide copie de la mémoire de leurs structures et autant que je sache, il n'est pas possible d'introduire ou de la force de votre propre procédure de copie. Vous pouvez introduire votre propre Clone méthode ou même un constructeur par copie, mais vous ne pouvaient pas faire valoir qu'ils les utilisent.

Votre meilleur pari, si possible, pour faire de votre structure immuable (ou immuable de la classe) ou de refonte en général pour éviter ce problème. Si vous êtes le seul consommateur de l'API, alors peut-être vous pouvez simplement rester très vigilant.

Jon Skeet (et d'autres) ont décrit ce problème et, même s'il peut y avoir des exceptions, d'une manière générale: les structures mutables sont le mal.
Peut les structures qui contiennent des champs de types de référence

OriginalL'auteur Chris Sinclair

Comme une solution de contournement, je vais mettre en œuvre les suivantes.

Il y a 2 méthodes dans la structure qui permet de modifier le contenu de BoolArray. Plutôt que de créer de la matrice lorsque la structure est copié, BoolArray sera créé à nouveau lors d'un appel au changement c'est fait, comme suit

public void ChangeBoolValue(int index, int value)
{
    bool[] Copy = new bool[4];
    BoolArray.CopyTo(Copy, 0);
    BoolArray = Copy;

    BoolArray[index] = value;
}

Bien que ce serait mauvais pour les utilisations qui a impliqué beaucoup de changement de la BoolArray, mon utilisation de la structure est beaucoup de copie, et très peu en train de changer. Cela ne fera que modifier la référence à la matrice lorsqu'un changement est nécessaire.

OriginalL'auteur 3Pi

Je pensais à un problème similaire liées à des types de valeur, et a trouvé une "solution" à ce. Vous voyez, vous ne peut pas modifier le constructeur de copie par défaut en C# comme vous pouvez le faire en C++, car il est conçu pour être léger et effets secondaires-gratuit. Cependant, ce que vous pouvez faire est d'attendre jusqu'à ce que vous réellement accès à la structure, et de vérifier ensuite si elle a été copié.

Le problème, c'est qu'à la différence de types de référence, les structures n'ont pas de véritable identité; il est seulement par la valeur de l'égalité. Cependant, ils doivent toujours être stockés à un certain endroit dans la mémoire, et cette adresse peut être utilisée pour identifier (même temporairement) un type de valeur. La GC est une préoccupation ici, parce qu'il peut déplacer des objets, et donc modifier l'adresse à laquelle la structure est situé, de sorte que vous devez être en mesure de faire face à cette situation (par exemple, faire de la structure de données du privé).

Dans la pratique, l'adresse de la structure peut être obtenue à partir de la this de référence, parce que c'est un simple ref T dans le cas d'un type de valeur. Je laisse le moyens pour obtenir l'adresse d'une référence à ma bibliothèque, mais c'est assez simple à émettre personnalisé CIL. Dans cet exemple, je crée quelque chose de ce qui est essentiellement un byval tableau.

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

Comme vous pouvez le voir, ce type de valeur se comporte exactement comme si le sous-jacent tableau a été copié vers un nouvel emplacement à chaque fois que la référence au tableau est copié.

ATTENTION!!! Utilisez ce code uniquement à vos propres risques, et, de préférence, jamais dans un code de production. Cette technique est mal et le mal à de nombreux niveaux, car il suppose d'identité pour quelque chose qui ne devrait pas l'avoir. Bien que cette méthode tente de "faire respecter" type de la valeur sémantique de cette structure ("la fin justifie les moyens"), il y a certainement de meilleures solutions pour le problème réel dans presque tout cas. Veuillez également noter que, bien que j'ai essayé de prévoir prévisibles des problèmes avec cela, il pourrait y avoir des cas où ce type de tout à fait un comportement inattendu.

OriginalL'auteur IllidanS4