private void Serialize(XmlWriter xmlWriter)
{
var customProperties = new PropertyBag();
_adapter.Save(customProperties);
CachingXmlSerializerFactory.Create(typeof(PropertyBag), new XmlRootAttribute("CustomProps")).SerializeWithoutDefaultNamespaces(xmlWriter, customProperties);
}
/// <summary>
/// Function to serialize an object into XML
/// </summary>
/// <param name="objectToSerialize">Object to serialize</param>
/// <param name="documentElementName">Element name</param>
/// <returns></returns>
public static XmlDocument SerializeToXml(Object objectToSerialize, string documentElementName)
{
XmlTypeAttribute xta = Attribute.GetCustomAttribute(objectToSerialize.GetType(), typeof(XmlTypeAttribute)) as XmlTypeAttribute;
XmlDocument output = new XmlDocument();
output.PreserveWhitespace = true;
XmlRootAttribute xmlRoot = new XmlRootAttribute(documentElementName);
xmlRoot.Namespace = xta.Namespace;
XmlSerializerNamespaces xsn = new XmlSerializerNamespaces();
xsn.Add("", "urn:hl7-org:v3");
StringBuilder sb = new StringBuilder();
XmlWriter xmlw = XmlWriter.Create(sb);
//XmlSerializer xmlSerializer = new XmlSerializer(objectToSerialize.GetType(), xmlRoot); -- Use new CachingXmlSerializerFactory class
var xmlSerializer = CachingXmlSerializerFactory.Create(objectToSerialize.GetType(), xmlRoot);
xmlSerializer.Serialize(xmlw, objectToSerialize, xsn);
xmlw.Close();
output.LoadXml(sb.ToString());
return(output);
}
public void TestCachingSerializer_Caching()
{
var ser1 = CachingXmlSerializerFactory.Create <List <int> >();
var ser2 = CachingXmlSerializerFactory.Create <List <int> >();
Assert.AreEqual(ser1, ser2);
}
//TEST
/// <summary>
/// Deserialize XML string, optionally only an inner fragment of the XML, as specified by the innerStartTag parameter.
/// </summary>
public static T FromXml <T>(this XmlReader @this, string rootTag, string defaultNamespace = "")
{
var root = new XmlRootAttribute(rootTag)
{
Namespace = defaultNamespace
};
var xmlSerializer = CachingXmlSerializerFactory.Create(typeof(T), root);
return((T)xmlSerializer.Deserialize(@this));
}
public static string ToXml <T>(this T @object)
{
using (var stringWriter = new StringWriter())
using (var writer = XmlWriter.Create(stringWriter, new() { Indent = false, Encoding = Encoding.UTF8, OmitXmlDeclaration = true }))
{
var serializer = CachingXmlSerializerFactory.Create(typeof(T));
serializer.SerializeWithoutDefaultNamespaces(writer, @object);
return(stringWriter.ToString());
}
}
protected string Serialize()
{
var builder = new StringBuilder();
using (var writer = XmlWriter.Create(builder, new() { OmitXmlDeclaration = true }))
{
var serializer = CachingXmlSerializerFactory.Create(GetType());
serializer.SerializeWithoutDefaultNamespaces(writer !, this);
}
return(builder.ToString());
}
public static T Clone <T>(this T source)
{
var serializer = CachingXmlSerializerFactory.Create <T>();
using (MemoryStream ms = new MemoryStream())
{
serializer.Serialize(ms, source);
ms.Seek(0, SeekOrigin.Begin);
return((T)serializer.Deserialize(ms));
}
}
internal static Document LoadPolicyResourceDocument(string name)
{
// see Microsoft.BizTalk.PipelineEditor.PolicyFile.Document::Load, Microsoft.BizTalk.PipelineOM, Version=3.0.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35
var xmlSchemas = (XmlSchemas)Reflector.GetProperty <Document>("SchemasForObjectModel");
using (var stream = ResourceManager.Load(Assembly.GetExecutingAssembly(), $"{typeof(IStage).Namespace}.Resources.{name}"))
using (var xmlReader = XmlReader.Create(stream, ValidatingXmlReaderSettings.Create(XmlSchemaContentProcessing.Strict, xmlSchemas.ToArray())))
{
var xmlSerializer = CachingXmlSerializerFactory.Create(typeof(Document));
return((Document)xmlSerializer.Deserialize(xmlReader));
}
}
//TEST
public static string ToXml <T>(this T @this, string rootTag, string defaultNamespace, XmlSerializerNamespaces namespaces)
{
using (var stream = new MemoryStream()) {
var root = new XmlRootAttribute(rootTag)
{
Namespace = defaultNamespace
};
var xmlSerializer = CachingXmlSerializerFactory.Create(typeof(T), root);
xmlSerializer.Serialize(stream, @this, namespaces);
stream.Position = 0;
using (var reader = new StreamReader(stream)) {
var result = reader.ReadToEnd();
return(result);
}
}
}
/// <summary>
/// Deserialize XML string, optionally only an inner fragment of the XML, as specified by the innerStartTag parameter.
/// </summary>
public static T DeserializeXml <T>(this string @this, string innerStartTag = null)
{
using (var stringReader = new StringReader(@this))
{
using (var xmlReader = XmlReader.Create(stringReader))
{
if (innerStartTag != null)
{
xmlReader.ReadToDescendant(innerStartTag);
var xmlSerializer = CachingXmlSerializerFactory.Create(typeof(T), new XmlRootAttribute(innerStartTag));
return((T)xmlSerializer.Deserialize(xmlReader.ReadSubtree()));
}
return((T)CachingXmlSerializerFactory.Create(typeof(T)).Deserialize(xmlReader));
}
}
}
public static void Serialize(this IMicroComponent component, XmlWriter writer)
{
if (component == null)
{
throw new ArgumentNullException(nameof(component));
}
var overrides = new XmlAttributeOverrides();
overrides.Add(component.GetType(), new() { XmlRoot = new(Constants.MICRO_COMPONENT_ELEMENT_NAME) });
var serializer = CachingXmlSerializerFactory.Create(component.GetType(), overrides);
using (var microComponentXmlWriter = new MicroComponentXmlWriter(writer, component))
{
serializer.SerializeWithoutDefaultNamespaces(microComponentXmlWriter, component);
}
}
protected override XmlSerializer CreateXmlSerializer()
{
var overrides = new XmlAttributeOverrides();
overrides.Ignore <Document>(d => d.PolicyFilePath);
overrides.Add <Document>(d => d.CategoryId, new XmlAttributes {
XmlElements = { new XmlElementAttribute(nameof(Document.CategoryId), typeof(string)) }
});
overrides.Add <Document>(d => d.FriendlyName, new XmlAttributes {
XmlElements = { new XmlElementAttribute(nameof(Document.FriendlyName), typeof(string)) }
});
overrides.Ignore <PolicyFileStage>(s => s.CategoryId);
overrides.Add <PolicyFileStage>(
s => s.PolicyFileStage,
new XmlAttributes {
XmlElements = { new XmlElementAttribute(nameof(PolicyFileStage.PolicyFileStage), typeof(Microsoft.BizTalk.PipelineEditor.PolicyFile.Stage)) }
});
return(CachingXmlSerializerFactory.Create(typeof(Document), overrides));
}
public static IMicroComponent DeserializeMicroPipelineComponent(this XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
reader.AssertStartElement(Constants.MICRO_COMPONENT_ELEMENT_NAME);
var microPipelineComponentType = Type.GetType(reader.GetMandatoryAttribute(Constants.MICRO_COMPONENT_TYPE_ATTRIBUTE_NAME), true);
if (!typeof(IMicroComponent).IsAssignableFrom(microPipelineComponentType))
{
throw new ConfigurationErrorsException($"{microPipelineComponentType.AssemblyQualifiedName} does not implement {nameof(IMicroComponent)}.");
}
// reset position to an element as required to call ReadSubtree()
reader.MoveToElement();
var microPipelineComponentXmlSubtree = reader.ReadSubtree();
IMicroComponent component;
if (typeof(IXmlSerializable).IsAssignableFrom(microPipelineComponentType))
{
component = (IMicroComponent)Activator.CreateInstance(microPipelineComponentType);
// relieve micro pipeline components from having to deal with surrounding mComponent XML element
microPipelineComponentXmlSubtree.MoveToContent();
reader.ReadStartElement(Constants.MICRO_COMPONENT_ELEMENT_NAME);
((IXmlSerializable)component).ReadXml(microPipelineComponentXmlSubtree);
}
else
{
var overrides = new XmlAttributeOverrides();
overrides.Add(microPipelineComponentType, new XmlAttributes {
XmlRoot = new XmlRootAttribute(Constants.MICRO_COMPONENT_ELEMENT_NAME)
});
var serializer = CachingXmlSerializerFactory.Create(microPipelineComponentType, overrides);
component = (IMicroComponent)serializer.Deserialize(microPipelineComponentXmlSubtree);
}
reader.Skip();
return(component);
}
private XmlSerializer CreateXmlSerializer()
{
var overrides = new XmlAttributeOverrides();
overrides.Add <Document>(new() { XmlType = new("Root") });
overrides.Ignore <Document>(d => d.Description);
overrides.Ignore <Document>(d => d.MajorVersion);
overrides.Ignore <Document>(d => d.MinorVersion);
overrides.Ignore <Document>(d => d.PolicyFilePath);
overrides.Add <Stage>(s => s.Components, new() { XmlArrayItems = { new XmlArrayItemAttribute("Component", typeof(ComponentBinding)) } });
overrides.Add <ComponentInfo>(ci => ci.QualifiedNameOrClassId, new() { XmlAttribute = new("Name") });
overrides.Ignore <ComponentInfo>(ci => ci.CachedDisplayName);
overrides.Ignore <ComponentInfo>(ci => ci.CachedIsManaged);
overrides.Ignore <ComponentInfo>(ci => ci.ComponentName);
overrides.Ignore <ComponentInfo>(ci => ci.ComponentProperties);
overrides.Ignore <ComponentInfo>(ci => ci.Description);
overrides.Ignore <ComponentInfo>(ci => ci.Version);
return(CachingXmlSerializerFactory.Create(typeof(Document), overrides));
}
/// <summary>
/// Converts a PCEHR header into a common PCEHR header that can be validated.
/// </summary>
/// <typeparam name="T">PCEHR header type.</typeparam>
/// <param name="header">PCEHR header.</param>
/// <returns>Converted header.</returns>
private static PCEHRHeader ConvertPcehrHeader <T>(T header)
{
Debug.Assert(typeof(T).IsClass);
Debug.Assert(typeof(T).Name == "PCEHRHeader");
// Serialize
MemoryStream memoryStream = new MemoryStream();
//Updated to use memory safe version
//XmlSerializer serializer = new XmlSerializer(typeof(T));
XmlSerializer serializer = CachingXmlSerializerFactory.Create(typeof(T));
serializer.Serialize(memoryStream, header);
memoryStream.Position = 0;
// Deserialize
//Updated to use memory safe version
//XmlSerializer deserializer = new XmlSerializer(typeof(PCEHRHeader));
XmlSerializer deserializer = CachingXmlSerializerFactory.Create(typeof(PCEHRHeader));
PCEHRHeader pcehrHeader = (PCEHRHeader)deserializer.Deserialize(memoryStream);
return(pcehrHeader);
}
private void Serialize(XmlWriter xmlWriter)
{
CachingXmlSerializerFactory.Create(typeof(BindingInfo)).Serialize(xmlWriter, _applicationBinding.Accept(new BindingInfoBuilder()).BindingInfo);
}
protected override XmlSerializer CreateXmlSerializer()
{
return(CachingXmlSerializerFactory.Create(typeof(Document)));
}
