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 ();
}
}
void WriteWorkspaceItem (FilePath actualFile, FilePath outFile, WorkspaceItem item, IProgressMonitor monitor)
{
Workspace ws = item as Workspace;
if (ws != null) {
monitor.BeginTask (null, ws.Items.Count);
try {
foreach (WorkspaceItem it in ws.Items) {
it.Save (monitor);
monitor.Step (1);
}
} finally {
monitor.EndTask ();
}
}
StreamWriter sw = new StreamWriter (outFile);
try {
monitor.BeginTask (GettextCatalog.GetString ("Saving item: {0}", actualFile), 1);
XmlTextWriter tw = new XmlTextWriter (sw);
tw.Formatting = Formatting.Indented;
XmlDataSerializer ser = new XmlDataSerializer (MD1ProjectService.DataContext);
ser.SerializationContext.BaseFile = actualFile;
ser.SerializationContext.ProgressMonitor = monitor;
ser.Serialize (sw, item, typeof(WorkspaceItem));
} catch (Exception ex) {
monitor.ReportError (GettextCatalog.GetString ("Could not save item: {0}", actualFile), ex);
throw;
} finally {
monitor.EndTask ();
sw.Close ();
}
}
internal static Repository InternalGetRepositoryReference (string path, string id)
{
string file = Path.Combine (path, id) + ".mdvcs";
if (!File.Exists (file))
return null;
XmlDataSerializer ser = new XmlDataSerializer (dataContext);
XmlTextReader reader = new XmlTextReader (new StreamReader (file));
try {
return (Repository) ser.Deserialize (reader, typeof(Repository));
} finally {
reader.Close ();
}
}
static VersionControlConfiguration GetConfiguration ()
{
if (configuration == null) {
if (File.Exists (ConfigFile)) {
try {
XmlDataSerializer ser = new XmlDataSerializer (dataContext);
using (var reader = File.OpenText (ConfigFile))
configuration = (VersionControlConfiguration) ser.Deserialize (reader, typeof (VersionControlConfiguration));
} catch {
((FilePath) ConfigFile).Delete ();
}
}
if (configuration == null)
configuration = new VersionControlConfiguration ();
}
return configuration;
}
static void OnWorkspaceItemLoaded (object sender, WorkspaceItemEventArgs e)
{
string fileToLoad = GetUserTasksFilename (e.Item);
userTasks.BeginTaskUpdates ();
try {
// Load User Tasks from xml file
if (File.Exists (fileToLoad)) {
XmlDataSerializer serializer = new XmlDataSerializer (new DataContext ());
List<Task> ts = (List<Task>) serializer.Deserialize (fileToLoad, typeof(List<Task>));
foreach (Task t in ts) {
t.WorkspaceObject = e.Item;
userTasks.Add (t);
}
}
}
catch (Exception ex) {
LoggingService.LogWarning ("Could not load user tasks: " + fileToLoad, ex);
}
finally {
userTasks.EndTaskUpdates ();
}
}
internal static void SaveUserTasks (IWorkspaceObject item)
{
string fileToSave = GetUserTasksFilename ((WorkspaceItem)item);
try {
List<Task> utasks = new List<Task> (userTasks.GetItemTasks (item, true));
if (utasks.Count == 0) {
if (File.Exists (fileToSave))
File.Delete (fileToSave);
} else {
XmlDataSerializer serializer = new XmlDataSerializer (new DataContext ());
serializer.Serialize (fileToSave, utasks);
}
} catch (Exception ex) {
LoggingService.LogWarning ("Could not save user tasks: " + fileToSave, ex);
}
}
internal static ComponentIndex Load ()
{
if (!File.Exists (ToolboxIndexFile))
return new ComponentIndex ();
XmlDataSerializer ser = new XmlDataSerializer (IdeApp.Services.ProjectService.DataContext);
try {
using (StreamReader sr = new StreamReader (ToolboxIndexFile)) {
return (ComponentIndex) ser.Deserialize (sr, typeof(ComponentIndex));
}
}
catch (Exception ex) {
// Ignore exceptions
LoggingService.LogError (ex.ToString ());
return new ComponentIndex ();
}
}
public static void SaveConfiguration ()
{
if (configuration != null) {
XmlDataSerializer ser = new XmlDataSerializer (dataContext);
using (var tw = new XmlTextWriter (File.CreateText (ConfigFile))) {
tw.Formatting = Formatting.Indented;
ser.Serialize (tw, configuration, typeof (VersionControlConfiguration));
}
}
}
public void Save ()
{
XmlDataSerializer ser = new XmlDataSerializer (IdeApp.Services.ProjectService.DataContext);
try {
using (StreamWriter sw = new StreamWriter (ToolboxIndexFile)) {
ser.Serialize (sw, this, typeof(ComponentIndex));
}
}
catch (Exception ex) {
// Ignore exceptions
LoggingService.LogError (ex.ToString ());
}
}
internal static void InternalStoreRepositoryReference (Repository repo, string path, string id)
{
string file = Path.Combine (path, id) + ".mdvcs";
XmlDataSerializer ser = new XmlDataSerializer (dataContext);
XmlTextWriter tw = new XmlTextWriter (new StreamWriter (file));
try {
ser.Serialize (tw, repo, typeof(Repository));
} finally {
tw.Close ();
}
}
void WriteProject (FilePath actualFile, FilePath outFile, Project project, IProgressMonitor monitor)
{
StreamWriter sw = new StreamWriter (outFile);
try {
monitor.BeginTask (GettextCatalog.GetString("Saving project: {0}", actualFile), 1);
XmlDataSerializer ser = new XmlDataSerializer (MD1ProjectService.DataContext);
ser.SerializationContext.BaseFile = actualFile;
ser.SerializationContext.ProgressMonitor = monitor;
ser.Serialize (sw, project, typeof(Project));
} catch (Exception ex) {
monitor.ReportError (GettextCatalog.GetString ("Could not save project: {0}", actualFile), ex);
throw;
} finally {
monitor.EndTask ();
sw.Close ();
}
}
