static void Main(string[] args)
{
XmlSerializer xs = new XmlSerializer(typeof(Person));
Person p = new Person();
p.Age = 35;
p.Name = "Arnold";
XDocument d = new XDocument();
using (XmlWriter xw = d.CreateWriter())
xs.Serialize(xw, p);
XElement elm = d.Root;
elm.Elements().All(e => { Console.WriteLine(string.Format("element name {0} , element value {1}", e.Name, e.Value)); return(true); });
Console.ReadLine();
}
public byte[] GenerarReporte(string sp, Dictionary <string, string> datos, string id, Resumen objresumen)
{
LogicaNegocio LN = new LogicaNegocio();
try
{
string xml = string.Empty;
DataSet res1 = new DataSet();
if (sp == "Prepago")
{
res1 = LN.ConsultaReporteBDDevolucion(datos["IdEmpresa"], datos["IdOperacion"], datos["Ncertificado"], "DocumentoCurse", "admin", "ReporteDevoluciones");
xml = res1.Tables[0].Rows[0][0].ToString(); //GenerarXMLContratoSubFianza(res1);
}
XDocument newTree = new XDocument();
XslCompiledTransform xsltt = new XslCompiledTransform();
using (XmlWriter writer = newTree.CreateWriter())
{
xsltt.Load(@"C:/inetpub/wwwroot/wss/VirtualDirectories/80/xsl/request/" + sp + ".xslt");
}
using (var sw = new StringWriter())
using (var sr = new StringReader(xml))
using (var xr = XmlReader.Create(sr))
{
xsltt.Transform(xr, null, sw);
html = sw.ToString();
}
try
{
sDocumento.Append(html);
return(util.ConvertirAPDF_Control(sDocumento));
}
catch { }
}
catch (Exception ex)
{
LoggingError.PostEventRegister(ex, ConfigurationManager.AppSettings["pathLog"].ToString(), "", "", ConfigurationManager.AppSettings["logName"].ToString(), Convert.ToBoolean(ConfigurationManager.AppSettings["enabledLog"].ToString()), Convert.ToBoolean(ConfigurationManager.AppSettings["enabledEventViewer"].ToString()), ConfigurationManager.AppSettings["registerEventsTypes"].ToString(), EventLogEntryType.Error);
}
return(null);
}
public object Execute(ParameterList parameters, FunctionContextContainer context)
{
Guid xsltFunctionId = this._xsltFunction.Id;
if (_FunctionCalls == null)
{
lock (_lock)
{
if (_FunctionCalls == null)
{
_FunctionCalls = RenderHelper.GetValidatedFunctionCalls(xsltFunctionId);
}
}
}
TransformationInputs transformationInput = RenderHelper.BuildInputDocument(_FunctionCalls, parameters, false);
XDocument newTree = new XDocument();
using (XmlWriter writer = new LimitedDepthXmlWriter(newTree.CreateWriter()))
{
XslCompiledTransform xslTransformer = GetXslCompiledTransform();
XsltArgumentList transformArgs = new XsltArgumentList();
XslExtensionsManager.Register(transformArgs);
if (transformationInput.ExtensionDefinitions != null)
{
foreach (IXsltExtensionDefinition extensionDef in transformationInput.ExtensionDefinitions)
{
transformArgs.AddExtensionObject(extensionDef.ExtensionNamespace.ToString(), extensionDef.EntensionObjectAsObject);
}
}
xslTransformer.Transform(transformationInput.InputDocument.CreateReader(), transformArgs, writer);
}
if (this._xsltFunction.OutputXmlSubType == "XHTML")
{
return(new XhtmlDocument(newTree));
}
return(newTree.Root);
}
public void HelloWorld_XElement()
{
var rtf = @"{\rtf1\ansi\deff0 {\fonttbl {\f0 Monotype Corsiva;}}
\qc\f0\fs120\i\b Hello,\line World!
}";
var doc = new XDocument();
using (var writer = doc.CreateWriter())
{
Rtf.ToHtml(rtf, writer);
}
Assert.AreEqual(@"<div style=""font-size:12pt;font-family:"Monotype Corsiva";"">
<p style=""text-align:center;font-size:60pt;margin:0;"">
<strong>
<em>Hello,<br />World!</em>
</strong>
</p>
</div>", doc.Root.ToString());
}
public static XDocument CreateXDocument(this Message message)
{
XDocument Document = new XDocument();
XmlWriter Writer = Document.CreateWriter();
XmlReader Reader = message.CreateReader();
Writer.WriteStartDocument();
Reader.MoveToContent();
Writer.WriteNode(Reader, true);
Writer.WriteEndDocument();
Writer.Flush();
Writer.Close();
Reader.Close();
message.BodyStream.Seek(0, SeekOrigin.Begin);
return(Document);
}
XElement Serialize(string sName, object obj, XmlSerializerNamespaces ns)
{
XmlWriterSettings ws = new XmlWriterSettings();
ws.OmitXmlDeclaration = true;
ws.NamespaceHandling = NamespaceHandling.OmitDuplicates;
XDocument xDoc = new XDocument();
using (XmlWriter oWriter = XmlWriter.Create(xDoc.CreateWriter(), ws)) {
XmlSerializer oSerializer = new XmlSerializer(obj.GetType());
oSerializer.Serialize(oWriter, obj, ns);
}
XElement xElem = xDoc.Root;
xElem.Name = sName;
return(xElem);
}
public static XElement XmlWriterSerialize <T>(this T obj, XmlWriter writer, string rootName)
{
var x = new XDocument();
Type type = obj.GetType();
XmlSerializer xmlSerializer = type.XmlSerializer(rootName);
if (writer == null)
{
using (var w = x.CreateWriter())
{
xmlSerializer.Serialize(w, obj); //finally call the System.Xml.Serialization.XmlSerializer.Serialize()
}
}
else
{
xmlSerializer.Serialize(writer, obj);
}
return(x.Root);
}
/// <exclude />
public override IEnumerable <XElement> Install()
{
if (_xslTransformations == null)
{
throw new InvalidOperationException("FileXslTransformationPackageFragmentInstaller has not been validated");
}
Stream stream;
foreach (XslTransformation xslfile in _xslTransformations)
{
string messageFormat = xslfile.InputXmlPath == xslfile.OutputXmlPath ?
"Performing XSL-transformation. xml-file: '{1}'; xsl-file: '{0}'"
: "Performing XSL-transformation. xsl-file: '{0}'; input xml file: '{1}'; output xml file: '{2}'";
Log.LogVerbose(LogTitle, string.Format(messageFormat, xslfile.XslPath, xslfile.InputXmlPath, xslfile.OutputXmlPath));
string inputXml = PathUtil.Resolve(xslfile.InputXmlPath);
string outputXml = PathUtil.Resolve(xslfile.OutputXmlPath);
using (stream = this.InstallerContext.ZipFileSystem.GetFileStream(xslfile.XslPath))
{
var xslt = new XslCompiledTransform();
using (XmlReader xslReader = XmlReader.Create(stream))
{
xslt.Load(xslReader);
}
var resultDocument = new XDocument();
using (XmlWriter writer = resultDocument.CreateWriter())
{
xslt.Transform(inputXml, writer);
}
resultDocument.SaveToFile(outputXml);
Log.LogVerbose(LogTitle, resultDocument.ToString());
}
}
return(new[] { this.Configuration.FirstOrDefault() });
}
private void Initialize()
{
try
{
string state = "ok";
if (String.IsNullOrEmpty(_emailTemplateTransformUrl))
{
throw new Exception("Missing email campaign template location from configuration");
}
if ((String.IsNullOrEmpty(_apiKey) || String.IsNullOrEmpty(_accessToken)) && !String.IsNullOrEmpty(_emailConnectionTransformUrl))
{
XDocument emailConnection = new XDocument();
using (System.Xml.XmlWriter writer = emailConnection.CreateWriter())
{
XslCompiledTransform emailConnectionTransform = new XslCompiledTransform();
emailConnectionTransform.Load(_emailConnectionTransformUrl);
emailConnectionTransform.Transform(XDocument.Parse("<dummy />").CreateReader(), writer);
}
}
if (String.IsNullOrEmpty(_accessToken))
{
_accessToken = OAuth.AuthenticateFromWinProgram(ref state);
}
if (string.IsNullOrEmpty(_accessToken))
{
throw new Exception("Unable to authenticate & retrieve access token");
}
//initialize ConstantContact members
IUserServiceContext userServiceContext = new UserServiceContext(_accessToken, _apiKey);
ConstantContactFactory _constantContactFactory = new ConstantContactFactory(userServiceContext);
_emailCampaignService = _constantContactFactory.CreateEmailCampaignService();
_emailCampaginScheduleService = _constantContactFactory.CreateCampaignScheduleService();
_listService = _constantContactFactory.CreateListService();
}
catch (OAuth2Exception oauthEx)
{
GlobalFunctions.WarnLog(string.Format("Authentication failure: {0}", oauthEx.Message));
}
}
public void AfterReceiveReply(ref Message reply, object correlationState)
{
if (reply.IsFault)
{
MessageBuffer msgbuf = reply.CreateBufferedCopy(int.MaxValue);
Message tmpMessage = msgbuf.CreateMessage();
var xdoc = new XDocument();
using (var wr = xdoc.CreateWriter())
{
tmpMessage.WriteBody(wr);
}
var q = from h in xdoc.Root.Elements(NameSpaces.xsoap + "Header")
from i in h.Elements(NameSpaces.xsosi + "implicitLoginHeader")
from r in i.Elements(NameSpaces.xsosi + "requestIdCardDigestForSigningResponse")
select new SosiGWLoginError()
{
DigestValue = r.Element(NameSpaces.xds + "DigestValue").Value,
BrowserUrl = r.Element(NameSpaces.xsosi + "BrowserUrl").Value
};
var le = q.FirstOrDefault();
var reason = xdoc.Root.Elements(NameSpaces.xsoap + "Body")
.Elements(NameSpaces.xsoap + "Fault")
.Elements("faultstring")
.Select(v => v.Value).FirstOrDefault();
if (le != null)
{
throw new FaultException <SosiGWLoginError>(le, new FaultReason(reason));
}
var dgwsfc = xdoc.Root.Descendants(NameSpaces.xdgws + "FaultCode").FirstOrDefault();
if (dgwsfc != null)
{
var fs = xdoc.Root.Descendants("faultstring").First();
throw new FaultException <XElement>(dgwsfc, new FaultReason(fs.Value), new FaultCode("Server"), null);
}
reply = msgbuf.CreateMessage();
}
}
public void BeforeSendReply(ref Message reply, object correlationState)
{
var reqxdoc = correlationState as XDocument;
if (reply.IsFault) //replaces s:Server with Server in faultcode
{
MessageBuffer msgbuf = reply.CreateBufferedCopy(int.MaxValue);
var r = msgbuf.CreateMessage();
var xdoc = new XDocument();
using (var wr = xdoc.CreateWriter())
{
r.WriteMessage(wr);
}
if (xdoc.Descendants("faultstring").First().Value == "requesterror")
{
var fc = xdoc.Descendants(NameSpaces.xdgws + "FaultCode").First();
reqxdoc = XDocument.Parse(fc.Value);
var xfault = reqxdoc.Root.Element("Fault");
xdoc.Descendants("faultstring").First().Value = xfault.Element("reason").Value;
fc.Value = xfault.Element("detail").Value;
}
xdoc.Descendants("faultcode").First().Value = "Server";
using (var reader = xdoc.CreateReader())
{
var rmsg = Message.CreateMessage(reader, int.MaxValue, reply.Version).CreateBufferedCopy(int.MaxValue);
reply = rmsg.CreateMessage();
}
}
if (reqxdoc != null)
{
var msg = reqxdoc.Descendants(NameSpaces.xdgws + "MessageID").First();
reqxdoc.Descendants(NameSpaces.xdgws + "Linking").First().Add(new XElement(NameSpaces.xdgws + "RequireNonRepudiationReceipt", msg.Value));
msg.Value = Guid.NewGuid().ToString("D");
reply.Headers.Add(new DgwsMessageHeader(new DgwsHeader(reqxdoc.Root.Element(NameSpaces.xdgws + "Header"))));
reqxdoc.Descendants(NameSpaces.xdgws + "FlowStatus").First().Value = "flow_finalized_succesfully";
}
}
public byte[] GenerarReporte(int idEmpresa)
{
LogicaNegocio MTO = new LogicaNegocio();
try
{
String xml = String.Empty;
DataSet res1 = new DataSet();
res1 = MTO.ConsultaReporteScoring(idEmpresa, "usuario", "perfil");
for (int i = 0; i < res1.Tables[0].Rows.Count; i++)
{
xml = xml + res1.Tables[0].Rows[i][0].ToString();
}
XDocument newTree = new XDocument();
XslCompiledTransform xsltt = new XslCompiledTransform();
using (XmlWriter writer = newTree.CreateWriter())
{
xsltt.Load(@"C:/inetpub/wwwroot/wss/VirtualDirectories/80/xsl/request/" + "Scoring" + ".xslt");
}
using (var sw = new StringWriter())
using (var sr = new StringReader(xml))
using (var xr = XmlReader.Create(sr))
{
xsltt.Transform(xr, null, sw);
html = sw.ToString();
}
try
{
sDocumento.Append(html);
return(util.ConvertirAPDF_Control(sDocumento));
}
catch { }
}
catch (Exception ex)
{
LoggingError.PostEventRegister(ex, ConfigurationManager.AppSettings["pathLog"].ToString(), "", "", ConfigurationManager.AppSettings["logName"].ToString(), Convert.ToBoolean(ConfigurationManager.AppSettings["enabledLog"].ToString()), Convert.ToBoolean(ConfigurationManager.AppSettings["enabledEventViewer"].ToString()), ConfigurationManager.AppSettings["registerEventsTypes"].ToString(), EventLogEntryType.Error);
}
return(null);
}
public static XElement ToXamlXElement(this FrameworkContentElement element) // For instance, a FlowDocument
{
if (element == null)
{
return(null);
}
var doc = new XDocument();
using (var xmlWriter = doc.CreateWriter())
{
XamlWriter.Save(element, xmlWriter);
}
var xElement = doc.Root;
if (xElement != null)
{
xElement.Remove();
}
return(xElement);
}
public void FormatAmlTest_XmlWriter()
{
var doc = new XDocument();
var cmd = new Command("<Item><name>@0</name><is_current>@1</is_current><date>@2</date></Item>");
using (var writer = doc.CreateWriter())
{
cmd.ToNormalizedAml(ElementFactory.Local.LocalizationContext, writer);
}
Assert.AreEqual("<Item>\r\n <name>@0</name>\r\n <is_current>@1</is_current>\r\n <date>@2</date>\r\n</Item>", doc.ToString());
doc = new XDocument();
cmd = new Command("<Item><name>@0</name><is_current>@1</is_current><date>@2</date></Item>",
"first & second > third", true, new DateTime(2015, 1, 1));
using (var writer = doc.CreateWriter())
{
cmd.ToNormalizedAml(ElementFactory.Local.LocalizationContext, writer);
}
Assert.AreEqual("<Item>\r\n <name>first & second > third</name>\r\n <is_current>1</is_current>\r\n <date>2015-01-01T00:00:00</date>\r\n</Item>", doc.ToString());
}
public void LoadWriteLoad()
{
string dsdPath = Utility.GetPath("lib\\StructureSample.xml");
var message = StructureMessage.Load(dsdPath);
var doc = new XDocument();
using (var writer = doc.CreateWriter())
message.Write(writer);
// Console.Write(doc);
using (var reader = doc.CreateReader())
Assert.IsTrue(MessageValidator.ValidateXml(reader, w => Console.WriteLine(w), e => Console.WriteLine(e)));
StructureMessage message2 = null;
using (var reader = doc.CreateReader())
message2 = StructureMessage.Read(reader);
}
public static XDocument Transform(XDocument doc, string fileXslt)
{
XDocument xslt = XDocument.Load(fileXslt); // check Xslt file is valid
XslCompiledTransform trans = new XslCompiledTransform();
// XsltArgumentList xsltArg = new XsltArgumentList();
// xsltArg.AddExtensionObject("urn:script-items", obj);
trans.Load(fileXslt); // xslt.CreateReader());
XDocument outputDoc = new XDocument();
using (var writer = outputDoc.CreateWriter())
{
trans.Transform(doc.CreateReader(), writer);
}
return(outputDoc);
}
private static void ExportMetadata(ServiceEndpoint endpoint, EndpointDiscoveryBehavior discovery)
{
var exporter = new WsdlExporter();
exporter.ExportEndpoint(endpoint);
var metadata = exporter.GetGeneratedMetadata();
var document = new XDocument();
using (var xmlWriter = document.CreateWriter())
{
xmlWriter.WriteStartElement(WcfConstants.EndpointMetadata.LocalName,
WcfConstants.EndpointMetadata.Namespace.NamespaceName);
metadata.WriteTo(xmlWriter);
xmlWriter.WriteEndElement();
xmlWriter.Flush();
}
discovery.Extensions.Add(document.Root);
}
public void SaveProfile(string BaseDirectory)
{
try
{
var ProfilePath = CreateProfilePathIfNecessary(BaseDirectory);
XDocument doc = new XDocument();
using (var writer = doc.CreateWriter())
{
var serializer = new DataContractSerializer(this.GetType());
serializer.WriteObject(writer, this);
}
var cleanFileName = this.Name.Replace(" ", "");
File.WriteAllText(Path.Combine(ProfilePath, cleanFileName + ".xml"), doc.ToString());
}
catch (Exception)
{
throw;
}
}
public static XElement ToXElement <T>(this object obj, string nameSpace = "http://www.portalfiscal.inf.br/nfe")
{
try
{
var doc = new XDocument();
using (var escritor = doc.CreateWriter())
{
var name = new XmlSerializerNamespaces();
name.Add(string.Empty, string.Empty);
name.Add(string.Empty, nameSpace);
var xmlSerializer = new XmlSerializer(typeof(T));
xmlSerializer.Serialize(escritor, obj, name);
}
return(doc.Root);
}
catch (Exception e)
{
throw e;
}
}
public XDocument Transform(string xml, string xsl)
{// from SO. to apply XLST to XML
var originalXml = XDocument.Load(new StringReader(xml));
var transformedXml = new XDocument();
using (var xmlWriter = transformedXml.CreateWriter())
{
var xslt = new XslCompiledTransform();
xslt.Load(XmlReader.Create(new StringReader(xsl)));
// Add XSLT parameters if you need
XsltArgumentList xsltArguments = null; // new XsltArgumentList();
// xsltArguments.AddParam(name, namespaceUri, parameter);
xslt.Transform(originalXml.CreateReader(), xsltArguments, xmlWriter);
}
return(transformedXml);
}
public XDocument Serialize(object value)
{
var formatter = new XmlSerializer(typeof(string));
var doc = new XDocument();
using (var writer = doc.CreateWriter())
{
writer.WriteStartElement("Value");
writer.WriteAttributeString("xmlns", "xsi", null, "http://www.w3.org/2001/XMLSchema-instance");
writer.WriteAttributeString("xmlns", "xsd", null, "http://www.w3.org/2001/XMLSchema");
AddStringElement(writer, "Type", (new TypeNameWithoutVersion(value.GetType())).Value);
AddStringElement(writer, "Version", VERSION);
formatter.Serialize(writer, value.Serialize());
writer.WriteEndElement();
}
return(doc);
}
//[Variation(Id = 3, Desc = "Attributes of nested elements", Priority = 1)]
public void NewLineOnAttributes_3()
{
XDocument d = new XDocument();
XmlWriter w = d.CreateWriter();
w.WriteStartElement("level1");
w.WriteAttributeString("attr1", "value1");
w.WriteAttributeString("attr2", "value2");
w.WriteStartElement("level2");
w.WriteAttributeString("attr1", "value1");
w.WriteAttributeString("attr2", "value2");
w.WriteEndElement();
w.WriteEndElement();
w.Dispose();
if (!CompareBaseline(d, "NewLineOnAttributes3.txt"))
{
throw new TestException(TestResult.Failed, "");
}
}
public static List <XElement> SerializeToXElements <T>(this T obj, XmlSerializer serializer, bool omitStandardNamespaces)
{
var list = new List <XElement>();
var type = obj.GetType();
if (obj is IList &&
type.IsGenericType &&
type.GetGenericTypeDefinition().IsAssignableFrom(typeof(List <>)))
{
List <object> genericList = (obj as IEnumerable <object>).ToList();
var elementType = type.GetGenericArguments()[0];
foreach (var item in genericList)
{
var doc = new XDocument();
using (var writer = doc.CreateWriter())
{
XmlSerializerNamespaces ns = null;
if (omitStandardNamespaces)
{
(ns = new XmlSerializerNamespaces()).Add(string.Empty, string.Empty);
}
serializer = serializer ?? new XmlSerializer(elementType);
serializer.Serialize(writer, item, ns);
}
var element = doc.Root;
if (element != null)
{
element.Remove();
}
list.Add(element);
}
}
else
{
list.Add(SerializeToXElement(obj, null, true));
}
return(list);
}
private string GetEntryValueInString(ObjectStateEntry entry, bool isOrginal)
{
if (entry.Entity is EntityObject)
{
object target = CloneEntity((EntityObject)entry.Entity);
foreach (string propName in entry.GetModifiedProperties())
{
object setterValue = null;
if (isOrginal)
{
//Get orginal value
setterValue = entry.OriginalValues[propName];
}
else
{
//Get orginal value
setterValue = entry.CurrentValues[propName];
}
//Find property to update
PropertyInfo propInfo = target.GetType().GetProperty(propName);
//update property with orgibal value
if (setterValue == DBNull.Value)
{//
setterValue = null;
}
propInfo.SetValue(target, setterValue, null);
}//end foreach
XmlSerializer formatter = new XmlSerializer(target.GetType());
XDocument document = new XDocument();
using (XmlWriter xmlWriter = document.CreateWriter())
{
formatter.Serialize(xmlWriter, target);
}
return(document.Root.ToString());
}
return(null);
}
//[Variation(Id = 2, Desc = "Change to CL Document after WriteStartDocument(standalone = true)", Priority = 0, Param = "true")]
//[Variation(Id = 3, Desc = "Change to CL Document after WriteStartDocument(standalone = false)", Priority = 0, Param = "false")]
public void auto_2()
{
XDocument d = new XDocument();
XmlWriter w = d.CreateWriter();
switch (Variation.Param.ToString())
{
case "true":
w.WriteStartDocument(true);
break;
case "false":
w.WriteStartDocument(false);
break;
}
// PROLOG
TestLog.Compare(w.Settings.ConformanceLevel, ConformanceLevel.Document, "Error");
w.WriteStartElement("root");
// ELEMENT CONTENT
TestLog.Compare(w.Settings.ConformanceLevel, ConformanceLevel.Document, "Error");
// Inside Attribute
w.WriteStartAttribute("attr");
TestLog.Compare(w.Settings.ConformanceLevel, ConformanceLevel.Document, "Error");
w.WriteEndElement();
// Try writing another root element, should error
try
{
w.WriteStartElement("root");
}
catch (InvalidOperationException)
{
return;
}
finally
{
w.Dispose();
}
TestLog.WriteLine("Conformance level = Document did not take effect");
throw new TestException(TestResult.Failed, "");
}
public static XElement SerializeToXElement <T>(this T obj, XmlSerializer serializer = null, bool omitStandardNamespaces = true)
{
var doc = new XDocument();
using (var writer = doc.CreateWriter())
{
XmlSerializerNamespaces ns = null;
if (omitStandardNamespaces)
{
(ns = new XmlSerializerNamespaces()).Add("", ""); // Disable the xmlns:xsi and xmlns:xsd lines.
}
(serializer ?? new XmlSerializer(obj.GetType())).Serialize(writer, obj, ns);
}
var element = doc.Root;
if (element != null)
{
element.Remove();
}
return(element);
}
public Features GetFeatures(string srcFile)
{
var data = new XPathDocument(srcFile);
var extract = new XDocument();
using (var dwriter = extract.CreateWriter())
{
_xslt.Transform(data, dwriter);
}
var ser = new DataContractSerializer(typeof(CensusMedians));
using (var xreader = extract.CreateReader())
{
var cm = (CensusMedians)ser.ReadObject(xreader, false);
cm.TransformFeatures();
return(cm.Features);
}
}
private XDocument ApplyTransform(XDocument input, XProcessingInstruction pi)
{
var match = Regex.Match(pi.Data, @"href\s*=\s*""([^""]*)""");
if (match == null)
{
throw new RdfParseException("Expected href value in xml-stylesheet PI");
}
var xslRef = match.Groups[1].Value;
var xslt = new XslCompiledTransform();
var xmlStringBuilder = new StringBuilder();
xslt.Load(XmlReader.Create(new StreamReader(xslRef), GetSettings()));
var output = new XDocument();
using (var writer = output.CreateWriter())
{
xslt.Transform(input.CreateReader(), writer);
}
return(output);
}
public void Save(ScheduledTask task)
{
ValidateTask(task);
var element = new XDocument();
using (var writer = element.CreateWriter())
new DataContractSerializer(typeof(ScheduledTask)).WriteObject(writer, task);
element.Root.RemoveAttributes();
var document = LoadXml();
var existing = document.Elements().FirstOrDefault(x => x.Element(XName.Get("Name", "http://schemas.datacontract.org/2004/07/Pendulum")).Value == task.Name);
if (existing == null)
{
document.Add(element.Root);
}
else
{
existing.ReplaceWith(element.Root);
}
document.Save(FileName);
}
public static XDocument Serialize <T>(T source, bool skipNamespace)
{
var target = new XDocument();
var serializer = new XmlSerializer(typeof(T));
using (var writer = target.CreateWriter())
{
if (skipNamespace)
{
var ns = new XmlSerializerNamespaces();
ns.Add(string.Empty, string.Empty);
serializer.Serialize(writer, source, ns);
}
else
{
serializer.Serialize(writer, source);
}
}
return(target);
}
