Comment faire une copie profonde d'un tableau?

Je ne sais pas où j'ai obtenu ce à partir, mais cela fonctionne bien pour moi.

public static class GenericCopier<T>    //deep copy a list
    {
        public static T DeepCopy(object objectToCopy)
        {
            using (MemoryStream memoryStream = new MemoryStream())
            {
                BinaryFormatter binaryFormatter = new BinaryFormatter();
                binaryFormatter.Serialize(memoryStream, objectToCopy);
                memoryStream.Seek(0, SeekOrigin.Begin);
                return (T)binaryFormatter.Deserialize(memoryStream);
            }
        }
    }

Le noeud du problème est là:

J'y stocker ces valeurs dans un autre tableau à deux dimensions

C'est en fait inexact. Vous n'êtes pas de la création d'un nouveau tableau; vous définissez votre originalValues variable la même tableau. Pour une explication plus détaillée, voir ci-dessous.

---

La confusion exprimée dans les commentaires de Pieter de réponse est en raison de l'incertitude entourant le terme "copie en profondeur."

Quand il s'agit de la copie d'objets, il y a copie profonde et peu profonde de la copie.

Profonde de la copie s'agit de faire une copie de tous les données appartenant à un objet, ce qui signifie que si l'objet est composé de membres qui sont eux-mêmes complexes (par exemple, les instances de l'utilisateur défini les types de référence), ces objets doit être profonde copié (avec tous leur membres, et ainsi de suite).

Peu profonde de la copie suppose simplement la copie de tous les champs d'un objet à l'autre, ce qui signifie que si l'objet comprend les types de référence, seules les références doivent être copiés (et donc le copié les références pointant vers le même objet).

Dans le cas du code que vous avez posté:

int[,] originalValues = this.Metrics;

... il y a en fait aucune copie de tous les objets à tous les. Tout ce que vous avez fait est copié une référence unique, de l'affectation de la valeur de this.Metrics (une référence) à la variable originalValues (également une référence, au même tableau). C'est essentiellement la même qu'une simple affectation de la valeur, comme ceci:

int x = y; //No objects being copied here.

Maintenant, le Array.Clone méthode permet, en fait, un peu profonde copie. Mais comme Pieter souligné, il n'y a vraiment pas de différence entre un "peu profonde" ou "profond" copie d'un tableau de entierspuisque les nombres entiers ne sont pas des objets complexes.

Si vous aviez quelque chose comme ceci:

StringBuilder[,] builders = GetStringBuilders();
StringBuilder[,] builderCopies = (StringBuilder[,])builders.Clone();

..., vous finirais avec une toute nouvelle tableau (une copie, oui), mais qui contient tout de même StringBuilder objets (donc d'une copie). C'est là une profonde peu profonde contre la copie; si vous vouliez un nouveau tableau contenant copies de tous les StringBuilder objets de buildersvous auriez besoin de faire une copie en profondeur.

IClonable est grande, mais à moins que vous IClonable chaque type dans votre top niveau cloné type, vous vous retrouvez avec des références, autant que je sache.

Sur cette base, sauf si vous voulez marcher l'objet et le clone de chaque objet à l'intérieur, ce qui semble l'approche la plus simple.

C'est simple et garantit une rupture nette avec les références de la profondeur des objets dans l'original:

using Newtonsoft.Json;

private T DeepCopy<T>(object input) where T : class
{
    var copy = JsonConvert.SerializeObject((T)input); //serialise to string json object
    var output = JsonConvert.DeserializeObject<T>(copy); //deserialise back to poco
    return output;
}

Utilisation:

var x = DeepCopy<{ComplexType}>(itemToBeCloned);

Où ComplexType est quelque chose qui veulent une pause de références.

Il faut de tout Type, stringifies, puis de stringifies à une nouvelle copie.

Meilleur exemple d'utilisation:
Si vous avez sélectionné un type complexe comme un résultat d'un lambda de requête et souhaitez modifier le résultat, sans affecter l'original.

Si vous voulez profonde copie d'un tableau de types de référence, vous pouvez le faire de cette méthodologie:

Mettre en œuvre IClonable iterface pour votre classe et de faire de votre copie en profondeur de toute valeur saisie des champs à l'intérieur d'un autre objet construit.

class A: ICloneable {
     int field1;
     public object Clone()
        {
            A a= new A();
            //copy your fields here 
            a.field1 = this.field1;
            ...
        }
}

Ensuite, vous pouvez faire la copie réelle à l'aide de

A[] array1 = new A[]{....};
A[] array2 = array1.Select(a => a.Clone()).ToList();