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 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 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 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));
}
}
}
static public void Serialize(IDictionary <A, B> dictionary, string filePath)
{
List <Item> itemList = new List <Item>();
foreach (A key in dictionary.Keys)
{
itemList.Add(new Item()
{
Key = key, Value = dictionary[key]
});
}
XmlDataSerializer.Serialize <List <Item> >(itemList, filePath);
}
public static string Serialize(object entity, string rootElementName, XmlSerializerSettings settings)
{
XmlDataSerializer serializer = new XmlDataSerializer(settings);
if (string.IsNullOrEmpty(rootElementName))
{
return(serializer.Serialize(entity));
}
else
{
return(serializer.Serialize(entity, rootElementName));
}
}
public static void SaveConfiguration()
{
if (configuration != null)
{
XmlDataSerializer ser = new XmlDataSerializer(dataContext);
XmlTextWriter tw = new XmlTextWriter(new StreamWriter(ConfigFile));
try {
ser.Serialize(tw, configuration, typeof(VersionControlConfiguration));
} finally {
tw.Close();
}
}
}
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);
}
}
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();
}
}
public void SerializeObject(bool serialize, int size)
{
var order = new MainDataOne();
order.Name = "Test";
var serializerTests = new XmlDataSerializer(serialize);
var data = serializerTests.Serialize(order);
var orderResult = (IMainData)serializerTests.Deserialize(typeof(MainDataOne), data);
Assert.AreNotSame(order, orderResult);
Assert.AreEqual(size, data.Length);
Assert.AreEqual("Test", orderResult.Name);
}
public async Task WhenContentIsXml_ThenReturnObj()
{
var dummy = new TestDummy {
Name = "John"
};
var xml = XmlDataSerializer.Serialize(dummy);
var sut = new StringContent(xml);
var result = await sut.ReadAsXmlAsync <TestDummy>();
Assert.That(result.Name, Is.EqualTo(dummy.Name));
}
protected override XmlDataSerializer CreateSerializer(FilePath file)
{
XmlDataSerializer serializer = base.CreateSerializer(file);
foreach (Type projectContent in ProjectFileFormat.projectContentList)
{
serializer.SerializationContext.Serializer.DataContext.IncludeType(projectContent);
}
foreach (Type dataModel in ProjectsService.Instance.DataModelManager.GetDataModelCollection())
{
serializer.SerializationContext.Serializer.DataContext.IncludeType(dataModel);
}
return(serializer);
}
static void SaveGlobalCustomExecutionModes()
{
if (globalModes == null)
{
return;
}
try {
XmlDataSerializer ser = new XmlDataSerializer(GetDataContext());
FilePath file = UserProfile.Current.ConfigDir.Combine("custom-command-modes.xml");
ser.Serialize(file, globalModes, typeof(CustomExecutionModes));
} catch (Exception ex) {
LoggingService.LogError("Could not save global custom execution modes.", ex);
}
}
public IEnumerable <T> Fetch <T>() where T : IEntity
{
var path = GetDirectory();
var serializer = new XmlDataSerializer();
return(Directory.GetFiles(path, "*.xml")
.Select(file =>
{
var content = File.ReadAllText(file, _encoding);
return new StringBuilder(content);
})
.Where(serializer.CanDeserialize <T>)
.Select(serializer.Deserialize <T>));
}
static void SaveRuntimes()
{
try
{
XmlDataSerializer ser = new XmlDataSerializer(new DataContext());
using (StreamWriter sw = new StreamWriter(configFile))
{
ser.Serialize(sw, customRuntimes);
}
}
catch
{
}
}
public string LoadItems(string asmName, string typeName, string fileName)
{
XmlDataSerializer ser = new XmlDataSerializer(MonoDevelop.Projects.Services.ProjectService.DataContext);
ToolboxList tl = new ToolboxList();
object ob = Activator.CreateInstance(asmName, typeName).Unwrap();
IExternalToolboxLoader loader = (IExternalToolboxLoader)ob;
IList <ItemToolboxNode> list = loader.Load(fileName);
tl.AddRange(list);
StringWriter sw = new StringWriter();
ser.Serialize(sw, tl);
return(sw.ToString());
}
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());
}
}
static void LoadRuntimes()
{
if (!File.Exists(configFile))
{
return;
}
try {
XmlDataSerializer ser = new XmlDataSerializer(new DataContext());
using (StreamReader sr = new StreamReader(configFile)) {
customRuntimes = (RuntimeCollection)ser.Deserialize(sr, typeof(RuntimeCollection));
}
} catch (Exception ex) {
LoggingService.LogError("Error while loading mono-runtimes.xml.", ex);
}
}
public IList <ItemToolboxNode> LoadItemsIsolated(TargetRuntime runtime, Type loaderType, string filename)
{
if (!typeof(IExternalToolboxLoader).IsAssignableFrom(loaderType))
{
throw new InvalidOperationException("Type '" + loaderType + "' does not implement 'IExternalToolboxLoader'");
}
try {
ExternalItemLoader loader = CreateExternalLoader <ExternalItemLoader> (runtime);
string s = loader.LoadItems(loaderType.Assembly.FullName, loaderType.FullName, filename);
XmlDataSerializer ser = new XmlDataSerializer(MonoDevelop.Projects.Services.ProjectService.DataContext);
ToolboxList list = (ToolboxList)ser.Deserialize(new StringReader(s), typeof(ToolboxList));
return(list);
} catch {
return(new List <ItemToolboxNode> ());
}
}
public void TestInitialize()
{
dataFiller = new RandomDataFiller()
{
NumberOfBooks = 1000,
NumberOfBookStates = 1000,
NumberOfBookReaders = 1000,
NumberOfEvents = 1000
};
context = new DataContext();
dataFiller.Fill(ref context);
fileName = "xml_data.xml";
xmlSerializer = new XmlDataSerializer()
{
FileName = fileName
};
}
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();
}
}
protected override XmlDataSerializer CreateSerializer(FilePath file)
{
XmlDataSerializer serializer = base.CreateSerializer(file);
DataContext dataContext = serializer.SerializationContext.Serializer.DataContext;
foreach (Type resourceType in FileFormat.ResourceTypeManager.ResourceTypeList)
{
dataContext.IncludeType(resourceType);
}
string str = (string)file.ParentDirectory.Combine(new string[1] {
"CocosStudio".ToLower()
}).Combine(new string[1] {
"TempAppendFileName.Folder"
});
serializer.SerializationContext.BaseFile = str;
return(serializer);
}
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();
}
}
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();
}
}
internal void SaveGeneratedFrameworkInfo()
{
if (GeneratedFrameworksFile != null)
{
Console.WriteLine("Saving frameworks file: " + GeneratedFrameworksFile);
using (StreamWriter sw = new StreamWriter(GeneratedFrameworksFile)) {
XmlTextWriter tw = new XmlTextWriter(sw);
tw.Formatting = Formatting.Indented;
XmlDataSerializer ser = new XmlDataSerializer(new DataContext());
ser.Serialize(tw, frameworks);
}
XmlDocument doc = new XmlDocument();
doc.Load(GeneratedFrameworksFile);
doc.DocumentElement.InsertBefore(doc.CreateComment("This file has been autogenerated. DO NOT MODIFY!"), doc.DocumentElement.FirstChild);
doc.Save(GeneratedFrameworksFile);
}
}
internal static Repository InternalGetRepositoryReference(string path, string id)
{
string file = InternalGetRepositoryPath(path, id);
if (file == null)
{
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();
}
}
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 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());
}
}
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);
}
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();
}
