static void Main(string[] args)
{
try
{
XTest xtest = new XTest()
{
PropertyName = "Raj"
};
StringBuilder xmlString = new StringBuilder();
using (XmlWriter xtw = XmlTextWriter.Create(xmlString))
{
XmlSerializer serializer = new XmlSerializer(typeof(XTest), GetXmlAttributeOverrides(typeof(XTest)));
serializer.Serialize(xtw, xtest);
xtw.Flush();
}
Console.WriteLine(xmlString.ToString());
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
/// <summary>
/// Serialize object to XML string.
/// </summary>
/// <param name="o">The object to serialize.</param>
/// <param name="encoding">The encoding to use (default is UTF8).</param>
/// <param name="namespaces">Contains the XML namespaces and prefixes that the XmlSerializer uses to generate qualified names in an XML-document instance.</param>
/// <returns>XML string.</returns>
public static string SerializeToXmlString(object o, Encoding encoding = null, bool omitXmlDeclaration = false)
{
if (o == null)
{
return(null);
}
// Create serialization settings.
encoding = encoding ?? Encoding.UTF8;
XmlWriterSettings settings = new XmlWriterSettings();
settings.OmitXmlDeclaration = true;
settings.Encoding = encoding;
settings.Indent = true;
// Serialize.
XmlSerializer serializer = GetXmlSerializer(o.GetType());
MemoryStream ms = new MemoryStream();
XmlWriter xw = XmlTextWriter.Create(ms, settings);
lock (serializer) { serializer.Serialize(xw, o); }
xw.Flush();
StreamReader tr = new StreamReader(ms);
ms.Seek(0, SeekOrigin.Begin);
string xml = tr.ReadToEnd();
xw.Close();
ms.Close();
xw = null;
ms = null;
return(xml);
}
public XmlDocument Serialize()
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.UTF8;
settings.OmitXmlDeclaration = true;
settings.Indent = true;
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("oai_dc", "http://www.openarchives.org/OAI/2.0/oai_dc/");
ns.Add("dc", "http://purl.org/dc/elements/1.1/");
MemoryStream stream = new MemoryStream();
XmlSerializer serializer = new XmlSerializer(typeof(DublinCoreFile));
XmlWriter textWriter = XmlTextWriter.Create(stream, settings);
serializer.Serialize(textWriter, this, ns);
textWriter.Flush();
stream.Position = 0;
XmlDocument xml = new XmlDocument();
xml.Load(stream);
textWriter.Close();
return(xml);
}
// Evento para agregar un nuevo ejercicio a la lista
protected void btnAgregarEjercicio_Click(object sender, EventArgs e)
{
XDocument document;
try
{ // Carga el archivo XML, y si no lo encuentra accede al catch para crearlo
document = XDocument.Load(Server.MapPath("ejercicios.xml"));
}
catch (Exception)
{
generarXMLEjercicios();
return;
}
XElement ejercicio = new XElement("Ejercicio");
ejercicio.Add(new XElement("IDEjercicio", txtIDEjercicio.Text));
ejercicio.Add(new XElement("Nombre", txtNombreEjercicio.Text));
ejercicio.Add(new XElement("GrupoMuscular", ddlListaGrupoMusc.SelectedValue));
document.Descendants("Ejercicios").First().Add(ejercicio);
using (XmlWriter writer = XmlTextWriter.Create(Server.MapPath("ejercicios.xml")))
{
document.Save(writer);
}
cargarDatosEjercicios();
}
// Evento para agregar un nuevo grupo muscular a la lista
protected void btnAgregarGrupo_Click(object sender, EventArgs e)
{
XDocument document;
try
{ // Se carga el archivo xml, y si no lo encuentra accede a crearlo en el catch
document = XDocument.Load(Server.MapPath("gruposMusculares.xml"));
}
catch (Exception)
{
generarXMLGruposMusc();
return;
}
XElement grupoMuscular = new XElement("GrupoMuscular");
grupoMuscular.Add(new XElement("IDGrupoMuscular", txtIDGrupoMusc.Text));
grupoMuscular.Add(new XElement("Nombre", txtNombreGrupoMusc.Text));
document.Descendants("GruposMusculares").First().Add(grupoMuscular);
using (XmlWriter writer = XmlTextWriter.Create(Server.MapPath("gruposMusculares.xml")))
{
document.Save(writer);
}
cargarDDLDatosGruposM();
cargarDatosGruposM();
}
/// <summary>
/// Saves all the states to a persistance file.
/// </summary>
private void SaveProjectStates()
{
if (projectStates != null)
{
var stateDocument = new XmlDocument();
var rootElement = stateDocument.CreateElement("state");
stateDocument.AppendChild(rootElement);
foreach (var projectName in projectStates.Keys)
{
if (!projectStates[projectName])
{
var projectElement = stateDocument.CreateElement("project");
projectElement.InnerText = projectName;
rootElement.AppendChild(projectElement);
}
}
using (var stream = fileSystem.OpenOutputStream(persistanceFileName))
{
var settings = new XmlWriterSettings
{
Encoding = Encoding.UTF8,
OmitXmlDeclaration = true,
Indent = false
};
using (var xmlWriter = XmlTextWriter.Create(stream, settings))
{
stateDocument.Save(xmlWriter);
}
}
}
}
public void Handle(string path, Stream request, Stream responseStream, OSHttpRequest httpRequest, OSHttpResponse httpResponse)
{
RestSessionObject <TRequest> deserial = default(RestSessionObject <TRequest>);
bool fail = false;
using (XmlTextReader xmlReader = new XmlTextReader(request))
{
try
{
XmlSerializer deserializer = new XmlSerializer(typeof(RestSessionObject <TRequest>));
deserial = (RestSessionObject <TRequest>)deserializer.Deserialize(xmlReader);
}
catch (Exception e)
{
m_log.Error("[Rest]: Deserialization problem. Ignoring request. " + e);
fail = true;
}
}
TResponse response = default(TResponse);
if (!fail && m_smethod(deserial.SessionID, deserial.AvatarID))
{
response = m_method(deserial.Body);
}
using (XmlWriter xmlWriter = XmlTextWriter.Create(responseStream))
{
XmlSerializer serializer = new XmlSerializer(typeof(TResponse));
serializer.Serialize(xmlWriter, response);
}
}
/// <summary>
/// 將資料轉換成 Xml，並格式化輸出。
/// </summary>
/// <returns></returns>
public override string ToString()
{
StringBuilder sb = new StringBuilder();
XmlWriterSettings setting = new XmlWriterSettings();
setting.OmitXmlDeclaration = true;
setting.Indent = true;
using (XmlWriter writer = XmlTextWriter.Create(sb, setting))
{
if (!UniqueMode)
{
writer.WriteStartElement("_auto_generate_root");
foreach (XmlObject each in XmlRecordList)
{
each.Write(writer);
}
writer.WriteEndElement();
}
else
{
Write(writer);
}
}
return(sb.ToString());
}
/// <summary>
/// Accepts SAML Response, serializes it to XML and signs using the supplied certificate
/// </summary>
/// <param name="Response">SAML 2.0 Response</param>
/// <param name="SigningCert">X509 certificate</param>
/// <returns>XML Document with computed signature</returns>
private static XmlDocument SerializeAndSignSAMLResponse(ResponseType Response, X509Certificate2 SigningCert)
{
// Set serializer and writers for action
XmlSerializer responseSerializer = new XmlSerializer(Response.GetType());
StringWriter stringWriter = new StringWriter();
XmlWriter responseWriter = XmlTextWriter.Create(stringWriter, new XmlWriterSettings()
{
OmitXmlDeclaration = true, Indent = true, Encoding = Encoding.UTF8
});
responseSerializer.Serialize(responseWriter, Response);
responseWriter.Close();
XmlDocument xmlResponse = new XmlDocument();
xmlResponse.LoadXml(stringWriter.ToString());
// Set the namespace for prettire and more consistent XML
XmlNamespaceManager ns = new XmlNamespaceManager(xmlResponse.NameTable);
ns.AddNamespace("saml", "urn:oasis:names:tc:SAML:2.0:assertion");
CertificateUtility.AppendSignatureToXMLDocument(ref xmlResponse, "#" + ((AssertionType)Response.Items[0]).ID, SigningCert);
return(xmlResponse);
}
public static void WriteQueueToXml(IDataQueue queue, Stream fw, string dbName, string tableName)
{
DataTable table = ConnTools.DataTableFromStructure(queue.GetRowFormat);
table.TableName = tableName;
List <string> fldnames = new List <string>();
foreach (IColumnStructure col in queue.GetRowFormat.Columns)
{
fldnames.Add(col.ColumnName);
}
XmlWriter xw = XmlTextWriter.Create(fw, new XmlWriterSettings {
Encoding = Encoding.UTF8, CheckCharacters = false
});
//XmlTextWriter xw = new XmlTextWriter(fw, Encoding.UTF8);
//xw.Settings = new XmlWriterSettings { CheckCharacters = false };
xw.WriteStartDocument();
xw.WriteStartElement(dbName);
// mono has bug in writing schema
if (!Core.IsMono)
{
table.WriteXmlSchema(xw);
}
List <string> ids = new List <string>();
foreach (IColumnStructure col in queue.GetRowFormat.Columns)
{
ids.Add(XmlTool.NormalizeIdentifier(col.ColumnName));
}
try
{
while (!queue.IsEof)
{
IBedRecord row = queue.GetRecord();
xw.WriteStartElement(tableName);
for (int i = 0; i < row.FieldCount; i++)
{
row.ReadValue(i);
var type = row.GetFieldType();
if (type == TypeStorage.Null)
{
continue;
}
xw.WriteElementString(ids[i], XmlTool.ObjectToString(row.GetValue(i)));
}
xw.WriteEndElement();
}
}
finally
{
queue.CloseReading();
}
xw.WriteEndElement();
xw.WriteEndDocument();
xw.Flush();
}
public static void WriteOptions()
{
FileStream fileStream = null;
XmlWriter writer = null;
string path = AppStartPath + "\\Options.xml";
fileStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write);
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.NewLineHandling = NewLineHandling.Entitize;
writer = XmlTextWriter.Create(fileStream, settings);
writer.WriteStartElement("Options");
writer.WriteStartElement("ShowStartupScreen");
writer.WriteValue(Statics.IsShowStratupScreen.ToString());
writer.WriteFullEndElement();
writer.WriteFullEndElement();
writer.Close();
fileStream.Close();
}
void RefreshXML()
{
if (AsReflectionObject)
{
try
{
XmlSerializer xmls = new XmlSerializer(ObjectType);
//WindowsAPI.BeginPaint(hTextBox);
using (MemoryStream ms = new MemoryStream())
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.UTF8;
settings.Indent = true;
settings.IndentChars = "\t";
settings.NewLineChars = Environment.NewLine;
settings.ConformanceLevel = ConformanceLevel.Document;
using (XmlWriter writer = XmlTextWriter.Create(ms, settings))
{
xmls.Serialize(writer, LoadObject);
}
string xml = Encoding.UTF8.GetString(ms.ToArray());
hTextBox.LoadString(xml);
}
//WindowsAPI.EndPaint(hTextBox);
}
catch
{
tsLabel.Text = "属性结构发生错误。";
}
}
}
protected virtual string BuildData(ActionExecutingContext filterContext)
{
string ret = null;
if (filterContext.ActionParameters.Count > 0 ||
filterContext.HttpContext.Request.QueryString.Count > 0 ||
filterContext.HttpContext.Request.Form.Count > 0)
{
StringBuilder sb = new StringBuilder();
using (var wr = XmlTextWriter.Create(sb, WriterSettings))
{
wr.WriteStartElement("Data");
// Action parameters
WriteData_ActionParameters(filterContext, wr);
// Query strings
WriteData_QueryStrings(filterContext, wr);
// Form data
WriteData_Form(filterContext, wr);
wr.WriteEndElement();
wr.Flush();
}
ret = sb.ToString();
}
return(ret);
}
/// <summary>
/// 为pXmlObj执行XML序列化并返回序列化后的XML字符串内容
/// </summary>
/// <param name="pXmlObj">待操作的对象</param>
/// <returns></returns>
public string Serialize(object pXmlObj)
{
string xmlDes = string.Empty;
using (MemoryStream ms = new MemoryStream())
{
//设置序序化XML格式
XmlWriterSettings xws = new XmlWriterSettings();
xws.Indent = true;// false;
xws.OmitXmlDeclaration = true;
xws.Encoding = Encoding.UTF8;
using (XmlWriter xtw = XmlTextWriter.Create(ms, xws))
{
// XML namespace setting
XmlSerializerNamespaces _namespaces = new XmlSerializerNamespaces(new XmlQualifiedName[] { new XmlQualifiedName(string.Empty, string.Empty) });
XmlSerializer xml = new XmlSerializer(pXmlObj.GetType());
xml.Serialize(xtw, pXmlObj, _namespaces); // serialize obj to XML
// read to string.
ms.Seek(0, SeekOrigin.Begin);
XmlDoc.Load(ms);
XmlDeclaration xmlDecl = XmlDoc.CreateXmlDeclaration("1.0", "UTF-8", "yes");
xmlDes = xmlDecl.OuterXml + XmlDoc.OuterXml;
}
}
return(xmlDes);
}
public string GetXmlDescription(bool partial)
{
StringBuilder sb = new StringBuilder();
using (XmlWriter writer = XmlTextWriter.Create(sb))
{
if (!partial)
{
writer.WriteStartDocument();
}
writer.WriteStartElement("RpcBroker");
writer.WriteElementString("CurrentContext", this.CurrentContext);
writer.WriteElementString("Initialized", this.initialized.ToString());
if (this.vistaSocket != null)
{
writer.WriteRaw(this.vistaSocket.GetXmlDescription(true));
}
writer.WriteEndElement();
if (!partial)
{
writer.WriteEndDocument();
}
}
return(sb.ToString());
}
public void SaveSession(string filename)
{
// Get root node from current selection
var indexPath = TestResultController.SelectionIndexPath;
if (indexPath == null)
{
return;
}
var index = indexPath.IndexAtPosition(0);
var internalArray = (NSArray)TestResultController.Content;
var rootNode = internalArray.GetItem <TestListNode> (index);
var model = rootNode as TestResultModel;
if (model == null)
{
return;
}
var result = model.Result;
var element = TestSerializer.WriteTestResult(result);
var settings = new XmlWriterSettings {
Indent = true
};
using (var writer = XmlTextWriter.Create(filename, settings)) {
element.WriteTo(writer);
}
}
/// <summary>
/// Reads an object from the body of an XML element.
/// </summary>
private static string SetObject(Type type, object value)
{
// serialize object to a string.
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
StringBuilder buffer = new StringBuilder();
XmlWriter writer = XmlTextWriter.Create(buffer, settings);
try
{
DataContractSerializer serializer = new DataContractSerializer(type);
serializer.WriteObject(writer, value);
}
finally
{
writer.Close();
}
// must extract the inner xml.
XmlDocument document = new XmlDocument();
document.InnerXml = buffer.ToString();
return(document.DocumentElement.InnerXml);
}
void WriteRegexes()
{
Stream stream = new FileStream(LibraryLocation, FileMode.Create);
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = System.Text.Encoding.UTF8;
settings.Indent = true;
XmlWriter writer = XmlTextWriter.Create(stream, settings);
try {
writer.WriteStartElement(Node);
writer.WriteAttributeString(VersionAttribute, version);
foreach (Expression expr in expressions)
{
writer.WriteStartElement(ExpressionNode);
writer.WriteAttributeString(AuthorAttribute, expr.AuthorName);
writer.WriteAttributeString(SourceAttribute, expr.Source);
writer.WriteAttributeString(DescriptionAttribute, expr.Description);
writer.WriteAttributeString(PatternAttribute, expr.Pattern);
writer.WriteAttributeString(RatingAttribute, expr.Rating.ToString());
writer.WriteAttributeString(TitleAttribute, expr.Title);
writer.WriteAttributeString(MatchingAttribute, Validate(expr.MatchingText));
writer.WriteAttributeString(NonMatchingAttribute, Validate(expr.NonMatchingText));
writer.WriteEndElement(); // ExpressionNode
}
writer.WriteEndElement(); // Node
} finally {
writer.Close();
stream.Close();
}
}
/// <summary>
///
/// </summary>
public void SaveToFile()
{
string fileName = this._fileName;
XmlWriterSettings settings = new XmlWriterSettings
{
Indent = true,
Encoding = Encoding.UTF8
};
Directory.CreateDirectory(Path.GetDirectoryName(fileName));
using (XmlWriter writer = XmlTextWriter.Create(fileName, settings))
{
var modelDictionary = this._TDictionary;
List <T> list = new List <T>();
foreach (var i in modelDictionary)
{
list.Add(i.Value);
}
this._serializer.Serialize(writer, list);
}
}
public override void SaveFile(string sNewPath)
{
try {
DebugUtil.Log(1, "Saving scene to path " + sNewPath);
SceneGraphConfig.LastFileOpenPath = ListView.FolderPath;
if (!sNewPath.EndsWith(".xml", StringComparison.InvariantCultureIgnoreCase))
{
sNewPath += ".xml";
}
XMLOutputStream stream = new XMLOutputStream(XmlTextWriter.Create(sNewPath,
new XmlWriterSettings()
{
Indent = true, NewLineOnAttributes = true
}));
stream.Writer.WriteStartDocument();
SceneSerializer serializer = new SceneSerializer();
serializer.TargetFilePath = sNewPath;
serializer.Store(stream, ActiveCockpit.Scene);
stream.Writer.WriteEndDocument();
stream.Writer.Close();
ActiveCockpit.Context.PopCockpit(true);
} catch (Exception e) {
Debug.Log("[SaveScene] save of " + sNewPath + " failed: " + e.Message);
HUDUtil.ShowCenteredPopupMessage("Save Failed", "Sorry, could not save to path " + sNewPath, ActiveCockpit);
}
}
public void Handle(string path, Stream request, Stream responseStream, OSHttpRequest httpRequest, OSHttpResponse httpResponse)
{
TRequest deserial = default(TRequest);
bool fail = false;
using (XmlTextReader xmlReader = new XmlTextReader(request))
{
try
{
XmlSerializer deserializer = new XmlSerializer(typeof(TRequest));
deserial = (TRequest)deserializer.Deserialize(xmlReader);
}
catch (Exception e)
{
m_log.Error("[Rest]: Deserialization problem. Ignoring request. " + e);
fail = true;
}
}
TResponse response = default(TResponse);
if (!fail && m_tmethod(httpRequest.RemoteIPEndPoint))
{
response = m_method(deserial);
}
using (XmlWriter xmlWriter = XmlTextWriter.Create(responseStream))
{
XmlSerializer serializer = new XmlSerializer(typeof(TResponse));
serializer.Serialize(xmlWriter, response);
}
}
private void WriteConfigFile()
{
var dirName = Path.GetDirectoryName(this.ConfigFile);
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
using (XmlWriter writer = XmlTextWriter.Create(this.ConfigFile, new XmlWriterSettings()
{
Encoding = Encoding.Unicode, Indent = true
}))
{
writer.WriteStartDocument();
writer.WriteStartElement("Root");
writer.WriteStartElement("XTMFUpdateServerLocation");
writer.WriteString(this.XTMFUpdateServerLocation);
writer.WriteEndElement();
writer.WriteStartElement("XTMFUpdateServerPort");
writer.WriteString(this.XTMFUpdateServerPort.ToString());
writer.WriteEndElement();
writer.WriteStartElement("UseWebservices");
writer.WriteString(this.UseWebservices.ToString());
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteEndDocument();
}
}
protected void btnEliminarEjercicio_Click(object sender, EventArgs e) //Elimina un ejercicio
{
XDocument document = XDocument.Load(Server.MapPath("ejercicios.xml"));
int index = 0;
foreach (var node in document.Root.Elements("Ejercicio"))
{
string idGrupo = node.Element("IDEjercicio").Value; //Obtiene el valor del ID
if (idGrupo.Equals(txtIDEjercicio.Text)) //Si el ID coincide procede a usar el index
{
break;
}
index++;
}
try
{
document.Root.Elements().ElementAt(index).Remove(); // elimina el elemento coincidente
using (XmlWriter writer = XmlTextWriter.Create(Server.MapPath("ejercicios.xml")))
{
document.Save(writer); //guarda el documento
}
cargarDatosEjercicios();
}
catch (Exception)
{
}
}
private void ProcessAssembly(Assembly assembly)
{
_visitor.VisitAssembly(assembly);
using (StringWriter stringWriter = new StringWriter())
{
using (_xmlWriter = XmlTextWriter.Create(stringWriter))
{
_xmlWriter.WriteStartElement("Cmdlets");
_xmlWriter.WriteAttributeString("xmlns", "xsd", null, NamespaceXmlSchema);
_xmlWriter.WriteAttributeString("xmlns", "xsi", null, NamespaceXmlSchemaInstance);
foreach (CmdletInfo cmdletInfo in _cmdlets)
{
cmdletInfo.MergeWithLocalizedXml(_localizedHelpPath);
WriteCmdlet(cmdletInfo);
}
_xmlWriter.WriteEndElement(); // </Cmdlets>
_xmlWriter.WriteEndDocument();
}
WriteObject(stringWriter.ToString());
}
}
public XmlDocument Serialize()
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.UTF8;
settings.OmitXmlDeclaration = false;
settings.Indent = true;
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("foxml", "info:fedora/fedora-system:def/foxml# http://www.fedora.info/definitions/1/0/foxml1-1.xsd");
MemoryStream stream = new MemoryStream();
XmlSerializer serializer = new XmlSerializer(typeof(FoxmlDigitalObject));
XmlWriter textWriter = XmlTextWriter.Create(stream, settings);
serializer.Serialize(textWriter, this, ns);
textWriter.Flush();
stream.Position = 0;
XmlDocument xml = new XmlDocument();
xml.Load(stream);
textWriter.Close();
return(xml);
}
public void Save(string fileName)
{
this.fileName = fileName;
XmlDocument doc = Write(false);
XmlWriter writer = null;
try {
//Always normalize line endings to \n so that they remain consistent.
//Else, because of the way subdocument are persisted unmodified, we could
//end up with mixed line endings.
//Also, string arrays are stored in plain text data with \n separators,
//and break badly if we have \r\n.
var settings = new XmlWriterSettings()
{
NewLineHandling = NewLineHandling.Replace,
Encoding = System.Text.Encoding.UTF8,
NewLineChars = "\n",
Indent = true,
};
// Write to a temporary file first, just in case something fails
writer = XmlTextWriter.Create(fileName + "~", settings);
doc.Save(writer);
writer.Close();
File.Copy(fileName + "~", fileName, true);
File.Delete(fileName + "~");
} finally {
if (writer != null)
{
writer.Close();
}
}
}
static public void Write(string filename, params string[] plugins)
{
XmlWriterSettings ws = new XmlWriterSettings();
ws.Indent = true;
ws.ConformanceLevel = ConformanceLevel.Document;
ws.NewLineChars = "\r\n";
ws.IndentChars = "\t";
// ws.NewLineHandling = NewLineHandling.Entitize;
File.Delete(filename);
using (System.IO.FileStream fs = new System.IO.FileStream(filename, FileMode.Create))
using (XmlWriter writer = XmlTextWriter.Create(fs, ws))
{
writer.WriteStartDocument();
writer.WriteStartElement("Plugins");
foreach (string c in plugins)
{
if (!string.IsNullOrEmpty(c))
{
writer.WriteElementString("plugin", c);
}
}
writer.WriteEndElement();
writer.WriteEndDocument();
}
}
public void WriteToFile(string fileName)
{
var xmlSettings = new XmlWriterSettings()
{
Encoding = Encoding.UTF8,
CloseOutput = false,
Indent = true,
IndentChars = "\t",
NewLineChars = "\n",
};
var tempFile = FileUtil.GetTempFilenameForWrite(fileName);
bool success = false;
try {
using (var writer = XmlTextWriter.Create(tempFile, xmlSettings)) {
Write(writer);
}
FileUtil.SystemRename(tempFile, fileName);
success = true;
} finally {
if (!success)
{
try {
File.Delete(tempFile);
} catch {
//the original exception is more important than this one
}
}
}
}
public string GetXmlDescription(bool partial)
{
StringBuilder sb = new StringBuilder();
using (XmlWriter writer = XmlTextWriter.Create(sb))
{
if (!partial)
{
writer.WriteStartDocument();
}
writer.WriteStartElement("RpcSocket");
writer.WriteElementString("ServerName", this.ServerName);
writer.WriteElementString("ServerPort", this.ServerPort.ToString());
writer.WriteEndElement();
if (!partial)
{
writer.WriteEndDocument();
}
}
return(sb.ToString());
}
public XmlDocument Serialize()
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.UTF8;
settings.OmitXmlDeclaration = true;
settings.Indent = true;
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("mets", "http://www.loc.gov/METS/");
ns.Add("xlink", "http://www.w3.org/TR/xlink/");
MemoryStream stream = new MemoryStream();
XmlSerializer serializer = new XmlSerializer(typeof(MetsFile));
XmlWriter textWriter = XmlTextWriter.Create(stream, settings);
serializer.Serialize(textWriter, this, ns);
textWriter.Flush();
stream.Position = 0;
XmlDocument xml = new XmlDocument();
xml.Load(stream);
textWriter.Close();
return(xml);
}
