Serialization into the registry - Testers wanted

Hi there,

I have been writing a small program that will serialize objects into the registry. It would be good if some one could test it and recommend any improvements. Also if there is a simple way of doing this by using existing serialization methods i would appreciate the information.

Code:

---

using System;
using Microsoft.Win32;
using System.Reflection;
using System.Collections;

namespace MyDefaultNamespace.RegistrySerializer
{
        class RegistrySerializer
        {
                private Hashtable reflectedObjects;
                private Type _type;

                [STAThread]
                static void Main(string[] args)
                {
                        RegistryKey key = Registry.CurrentUser.CreateSubKey("Software").CreateSubKey("Demo Application");
                        RegistrySerializer s = new RegistrySerializer(typeof(test));
                        s.Serialize(new test(),key);
                        RegistryNodeCollection c = new RegistryNodeCollection();
                }

                public RegistrySerializer(Type type)
                {
                        reflectedObjects = new Hashtable();
                        _type = type;
                }

                public void Serialize(object o, RegistryKey key)
                {
                        if(key.OpenSubKey(o.GetType().FullName) != null)
                        {
                                key.DeleteSubKeyTree(o.GetType().FullName);
                        }

                        RegistryNode n = new RegistryNode(string.Empty);
                        reflectedObjects.Clear();

                        SerializeMember(o,string.Empty,n);
                        n.Name = o.ToString();
                        n.IsKey = true;
                        PersistData(n,key);
                }

                public void PersistData(RegistryNode node,RegistryKey key)
                {
                        if(node.IsKey)
                        {
                                key = key.CreateSubKey(node.Name);
                        }
                        else
                        {
                                key.SetValue(node.Name,node.Value);
                        }
                        foreach(RegistryNode n in node.Nodes.Nodes)
                        {
                                PersistData(n,key);
                        }
                }

                void SerializeMember(object  o, string name, RegistryNode n)
                {
                        if (o == null)
                                return;

                        Type type = o.GetType();

                        if (!type.Equals(typeof(string)) && !type.IsValueType)
                        {

                                if (reflectedObjects.Contains(o) == true)
                                {
                                        n.Value = reflectedObjects[o];
                                        return;
                                }

                                reflectedObjects.Add(o, "{" + n.Name + " : " + o.ToString() + "}");

                                MemberInfo[] members = type.GetMembers(BindingFlags.Public | BindingFlags.Instance  | BindingFlags.DeclaredOnly);

                                for(int i = 0; members != null && i < members.Length; i++)
                                {
                                        n.IsKey = true;
                                        MemberInfo member = members[i];
                                       
                                        RegistryNode nn;
                                        object oChild;

                                        switch(member.MemberType)
                                        {
                                                case MemberTypes.Field:
                                                        nn = new RegistryNode(member.Name);
                                                        n.Nodes.Add(nn);
                                                        nn.IsKey = false;
                                                        oChild = ((FieldInfo) member).GetValue(o);

                                                        ParseCollectionMember(oChild, nn);

                                                        if (oChild != null)
                                                                SerializeMember(oChild, member.Name,nn);

                                                        break;
                                                case MemberTypes.Property:
                                                       
                                                        PropertyInfo property = (PropertyInfo) member;
                                                        if (!property.CanRead)
                                                                break;
                                                        nn = new RegistryNode(member.Name);
                                                        nn.IsKey = false;
                                                        n.Nodes.Add(nn);

                                                        ParameterInfo[] parameters =  property.GetIndexParameters();

                                                        if (property.GetIndexParameters() == null || parameters.Length == 0)
                                                        {
                                                                oChild = property.GetValue(o, null);

                                                                ParseCollectionMember(oChild, nn);

                                                                if (oChild != null)
                                                                        SerializeMember(oChild, member.Name,nn);
                                                        }
                                                        break;
                                        }
                               
                                }
                        }
                        else
                        {
                                if (o is DateTime)
                                {
                                        n.Value = o;
                                }
                                else
                                {
                                        n.Value = o;
                                }
                        }
                }

                void ParseCollectionMember(object oChild,RegistryNode n)
                {
                        IEnumerable enumerable;
                        int j;

                        if (oChild is IEnumerable && !(oChild is string))
                        {
                                RegistryNode nnn = new RegistryNode(oChild.GetType().FullName);
                                nnn.IsKey = true;
                                n.Nodes.Add(nnn);
                                enumerable = (IEnumerable) oChild;
                                j = 0;

                                foreach (object obj in enumerable)
                                {
                                        RegistryNode nn = new RegistryNode("[" + j.ToString() + "]");
                                        nn.IsKey = false;
                                        nnn.Nodes.Add(nn);

                                        SerializeMember(obj, string.Empty,nn);
                                        j++;
                                }
                        }
                }
        }

        public class RegistryNode
        {
                private string _strName;
                private object _obj;
                private RegistryNodeCollection _nodes;
                private bool _bIsKey;

                public RegistryNode(string name)
                {
                        _strName = name;
                        _obj = null;
                        _nodes = new RegistryNodeCollection();
                }

                public bool IsKey
                {
                        get{return _bIsKey;}
                        set{_bIsKey = value;}
                }

                public string Name
                {
                        get{return _strName;}
                        set{_strName = value;}
                }
               
                public object Value
                {
                        get{return _obj;}
                        set{_obj = value;}
                }
               
                public RegistryNodeCollection Nodes
                {
                        get{return _nodes;}
                        set{_nodes = value;}
                }
        }

        public class RegistryNodeCollection
        {
                private ArrayList _arrayNodes;

                public RegistryNodeCollection()
                {
                        _arrayNodes = new ArrayList();
                }

                public int Add(RegistryNode node)
                {
                        return _arrayNodes.Add(node);
                }

                public ArrayList Nodes
                {
                        get{return _arrayNodes;}
                        set{_arrayNodes = value;}
                }
        }

        public class test
        {
                public string message;
                private OtherObject[] oo;
               

                public test()
                {
                        message = "Please test this";
                        oo = new OtherObject[2];
                        oo.SetValue(new OtherObject(10,"Luke Skywalker"),0);
                        oo.SetValue(new OtherObject(20,"Han Solo"),1);
                }

                public char[] chararray
                {
                        get{return message.ToCharArray();}
                }

                public OtherObject[] OO
                {
                        get{return oo;}
                        set{oo = value;}
                }

                public DateTime datetest
                {
                        get{return DateTime.Now;}
                }

                public int IntegerValue
                {
                        get{return int.MaxValue;}
                }
        }

        public class OtherObject
        {
                public string objectname;
                public int age;

                public OtherObject()
                {
                }

                public OtherObject(int a, string n)
                {
                        objectname = n;
                        age = a;
                }

        }
}

---

Thanks Rohan :afrog: