/// <summary>method add child element with Interpretation reference table content
/// </summary>
private void AddInterpretationRefTableData()
{
int i, j;
XElement root = this.AddChildElement(InterpretationRefTable);
root.AddChildElement(InterpretationRefHeaderTableText, m_InterpretationRefTableTextData);
XElement headersCollection = root.AddChildElement(InterpretationRefTableHeadersCollection);
for (i = 0; i < m_InterpretationRefTableHeaderData.GetLength(0); i++)
{
headersCollection.AddChildElement(InterpretationRefTableHeader, m_InterpretationRefTableHeaderData[i]);
}
XElement rowsCollection = root.AddChildElement(InterpretationRefTableRowsCollection);
m_InterpretationRefTableDataRowsCount = m_InterpretationRefTableData.GetLength(0);
for (i = 0; i < m_InterpretationRefTableDataRowsCount; i++)
{
XElement row = rowsCollection.AddChildElement(InterpretationRefTableRow);
m_InterpretationRefTableDataColsCount = m_InterpretationRefTableData.GetLength(1);
for (j = 0; j < m_InterpretationRefTableDataColsCount; j++)
{
row.AddChildElement(InterpretationRefTableColumns[j], m_InterpretationRefTableData[i, j]);
}
}
}
/// <summary>method add "BlastHeader" data block
/// </summary>
/// <param name="flowLeukemia">flowLeukemia section of XML document with report data</param>
private void AddReportBlastData(XElement flowLeukemia)
{
int blastCount = BlastNames.GetLength(0);
string[] blastNames = new string[blastCount];
decimal[] blastValues = new decimal[blastCount];
bool isVisible = false;
for (int i = 0; i < blastCount; i++)
{
blastNames[i] = string.Format("{0}{1}{2}", BlastNamesPrefix, BlastNames[i], BlastNamesSuffix);
blastValues[i] = flowLeukemia.GetDecimalValue(blastNames[i]);
if (blastValues[i] != 0)
{
isVisible = true;
}
}
XElement reportBlast = this.AddChildElement(BlastHeaderSection);
reportBlast.AddChildElement(BlastHeaderSectionIsVisible, isVisible.ToString());
for (int i = 0; i < blastCount; i++)
{
reportBlast.AddChildElement(blastNames[i], string.Format(m_Nfi, "{0}", blastValues[i]));
}
}
/// <summary>method add MSH segment data block to document's root element
/// </summary>
private void AddMshSegment()
{
const string type = "ORU";
const string subType = "R01";
string timeStamp = DateTime.Now.ToString("yyyyMMddHHmmss");
string messageID = Guid.NewGuid().ToString().Replace("-", string.Empty);
XElement msh = new XElement("MSH");
msh.AddChildElement("MSH.1", @"|");
msh.AddChildElement("MSH.2", @"^~\&");
msh.AddChildElement("MSH.3").AddChildElement("MSH.3.1", "YPILIS");
XElement msh4 = msh.AddChildElement("MSH.4");
msh4.AddChildElement("MSH.4.1", "YPIBILLINGS");
msh4.AddChildElement("MSH.4.2", "27D0946844");
msh4.AddChildElement("MSH.4.3", "CLIA");
msh.AddChildElement("MSH.7").AddChildElement("MSH.7.1", timeStamp);
XElement msh9 = msh.AddChildElement("MSH.9");
msh9.AddChildElement("MSH.9.1", type);
msh9.AddChildElement("MSH.9.2", subType);
msh.AddChildElement("MSH.10").AddChildElement("MSH.10.1", messageID);
msh.AddChildElement("MSH.11").AddChildElement("MSH.11.1", "P");
msh.AddChildElement("MSH.12").AddChildElement("MSH.12.1", "2.3");
m_Root.Add(msh);
}
/// <summary>
/// 将对象序列化到一个XElement元素上
/// </summary>
/// <param name="element"></param>
/// <param name="refNodeName">可参照的节点名称，如果此参数不为空，则增加此名称的子节点</param>
public void ToXElement(XElement element, string refNodeName)
{
element.NullCheck("element");
if (refNodeName.IsNotEmpty())
{
element = element.AddChildElement(refNodeName);
}
this.ObjectTypeName.IsNotEmpty(tn => element.SetAttributeValue("typeName", tn));
foreach (ObjectPropertyCompareResult pcr in this)
{
XElement propElement = element.AddChildElement("Property");
propElement.SetAttributeValue("name", pcr.PropertyName);
pcr.PropertyTypeName.IsNotEmpty(tn => propElement.SetAttributeValue("typeName", tn));
propElement.SetAttributeValue("sortID", pcr.SortID);
pcr.Description.IsNotEmpty(desp => propElement.SetAttributeValue("description", desp));
pcr.OldValue.IsNotNull(oldValue => propElement.SetAttributeValue("oldValue", oldValue));
pcr.NewValue.IsNotNull(newValue => propElement.SetAttributeValue("newValue", newValue));
IObjectCompareResult subResult = pcr.SubObjectCompareResult;
if (subResult.AreDifferent && subResult is ISimpleXmlSerializer)
{
((ISimpleXmlSerializer)subResult).ToXElement(propElement, "Object");
}
}
}
/// <summary>method add child element to XML data class
/// </summary>
/// <param name="e">XElement instance</param>
/// <param name="xmlDataDocument">source XML element</param>
/// <param name="rootName">name of source XML parent collection element</param>
/// <param name="itemName">name of source XML collection item element</param>
/// <param name="srcItemChildName">name of source XML collection item's child element</param>
/// <param name="destItemChildName">name of added XML element</param>
/// <param name="whereItemChildName">optional name of source XML collection item's child element used for filtration</param>
/// <param name="whereItemChildValue">optional value of source XML collection item's child element used for filtration</param>
public static XElement AddChildElement(this XElement e, XElement xmlDataDocument, string rootName, string itemName, string srcItemChildName, string destItemChildName, string[] whereItemChildNames = null, string[] whereItemChildValues = null)
{
XElement childElement;
XElement root = xmlDataDocument.Descendants(rootName).FirstOrDefault();
if (root != null)
{
XElement xElement = null;
if (whereItemChildNames != null)
{
int whereCount = whereItemChildNames.GetLength(0);
if (whereCount > 0)
{
List <XElement> query = root.Elements(itemName).Where((x) => x.Element(whereItemChildNames[0]).Value == whereItemChildValues[0]).ToList();
if (query.Count() > 0 && whereCount > 1)
{
for (int i = 1; i < whereCount; i++)
{
query = query.Where((x) => x.Element(whereItemChildNames[i]).Value == whereItemChildValues[i]).ToList();
if (query.Count() == 0)
{
break;
}
}
}
if (query.Count > 0)
{
xElement = query[0];
}
else
{
xElement = null;
}
}
else
{
xElement = root.Elements(itemName).FirstOrDefault();
}
}
else
{
xElement = root.Elements(itemName).FirstOrDefault();
}
if (xElement != null)
{
childElement = e.AddChildElement(destItemChildName, xElement.GetStringValue(srcItemChildName));
}
else
{
childElement = e.AddChildElement(destItemChildName);
}
}
else
{
childElement = e.AddChildElement(destItemChildName);
}
return(childElement);
}
/// <summary>method add specimen information data colection
/// </summary>
/// <param name="xmlDataDocument">XML document with report data</param>
private void AddSpecimenInformationData(XElement xmlDataDocument)
{
XElement destRoot = this.AddChildElement(SpecimenInformation);
destRoot.AddChildElement(xmlDataDocument, "SpecimenOrderCollection", "SpecimenOrder", "Description", SpecimenType);
destRoot.AddChildElement(xmlDataDocument, "SpecimenOrderCollection", "SpecimenOrder", "ClientFixation", SpecimenFixation);
destRoot.AddChildElement(SpecimenFixationTime, m_SpecimenFixationTime);
destRoot.AddChildElement(SpecimenFixationDuration, m_SpecimenFixationDuration);
destRoot.AddChildElement(SpecimenSampleAdequacy, m_SpecimenSampleAdequacy);
}
/// <summary>method add result data colection
/// </summary>
/// <param name="xmlDataDocument">XML document with report data</param>
private void AddResultData(XElement xmlDataDocument)
{
XElement destRoot = this.AddChildElement(ResultDataCollectionName);
destRoot.AddChildElement(ResultDataInvasiveTumorСells, m_InvasiveTumorСells.ToString(m_Nfi));
destRoot.AddChildElement(ObserversNumber, m_ObserversNumber.ToString(m_Nfi));
destRoot.AddChildElement(Her2CopyNumber, m_Her2CopyNumber.ToString(m_Nfi));
destRoot.AddChildElement(Chr17CopyNumber, m_Chr17CopyNumber.ToString(m_Nfi));
destRoot.AddChildElement(Her2Chr17Ratio, m_Her2Chr17Ratio.ToString(m_Nfi));
}
private void SerializePropertiesToNodes(XElement parent, object graph, XmlSerializeContext context)
{
TypeFields tf = TypeFields.GetTypeFields(graph.GetType());
foreach (KeyValuePair <TypeFieldInfo, ExtendedFieldInfo> kp in tf.Fields)
{
ExtendedFieldInfo efi = kp.Value;
if (efi.IsNotSerialized == false && OnFieldCanXElementSerialize(efi))
{
object data = GetValueFromObject(efi.FieldInfo, graph);
if ((data == null || data == DBNull.Value) == false)
{
if (Type.GetTypeCode(data.GetType()) == TypeCode.Object)
{
int objID = 0;
if (context.ObjectContext.TryGetValue(data, out objID) == false)
{
objID = context.CurrentID;
context.ObjectContext.Add(data, objID);
context.ContainerTypeName = graph.GetType().AssemblyQualifiedName + "." + efi.FieldInfo.Name;
SerializeObjectToNode(parent, data, context);
}
XElement propertyElem = parent.AddChildElement("F");
propertyElem.SetAttributeValue("n", efi.AlternateFieldName);
propertyElem.SetAttributeValue("v", objID);
propertyElem.SetAttributeValue("r", true);
propertyElem.SetAttributeValue("oti", context.GetTypeID(kp.Key.ObjectType));
if (efi.IgnoreDeserializeError)
{
propertyElem.SetAttributeValue("ide", efi.IgnoreDeserializeError);
}
}
else
{
XElement propertyElem = parent.AddChildElement("F");
propertyElem.SetAttributeValue("n", efi.AlternateFieldName);
propertyElem.SetAttributeValue("v", data);
propertyElem.SetAttributeValue("oti", context.GetTypeID(kp.Key.ObjectType));
if (efi.IgnoreDeserializeError)
{
propertyElem.SetAttributeValue("ide", efi.IgnoreDeserializeError);
}
}
}
}
}
}
/// <summary>method add PID segment data block to document's root element
/// </summary>
private void AddPidSegment(ReportHeaderData headerData)
{
//ReportHeaderData headerData = m_Data.PageHeader;
XElement pid = new XElement("PID");
XElement pid5 = pid.AddChildElement("PID.5");
pid5.AddChildHl7Element("PID.5.1", headerData.GetStringValue("PLastName"));
pid5.AddChildHl7Element("PID.5.2", headerData.GetStringValue("PFirstName"));
pid.AddChildElement("PID.7").AddChildHl7Element("PID.7.1", headerData.GetDateTime(ReportHeaderData.PatientBirthdate, "yyyyMMdd"));
pid.AddChildElement("PID.8").AddChildHl7Element("PID.8.1", headerData.GetStringValue("PSex"));
pid.AddChildElement("PID.19").AddChildHl7Element("PID.19.1", headerData.GetStringValue("PSSN"));
m_Root.Add(pid);
}
/// <summary>method add OBX segment data block to document's root element
/// </summary>
/// <param name="root">document's root element</param>
/// <param name="text">OBX segment value</param>
protected void AddObxSegment(string text = "")
{
XElement obx = new XElement("OBX");
obx.AddChildElement("OBX.1").AddChildHl7Element("OBX.1.1", _obxSegmentNo.ToString());
_obxSegmentNo++;
obx.AddChildElement("OBX.2").AddChildHl7Element("OBX.2.1", "TX");
obx.AddChildElement("OBX.3").AddChildHl7Element("OBX.3.1", ">");
//obx.AddChildElement("OBX.4");
obx.AddChildElement("OBX.5").AddChildHl7Element("OBX.5.1", text);
obx.AddChildElement("OBX.11").AddChildHl7Element("OBX.11.1", "F");
m_Root.Add(obx);
}
void ISimpleXmlSerializer.ToXElement(XElement element, string refNodeName)
{
if (refNodeName.IsNotEmpty())
{
element = element.AddChildElement(refNodeName);
}
foreach (WfBranchProcessTemplateDescriptor bptd in this)
{
XElement subRoot = element.AddChildElement("Template");
((ISimpleXmlSerializer)bptd).ToXElement(subRoot, string.Empty);
}
}
/// <summary>method add child element to this element from source element or empty child element, if source child element is not found
/// </summary>
/// <param name="e">XElement instance</param>
/// <param name="srcParentElement">source element with child element, which value is used for new element</param>
/// <param name="srcChildElementName">child element name, which value is used for new element</param>
/// <param name="destChildElementName">name of new element, default is source child element name</param>
/// <returns>added child element</returns>
public static XElement AddChildElement(this XElement e, XElement srcParentElement, string srcChildElementName, string destChildElementName = "")
{
string name = (destChildElementName == "" ? srcChildElementName : destChildElementName);
XElement srcElement = srcParentElement.Element(srcChildElementName);
if (srcElement != null)
{
return(e.AddChildElement(name, srcElement.Value));
}
else
{
return(e.AddChildElement(name));
}
}
/// <summary>method add child element to this element from source element descendands or empty child element, if source child element is not found
/// </summary>
/// <param name="e">XElement instance</param>
/// <param name="srcParentElement">source element with descendant elements, which value is used for new element</param>
/// <param name="srcChildElementName">descendant element name, which value is used for new element</param>
/// <param name="destChildElementName">name of added element, default is source child element name</param>
/// <returns></returns>
public static XElement AddFirstDescendantElement(this XElement e, XElement srcParentElement, string srcChildElementName, string destChildElementName = "")
{
string name = (destChildElementName == "" ? srcChildElementName : destChildElementName);
XElement srcElement = srcParentElement.Descendants(srcChildElementName).FirstOrDefault();
if (srcElement != null)
{
return(e.AddChildElement(name, srcElement.Value));
}
else
{
return(e.AddChildElement(name));
}
}
void ISimpleXmlSerializer.ToXElement(XElement element, string refNodeName)
{
if (refNodeName.IsNotEmpty())
{
element = element.AddChildElement(refNodeName);
}
foreach (WfServiceOperationParameter param in this)
{
XElement paramElement = element.AddChildElement("Param", string.Empty);
((ISimpleXmlSerializer)param).ToXElement(paramElement, string.Empty);
}
}
/// <summary>method add OBR segment data block to document's root element
/// </summary>
private void AddObrSegment()
{
XElement obr = new XElement("OBR");
obr.AddChildElement("OBR.1").AddChildHl7Element("OBR.1.1", "1");
XElement obr3 = obr.AddChildElement("OBR.3");
obr3.AddChildHl7Element("OBR.3.1", m_FillerOrderNumber);
obr3.AddChildHl7Element("OBR.3.2", m_FillerOrderCode);
XElement obr4 = obr.AddChildElement("OBR.4");
obr4.AddChildHl7Element("OBR.4.1", m_UniversalServiceIdentifier);
obr4.AddChildHl7Element("OBR.4.2", m_UniversalServiceIdentifierText);
obr.AddChildElement("OBR.7").AddChildHl7Element("OBR.7.1", m_RequestedDateTime.ToString("yyyyMMddHHmm"));
obr.AddChildElement("OBR.14").AddChildHl7Element("OBR.14.1", m_SpecimenReceivedDateTime.ToString("yyyyMMddHHmm"));
obr.AddChildElement("OBR.22").AddChildHl7Element("OBR.22.1", m_ResultsDateTime.ToString("yyyyMMddHHmm"));
obr.AddChildElement("OBR.25").AddChildHl7Element("OBR.25.1", "F");
XElement obr32 = obr.AddChildElement("OBR.32");
obr32.AddChildHl7Element("OBR.32.1", m_PrincipalResultInterpreterID);
obr32.AddChildHl7Element("OBR.32.2", m_PrincipalResultInterpreterLastName);
obr32.AddChildHl7Element("OBR.32.3", m_PrincipalResultInterpreterFirstName);
obr32.AddChildHl7Element("OBR.32.9", m_PrincipalResultInterpreterAssigningAuthority);
obr32.AddChildHl7Element("OBR.32.13", m_PrincipalResultInterpreterIdentifierTypeCode);
m_Root.Add(obr);
}
void ISimpleXmlSerializer.ToXElement(XElement element, string refNodeName)
{
if (refNodeName.IsNotEmpty())
{
element = element.AddChildElement(refNodeName);
}
foreach (WfResourceDescriptor resource in this)
{
XElement actElem = element.AddChildElement("Resource");
((ISimpleXmlSerializer)resource).ToXElement(actElem, string.Empty);
}
}
private void SerializableBinaryToNode(XElement parent, XmlObjectMappingItem item, object graph, XmlSerializeContext context)
{
//此处对没有标记为序列化的需要做一个异常处理,还是?
XElement xElement = context.RootElement.AddChildElement("object");
xElement.SetAttributeValue("id", context.CurrentID++);
if (this.OutputShortType)
{
xElement.SetAttributeValue("shortType", graph.GetType().Name);
}
xElement.SetAttributeValue("oti", context.GetTypeID(graph.GetType()));
XElement itemNode = xElement.AddChildElement("value");
byte[] buffer = null;
using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
{
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(ms, graph);
buffer = ms.GetBuffer();
}
string imageBase64String = Convert.ToBase64String(buffer);
itemNode.Add(imageBase64String);
}
void ISimpleXmlSerializer.ToXElement(XElement element, string refNodeName)
{
if (refNodeName.IsNotEmpty())
{
element = element.AddChildElement(refNodeName);
}
((ISimpleXmlSerializer)this.Properties).ToXElement(element, string.Empty);
if (this.Resources.Count > 0)
{
((ISimpleXmlSerializer)this.Resources).ToXElement(element, "Resources");
}
if (this.CancelSubProcessNotifier.Count > 0)
{
((ISimpleXmlSerializer)this.CancelSubProcessNotifier).ToXElement(element, "CancelSubProcessNotifier");
}
if (this.Condition.IsEmpty == false)
{
((ISimpleXmlSerializer)this.Condition).ToXElement(element, "Condition");
}
if (this.OperationDefinition != null)
{
((ISimpleXmlSerializer)this.OperationDefinition).ToXElement(element, "OperationDefinition");
}
if (this.RelativeLinks.Count > 0)
{
((ISimpleXmlSerializer)this.RelativeLinks).ToXElement(element, "RelativeLinks");
}
}
void ISimpleXmlSerializer.ToXElement(XElement element, string refNodeName)
{
element.NullCheck("element");
if (refNodeName.IsNotEmpty())
{
element = element.AddChildElement(refNodeName);
}
element.SetAttributeValue("ID", this.ID);
if (this.name != null)
{
element.SetAttributeValue("Name", this.name);
}
if (this.codeName != null)
{
element.SetAttributeValue("CodeName", this.codeName);
}
if (this.fullCodeName != null)
{
element.SetAttributeValue("FullCodeName", this.fullCodeName);
}
}
public override XElement AsXElement(XNamespace ns)
{
if (ns == null)
{
ns = string.Empty;
}
var element = new XElement(ns + XmlNodeName);
foreach (var prop in Properties)
{
// component type does not get serialized out, it becomes the node name
if (prop.Key == CommonProperties.Type)
{
continue;
}
element.AddAttributeIfHasValue(prop.Key, prop.Value);
}
element
.AddChildElement(DataItems.AsXElement(ns))
.AddChildElement(Components.AsXElement(ns));
return(element);
}
private void SerializeIEnumerableObject(XElement parent, IEnumerable graph, XmlSerializeContext context)
{
//此处对一维数组与list<类型>的处理,其它的都以base64string处理
Type objectType = graph.GetType();
if (objectType.IsArray)
{
(objectType.GetArrayRank() == 1).FalseThrow <InvalidOperationException>("{0}不是一维数组，我们只支持一维数组", objectType.FullName);
int rank = GetArrayRank(objectType);
if (rank == 1)
{
parent.SetAttributeValue("dimLength", GetArrayDimensionsLength(objectType.GetArrayRank(), (Array)graph));
SerializeIEnumerableOjbectToNode(graph, context, parent);
}
else
{
//嵌套数组
parent.AddChildElement("Value", SerializationHelper.SerializeObjectToString(graph, SerializationFormatterType.Binary));
}
}
else
{
SerializeIEnumerableOjbectToNode(graph, context, parent);
}
}
public override XElement AsXElement(XNamespace ns)
{
if (ns == null)
{
ns = string.Empty;
}
var element = new XElement(ns + NodeNames.Device);
foreach (var prop in Properties)
{
element.AddAttributeIfHasValue(prop.Key, prop.Value);
}
var dataItemElement = DataItems.AsXElement(ns);
//foreach(var condition in Conditions.AsXElement(ns).Elements(ns + NodeNames.DataItem))
//{
// dataItemElement.Add(condition);
//}
element
.AddChildElement(dataItemElement)
.AddChildElement(Components.AsXElement(ns));
return(element);
}
public void Serialize(XElement node, XmlSerializeContext context)
{
List <int> idList = new List <int>(50);
foreach (PropertyValue pv in this)
{
int objID = 0;
var newpv = pv.Clone();
if (newpv.Definition.DefaultValue.IsNullOrEmpty())
{
newpv.Definition.DefaultValue = string.Empty;
}
if (newpv.StringValue.IsNullOrEmpty())
{
newpv.StringValue = string.Empty;
}
if (context.ObjectContext.TryGetValue(newpv, out objID) && newpv.Definition.DefaultValue.ToLower() == newpv.StringValue.ToLower())
{
idList.Add(objID);
}
else
{
XElement itemNode = node.AddChildElement("I");
newpv.Serialize(itemNode, context);
}
}
if (idList.Count > 0)
{
node.SetAttributeValue("_pvs", string.Join(",", idList.ToArray()));
}
}
/// <summary>method add "Amendments" data block
/// </summary>
/// <param name="xmlDataDocument">XML document with report data</param>
private void AddAmendmentsData(XElement xmlDataDocument)
{
XElement destAmendments = this.AddChildElement(AmendmentCollectionName);
IEnumerable <XElement> srcAmendments = xmlDataDocument.Descendants(AmendmentItemName);
PageHeader.HasAmendments = (srcAmendments.Count() > 0);
for (int i = 0; i < srcAmendments.Count(); i++)
{
XElement srcAmendment = srcAmendments.ElementAt(i);
XElement destAmendment = destAmendments.AddChildElement(AmendmentItemName);
destAmendment.AddChildElement(RevisedDiagnosis, (srcAmendment.Element(RevisedDiagnosis) == null ? "false" : (srcAmendment.Element(RevisedDiagnosis).Value == "1" ? "true" : "false")));
destAmendment.AddChildElement(AmendmentType, srcAmendment.Element(AmendmentType).Value);
destAmendment.AddChildElement(AmendmentTime, srcAmendment.Element(AmendmentTime).Value);
destAmendment.AddChildElement(AmendmentText, srcAmendment.Element(AmendmentText).Value);
destAmendment.AddChildElement(AmendmentPathologistSignature, srcAmendment.Element(AmendmentPathologistSignature).Value);
}
}
/// <summary>method add result data colection
/// </summary>
/// <param name="xmlDataDocument">XML document with report data</param>
private void AddResultData(string reportNo, XElement xmlDataDocument)
{
IEnumerable <XElement> resultsList = xmlDataDocument.Descendants("PanelOrder").Where(e => e.Element("ReportNo").Value == reportNo);
XElement result = this.AddChildElement(ResultName);
if (resultsList.Count() > 0)
{
XElement resultSource = resultsList.FirstOrDefault().Element("TestOrderCollection").Elements("TestOrder").FirstOrDefault();
result.AddChildElement(TestName, m_TestName);
result.AddChildElement(TestResult, (resultSource != null ? resultSource.GetStringValue("Result") : string.Empty));
}
else
{
result.AddChildElement(TestName);
result.AddChildElement(TestResult);
}
}
public void ToSimpleXElement(XElement element, string childNodeName)
{
if (this.Count > 0)
{
XElement childNode = element.AddChildElement(childNodeName);
((ISimpleXmlSerializer)this).ToXElement(childNode, string.Empty);
}
}
void ISimpleXmlSerializer.ToXElement(XElement element, string refNodeName)
{
foreach (IWfActivity activity in this)
{
XElement actElem = element.AddChildElement("Activity");
((ISimpleXmlSerializer)activity).ToXElement(actElem, refNodeName);
}
}
void ISimpleXmlSerializer.ToXElement(XElement element, string refNodeName)
{
foreach (WfAssignee assignee in this)
{
XElement childElem = element.AddChildElement("User");
((ISimpleXmlSerializer)assignee).ToXElement(childElem, refNodeName);
}
}
void ISimpleXmlSerializer.ToXElement(XElement element, string refNodeName)
{
element.NullCheck("element");
if (refNodeName.IsNotEmpty())
{
element = element.AddChildElement(refNodeName);
}
element.SetAttributeValue("expression", this.Expression);
}
void ISimpleXmlSerializer.ToXElement(XElement element, string refNodeName)
{
if (refNodeName.IsNotEmpty())
{
element = element.AddChildElement(refNodeName);
}
element.SetAttributeValue("key", this.Key);
element.SetAttributeValue("serviceNS", this.ServiceNS);
element.SetAttributeValue("address", this.Address);
}
