public void SerializationDoubleRoundtrip ()
		{
			var bag = new PropertyBag ();
			var t = new SerializableObject {
				SomeValue = "test1"
			};
			bag.SetValue ("foo", t);

			var w = new StringWriter ();
			var ser = new XmlDataSerializer (new DataContext ());
			ser.Serialize (w, bag);
			var data = w.ToString ();

			SerializableObject.CreationCount = 0;

			bag = ser.Deserialize<PropertyBag> (new StringReader (data));

			// SerializableObject is not instantiated if not queried
			Assert.AreEqual (0, SerializableObject.CreationCount);

			w = new StringWriter ();
			ser.Serialize (w, bag);
			data = w.ToString ();

			bag = ser.Deserialize<PropertyBag> (new StringReader (data));

			// SerializableObject is not instantiated if not queried
			Assert.AreEqual (0, SerializableObject.CreationCount);

			t = bag.GetValue<SerializableObject> ("foo");
			Assert.NotNull (t);
			Assert.AreEqual ("test1", t.SomeValue);
		}

		public void SaveContents (string fileName)
		{
			using (StreamWriter writer = new StreamWriter (fileName)) {
				XmlDataSerializer serializer = new XmlDataSerializer (MonoDevelop.Projects.Services.ProjectService.DataContext);
				serializer.Serialize (writer, this);
			}
		}

		public TargetFramework CreateFramework ()
		{
			Stream s;
			if (SystemAssemblyService.UseExpandedFrameworksFile) {
				if (resource != null)
					s = Addin.GetResource (resource);
				else if (file != null)
					s = File.OpenRead (Addin.GetFilePath (file));
				else
					throw new InvalidOperationException ("Framework xml source not specified");
			}
			else {
				string file = System.IO.Path.Combine (SystemAssemblyService.ReferenceFrameworksPath, resource);
				Console.WriteLine ("Loading framework file: " + file);
				s = File.OpenRead (file);
			}
			
			using (s) {
				XmlTextReader reader = new XmlTextReader (s);
				XmlDataSerializer ser = new XmlDataSerializer (new DataContext ());
				TargetFramework fx = (TargetFramework) ser.Deserialize (reader, typeof(TargetFramework));
				fx.FrameworkNode = this;
				return fx;
			}
		}

        public static object DeserializeString(string XMLString, Type serType)
        {
            context.IncludeType (serType);

            XmlDataSerializer ser = new XmlDataSerializer (context);

            TextReader serReader = new StringReader (XMLString);
            return ser.Deserialize (serReader, serType);
        }

 public static void SaveConfig ()
 {
     if (configuration != null) {
         XmlDataSerializer s = new XmlDataSerializer (dataContext);
         using (var wr = new XmlTextWriter (File.CreateText (ConfigFile))) {
             wr.Formatting = Formatting.Indented;
             s.Serialize (wr, configuration, typeof(AddinConfig)); 
         }
     }
 }

		public static ToolboxConfiguration LoadFromFile (string fileName)
		{
			object o;
			
			using (StreamReader reader = new StreamReader (fileName))
			{
				XmlDataSerializer serializer = new XmlDataSerializer (MonoDevelop.Projects.Services.ProjectService.DataContext);
				o = serializer.Deserialize (reader, typeof (ToolboxConfiguration));	
			}
			return (ToolboxConfiguration) o;			
		}

		public XmlElement Write ()
		{
			XmlDataSerializer ser = new XmlDataSerializer (new DataContext ());
			ser.Namespace = MSBuildProject.Schema;
			var sw = new StringWriter ();
			ser.Serialize (new XmlTextWriter (sw), this);
			XmlDocument doc = new XmlDocument ();
			doc.LoadXml (sw.ToString ());
			var elem = doc.DocumentElement;
			doc.RemoveChild (elem);
			return elem;
		}

		static void SaveConfig ()
		{
			try {
				XmlDataSerializer ser = new XmlDataSerializer (new DataContext ());
				StreamWriter sw = new StreamWriter (configFile);
				using (sw) {
					ser.Serialize (new XmlTextWriter (sw), config, typeof(AddinAuthoringServiceConfig));
				}
			}
			catch (Exception ex) {
				LoggingService.LogError ("Could not save add-in authoring service configuration", ex);
			}
		}

		public static LinuxDeployData GetLinuxDeployData (Project entry)
		{
			LinuxDeployData data = (LinuxDeployData) entry.ExtendedProperties ["Deployment.LinuxDeployData"];
			if (data != null)
				return data;
			
			var elem = entry.MSBuildProject.GetMonoDevelopProjectExtension ("Deployment.LinuxDeployData");
			if (elem != null) {
				XmlDataSerializer ser = new XmlDataSerializer (new DataContext ());
				data = (LinuxDeployData) ser.Deserialize (new XmlNodeReader (elem), typeof(LinuxDeployData));
			} else {
				data = CreateDefault (entry);
			}
			data.entry = entry;
			entry.ExtendedProperties ["Deployment.LinuxDeployData"] = data;
			return data;
		}

		public TargetFramework CreateFramework ()
		{
			Stream s;
			if (resource != null)
				s = Addin.GetResource (resource);
			else if (file != null)
				s = File.OpenRead (Addin.GetFilePath (file));
			else
				throw new InvalidOperationException ("Framework xml source not specified");
			
			using (s) {
				XmlTextReader reader = new XmlTextReader (s);
				XmlDataSerializer ser = new XmlDataSerializer (new DataContext ());
				TargetFramework fx = (TargetFramework) ser.Deserialize (reader, typeof(TargetFramework));
				fx.FrameworkNode = this;
				return fx;
			}
		}

		void LoadViews ()
		{
			try {
				XmlDataSerializer ser = new XmlDataSerializer (new DataContext ());
				FilePath file = ConfigFile;
				if (System.IO.File.Exists (file)) {
					views = (List<ChartView>) ser.Deserialize (file, typeof (List<ChartView>));
					UpdateViews ();
					return;
				}
			} catch (Exception ex) {
				LoggingService.LogError ("Error while loading monitor-views.xml", ex);
			}
			views = new List<ChartView> ();
			ChartView v = new ChartView ();
			v.Name = "Default";
			views.Add (v);
			UpdateViews ();
		}

		WorkspaceItem ReadWorkspaceItemFile (FilePath fileName, ProgressMonitor monitor)
		{
			XmlTextReader reader = new XmlTextReader (new StreamReader (fileName));
			try {
				monitor.BeginTask (string.Format (GettextCatalog.GetString ("Loading workspace item: {0}"), fileName), 1);
				reader.MoveToContent ();
				XmlDataSerializer ser = new XmlDataSerializer (MD1ProjectService.DataContext);
				ser.SerializationContext.BaseFile = fileName;
				ser.SerializationContext.ProgressMonitor = monitor;
				WorkspaceItem entry = (WorkspaceItem)ser.Deserialize (reader, typeof(WorkspaceItem));
				entry.FileName = fileName;
				return entry;
			} catch (Exception ex) {
				monitor.ReportError (string.Format (GettextCatalog.GetString ("Could not load solution item: {0}"), fileName), ex);
				throw;
			} finally {
				monitor.EndTask ();
				reader.Close ();
			}
		}

        public static string SerializeObjectToString(object o)
        {
            LogUtil log = new LogUtil ("Util.Serialization");
            // log.DEBUG("Serializing - " + o.ToString());
            //StringBuilder resultString;
            context.IncludeType (o.GetType ());

            XmlDataSerializer ser = new XmlDataSerializer (context);
            //XmlTextWriter xtw = new XmlTextWriter(Console.Out);
            TextWriter serWriter = new StringWriter ();
            XmlTextWriter xtw = new XmlTextWriter (serWriter);

            ser.Serialize (xtw, o);
            string serializedString = serWriter.ToString ();
            //serializedString = serReader.ReadToEnd();

            //log.DEBUG("The serialized string is - " + serializedString);

            return serializedString;
        }

		static AddinAuthoringService ()
		{
			if (IdeApp.IsInitialized) {
				IdeApp.ProjectOperations.EndBuild += OnEndBuild;
			}
			
			configFile = Path.Combine (PropertyService.ConfigPath, "AddinAuthoring.config");
			if (File.Exists (configFile)) {
				try {
					XmlDataSerializer ser = new XmlDataSerializer (new DataContext ());
					StreamReader sr = new StreamReader (configFile);
					using (sr) {
						config = (AddinAuthoringServiceConfig) ser.Deserialize (new XmlTextReader (sr), typeof(AddinAuthoringServiceConfig));
					}
				}
				catch (Exception ex) {
					LoggingService.LogError ("Could not load add-in authoring service configuration", ex);
				}
			}
			if (config == null)
				config = new AddinAuthoringServiceConfig ();
		}

 private static AddinConfig GetConfig ()
 {
     if (configuration != null) {
         return configuration;
     }
     if (File.Exists (ConfigFile)) {
         try {
             XmlDataSerializer s = new XmlDataSerializer (dataContext);
             using (var reader = File.OpenText (ConfigFile)) {
                 configuration = (AddinConfig)s.Deserialize (reader, typeof(AddinConfig));
             }
         } catch {
             ((FilePath)ConfigFile).Delete ();
         }
     }
     if (configuration == null) {
         configuration = new AddinConfig ();
     }
     return configuration;
 }

		public void SaveViews ()
		{
			try {
				XmlDataSerializer ser = new XmlDataSerializer (new DataContext ());
				ser.Serialize (ConfigFile, views);
			} catch (Exception ex) {
				LoggingService.LogError ("Error while saving monitor-views.xml", ex);
			}
		}

		public static void SaveConfiguration ()
		{
			if (configuration != null) {
				XmlDataSerializer ser = new XmlDataSerializer (dataContext);
				XmlTextWriter tw = new XmlTextWriter (new StreamWriter (ConfigFile));
				tw.Formatting = Formatting.Indented;
				try {
					ser.Serialize (tw, configuration, typeof (VersionControlConfiguration));
				} finally {
					tw.Close ();
				}
			}
		}

		static VersionControlConfiguration GetConfiguration ()
		{
			if (configuration == null) {
				if (File.Exists (ConfigFile)) {
					XmlDataSerializer ser = new XmlDataSerializer (dataContext);
					XmlTextReader reader = new XmlTextReader (new StreamReader (ConfigFile));
					try {
						configuration = (VersionControlConfiguration) ser.Deserialize (reader, typeof (VersionControlConfiguration));
					} finally {
						reader.Close ();
					}
				}
				if (configuration == null)
					configuration = new VersionControlConfiguration ();
			}
			return configuration;
		}

		public object ReadFile (FilePath fileName, Type expectedType, IProgressMonitor monitor)
		{
			object readObject = null;
			
			ProjectExtensionUtil.BeginLoadOperation ();
			try {
				string ext = Path.GetExtension (fileName).ToLower ();
				
				if (ext == ".mdp") {
					object project = ReadProjectFile (fileName, monitor);
					if (project is DotNetProject)
						((DotNetProject)project).SetItemHandler (new MD1DotNetProjectHandler ((DotNetProject) project));
					readObject = project;
				}
				else if (ext == ".mds") {
					readObject = ReadCombineFile (fileName, monitor);
				}
				else if (ext == ".mdw") {
					readObject = ReadWorkspaceItemFile (fileName, monitor);
				}
				else {
					XmlTextReader reader = new XmlTextReader (new StreamReader (fileName));
					try {
						monitor.BeginTask (string.Format (GettextCatalog.GetString ("Loading solution item: {0}"), fileName), 1);
						reader.MoveToContent ();
						XmlDataSerializer ser = new XmlDataSerializer (MD1ProjectService.DataContext);
						ser.SerializationContext.BaseFile = fileName;
						ser.SerializationContext.ProgressMonitor = monitor;
						SolutionEntityItem entry = (SolutionEntityItem) ser.Deserialize (reader, typeof(SolutionEntityItem));
						entry.FileName = fileName;
						MD1ProjectService.InitializeHandler (entry);
						readObject = entry;
					}
					catch (Exception ex) {
						monitor.ReportError (string.Format (GettextCatalog.GetString ("Could not load solution item: {0}"), fileName), ex);
						throw;
					}
					finally {
						monitor.EndTask ();
						reader.Close ();
					}
				}
			} finally {
				ProjectExtensionUtil.EndLoadOperation ();
			}
			
			IWorkspaceFileObject fo = readObject as IWorkspaceFileObject;
			if (fo != null)
				fo.ConvertToFormat (MD1ProjectService.FileFormat, false);
			return readObject;
		}

		void WriteSolutionEntityItem (FilePath actualFile, FilePath outFile, object node, IProgressMonitor monitor)
		{
			StreamWriter sw = new StreamWriter (outFile);
			try {
				monitor.BeginTask (string.Format (GettextCatalog.GetString("Saving solution item: {0}"), actualFile), 1);
				XmlDataSerializer ser = new XmlDataSerializer (MD1ProjectService.DataContext);
				ser.SerializationContext.BaseFile = actualFile;
				ser.SerializationContext.ProgressMonitor = monitor;
				ser.Serialize (sw, node, typeof(SolutionEntityItem));
			} catch (Exception ex) {
				monitor.ReportError (string.Format (GettextCatalog.GetString ("Could not save solution item: {0}"), actualFile), ex);
			} finally {
				monitor.EndTask ();
				sw.Close ();
			}
		}