» serialization
This site relies heavily on Javascript. You should enable it if you want the full experience. Learn more.

serialization

acl(devvvv)

Serialization is a method to save objects from memory to the hard disk and deserialization is the way back from hard disk to memory. There are several implementations of serializers in .NET, ranging from simple XML to binary output. VVVV uses XML serialization based on the XElement type from System.Xml.Linq, which represents an XML tag.

Serializer Interface

For reasons of code clarity and human readability of the XML output we use our own serialization method, which is basically an interface with two methods:

public interface ISerializer
    {
        XElement Serialize(object value, Serializer serializer);
        object Deserialize(XElement data, Type type, Serializer serializer);
    }

As the type of the object to serialize/desrialize is most of the time known on compile time there is also a generic version of the interface which is commonly used:

public interface ISerializer<T>
    {
        XElement Serialize(T value, Serializer serializer);
        T Deserialize(XElement data, Type type, Serializer serializer);
    }

Global Serializer

The second important part of our serialization method is a global Serializer object. This global serializer knows all registered specific serializers and it also uses the .Net binary serializer to serialize all .Net types which are serializable by default. It is passed to each Serialize/Deserialize method, so that the writer of a serializer can serialize/deserialize objects of other types that may already have a registered serializer. The global serializer has a few methods to register specific Serializers and to serialize/deserialize objects:

//register specific serializer
public void Register<TSource, TDest>() where TDest : ISerializer
public void RegisterGeneric<TSource, TDest>() where TDest : ISerializer<TSource>
public void Register(Type sourceType, Type serializerType)
 
//serialize
public XElement Serialize(object value)
 
//deserialize
public T Deserialize<T>(XElement data, Type type)
public T Deserialize<T>(XElement data)
public object Deserialize(XElement data, Type type)

Writing a Serializer

To write a De-/Serializer for a certain type, one has to implement one of the interfaces above. And then register the serializer. For example, lets write a serializer for a simple class Foo:

class Foo
    {
        public string Bar;
        public int Baz;
 
        public Foo(string bar, int baz)
        {
            this.Bar = bar;
            this.Baz = baz;
        }
    }

The serializer could look like this:

class FooSerializer : ISerializer<Foo>
    {
 
        public XElement Serialize(Foo value, Serializer serializer)
        {
            //create base tag
            var x = new XElement("FOO");
 
            //add tags for the fields
            var xBar = new XElement("BAR");
            var xBaz = new XElement("BAZ");
 
            xBar.Value = value.Bar;
 
            //let the serializer handle the int field
            xBaz.Add(serializer.Serialize(value.Baz));
 
            x.Add(xBar);
            x.Add(xBaz);
 
            return x;
        }
 
        public Foo Deserialize(XElement data, Type type, Serializer serializer)
        {
            var bar = data.Element("BAR").Value;
 
            //get the int field
            var baz = serializer.Deserialize<int>(data.Element("BAZ").Element("OBJECT"));
 
            return new Foo(bar, baz);
        }
    }

Then the serializer must be registered at the global serializer, where and when this happens is application specific. Its as simple as:

GlobalSerializer.RegisterGeneric<Foo, FooSerializer>();

Then the it can be used to serialize/deserialize a Foo object:

//serialize
var foo = new Foo("Hallo serializer", 100);
var xml = GlobalSerializer.Serialize(foo);
xml.Save(@"c:\temp\Foo.xml");
 
//deserialize
var xml = XElement.Load(@"c:\temp\Foo.xml");
var foo = GlobalSerializer.Deserialize<Foo>(xml);

The resulting XML will lool like:

<FOO>
  <BAR>Hallo serializer</BAR>
  <BAZ>
    <OBJECT Type="System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral,
PublicKeyToken=b77a5c561934e089">100</OBJECT>
  </BAZ>
</FOO>

anonymous user login

Shoutbox

~3d ago

joreg: Workshop on 22 02: Unlocking Shader Artistry: A Journey through ‘The Book of Shaders’ with FUSE. Signup here: https://thenodeinstitute.org/courses/ws23-vvvv-12-book-of-shaders/

~15d ago

joreg: Talk and Workshop on February 15 & 16 in Frankfurt: https://visualprogramming.net/blog/vvvv-at-node-code-frankfurt/

~16d ago

woei: @Joanie_AntiVJ: think so, looks doable

~17d ago

xd_nitro: Anyone remember who increased projector brightness by removing some components that product the color?

~17d ago

Joanie_AntiVJ: This looks super interesting (vectors over network) would anyone here know how to implement this in beta? https://github.com/madmappersoftware/Ponk

~24d ago

joreg: Workshop on 01 02: Data Sensing and Logging with Arduino Signup here: https://thenodeinstitute.org/courses/ws23-vvvv-09-data-sensing-and-logging-with-arduino-and-vvvv/

~29d ago

domj: I've added myself to vvvv specialists available for hire See at the bottom, lmk if you want to collab or in need of tutoring! ❤️

~1mth ago

joreg: Workshop on 25.01: Create Sequencers and Precise Clock Based Tools. Signup here: https://thenodeinstitute.org/courses/ws23-vvvv-08-create-sequencers-and-precise-clock-based-tools-in-vvvv-gamma/