private void WritePropertiesWhichAreAttributes(EXmlWriter wrt, object item, List <PropertyInfo> attProps)
{
attProps.ForEach(i =>
{
EvaluatePropertyFormatAndWriteIt(wrt, item, i, WritePropertyAsAttribute);
});
}
private void WritePropertyAsAttribute(EXmlWriter wrt, object item, PropertyInfo property)
{
var beh = GetXmlBehaviorOf(property);
bool cultureAdded = base.AddCultureIfRequired(beh);
object objValue = GetPropertyValue(item, property);
// pokud je hodnota NULL, tak se nic neuklada
if (objValue != null)
{
string strValue;
if (objValue is bool && beh.ExplicitBoolTrueFalseValues != null)
{
strValue = beh.GetExplicitBoolValueFor((bool)objValue);
}
else
{
strValue = GetToStringValue(objValue, beh.Format);
}
string attribName = GetAttributeName(property.Name, beh);
if (cultureAdded)
{
base.RemoveCulture();
}
wrt.AddAttribute(attribName, strValue);
}
}
private void WritePropertiesWhichAreElements(EXmlWriter wrt, object item, List <PropertyInfo> elmProps)
{
elmProps.ForEach(i =>
{
EvaluatePropertyFormatAndWriteIt(wrt, item, i, WritePropertyAsElement);
});
}
private void WritePropertyAsElement(EXmlWriter wrt, object item, PropertyInfo property)
{
var beh = property.GetXmlBehavior();
object val = GetPropertyValue(item, property);
string elementName = null;
int hierarchyLevel = 0;
if (beh.IsXmlMappingToSelf())
{
elementName = null;
}
else if (beh.IsXmlMappingWithHierarchy())
{
hierarchyLevel = BuildHierarchy(wrt, beh.XmlMapping);
}
else if (beh.XmlMapping != null)
{
elementName = beh.XmlMapping;
}
else
{
elementName = GetElementName(property);
}
SerializeItem(wrt, elementName, val, property.PropertyType);
if (hierarchyLevel > 0)
{
for (int i = 0; i < hierarchyLevel; i++)
{
wrt.EndElement();
}
}
}
private int BuildHierarchy(EXmlWriter wrt, string mapping)
{
string[] elms = mapping.Split('/');
for (int i = 0; i < elms.Length - 1; i++)
{
wrt.BeginElement(elms[i]);
}
return(elms.Length - 1);
}
public void Serialize(EXmlWriter wrt, object item, string elementName, string dtdFile)
{
wrt.WriteDocumentHeader();
if (string.IsNullOrEmpty(dtdFile) == false)
{
wrt.WriteDoctype(elementName, dtdFile);
}
SerializeItem(wrt, elementName, item, null);
}
private void WriteDesiredTypeAttributeIfRequired(EXmlWriter wrt, bool isElementNameEmpty, object item, Type desiredType)
{
if (desiredType != null &&
item.GetType() != desiredType)
{
if (isElementNameEmpty)
{
throw new Exception("Cannot write desired-type attribute, because mapping defines that inner element is mapped to its parent.");
}
wrt.AddAttribute(DESIRED_TYPE_ATTRIBUTE, item.GetType().FullName);
}
}
private void SaveIEnumerableItems(EXmlWriter wrt, object item)
{
System.Collections.IEnumerable lst;
lst = ConvertToIEnumerable(item);
var beh = item.GetType().GetXmlTypeBehavior();
string elementName = beh.IListItemXmlElement;
Type itemType = base.GetTypeOfListItem(lst);
foreach (var it in lst)
{
SerializeItem(wrt, elementName, it, itemType);
}
}
private void EvaluatePropertyFormatAndWriteIt(EXmlWriter wrt, object item, PropertyInfo property,
Action <EXmlWriter, object, PropertyInfo> actionForNonFormat)
{
var beh = property.GetXmlBehavior();
if (string.IsNullOrEmpty(beh.Format))
{
actionForNonFormat(wrt, item, property);
}
else
{
string elementName = GetElementName(property);
object val = GetPropertyValue(item, property);
WriteToStringAsElement(wrt, elementName, val, beh.Format);
}
}
private void SaveObject(EXmlWriter wrt, object item, string elementName, Type desiredType, bool isObjectIEnumerable)
{
List <PropertyInfo> elmProps;
List <PropertyInfo> attProps;
AnalyseProperties(item, isObjectIEnumerable, out elmProps, out attProps);
if (attProps.Count > 0 && elementName == null)
{
throw new Exception("Unable to have xmlAttribute-properties in type which XmlMapping defines item to its subject xml element.");
}
if (elementName != null)
{
wrt.BeginOpeningTag(elementName);
}
WriteDesiredTypeAttributeIfRequired(wrt, elementName == null, item, desiredType);
WritePropertiesWhichAreAttributes(wrt, item, attProps);
// this is here to build .. /> in XML
if (elmProps.Count > 0 || isObjectIEnumerable)
{
if (elementName != null)
{
wrt.EndOpeningTag();
}
WritePropertiesWhichAreElements(wrt, item, elmProps);
if (isObjectIEnumerable)
{
SaveIEnumerableItems(wrt, item);
}
}
if (elementName != null)
{
wrt.EndElement();
}
}
private void SerializeItem(EXmlWriter wrt, string elementName, object item, Type desiredType)
{
eBehavior beh = GetBehaviorOf(item.GetType());
switch (beh)
{
case eBehavior.Primitive:
case eBehavior.String:
WriteToStringAsElement(wrt, elementName, item, null);
break;
case eBehavior.IEnumerable:
SaveObject(wrt, item, elementName, desiredType, true);
break;
case eBehavior.DataType:
SaveObject(wrt, item, elementName, desiredType, false);
break;
default:
throw new NotImplementedException();
}
}
private void WriteBooleanAsElement(EXmlWriter wrt, string element, object item, string explicitValues)
{
string t = true.ToString();
string f = false.ToString();
if (explicitValues != null)
{
string[] spl = explicitValues.Split(';');
t = spl[0];
f = spl[1];
}
bool value = (bool)item;
string valueString;
if (value)
{
valueString = t;
}
else
{
valueString = f;
}
wrt.WriteElement(element, valueString);
}
private void WriteToStringAsElement(EXmlWriter wrt, string element, object item, string formatIfAny)
{
string value = GetToStringValue(item, formatIfAny);
wrt.WriteElement(element, value);
}
