class/System.Design/System.ComponentModel.Design.Serialization/CodeDomComponentSerializationService.cs

   1 //
   2 // System.ComponentModel.Design.Serialization.CodeDomComponentSerializationService
   3 //
   4 // Authors:
   5 //        Ivan N. Zlatev (contact@i-nZ.net)
   6 //
   7 // (C) 2007 Ivan N. Zlatev
   8
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 #if NET_2_0
  31
  32 using System;
  33 using System.Runtime.Serialization;
  34 using System.Runtime.Serialization.Formatters.Binary;
  35 using System.ComponentModel;
  36 using System.ComponentModel.Design.Serialization;
  37 using System.Collections;
  38 using System.Collections.Generic;
  39 using System.IO;
  40
  41 namespace System.ComponentModel.Design.Serialization
  42 {
  43         // A ComponentSerializationService that uses a CodeDomSerializationStore
  44         // to serialize Components and MemberDescriptors to CodeStatement and CodeStatementCollection
  45         //
  46         public sealed class CodeDomComponentSerializationService : ComponentSerializationService
  47         {
  48                 [Serializable]
  49                 private class CodeDomSerializationStore : SerializationStore, ISerializable
  50                 {
  51                         [Serializable]
  52                         private class Entry
  53                         {
  54                                 private bool _isSerialized;
  55                                 private object _serialized;
  56                                 private bool _absolute;
  57                                 private string _name;
  58
  59                                 protected Entry ()
  60                                 {
  61                                 }
  62
  63                                 public Entry (string name)
  64                                 {
  65                                         if (name == null)
  66                                                 throw new ArgumentNullException ("name");
  67                                         _name = name;
  68                                         _isSerialized = false;
  69                                         _absolute = false;
  70                                 }
  71
  72                                 public bool IsSerialized {
  73                                         get { return _isSerialized; }
  74                                         set { _isSerialized = value; }
  75                                 }
  76
  77                                 public object Serialized {
  78                                         get { return _serialized; }
  79                                         set {
  80                                                 _serialized = value;
  81                                                 _isSerialized = true;
  82                                         }
  83                                 }
  84
  85                                 public bool Absolute {
  86                                         get { return _absolute; }
  87                                         set { _absolute = value; }
  88                                 }
  89
  90                                 public string Name {
  91                                         get { return _name; }
  92                                         set { _name = value; }
  93                                 }
  94                         }
  95
  96                         [Serializable]
  97                         private class MemberEntry : Entry
  98                         {
  99                                 private MemberDescriptor _descriptor;
 100
 101                                 protected MemberEntry ()
 102                                 {
 103                                 }
 104
 105                                 public MemberEntry (MemberDescriptor descriptor)
 106                                 {
 107                                         if (descriptor == null)
 108                                                 throw new ArgumentNullException ("descriptor");
 109                                         _descriptor = descriptor;
 110                                         base.Name = descriptor.Name;
 111                                 }
 112
 113                                 public MemberDescriptor Descriptor {
 114                                         get { return _descriptor; }
 115                                         set { _descriptor = value; }
 116                                 }
 117                         }
 118
 119                         [Serializable]
 120                         private class ObjectEntry : Entry
 121                         {
 122                                 private Type _type;
 123                                 [NonSerialized]
 124                                 private object _instance;
 125                                 private Dictionary<string,MemberEntry> _members;
 126                                 private bool _entireObject;
 127
 128                                 protected ObjectEntry ()
 129                                 {
 130                                 }
 131
 132                                 public ObjectEntry (object instance, string name) : base (name)
 133                                 {
 134                                         if (instance == null)
 135                                                 throw new ArgumentNullException ("instance");
 136                                         _instance = instance;
 137                                         _type = instance.GetType ();
 138                                         _entireObject = false;
 139                                 }
 140
 141                                 public Type Type {
 142                                         get { return _type; }
 143                                 }
 144
 145                                 public object Instance {
 146                                         get { return _instance; }
 147                                         set {
 148                                                 _instance = value;
 149                                                 if (value != null)
 150                                                         _type = value.GetType ();
 151                                         }
 152                                 }
 153
 154                                 public Dictionary<string,MemberEntry> Members {
 155                                         get {
 156                                                 if (_members == null)
 157                                                         _members = new Dictionary <string, MemberEntry> ();
 158                                                 return _members;
 159                                         }
 160                                         set { _members = value; }
 161                                 }
 162
 163                                 public bool IsEntireObject {
 164                                         get { return _entireObject; }
 165                                         set { _entireObject = value; }
 166                                 }
 167                         }
 168
 169                         // When e.g Copy->Pasting a component will not be preserved, but the serialized
 170                         // data will contain references to the original component name. We handle this
 171                         // here by checking whether CreateInstance returns a component with a different
 172                         // name and we map the old name to the new one so that GetInstance will return
 173                         // a reference to the new component.
 174                         //
 175                         private class InstanceRedirectorDesignerSerializationManager : IDesignerSerializationManager, IServiceProvider
 176                         {
 177                                 DesignerSerializationManager _manager;
 178                                 private Dictionary <string, string> _nameMap;
 179
 180                                 public InstanceRedirectorDesignerSerializationManager (IServiceProvider provider, IContainer container,
 181                                                                                        bool validateRecycledTypes)
 182                                 {
 183                                         if (provider == null)
 184                                                 throw new ArgumentNullException ("provider");
 185                                         DesignerSerializationManager manager = new DesignerSerializationManager (provider);
 186                                         manager.PreserveNames = false;
 187                                         if (container != null)
 188                                                 manager.Container = container;
 189                                         manager.ValidateRecycledTypes = validateRecycledTypes;
 190                                         _manager = manager;
 191                                 }
 192
 193                                 public IDisposable CreateSession ()
 194                                 {
 195                                         return _manager.CreateSession ();
 196                                 }
 197
 198                                 public IList Errors {
 199                                         get { return _manager.Errors; }
 200                                 }
 201
 202                                 object IServiceProvider.GetService (Type service)
 203                                 {
 204                                         return ((IServiceProvider)_manager).GetService (service);
 205                                 }
 206
 207                                 #region IDesignerSerializationManager Wrapper Implementation
 208
 209                                 void IDesignerSerializationManager.AddSerializationProvider (IDesignerSerializationProvider provider)
 210                                 {
 211                                         ((IDesignerSerializationManager)_manager).AddSerializationProvider (provider);
 212                                 }
 213
 214                                 void IDesignerSerializationManager.RemoveSerializationProvider (IDesignerSerializationProvider provider)
 215                                 {
 216                                         ((IDesignerSerializationManager)_manager).RemoveSerializationProvider (provider);
 217                                 }
 218
 219                                 object IDesignerSerializationManager.CreateInstance (Type type, ICollection arguments, string name, bool addToContainer)
 220                                 {
 221                                         object instance = ((IDesignerSerializationManager)_manager).CreateInstance (type, arguments, name, addToContainer);
 222                                         string newName = ((IDesignerSerializationManager)_manager).GetName (instance);
 223                                         if (newName != name) {
 224                                                 if (_nameMap == null)
 225                                                         _nameMap = new Dictionary<string, string> ();
 226                                                 _nameMap[name] = newName;
 227                                         }
 228                                         return instance;
 229                                 }
 230
 231                                 object IDesignerSerializationManager.GetInstance (string name)
 232                                 {
 233                                         if (_nameMap != null && _nameMap.ContainsKey (name))
 234                                                 return ((IDesignerSerializationManager)_manager).GetInstance (_nameMap[name]);
 235                                         return ((IDesignerSerializationManager)_manager).GetInstance (name);
 236                                 }
 237
 238                                 Type IDesignerSerializationManager.GetType (string name)
 239                                 {
 240                                         return ((IDesignerSerializationManager)_manager).GetType (name);
 241                                 }
 242
 243                                 object IDesignerSerializationManager.GetSerializer (Type type, Type serializerType)
 244                                 {
 245                                         return ((IDesignerSerializationManager)_manager).GetSerializer (type, serializerType);
 246                                 }
 247
 248                                 string IDesignerSerializationManager.GetName (object instance)
 249                                 {
 250                                         return ((IDesignerSerializationManager)_manager).GetName (instance);
 251                                 }
 252
 253                                 void IDesignerSerializationManager.SetName (object instance, string name)
 254                                 {
 255                                         ((IDesignerSerializationManager)_manager).SetName (instance, name);
 256                                 }
 257
 258                                 void IDesignerSerializationManager.ReportError (object error)
 259                                 {
 260                                         ((IDesignerSerializationManager)_manager).ReportError (error);
 261                                 }
 262
 263                                 ContextStack IDesignerSerializationManager.Context {
 264                                         get { return ((IDesignerSerializationManager)_manager).Context; }
 265                                 }
 266
 267                                 PropertyDescriptorCollection IDesignerSerializationManager.Properties {
 268                                         get { return ((IDesignerSerializationManager)_manager).Properties; }
 269                                 }
 270
 271                                 event EventHandler IDesignerSerializationManager.SerializationComplete {
 272                                         add { ((IDesignerSerializationManager)_manager).SerializationComplete += value; }
 273                                         remove { ((IDesignerSerializationManager)_manager).SerializationComplete -= value; }
 274                                 }
 275
 276                                 event ResolveNameEventHandler IDesignerSerializationManager.ResolveName {
 277                                         add { ((IDesignerSerializationManager)_manager).ResolveName += value; }
 278                                         remove { ((IDesignerSerializationManager)_manager).ResolveName -= value; }
 279                                 }
 280                                 #endregion
 281                         } // InstanceRedirectorDesignerSerializationManager
 282
 283                         private bool _closed;
 284                         private Dictionary <string, ObjectEntry> _objects;
 285                         private IServiceProvider _provider;
 286                         private ICollection _errors;
 287
 288                         internal CodeDomSerializationStore () : this (null)
 289                         {
 290                         }
 291
 292                         internal CodeDomSerializationStore (IServiceProvider provider)
 293                         {
 294                                 _provider = provider;
 295                         }
 296
 297                         private CodeDomSerializationStore (SerializationInfo info, StreamingContext context)
 298                         {
 299                                 _objects = (Dictionary<string, ObjectEntry>) info.GetValue ("objects", typeof (Dictionary<string, ObjectEntry>));
 300                                 _closed = (bool) info.GetValue ("closed", typeof (bool));
 301                         }
 302
 303                         void ISerializable.GetObjectData (SerializationInfo info, StreamingContext context)
 304                         {
 305                                 info.AddValue ("objects", _objects);
 306                                 info.AddValue ("closed", _closed);
 307                         }
 308
 309                         public override void Close ()
 310                         {
 311                                 if (!_closed) {
 312                                         Serialize (_provider);
 313                                         _closed = true;
 314                                 }
 315                         }
 316
 317                         internal static CodeDomSerializationStore Load (Stream stream)
 318                         {
 319                                 return new BinaryFormatter ().Deserialize (stream) as CodeDomSerializationStore;
 320                         }
 321
 322                         public override void Save (Stream stream)
 323                         {
 324                                 Close ();
 325                                 new BinaryFormatter ().Serialize (stream, this);
 326                         }
 327
 328                         private void Serialize (IServiceProvider provider)
 329                         {
 330                                 if (provider == null || _objects == null)
 331                                         return;
 332
 333                                 // Use a new serialization manager to prevent from "deadlocking" the surface one
 334                                 // by trying to create new session when one currently exists
 335                                 //
 336                                 InstanceRedirectorDesignerSerializationManager manager =
 337                                         new InstanceRedirectorDesignerSerializationManager (provider, null, false);
 338                                 ((IDesignerSerializationManager)manager).AddSerializationProvider (CodeDomSerializationProvider.Instance);
 339                                 IDisposable session = manager.CreateSession ();
 340                                 foreach (ObjectEntry objectEntry in _objects.Values) {
 341                                         if (objectEntry.IsEntireObject) {
 342                                                 CodeDomSerializer serializer = (CodeDomSerializer) ((IDesignerSerializationManager)manager).GetSerializer (objectEntry.Type,
 343                                                                                                         typeof (CodeDomSerializer));
 344                                                 if (serializer != null) {
 345                                                         object serialized = null;
 346                                                         if (objectEntry.Absolute)
 347                                                                 serialized = serializer.SerializeAbsolute (manager,
 348                                                                                                            objectEntry.Instance);
 349                                                         else
 350                                                                 serialized = serializer.Serialize (manager, objectEntry.Instance);
 351                                                         objectEntry.Serialized = serialized;
 352                                                 }
 353                                         } else {
 354                                                 foreach (MemberEntry memberEntry in objectEntry.Members.Values) {
 355                                                         CodeDomSerializer serializer = (CodeDomSerializer) ((IDesignerSerializationManager)manager).GetSerializer (
 356                                                                 objectEntry.Type, typeof (CodeDomSerializer));
 357                                                         if (serializer != null) {
 358                                                                 object serialized = null;
 359                                                                 if (memberEntry.Absolute) {
 360                                                                         serialized = serializer.SerializeMemberAbsolute (manager,
 361                                                                                                                          objectEntry.Instance,
 362                                                                                                                          memberEntry.Descriptor);
 363                                                                 } else {
 364                                                                         serialized = serializer.SerializeMember (manager,
 365                                                                                                                  objectEntry.Instance,
 366                                                                                                                  memberEntry.Descriptor);
 367                                                                 }
 368                                                                 memberEntry.Serialized = serialized;
 369                                                         }
 370                                                 }
 371                                         }
 372                                 }
 373                                 _errors = manager.Errors;
 374                                 session.Dispose ();
 375                         }
 376
 377                         internal void AddObject (object instance, bool absolute)
 378                         {
 379                                 if (_closed)
 380                                         throw new InvalidOperationException ("store is closed");
 381
 382                                 if (_objects == null)
 383                                         _objects = new Dictionary <string, ObjectEntry> ();
 384                                 string objectName = GetName (instance);
 385
 386                                 if (!_objects.ContainsKey (objectName)) {
 387                                         ObjectEntry objectEntry = new ObjectEntry (instance, objectName);
 388                                         objectEntry.Absolute = absolute;
 389                                         objectEntry.IsEntireObject = true;
 390                                         _objects[objectName] = objectEntry;
 391                                 }
 392                         }
 393
 394                         internal void AddMember (object owner, MemberDescriptor member, bool absolute)
 395                         {
 396                                 if (_closed)
 397                                         throw new InvalidOperationException ("store is closed");
 398                                 if (member == null)
 399                                         throw new ArgumentNullException ("member");
 400                                 if (owner == null)
 401                                         throw new ArgumentNullException ("owner");
 402
 403                                 if (_objects == null)
 404                                         _objects = new Dictionary <string, ObjectEntry> ();
 405
 406                                 string objectName = GetName (owner);
 407                                 if (!_objects.ContainsKey (objectName))
 408                                         _objects.Add (objectName,  new ObjectEntry (owner, objectName));
 409                                 MemberEntry memberEntry = new MemberEntry (member);
 410                                 memberEntry.Absolute = absolute;
 411                                 _objects[objectName].Members[member.Name] = memberEntry;
 412                         }
 413
 414                         private string GetName (object value)
 415                         {
 416                                 if (value == null)
 417                                         throw new ArgumentNullException ("value");
 418                                 string name = null;
 419
 420                                 IComponent component = value as IComponent;
 421                                 if (component != null && component.Site != null) {
 422                                         if (component.Site is INestedSite)
 423                                                 name = ((INestedSite)component.Site).FullName;
 424                                         else
 425                                                 name = component.Site != null ? component.Site.Name : null;
 426                                 } else if (value is MemberDescriptor) {
 427                                         name = ((MemberDescriptor) value).Name;
 428                                 } else {
 429                                         name = value.GetHashCode ().ToString ();
 430                                 }
 431
 432                                 return name;
 433                         }
 434
 435                         internal ICollection Deserialize (IServiceProvider provider, IContainer container,
 436                                                           bool validateRecycledTypes, bool applyDefaults)
 437                         {
 438                                 List<object> objectInstances = new List<object> ();
 439
 440                                 if (provider == null || _objects == null)
 441                                         return objectInstances;
 442                                 _provider = provider;
 443
 444                                 // Use a new serialization manager to prevent from "deadlocking" the surface one
 445                                 // by trying to create new session when one currently exists
 446                                 //
 447                                 InstanceRedirectorDesignerSerializationManager manager =
 448                                         new InstanceRedirectorDesignerSerializationManager (provider, container, validateRecycledTypes);
 449                                 ((IDesignerSerializationManager)manager).AddSerializationProvider (CodeDomSerializationProvider.Instance);
 450                                 IDisposable session = manager.CreateSession ();
 451                                 foreach (ObjectEntry entry in _objects.Values)
 452                                         objectInstances.Add (DeserializeEntry (manager, entry));
 453                                 _errors = manager.Errors;
 454                                 session.Dispose ();
 455                                 return objectInstances;
 456                         }
 457
 458                         private object DeserializeEntry (IDesignerSerializationManager manager, ObjectEntry objectEntry)
 459                         {
 460                                 object deserialized = null;
 461
 462                                 if (objectEntry.IsEntireObject) {
 463                                         CodeDomSerializer serializer = (CodeDomSerializer) manager.GetSerializer (objectEntry.Type,
 464                                                                                                                   typeof (CodeDomSerializer));
 465                                         if (serializer != null) {
 466                                                 deserialized = serializer.Deserialize (manager, objectEntry.Serialized);
 467                                                 // check if the name of the object has changed
 468                                                 // (if it e.g clashes with another name)
 469                                                 string newName = manager.GetName (deserialized);
 470                                                 if (newName != objectEntry.Name)
 471                                                         objectEntry.Name = newName;
 472                                         }
 473                                 } else {
 474                                         foreach (MemberEntry memberEntry in objectEntry.Members.Values) {
 475                                                 CodeDomSerializer serializer = (CodeDomSerializer) manager.GetSerializer (objectEntry.Type,
 476                                                                                                                           typeof (CodeDomSerializer));
 477                                                 if (serializer != null)
 478                                                         serializer.Deserialize (manager, memberEntry.Serialized);
 479                                         }
 480                                 }
 481
 482                                 return deserialized;
 483                         }
 484
 485                         public override ICollection Errors {
 486                                 get {
 487                                         if (_errors == null)
 488                                                 _errors = new object[0];
 489                                         return _errors;
 490                                 }
 491                         }
 492                 } // CodeDomSerializationStore
 493
 494                 private IServiceProvider _provider;
 495
 496                 public CodeDomComponentSerializationService () : this (null)
 497                 {
 498                 }
 499
 500                 public CodeDomComponentSerializationService (IServiceProvider provider)
 501                 {
 502                         _provider = provider;
 503                 }
 504
 505                 public override SerializationStore CreateStore ()
 506                 {
 507                         return new CodeDomSerializationStore (_provider);
 508                 }
 509
 510                 public override SerializationStore LoadStore (Stream stream)
 511                 {
 512                         return CodeDomSerializationStore.Load (stream);
 513                 }
 514
 515                 public override ICollection Deserialize (SerializationStore store)
 516                 {
 517                         return this.Deserialize (store, null);
 518                 }
 519
 520                 public override ICollection Deserialize (SerializationStore store, IContainer container)
 521                 {
 522                         return DeserializeCore (store, container, true, true);
 523                 }
 524
 525                 public override void DeserializeTo (SerializationStore store, IContainer container, bool validateRecycledTypes, bool applyDefaults)
 526                 {
 527                         DeserializeCore (store, container, validateRecycledTypes, applyDefaults);
 528                 }
 529
 530                 private ICollection DeserializeCore (SerializationStore store, IContainer container, bool validateRecycledTypes,
 531                                                      bool applyDefaults)
 532                 {
 533                         CodeDomSerializationStore codeDomStore = store as CodeDomSerializationStore;
 534                         if (codeDomStore == null)
 535                                 throw new InvalidOperationException ("store type unsupported");
 536                         return codeDomStore.Deserialize (_provider, container, validateRecycledTypes, applyDefaults);
 537                 }
 538
 539                 public override void Serialize (SerializationStore store, object value)
 540                 {
 541                         SerializeCore (store, value, false);
 542                 }
 543
 544                 public override void SerializeAbsolute (SerializationStore store, object value)
 545                 {
 546                         SerializeCore (store, value, true);
 547                 }
 548
 549                 public override void SerializeMember (SerializationStore store, object owningObject, MemberDescriptor member)
 550                 {
 551                         SerializeMemberCore (store, owningObject, member, false);
 552                 }
 553
 554                 public override void SerializeMemberAbsolute (SerializationStore store, object owningObject, MemberDescriptor member)
 555                 {
 556                         SerializeMemberCore (store, owningObject, member, true);
 557                 }
 558
 559                 private void SerializeCore (SerializationStore store, object value, bool absolute)
 560                 {
 561                         if (value == null)
 562                                 throw new ArgumentNullException ("value");
 563                         if (store == null)
 564                                 throw new ArgumentNullException ("store");
 565
 566                         CodeDomSerializationStore codeDomStore = store as CodeDomSerializationStore;
 567                         if (store == null)
 568                                 throw new InvalidOperationException ("store type unsupported");
 569
 570                         codeDomStore.AddObject (value, absolute);
 571                 }
 572
 573                 private void SerializeMemberCore (SerializationStore store, object owningObject, MemberDescriptor member, bool absolute)
 574                 {
 575                         if (member == null)
 576                                 throw new ArgumentNullException ("member");
 577                         if (owningObject == null)
 578                                 throw new ArgumentNullException ("owningObject");
 579                         if (store == null)
 580                                 throw new ArgumentNullException ("store");
 581
 582                         CodeDomSerializationStore codeDomStore = store as CodeDomSerializationStore;
 583                         if (codeDomStore == null)
 584                                 throw new InvalidOperationException ("store type unsupported");
 585                         codeDomStore.AddMember (owningObject, member, absolute);
 586                 }
 587         }
 588 }
 589 #endif