Serializing an object but none of its references c#

Question

Hi,

I have a situation where I need to serialize an object but don't want to serialize any of its references. This is because I don't know in advance which dlls the object might be referencing and therefore can't ensure that they are serializable objects. This has arisen from needing to serialise plugins to preserve their state.

Am I right in thinking that this is the case with XML serialization (shallow)? But that this will ignore anything private in the object - which isn't what I want?

Is this somehow possible?

Answer 1

If you know at the type declaration time which references should not be serialized you can use binary serialization and filter out members with the [NonSerialized] attribute.

Answer 2

Xml Serialization will only work on things that are publicly accessible. Also, unless you mark a public property / field with the [XmlIgnore] attribute, it will be serialized.

If you're just looking at some method of serialization, then use binary serialization. It will serialize the internal state of the object (all fields, private or otherwise). You can use the [NonSerialized] attribute to ignore specific references if you want.

Answer 3

Put NonSerialized attribute in case of binary and XmlIgnore attribute in case of xml serialization to reference properties or fields

Answer 4

You do know which properties you can serialize, though, correct? Are these plugins implementing a common interface? If that is the case, you should be able to write a generic serializer that will only serialize the specific properties that you choose.

Here is a basic example that will give you the idea of what you need to do: Object Serialization using C#

If you are just looking to serialize native types within your class instances, you should just be able to implement ISerializable, though, and decorate the properties that you do not want to be serialized.

Answer 5

You can try something like this:

Type myType = currentObject.GetType();

Then check to see if the object is serializable by using:

myType.IsSerializable; //returns a bool

That should tell you whether or not the object is serializable. If you really need to know whether every single object inside of a class is serializable, such as other nested classes or custom types, then you could probably use reflection to read each object, use the code above, and verify whether or not it is serializable. This, however, might be a more complicated approach, and may not be plausible, especially if you have overhead issues to deal with.

Answer 6

It may be useful for you to separate what you want to persist from how you persist it.

It seems like you want control over how you want to persist data, but obviously, cannot know what it is, because of your plugin model.

One scheme that may make sense to you is to give your plugins some sort of object or interface they can write to and read from when its time to save / load. Its fine to document these constraints.

For example, when persisting, allow your plugins to pass to you:

1. some arbitrary byte array which they are responsible for serializing / deserializing. Then it is a plugins responsibility to make sure they use objects that are appropriately serializable.
2. a dictionary of strings
3. an xml file
4. others...

Store this information per plugin (in whichever form you want), and loading up again, pass back the same information.

This is simply an approach around the fact that in the end, the plugin knows what it needs to save, and needs to own that piece of information.