private bool FillRecord(object rec, Tuple <long, XElement> pair)
{
long lineNo;
XElement node;
lineNo = pair.Item1;
node = pair.Item2;
fXElements = null;
fieldValue = null;
fieldConfig = null;
pi = null;
xpn = node.CreateNavigator(Configuration.NamespaceManager.NameTable);
ToDictionary(node);
foreach (KeyValuePair <string, ChoXmlRecordFieldConfiguration> kvp in Configuration.RecordFieldConfigurationsDict)
{
fieldValue = null;
fieldConfig = kvp.Value;
if (Configuration.PIDict != null)
{
Configuration.PIDict.TryGetValue(kvp.Key, out pi);
}
if (fieldConfig.XPath == "text()")
{
if (Configuration.GetNameWithNamespace(node.Name) == fieldConfig.FieldName)
{
object value = node;
if (!RaiseBeforeRecordFieldLoad(rec, pair.Item1, kvp.Key, ref value))
{
continue;
}
if (fieldConfig.ValueConverter != null)
{
value = fieldConfig.ValueConverter(value);
}
fieldValue = value is XElement ? ((XElement)value).ToObjectFromXml(typeof(ChoDynamicObject)) : value;
//fieldValue = value is XElement ? node.Value : value;
}
else if (Configuration.ColumnCountStrict)
{
throw new ChoParserException("Missing '{0}' xml node.".FormatString(fieldConfig.FieldName));
}
}
else
{
if (/*!fieldConfig.UseCache && */ !xDict.ContainsKey(fieldConfig.FieldName))
{
xNodes.Clear();
foreach (XPathNavigator z in xpn.Select(fieldConfig.XPath, Configuration.NamespaceManager))
{
xNodes.Add(z.UnderlyingObject);
}
object value = xNodes;
if (!RaiseBeforeRecordFieldLoad(rec, pair.Item1, kvp.Key, ref value))
{
continue;
}
if (fieldConfig.ValueConverter != null)
{
fieldValue = fieldConfig.ValueConverter(value);
}
else
{
//object[] xNodes = ((IEnumerable)node.XPathEvaluate(fieldConfig.XPath, Configuration.NamespaceManager)).OfType<object>().ToArray();
//continue;
XAttribute[] fXAttributes = xNodes.OfType <XAttribute>().ToArray();
if (!fXAttributes.IsNullOrEmpty()) //fXAttribute != null)
{
//fieldValue = fXAttribute.Value;
if (fieldConfig.FieldType == null)
{
if (fXAttributes.Length == 1)
{
if (fieldConfig.ItemConverter != null)
{
fieldValue = fieldConfig.ItemConverter(fXAttributes[0]);
}
else
{
fieldValue = fXAttributes[0].Value;
}
}
else
{
List <object> arr = new List <object>();
foreach (var ele in fXAttributes)
{
if (fieldConfig.ItemConverter != null)
{
arr.Add(fieldConfig.ItemConverter(ele));
}
else
{
arr.Add(ele.Value);
}
}
fieldValue = arr.ToArray();
}
}
else if (fieldConfig.FieldType == typeof(string) || fieldConfig.FieldType.IsSimple())
{
XAttribute fXElement = fXAttributes.FirstOrDefault();
if (fXElement != null)
{
if (fieldConfig.ItemConverter != null)
{
fieldValue = fieldConfig.ItemConverter(fXElement);
}
else
{
fieldValue = fXElement.Value;
}
}
}
else if (fieldConfig.FieldType.IsCollection())
{
List <object> list = new List <object>();
Type itemType = fieldConfig.FieldType.GetItemType().GetUnderlyingType();
foreach (var ele in fXAttributes)
{
if (fieldConfig.ItemConverter != null)
{
list.Add(fieldConfig.ItemConverter(ele));
}
else
{
if (itemType.IsSimple())
{
list.Add(ChoConvert.ConvertTo(ele.Value, itemType));
}
else
{
list.Add(ele.Value);
}
}
}
fieldValue = list.ToArray();
}
else
{
XAttribute fXElement = fXAttributes.FirstOrDefault();
if (fXElement != null)
{
if (fieldConfig.ItemConverter != null)
{
fieldValue = fieldConfig.ItemConverter(fXElement);
}
else
{
fieldValue = fXElement.Value;
}
}
}
}
else
{
fXElements = xNodes.OfType <XElement>().ToArray();
if (!fXElements.IsNullOrEmpty())
{
if (fieldConfig.IsArray != null && fieldConfig.IsArray.Value)
{
List <object> list = new List <object>();
Type itemType = fieldConfig.FieldType != null?fieldConfig.FieldType.GetItemType().GetUnderlyingType() :
typeof(ChoDynamicObject);
foreach (var ele in fXElements)
{
if (fieldConfig.ItemConverter != null)
{
list.Add(fieldConfig.ItemConverter(ele));
}
else
{
if (itemType.IsSimple())
{
list.Add(ChoConvert.ConvertTo(ele.Value, itemType));
}
else
{
if (itemType == typeof(ChoDynamicObject))
{
list.Add(ele.ToDynamic());
}
else
{
list.Add(ele.ToObjectFromXml(itemType, GetXmlOverrides(fieldConfig)));
}
}
}
}
fieldValue = list.ToArray();
}
else
{
if (fieldConfig.FieldType == null ||
fieldConfig.FieldType == typeof(object) ||
fieldConfig.FieldType.GetItemType() == typeof(object))
{
if (fXElements.Length == 1)
{
if (fieldConfig.ItemConverter != null)
{
fieldValue = fieldConfig.ItemConverter(fXElements[0]);
}
else
{
fieldValue = fXElements[0].ToObjectFromXml(typeof(ChoDynamicObject));
}
}
else
{
List <object> arr = new List <object>();
foreach (var ele in fXElements)
{
if (fieldConfig.ItemConverter != null)
{
arr.Add(fieldConfig.ItemConverter(ele));
}
else
{
arr.Add(ele.ToObjectFromXml(typeof(ChoDynamicObject)) as ChoDynamicObject);
}
}
fieldValue = arr.ToArray();
}
}
else if (fieldConfig.FieldType == typeof(string) || fieldConfig.FieldType.IsSimple())
{
XElement fXElement = fXElements.FirstOrDefault();
if (fXElement != null)
{
if (fieldConfig.ItemConverter != null)
{
fieldValue = fieldConfig.ItemConverter(fXElement);
}
else
{
fieldValue = fXElement.Value;
}
}
}
else if (fieldConfig.FieldType.IsCollection())
{
List <object> list = new List <object>();
Type itemType = fieldConfig.FieldType.GetItemType().GetUnderlyingType();
//if (!itemType.IsSimple())
//{
// fXElements = fXElements.SelectMany(e => e.Elements()).ToArray();
//}
foreach (var ele in fXElements)
{
if (fieldConfig.ItemConverter != null)
{
list.Add(fieldConfig.ItemConverter(ele));
}
else
{
if (itemType.IsSimple())
{
list.Add(ChoConvert.ConvertTo(ele.Value, itemType));
}
else
{
list.Add(ele.ToObjectFromXml(itemType, null));
}
}
}
fieldValue = list.ToArray();
}
else
{
XElement fXElement = fXElements.FirstOrDefault(); //.SelectMany(e => e.Elements()).FirstOrDefault();
if (fXElement != null)
{
if (fieldConfig.ItemConverter != null)
{
fieldValue = fieldConfig.ItemConverter(fXElement);
}
else
{
fieldValue = fXElement.ToObjectFromXml(fieldConfig.FieldType, null);
}
}
}
}
}
else
{
XText[] xTexts = xNodes.OfType <XText>().ToArray();
if (!xTexts.IsNullOrEmpty())
{
if (fieldConfig.FieldType == null)
{
if (xTexts.Length == 1)
{
if (fieldConfig.ItemConverter != null)
{
fieldValue = fieldConfig.ItemConverter(xTexts[0]);
}
else
{
fieldValue = xTexts[0].Value;
}
}
else
{
List <object> arr = new List <object>();
foreach (var ele in xTexts)
{
if (fieldConfig.ItemConverter != null)
{
arr.Add(fieldConfig.ItemConverter(ele));
}
else
{
arr.Add(ele.Value);
}
}
fieldValue = arr.ToArray();
}
}
else if (fieldConfig.FieldType == typeof(string) || fieldConfig.FieldType.IsSimple())
{
XText fXElement = xTexts.FirstOrDefault();
if (fXElement != null)
{
if (fieldConfig.ItemConverter != null)
{
fieldValue = fieldConfig.ItemConverter(fXElement);
}
else
{
fieldValue = fXElement.Value;
}
}
}
else if (fieldConfig.FieldType.IsCollection())
{
List <object> list = new List <object>();
Type itemType = fieldConfig.FieldType.GetItemType().GetUnderlyingType();
foreach (var ele in xTexts)
{
if (fieldConfig.ItemConverter != null)
{
list.Add(fieldConfig.ItemConverter(ele));
}
else
{
if (itemType.IsSimple())
{
list.Add(ChoConvert.ConvertTo(ele.Value, itemType));
}
else
{
list.Add(ele.Value);
}
}
}
fieldValue = list.ToArray();
}
else
{
XText fXElement = xTexts.FirstOrDefault();
if (fXElement != null)
{
if (fieldConfig.ItemConverter != null)
{
fieldValue = fieldConfig.ItemConverter(fXElement);
}
else
{
fieldValue = fXElement.Value;
}
}
}
}
else if (Configuration.ColumnCountStrict)
{
throw new ChoParserException("Missing '{0}' xml node.".FormatString(fieldConfig.FieldName));
}
}
}
}
}
else
{
if (xDict[fieldConfig.FieldName].Count == 1)
{
fieldValue = xDict[fieldConfig.FieldName][0];
}
else
{
fieldValue = xDict[fieldConfig.FieldName];
}
if (!RaiseBeforeRecordFieldLoad(rec, pair.Item1, kvp.Key, ref fieldValue))
{
continue;
}
if (fieldConfig.ValueConverter != null)
{
fieldValue = fieldConfig.ValueConverter(fieldValue);
}
}
}
if (Configuration.IsDynamicObject)
{
if (fieldValue != null && kvp.Value.FieldType == null && lineNo == 1)
{
kvp.Value.FieldType = fieldValue is ICollection?fieldValue.GetType() : fieldValue.GetType().IsSimple() ? DiscoverFieldType(fieldValue as string) : null;
}
}
else
{
if (pi != null)
{
kvp.Value.FieldType = pi.PropertyType;
}
else
{
kvp.Value.FieldType = typeof(string);
}
}
if (fieldValue is string)
{
fieldValue = CleanFieldValue(fieldConfig, kvp.Value.FieldType, fieldValue as string, kvp.Value.EncodeValue);
}
try
{
bool ignoreFieldValue = fieldConfig.IgnoreFieldValue(fieldValue);
if (ignoreFieldValue)
{
fieldValue = fieldConfig.IsDefaultValueSpecified ? fieldConfig.DefaultValue : null;
}
if (Configuration.IsDynamicObject)
{
var dict = rec as IDictionary <string, Object>;
if (!fieldConfig.IsArray.CastTo <bool>())
{
dict.ConvertNSetMemberValue(kvp.Key, kvp.Value, ref fieldValue, Configuration.Culture);
}
else
{
dict[kvp.Key] = fieldValue;
}
if ((Configuration.ObjectValidationMode & ChoObjectValidationMode.MemberLevel) == ChoObjectValidationMode.MemberLevel)
{
dict.DoMemberLevelValidation(kvp.Key, kvp.Value, Configuration.ObjectValidationMode);
}
}
else
{
if (pi != null)
{
rec.ConvertNSetMemberValue(kvp.Key, kvp.Value, ref fieldValue, Configuration.Culture);
}
else
{
throw new ChoMissingRecordFieldException("Missing '{0}' property in {1} type.".FormatString(kvp.Key, ChoType.GetTypeName(rec)));
}
if ((Configuration.ObjectValidationMode & ChoObjectValidationMode.MemberLevel) == ChoObjectValidationMode.MemberLevel)
{
rec.DoMemberLevelValidation(kvp.Key, kvp.Value, Configuration.ObjectValidationMode);
}
}
if (!RaiseAfterRecordFieldLoad(rec, pair.Item1, kvp.Key, fieldValue))
{
return(false);
}
}
catch (ChoParserException)
{
Reader.IsValid = false;
throw;
}
catch (ChoMissingRecordFieldException)
{
Reader.IsValid = false;
if (Configuration.ThrowAndStopOnMissingField)
{
throw;
}
}
catch (Exception ex)
{
Reader.IsValid = false;
ChoETLFramework.HandleException(ref ex);
if (fieldConfig.ErrorMode == ChoErrorMode.ThrowAndStop)
{
throw;
}
try
{
if (Configuration.IsDynamicObject)
{
var dict = rec as IDictionary <string, Object>;
if (dict.SetFallbackValue(kvp.Key, kvp.Value, Configuration.Culture, ref fieldValue))
{
dict.DoMemberLevelValidation(kvp.Key, kvp.Value, Configuration.ObjectValidationMode);
}
else if (dict.SetDefaultValue(kvp.Key, kvp.Value, Configuration.Culture))
{
dict.DoMemberLevelValidation(kvp.Key, kvp.Value, Configuration.ObjectValidationMode);
}
else
{
throw new ChoReaderException($"Failed to parse '{fieldValue}' value for '{fieldConfig.FieldName}' field.", ex);
}
}
else if (pi != null)
{
if (rec.SetFallbackValue(kvp.Key, kvp.Value, Configuration.Culture))
{
rec.DoMemberLevelValidation(kvp.Key, kvp.Value, Configuration.ObjectValidationMode);
}
else if (rec.SetDefaultValue(kvp.Key, kvp.Value, Configuration.Culture))
{
rec.DoMemberLevelValidation(kvp.Key, kvp.Value, Configuration.ObjectValidationMode);
}
else
{
throw new ChoReaderException($"Failed to parse '{fieldValue}' value for '{fieldConfig.FieldName}' field.", ex);
}
}
else
{
throw new ChoReaderException($"Failed to parse '{fieldValue}' value for '{fieldConfig.FieldName}' field.", ex);
}
}
catch (Exception innerEx)
{
if (ex == innerEx.InnerException)
{
if (fieldConfig.ErrorMode == ChoErrorMode.IgnoreAndContinue)
{
continue;
}
else
{
if (!RaiseRecordFieldLoadError(rec, pair.Item1, kvp.Key, fieldValue, ex))
{
throw new ChoReaderException($"Failed to parse '{fieldValue}' value for '{fieldConfig.FieldName}' field.", ex);
}
}
}
else
{
throw new ChoReaderException("Failed to assign '{0}' fallback value to '{1}' field.".FormatString(fieldValue, fieldConfig.FieldName), innerEx);
}
}
}
}
return(true);
}
private bool ToText(long index, object rec, out string recText)
{
if (typeof(IChoScalarObject).IsAssignableFrom(Configuration.RecordType))
{
rec = Activator.CreateInstance(Configuration.RecordType, rec);
}
recText = null;
if (rec == null)
{
if (Configuration.NullValueHandling == ChoNullValueHandling.Ignore)
{
return(false);
}
else if (Configuration.NullValueHandling == ChoNullValueHandling.Default)
{
rec = Activator.CreateInstance(Configuration.RecordType);
}
else
{
recText = @"<{0} xsi:nil=""true"" />".FormatString(Configuration.NodeName
).Indent(Configuration.Indent * 1, Configuration.IndentChar.ToString());
return(true);
}
}
StringBuilder msg = new StringBuilder();
object fieldValue = null;
string fieldText = null;
ChoXmlRecordFieldConfiguration fieldConfig = null;
if (Configuration.ColumnCountStrict)
{
CheckColumnsStrict(rec);
}
//bool firstColumn = true;
PropertyInfo pi = null;
bool isElementClosed = false;
bool isElementStart = false;
foreach (KeyValuePair <string, ChoXmlRecordFieldConfiguration> kvp in GetOrderedKVP())
{
fieldConfig = kvp.Value;
fieldValue = null;
fieldText = String.Empty;
if (Configuration.PIDict != null)
{
Configuration.PIDict.TryGetValue(kvp.Key, out pi);
}
if (Configuration.ThrowAndStopOnMissingField)
{
if (Configuration.IsDynamicObject)
{
var dict = rec.ToDynamicObject() as IDictionary <string, Object>;
if (!dict.ContainsKey(kvp.Key))
{
throw new ChoMissingRecordFieldException("No matching property found in the object for '{0}' Xml node.".FormatString(fieldConfig.FieldName));
}
}
else
{
if (pi == null)
{
throw new ChoMissingRecordFieldException("No matching property found in the object for '{0}' Xml node.".FormatString(fieldConfig.FieldName));
}
}
}
try
{
if (Configuration.IsDynamicObject)
{
IDictionary <string, Object> dict = rec.ToDynamicObject() as IDictionary <string, Object>;
fieldValue = dict[kvp.Key]; // dict.GetValue(kvp.Key, Configuration.FileHeaderConfiguration.IgnoreCase, Configuration.Culture);
if (kvp.Value.FieldType == null)
{
if (fieldValue == null)
{
kvp.Value.FieldType = typeof(string);
}
else
{
kvp.Value.FieldType = fieldValue.GetType();
}
}
}
else
{
if (pi != null)
{
fieldValue = ChoType.GetPropertyValue(rec, pi);
if (kvp.Value.FieldType == null)
{
kvp.Value.FieldType = pi.PropertyType;
}
}
else
{
kvp.Value.FieldType = typeof(string);
}
}
//Discover default value, use it if null
if (fieldValue == null)
{
if (fieldConfig.IsDefaultValueSpecified)
{
fieldValue = fieldConfig.DefaultValue;
}
}
if (!RaiseBeforeRecordFieldWrite(rec, index, kvp.Key, ref fieldValue))
{
return(false);
}
if (fieldConfig.ValueConverter != null)
{
fieldValue = fieldConfig.ValueConverter(fieldValue);
}
else
{
rec.GetNConvertMemberValue(kvp.Key, kvp.Value, Configuration.Culture, ref fieldValue, true);
}
if ((Configuration.ObjectValidationMode & ChoObjectValidationMode.ObjectLevel) == ChoObjectValidationMode.MemberLevel)
{
rec.DoMemberLevelValidation(kvp.Key, kvp.Value, Configuration.ObjectValidationMode, fieldValue);
}
if (!RaiseAfterRecordFieldWrite(rec, index, kvp.Key, fieldValue))
{
return(false);
}
}
catch (ChoParserException)
{
throw;
}
catch (ChoMissingRecordFieldException)
{
if (Configuration.ThrowAndStopOnMissingField)
{
throw;
}
}
catch (Exception ex)
{
ChoETLFramework.HandleException(ex);
if (fieldConfig.ErrorMode == ChoErrorMode.ThrowAndStop)
{
throw;
}
try
{
if (Configuration.IsDynamicObject)
{
var dict = rec.ToDynamicObject() as IDictionary <string, Object>;
if (dict.GetFallbackValue(kvp.Key, kvp.Value, Configuration.Culture, ref fieldValue))
{
dict.DoMemberLevelValidation(kvp.Key, kvp.Value, Configuration.ObjectValidationMode, fieldValue);
}
else if (dict.GetDefaultValue(kvp.Key, kvp.Value, Configuration.Culture, ref fieldValue))
{
dict.DoMemberLevelValidation(kvp.Key, kvp.Value, Configuration.ObjectValidationMode, fieldValue);
}
else
{
throw new ChoWriterException($"Failed to write '{fieldValue}' value for '{fieldConfig.FieldName}' member.", ex);
}
}
else if (pi != null)
{
if (rec.GetFallbackValue(kvp.Key, kvp.Value, Configuration.Culture, ref fieldValue))
{
rec.DoMemberLevelValidation(kvp.Key, kvp.Value, Configuration.ObjectValidationMode);
}
else if (rec.GetDefaultValue(kvp.Key, kvp.Value, Configuration.Culture, ref fieldValue))
{
rec.DoMemberLevelValidation(kvp.Key, kvp.Value, Configuration.ObjectValidationMode, fieldValue);
}
else
{
throw new ChoWriterException($"Failed to write '{fieldValue}' value for '{fieldConfig.FieldName}' member.", ex);
}
}
else
{
throw new ChoWriterException($"Failed to write '{fieldValue}' value for '{fieldConfig.FieldName}' member.", ex);
}
}
catch (Exception innerEx)
{
if (ex == innerEx.InnerException)
{
if (fieldConfig.ErrorMode == ChoErrorMode.IgnoreAndContinue)
{
continue;
}
else
{
if (!RaiseRecordFieldWriteError(rec, index, kvp.Key, fieldText, ex))
{
throw new ChoWriterException($"Failed to write '{fieldValue}' value of '{kvp.Key}' member.", ex);
}
}
}
else
{
throw new ChoWriterException("Failed to use '{0}' fallback value for '{1}' member.".FormatString(fieldValue, kvp.Key), innerEx);
}
}
}
if (fieldValue == null)
{
if (!fieldConfig.IsXmlAttribute && fieldConfig.IsNullable)
{
if (Configuration.RecordType == typeof(ChoScalarObject))
{
if (!isElementStart)
{
msg.Append(@"<{0} xsi:nil=""true""".FormatString(Configuration.NodeName).Indent(Configuration.Indent, Configuration.IndentChar.ToString()));
isElementStart = true;
}
if (!isElementClosed)
{
msg.AppendFormat(">{0}", Configuration.EOLDelimiter);
isElementClosed = true;
}
}
else
{
if (!isElementStart)
{
msg.Append("<{0}".FormatString(Configuration.NodeName).Indent(Configuration.Indent, Configuration.IndentChar.ToString()));
isElementStart = true;
}
if (!isElementClosed)
{
msg.AppendFormat(">{0}", Configuration.EOLDelimiter);
isElementClosed = true;
}
msg.Append(@"<{0} xsi:nil=""true"" />{1}".FormatString(fieldConfig.FieldName,
Configuration.EOLDelimiter).Indent(Configuration.Indent * 2, Configuration.IndentChar.ToString()));
}
}
else
{
if (Configuration.RecordType != typeof(ChoScalarObject))
{
if (!isElementStart)
{
msg.Append("<{0}".FormatString(Configuration.NodeName).Indent(Configuration.Indent, Configuration.IndentChar.ToString()));
isElementStart = true;
}
}
//isElementClosed = true;
fieldText = String.Empty;
}
}
else
{
if (!isElementStart)
{
msg.Append("<{0}".FormatString(Configuration.NodeName).Indent(Configuration.Indent, Configuration.IndentChar.ToString()));
isElementStart = true;
}
if (fieldValue.GetType().IsSimple())
{
fieldText = fieldValue.ToString();
if (Configuration.RecordType == typeof(ChoScalarObject))
{
if (fieldConfig.IsXmlAttribute)
{
msg.Append(@" {0}=""{1}""".FormatString(fieldConfig.FieldName, NormalizeFieldValue(kvp.Key, fieldText, kvp.Value.Size, kvp.Value.Truncate, kvp.Value.QuoteField, GetFieldValueJustification(kvp.Value.FieldValueJustification, kvp.Value.FieldType), GetFillChar(kvp.Value.FillChar, kvp.Value.FieldType), false)));
}
else
{
if (!isElementClosed)
{
msg.AppendFormat(">{0}", Configuration.EOLDelimiter);
isElementClosed = true;
}
msg.Append("{0}{1}".FormatString(
NormalizeFieldValue(kvp.Key, fieldText, kvp.Value.Size, kvp.Value.Truncate, kvp.Value.QuoteField, GetFieldValueJustification(kvp.Value.FieldValueJustification, kvp.Value.FieldType), GetFillChar(kvp.Value.FillChar, kvp.Value.FieldType), false),
Configuration.EOLDelimiter).Indent(Configuration.Indent * 2, Configuration.IndentChar.ToString()));
}
}
else if (fieldConfig.IsXmlAttribute)
{
msg.Append(@" {0}=""{1}""".FormatString(fieldConfig.FieldName, NormalizeFieldValue(kvp.Key, fieldText, kvp.Value.Size, kvp.Value.Truncate, kvp.Value.QuoteField, GetFieldValueJustification(kvp.Value.FieldValueJustification, kvp.Value.FieldType), GetFillChar(kvp.Value.FillChar, kvp.Value.FieldType), false)));
}
else
{
if (!isElementClosed)
{
msg.AppendFormat(">{0}", Configuration.EOLDelimiter);
isElementClosed = true;
}
msg.Append("<{0}>{1}</{0}>{2}".FormatString(fieldConfig.FieldName,
NormalizeFieldValue(kvp.Key, fieldText, kvp.Value.Size, kvp.Value.Truncate, kvp.Value.QuoteField, GetFieldValueJustification(kvp.Value.FieldValueJustification, kvp.Value.FieldType), GetFillChar(kvp.Value.FillChar, kvp.Value.FieldType), false),
Configuration.EOLDelimiter).Indent(Configuration.Indent * 2, Configuration.IndentChar.ToString()));
}
}
else
{
fieldText = ChoUtility.XmlSerialize(fieldValue);
fieldText = _beginTagRegex.Replace(fieldText, delegate(Match thisMatch)
{
return("<{0}>".FormatString(fieldConfig.FieldName));
});
fieldText = _endTagRegex.Replace(fieldText, delegate(Match thisMatch)
{
return("</{0}>".FormatString(fieldConfig.FieldName));
});
if (!isElementClosed)
{
msg.AppendFormat(">{0}", Configuration.EOLDelimiter);
isElementClosed = true;
}
msg.Append("{0}{1}".FormatString(fieldText,
Configuration.EOLDelimiter).Indent(Configuration.Indent * 2, Configuration.IndentChar.ToString()));
}
}
}
if (!isElementClosed && msg.Length > 0)
{
msg.AppendFormat(">{0}", Configuration.EOLDelimiter);
isElementClosed = true;
}
if (isElementStart)
{
msg.Append("</{0}>".FormatString(Configuration.NodeName).Indent(Configuration.Indent, Configuration.IndentChar.ToString()));
isElementStart = false;
}
recText = msg.ToString();
return(true);
}