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