Architecture and method for serialization and deserialization of objects

• US 6,928,488 B1
• Filed: 06/27/2001
• Issued: 08/09/2005
• Est. Priority Date: 06/27/2001
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Kakivaya, Gopala Krishna R., de Jong, Stephen Peter, Roxe, Joseph L.
• Primary Examiner(s): HARRELL, ROBERT B
• Application Number:
  US09/893,031
• Time in Patent Office: 1,504 Days
• Field of Search: 709/246, 709/200, 717/100, 717/106, 717/108
• US Class Current: 709/246
• CPC Class Codes: G06F 9/4493 Object persistence

Abstract

An architecture and method is provided that facilitates serialization of a graph of objects into streams of data in an arbitrary format, and deserialization of the streams of data back into the graph of objects. The architecture provides a number of services associated with the basic functionality of serialization and deserialization. The services can be employed to implement transparent remoting, copy items to a clipboard and save data to a file. The present invention provides facilities which support the plugging in of a new serialization encoding by separating the encoding from the reading and reinstantiation of the graph of objects which the encoding describes. Objects in a graph of objects are serialized and deserialized based on a selected rule set for that object. A rule set can be provided by a class author within a class or within a third party file referred to as a surrogate.

Claims

1. A serialization and deserialization architecture, comprising:

a serialization and deserialization portion adapted to provide serialization information on a data structure;

a pluggable formatter adapted to receive the serialization information and provide a serialized stream in an externalized format defined by the pluggable formatter; and

a utility and contract portion adapted to maintain invariants with serializing and deserializing of the data structure.

2. The architecture of claim 1, the serialization and deserialization portion employing a rule set to define the serialization information to be provided to the pluggable formatter.

3. The architecture of claim 2, the rule set specifying a different data structure to be serialized.

4. The architecture of claim 3, the different data structure being a reference data structure type containing information about the data structure.

5. The architecture of claim 3, the different data structure being a remote object type.

6. The architecture of claim 2, the rule set being provided in the data structure.

7. The architecture of claim 2, the rule set being provided in a third party file.

8. The architecture of claim 1, the pluggable formatter adapted to receive the serialized stream of the data structure and decode the serialized stream and the utility and contract portion to provide a data structure type for deserializing data from the serialized stream, the pluggable formatter and the utility and contract portion working in conjunction to populate the data structure type with the data from the serialized stream utilizing the serialization information.

9. The architecture of claim 8, the utility and contract portion further adapted to track data structures and provide fixups due to forward references.

10. The architecture of claim 8, the utility and contact portion further adapted to swap a reference data structure type with an actual data structure.

11. The architecture of claim 1, the data structure being an object.

12. The architecture of claim 1, the data structure being a graph of objects.

13. The architecture of claim 1, the externalized format being XML.

14. The architecture of claim 1, the externalized format being binary.

15. An architecture for facilitate deserialization of a serial stream into a graph of objects, comprising:

a plurality of rule sets defining serialization information about object types;

a serialization selector adapted to determine a rule set of the plurality of rule sets on how an object was serialized, so that objects can be deserialized by a formatter;

a serialization binder component adapted to specify an object type for deserialization of the objects; and

an object manager adapted to manage deserialization of the objects by the formatter.

16. The architecture of claim 15, further comprising a formatter services component adapted to register the objects with the object manager as the objects are retrieved from the formatter and instantiate an object type based on the object type specified by the serialization binder component.

17. The architecture of claim 16, the formatter services component being further adapted to extract serialization information from a reference object.

18. The architect of claim 17, the object manager being further adapted to call a get real object component and insert the get real object component in place of the reference object.

19. The architecture of claim 17, the formatter services component replacing the reference object with a proxy object.

20. The architecture of claim 15, further comprising a callback interface implementable into a class, the object manager being adapted to perform fixups on the object graph after all objects in the object graph have been deserialized for objects implementing the callback interface.

21. A computer readable medium having computer executable components comprising:

a formatter programmed to serialize objects based on a rule set for an object type, the rule set being provided in either an object or a third party object;

an object manager programmed to manage the deserialization of objects by the formatter.

22. The computer readable medium of claim 21, further comprising a formatter services component adapted to receive a serialized stream of the object and instantiate a given object type for deserialization of the serialized stream.

23. The computer readable medium of claim 22, further comprising a serialization binder component adapted to determine the given object type to instantiate.

24. The computer readable medium of claim 23, the object type being one of a similar type of the object being deserialized and a different type defined by a user.

25. The computer readable medium of claim 22, the formatter services component being further adapted to create a proxy for any object reference that is derived from a marshal by reference object.

26. The computer readable medium of claim 21, the formatter having a pluggable formatter portion for providing serialization information in an external format defined by the pluggable formatter portion.

27. The computer readable medium of claim 26, the pluggable formatter portion programmed to receive a serialized stream and decode the serialized stream into a graph of objects.

28. The computer readable medium of claim 21, the formatter having a decision loop portion programmed to retrieve the object and invoke a serialization selection routine, the serialization selection routine determining serialization information on the object, the serialization information being user definable in the object through one of methods defined in a serializable interface implemented in a class, methods defined in a surrogate class provide by a user and markings provided in the object invoking a default serialization format.

29. The computer readable medium of claim 21, the object manager programmed to track forward references to additional objects of a graph of objects down stream and perform fixups to the objects upon receipt of the additional objects.

30. The computer readable medium of claim 21, the object manager retrieving a real object component for retrieving real objects for any object reference types provided in place of the real objects and placing the real object in a graph.

31. An architecture for facilitating serialization of a graph of objects into a serial stream, comprising:

a formatter having a serialization decision loop and a pluggable formatter portion, the serialization decision loop retrieving an object from a graph of objects and determining serialization information to be provided to the pluggable formatter portion, the pluggable formatter portion providing a serialized stream populated with the serialization information in an externalized format defined by the pluggable formatter portion;

a surrogate selector defining whether an object type has a surrogate that defines the serialization information to be provided to a formatter; and

a serializable interface implementable into a class type that allows a user to define the serialization information to be provided to the formatter within the class type.

32. The architecture of claim 31, further comprising an object reference interface implementable into a class, so that a user can define an object reference type to be serialized instead of objects of that type corresponding to the class.

33. The architecture of claim 32, the serializable interface allowing a user to redefine the object type to an object reference type within the class and reference a class implementing the object reference interface so that the object reference type can be serialized instead of objects of that type corresponding to the class.

34. The architecture of claim 32, further comprising a remote surrogate that provides a marshal reference object for objects that implement the marshal by reference interface.

35. The architecture of claim 31, the serialization decision loop determining whether an object type has a surrogate selector and employing the surrogate selector to retrieve a surrogate that defines the serialization information to be provided to the pluggable formatter portion for objects of that type.

36. The architecture of claim 31, the serialization decision loop determining whether the object type employs the serializable interface and employing methods of the serializable interface within the object to provide the pluggable formatter portion with the serialization information for a given object of that type.

37. The architecture of claim 31, the serialization decision loop determining whether the object type includes serializable markings and employs a default serialization routine to provide the pluggable formatter portion with the serialization information for a given object of that type.

38. The architecture of claim 31, further comprising a marshal by reference interface implementable into a class to redefine the class as a remote object.

39. The architecture of claim 31, the serialization decision loop employing an object ID generator to assign object IDs to each object in the graph of objects.

40. A system for serializing a graph of objects into a serial stream, comprising:

a plurality of rule sets defining serialization information about object types;

a serialization selector determining a rule set of the plurality of rule sets to utilize in providing the serialization information to a formatter, the plurality of rule sets comprising a first rule set that allows a user to define the serialization information to be provided in an object and a second rule set that allows a user to define the serialization information of the object in a third party object.

41. The system of claim 40, at least one of the first rule set and the second rule set allows a user to define a reference object to be serialized in place of the object.

42. The system of claim 41, the reference object contains information about the object.

43. The system of claim 41, the reference object being a marshal by reference object.

44. The system of claim 40, the first rule set allows a user to provide markings in the object, such that the first rule set provides default serialization information about the object using data in the object.

45. The system of claim 40, the first rule set allows a user to restrict the serialization information provided to the formatter.

46. A system for deserializing a serial stream into a graph of objects, comprising:

plurality of rule sets defining serialization information about an object types;

a serialization selector adapted to determine a rule set of the plurality of rule sets on how an object was serialized, so the objects can be deserialized by a formatter;

an object type service adapted to create an unitialized instance of an object type for deserialization of the object;

an object tracking service adapted to track the objects during a deserialization process and register fixups due to forward references; and

a fixup service adapted to fill in the objects with data associated with the forward references.

47. The system of claim 46, further comprising an object swapping service adapted to extract the serialization information from a reference object.

48. The system of claim 47, the object swapping service replacing the reference object with a proxy object.

49. The system of claim 47, the object swapping service replacing the reference object with an actual object relating to the serialization information extracted from the reference object.

50. A method for deserialization of a stream into a graph of objects, the method comprising:

receiving a decoded serialized stream from a pluggable formatter;

retrieving an object from the decoded serialized stream;

determining an object type for deserialization of the object;

instantiating an uninitialized instance of the object type;

selecting serialization information for the object from one of a surrogate, a serializable interface employed in the object and a default serialization routine, the selected serialization information being employed in a deserialization process;

populating the uninitialized instance of the object type based on the selected serialization information;

registering fixups for the object during the deserialization process due to forward references within the object; and

performing fixups on objects in the object graph caused by the forward references.

51. The method of claim 50, further comprising retrieving real objects for any object reference types that are provided in place of the real object and placing the real objects in the graph in place of the reference object type.

52. The method of claim 50, further comprising creating a proxy for any object reference type that is derived from a marshal by reference object.

53. A method for serialization of a graph of objects into a stream, the method comprising:

retrieving an object from the graph of objects;

assigning the object a unique identification number;

determining if a surrogate selector is associated with the object for objects of that type and employing the surrogate selector to access a surrogate defining serialization information about the object;

determining if the object employs a serializable interface if the object does not have a surrogate, and accessing the serialization information within the object if the object employs the serializable interface and employing the serialization information to determine what portion of the object will be serialized;

determining if the object has serialization markings if the object does not employ the serializable interface or the surrogate and providing a default serialization routine for providing the serialization information;

pushing the object to a data structure and populating the data structure based on the serialization information; and

serializing the data structure to an externalized format defined by a pluggable formatter.

54. The method of claim 53, the pushing the object to a data structure and populating the data structure based on the serialization information being repeated for each object in the graph of objects prior to serializing the data structure to the externalized format defined by the pluggable formatter.

55. A system for serializing and deserializing a graph of objects, comprising:

means for providing serialization information of an object to a formatter, so that the formatter can serialize the object in a selectable externalized format, the means for providing serialization information being in either the object or a third party object;

means for tracking deserialization of the object outside the formatter; and

means for instantiating an uninitialized instance of a given object type, so that object information can populate the object type.

56. The system of claim 55, further comprising means for performing fixups on objects in the graphs of objects due to forward references.