Deep copy non serializable

Version imprimable

Bonjour,

Je souhaite effectuer une deepcopy d'une classe qui n'est pas défini par mes soins (Viewport3D : https://msdn.microsoft.com/fr-fr/lib...vs.110%29.aspx). En retournant l'interdent mondial j'ai trouvé quelques solutions ex :
Code:

1 2 3 4 5 6 7 8 9 IFormatter formatter = new BinaryFormatter(); Stream stream = new MemoryStream(); using (stream) { formatter.Serialize(stream, source); stream.Seek(0, SeekOrigin.Begin); return (T)formatter.Deserialize(stream); }
Le problème est que cette classe n'est pas serializable donc la solution n'est pas utilisable. Du coup comment puis-je faire ? A priori je ne peux pas "rendre une classe serializable"car si elle ne l'est pas c'est que certaines variables ne peuvent pas être stocker en tant que texte ?
De ce que j'ai lu je pourrais ajouter une "etension" à la classe pour y mettre une méthode qui copierait les items un a un.. Y a t-il une meilleure solution ?

Merci d'avance !

Bonjour,

Ceci devrait fonctionner

Code:

1
2
3
4
5
6
 
XmlSerializer xs = new XmlSerializer(typeof(Viewport3D));
    using (StreamWriter wr = new StreamWriter("Viewport3D.xml"))
    {
        xs.Serialize(wr, viewport);
    }

Façons typiques de copier un type référencé:

utilisation constructeur de copie
méthode de fabrique de l'utilisation (par exemple. types immuables)
utiliser votre propre "Clone"
copier seule référence (par ex. autres Root-Type)
créer une nouvelle instance et copier les propriétés (par ex. les types ne sont pas rédigés par vous-même dépourvus d'un constructeur de copie)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 class A { // copy constructor public A(A copy) {} } // a referenced class implementing class B : IDeepCopy { object Copy() { return new B(); } } class C : IDeepCopy { A A; B B; object Copy() { C copy = new C(); // copy property by property in a appropriate way copy.A = new A(this.A); copy.B = this.B.Copy(); } }

01/02/2016, 20h59
taspai

@mattdef J'ai du mal a comprendre comment je dois l'utiliser au niveau de la serialization/copie

@charouel la classe n'est pas écrite par moi du coup je ne peux pas mettre en place cette solution non ?

Merci de votre aide !
02/02/2016, 09h40
charouel

Tu fait une classe qui hérité de la classe que tu n'a pas fait => puis tu rajoute le constructeur de copie ;)
02/02/2016, 09h53
taspai

Aaaaah exact ! Merci Charouel, je vais essayer ça !

Edit : J'essaye d'utiliser GetProperties ( ex : destinationProperties = destination.GetType().GetProperties(); ) afin d'automatiser la copie des attributs car il y en a quand même pas mal mais ce n'est pas très concluent.. Un conseil à ce sujet ?
02/02/2016, 10h45
theMonz31

salut

il me semble (à tester) que si tu fais une serialization binaire puis une desérialisation (binaire aussi), tu auras une copie de ton objet

(Il me semble que la sérialization binaire fonctionne toujours meme sur des objets non sérializable) :)

@theMonz31 je viens d'essayer de serializer en binaire mais apparement ça ne fonctionne pas avec un objet non sérializable :(

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
        static void Serialize(Viewport3D vp3d)
        {
 
            FileStream fs = new FileStream("DataFile.dat", FileMode.Create);
 
            BinaryFormatter formatter = new BinaryFormatter();
            try
            {
                formatter.Serialize(fs, vp3d);
            }
            catch (SerializationException e)
            {
                Console.WriteLine("Failed to serialize. Reason: " + e.Message);
                throw;
            }
            finally
            {
                fs.Close();
            }
}

Informations supplémentaires : Type 'System.Windows.Controls.Viewport3D' in Assembly 'PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35' is not marked as serializable.

02/02/2016, 13h58
charouel

Essaye la Réflexion avec l’héritage ça fonctionneras

Bonsoir, j'utilise cette solutio avec la reflection :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public Viewport3D deepCopy(Viewport3D vp3d) { var myvp3d = Activator.CreateInstance<Viewport3D>(); var fields = myvp3d.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance); foreach (var field in fields) { var value = field.GetValue(vp3d); field.SetValue(myvp3d, value); } return (myvp3d); }
Comment puis je vérifier que mes deux instances sont différentes ? (ex : afficher l'adresse mémoire ?)

Edit : je ne peux pas utiliser correctement ma nouvelle instance de viewport plus loin dans le code car il semblerait qu'elle ne contienne pas tous les attributs de la précédente

Merci beaucoup !

03/02/2016, 13h55
ebastien

Citation:

Envoyé par taspai

je ne peux pas utiliser correctement ma nouvelle instance de viewport plus loin dans le code car il semblerait qu'elle ne contienne pas tous les attributs de la précédente

Petite précision : Si le champ n'est pas un type simple (int, string,...) mais un objet, field.GetValue(...) retournera un pointeur sur cet objet. Il faudra donc aussi cloner l'objet en question faute de quoi tes deux champs pointeront sur le même objet.

La classe Viewport3D m'a l'air relativement complexe et en faire un clone me paraît compliqué. N'as-tu pas d'autres options ?
03/02/2016, 15h17
taspai

Merci pour cette explication je n'avais pas vu que pour une objet c'était différent. Je ne vois pas vraiment comment faire différemment car j'utilise la viewport pour ma scène et au passage je fais un render bmp pour en sortir une vignette mais je ne veux pas altérer ma scène, c'est pour ça que je souhaite la cloner.

bonjour
Les espace de nom System.Windows.Markup et System.Xml permettent de
- serializer une instance de control WPF en un output de type string (chaine xaml )...
- de deserializer une chaine xaml en instance de control....

Code:

1
2
3
4
5
6
7
 
 
 string stringXaml = System.Windows.Markup.XamlWriter.Save(this.vp3d);
 
 StringReader stringReader = new StringReader(stringXaml);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            Viewport3D  readerViewport = (Viewport3D)System.Windows.Markup.XamlReader.Load(xmlReader);

Pour la serialization binaire le string Xaml peut etre ensuite serialiser :
- en memoire (memoryStream) puis converti en chaine binaire Base64 (Convert.ToBase64(Memorystream) et ecrit sur fichier ...

La deserialization se fait en sens inverse:
- deserialization de la chaine Base64 à partir du fichier
- conversion en memoire en chaine Xaml grace new MemoryStream(Convert.FromBase64String(stringBase64))

La serialization Xaml possede les limitations suivantes:
- les Bindings ,DataTemplates et Styles ne sont pas pris en compte...et doivent etre reconstitutes au run-time...
- neanmoins toutes les props et methodes du control sont disponibles avec leurs valeurs( si ells sont en "dur" au moment de la serialization) ...

Exemple code avec 2 buttons ,1 textblock et un viewport3d simple :

-le button 1 serialize en memoire le vp3d et affiche un apercu de la chaine Xaml converti en chaine base64 puis
deseriliaze en memoire la chaine base64 , la convertit en chaine Xaml d'origine et
l'API Markup et System.Xml restitue un Viewport3D affichie dans la Window3...

-le button 2 fait la meme tache sur disque et le control Viewport3D est affichee dans la Window4...

code xaml du form principal:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
<Window x:Class="WpfSerializeXamlMarkup.Window2"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Window2" Height="300" Width="300">
    <StackPanel>
        <Button 
            x:Name="btnSerialize"  Margin="15"
            Content="Serialize" Click="btnSerialize_Click">
        </Button>
        <Button 
            x:Name="btnSerializeToFile"  Margin="15"
            Content="SerializeToFile" Click="btnSerializeToFile_Click">
        </Button>
        <StackPanel Orientation="Horizontal"  >
            <TextBlock  
                x:Name="tb1"  Margin="10" 
                FontSize="14" Background="Red" Foreground="White" 
               >
            </TextBlock>
            <TextBlock  
                x:Name="tb2"  Margin="10" 
                FontSize="14" Background="DarkBlue" Foreground="White"  
                Text="apercu chaine base64">
            </TextBlock>
        </StackPanel> 
        <Viewbox>
            <Canvas Width="321" Height="201">
 
                <!-- The Viewport3D provides a rendering surface for 3-D visual content. -->
                <Viewport3D 
                    x:Name="vp3d"
                    ClipToBounds="True" Width="150" Height="150" Canvas.Left="0" Canvas.Top="10">
 
                    <!-- Defines the camera used to view the 3D object. -->
                    <Viewport3D.Camera>
                        <PerspectiveCamera Position="0,0,2" LookDirection="0,0,-1" FieldOfView="60" />
                    </Viewport3D.Camera>
 
                    <!-- The ModelVisual3D children contain the 3D models -->
                    <Viewport3D.Children>
 
                        <!-- This ModelVisual3D defines the light cast in the scene. Without light, the 3D 
                 object cannot be seen. Also, the direction of the lights affect shadowing. If desired,
                 you can create multiple lights with different colors that shine from different directions. -->
                        <ModelVisual3D>
                            <ModelVisual3D.Content>
                                <DirectionalLight Color="#FFFFFF" Direction="-0.612372,-0.5,-0.612372" />
                            </ModelVisual3D.Content>
                        </ModelVisual3D>
                        <ModelVisual3D>
                            <ModelVisual3D.Content>
                                <GeometryModel3D>
 
                                    <!-- The geometry specifes the shape of the 3D plane. In this sample, a flat sheet is created. -->
                                    <GeometryModel3D.Geometry>
                                        <MeshGeometry3D
                     TriangleIndices="0,1,2 3,4,5 "
                     Normals="0,0,1 0,0,1 0,0,1 0,0,1 0,0,1 0,0,1 "
                     TextureCoordinates="0,0 1,0 1,1 1,1 0,1 0,0 "
                     Positions="-0.5,-0.5,0.5 0.5,-0.5,0.5 0.5,0.5,0.5 0.5,0.5,0.5 -0.5,0.5,0.5 -0.5,-0.5,0.5 " />
                                    </GeometryModel3D.Geometry>
 
                                    <!-- The material specifies the material applied to the 3D object. In this sample a linear gradient 
                       covers the surface of the 3D object.-->
                                    <GeometryModel3D.Material>
                                        <MaterialGroup>
                                            <DiffuseMaterial>
                                                <DiffuseMaterial.Brush>
                                                    <LinearGradientBrush StartPoint="0,0.5" EndPoint="1,0.5">
                                                        <LinearGradientBrush.GradientStops>
                                                            <GradientStop Color="Yellow" Offset="0" />
                                                            <GradientStop Color="Red" Offset="0.25" />
                                                            <GradientStop Color="Blue" Offset="0.75" />
                                                            <GradientStop Color="LimeGreen" Offset="1" />
                                                        </LinearGradientBrush.GradientStops>
                                                    </LinearGradientBrush>
                                                </DiffuseMaterial.Brush>
                                            </DiffuseMaterial>
                                        </MaterialGroup>
                                    </GeometryModel3D.Material>
 
                                    <!-- Apply a transform to the object. In this sample, a rotation transform is applied, rendering the 
                       3D object rotated. -->
                                    <GeometryModel3D.Transform>
                                        <RotateTransform3D>
                                            <RotateTransform3D.Rotation>
                                                <AxisAngleRotation3D Axis="0,3,0" Angle="40" />
                                            </RotateTransform3D.Rotation>
                                        </RotateTransform3D>
                                    </GeometryModel3D.Transform>
                                </GeometryModel3D>
                            </ModelVisual3D.Content>
                        </ModelVisual3D>
                    </Viewport3D.Children>
 
                </Viewport3D>
            </Canvas>
        </Viewbox>
    </StackPanel>
 
</Window>

code behind .cs du form principal:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
//spcenames à rajouter
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization;
using System.Xml;
 
namespace WpfSerializeXamlMarkup
{
    /// <summary>
    /// Logique d'interaction pour Window2.xaml
    /// </summary>
    public partial class Window2 : Window
    {
        private string pathFile = Directory.GetCurrentDirectory() + "\\Vp3d.bin";
        public Window2()
        {
            InitializeComponent();
        }
 
        private void btnSerialize_Click(object sender, RoutedEventArgs e)
        {
            string stringXaml = System.Windows.Markup.XamlWriter.Save(this.vp3d);
            string stringBase64 = Serialize(stringXaml);
            this.tb1.Text = stringBase64;
 
 
            stringXaml = DeSerialize(stringBase64);
            StringReader stringReader = new StringReader(stringXaml);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            Viewport3D  readerViewport = (Viewport3D)System.Windows.Markup.XamlReader.Load(xmlReader);
 
 
 
            Window3 win =new Window3();
            win.Show();
            win.rootPanel.Children.Add(readerViewport);
        }
        private string Serialize(string stringXaml)
        {
            MemoryStream mem = new MemoryStream();
 
            BinaryFormatter bf = new BinaryFormatter();
            try
            {
                bf.Serialize(mem, stringXaml);
            }
            catch (SerializationException e)
            {
                Console.WriteLine("Failed to serialize. Reason: " + e.Message);
                throw;
            }
 
            //conversion en chaine binaire Base64
            string stringBase64 = Convert.ToBase64String(mem.ToArray());
 
            return stringBase64;
        }
 
        private string DeSerialize(string stringBase64)
        {
            string str = string.Empty;
 
 
            //conversion binaire
            MemoryStream mem = new MemoryStream(Convert.FromBase64String(stringBase64));
 
            BinaryFormatter bf = new BinaryFormatter();
            try
            {
                str = (string)bf.Deserialize(mem);
            }
            catch (SerializationException e)
            {
                Console.WriteLine("Failed to deserialize. Reason: " + e.Message);
                throw;
            }
 
 
            return str;
        }
        private void btnSerializeToFile_Click(object sender, RoutedEventArgs e)
        {
            string stringXaml = System.Windows.Markup.XamlWriter.Save(this.vp3d);
            SerializeToFile(stringXaml);
 
 
 
            string c = DeSerializeFromFile();
            StringReader stringReader = new StringReader(c);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            Viewport3D readerViewport = (Viewport3D)System.Windows.Markup.XamlReader.Load(xmlReader);
 
 
 
            Window4 win = new Window4();
            win.Show();
            win.rootPanel.Children.Add(readerViewport);
        }
        private void SerializeToFile(string stringXaml)
        {
            FileStream fs = new FileStream(pathFile , FileMode.Create);
            MemoryStream mem = new MemoryStream();
 
            BinaryFormatter bf = new BinaryFormatter();
            try
            {
                bf.Serialize(mem, stringXaml);
            }
            catch (SerializationException e)
            {
                Console.WriteLine("Failed to serialize. Reason: " + e.Message);
                throw;
            }
 
            //conversion en chaine Base64
            string stringBase64 = Convert.ToBase64String(mem.ToArray());
 
            bf.Serialize(fs, stringBase64);
 
            fs.Close();
 
        }
        private string DeSerializeFromFile()
        {
            string stringXaml = string.Empty;
            string stringBase64 = string.Empty;
 
 
            FileStream fs = new FileStream(pathFile, FileMode.Open);
            MemoryStream mem = null;
 
            BinaryFormatter bf = new BinaryFormatter();
            try
            {
                stringBase64 = (string)bf.Deserialize(fs);
 
                mem = new MemoryStream(Convert.FromBase64String(stringBase64));
 
                stringXaml = (string)bf.Deserialize(mem);
 
            }
            catch (SerializationException e)
            {
                Console.WriteLine("Failed to deserialize. Reason: " + e.Message);
                throw;
            }
            fs.Close();
 
 
 
            return stringXaml;
        }
 
 
    }
}

simple code xaml du form3 :

Code:

1
2
3
4
5
6
7
8
9
 
<Window x:Class="WpfSerializeXamlMarkup.Window3"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Window3" Height="300" Width="300">
    <Grid x:Name="rootPanel">
 
    </Grid>
</Window>

simple code xaml du form4 :

Code:

1
2
3
4
5
6
7
8
9
 
<Window x:Class="WpfSerializeXamlMarkup.Window4"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Window4" Height="300" Width="300">
    <Grid   x:Name="rootPanel">
 
    </Grid>
</Window>

bon code....