public static bool GetFallbackValue(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, CultureInfo culture, ref object fieldValue)
{
if (rec is ExpandoObject)
{
return(((IDictionary <string, object>)rec).GetFallbackValue(fn, fieldConfig, culture, ref fieldValue));
}
//Set Fallback value to member
bool FallbackValueExists = true;
object FallbackValue = null;
if (fieldConfig.IsFallbackValueSpecified)
{
FallbackValue = fieldConfig.FallbackValue;
}
else if (ChoType.HasFallbackValue(ChoTypeDescriptor.GetProperty(rec.GetType(), fn)))
{
FallbackValue = ChoType.GetRawFallbackValue(ChoTypeDescriptor.GetProperty(rec.GetType(), fn));
}
else
{
FallbackValueExists = false;
}
if (FallbackValueExists)
{
if (fieldConfig.Converters.IsNullOrEmpty())
{
fieldValue = ChoConvert.ConvertTo(FallbackValue, ChoType.GetMemberInfo(rec.GetType(), fn), null, culture);
}
else
{
fieldValue = ChoConvert.ConvertTo(FallbackValue, ChoType.GetMemberType(rec.GetType(), fn), null, fieldConfig.Converters.ToArray(), null, culture);
}
}
return(FallbackValueExists);
}
public static void ConvertNSetMemberValue(this IDictionary <string, object> dict, string fn, ChoRecordFieldConfiguration fieldConfig, ref object fieldValue, CultureInfo culture)
{
if (fieldValue is ChoDynamicObject)
{
((ChoDynamicObject)fieldValue).DynamicObjectName = fn;
}
if (fieldConfig.ValueConverter != null)
{
fieldValue = fieldConfig.ValueConverter(fieldValue);
}
else
{
object[] fcParams = fieldConfig.PropConverterParams;
if (!fieldConfig.FormatText.IsNullOrWhiteSpace())
{
fcParams = new object[] { new object[] { fieldConfig.FormatText } }
}
;
if (fieldConfig.Converters.IsNullOrEmpty())
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, fieldConfig.FieldType, null, fieldConfig.PropConverters, fcParams, culture);
}
else
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, fieldConfig.FieldType, null, fieldConfig.Converters.ToArray(), fcParams, culture);
}
}
dict.AddOrUpdate(fn, fieldValue);
if (dict is ChoDynamicObject && fieldValue == null && fieldConfig.FieldType != null)
{
var dobj = dict as ChoDynamicObject;
dobj.SetMemberType(fn, fieldConfig.FieldType);
}
}
public static void SetDefaultValue(this IDictionary <string, object> dict, string fn, ChoRecordFieldConfiguration fieldConfig, CultureInfo culture)
{
object fieldValue = null;
//Set default value to member
try
{
if (fieldConfig.IsDefaultValueSpecified)
{
if (fieldConfig.Converters.IsNullOrEmpty())
{
fieldValue = ChoConvert.ConvertFrom(fieldConfig.DefaultValue, fieldConfig.FieldType, null, ChoTypeDescriptor.GetTypeConvertersForType(fieldConfig.FieldType), null, culture);
}
else
{
fieldValue = ChoConvert.ConvertFrom(fieldConfig.DefaultValue, fieldConfig.FieldType, null, fieldConfig.Converters.ToArray(), null, culture);
}
dict.AddOrUpdate(fn, fieldValue);
}
}
catch { }
}
public object GetValue(object target)
{
if (MemberInfo != null)
{
return(ChoType.GetMemberValue(target, MemberInfo));
}
else if (target is IDictionary <string, object> ) ///ExpandoObject || target is ChoDynamicObject)
{
IDictionary <string, object> dict = target as IDictionary <string, object>;
if (dict.ContainsKey(MemberName))
{
return(((IDictionary <string, object>)target)[MemberName]);
}
else
{
throw new ApplicationException("Can't find '{0}' member in dynamic object.".FormatString(MemberName));
}
}
else
{
return(ChoConvert.ConvertTo(ChoType.GetMemberValue(target, MemberName), ProperyType));
}
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
if (value != null && _objType != null)
{
value = ChoConvert.ConvertTo(value, _objType, null, _fc.PropConverters, _fc.PropConverterParams, _culture);
}
if (_fc.CustomSerializer == null)
{
if (_fc.ValueConverter == null)
{
JToken t = JToken.FromObject(value);
t.WriteTo(writer);
}
else
{
object retValue = _fc.ValueConverter(value);
Validate(retValue);
ChoETLRecordHelper.DoMemberLevelValidation(retValue, _fc.Name, _fc, _validationMode);
JToken t = JToken.FromObject(retValue);
t.WriteTo(writer);
}
}
else
{
object retValue = _fc.CustomSerializer(writer);
if (retValue != null)
{
Validate(retValue);
JToken t = JToken.FromObject(value);
t.WriteTo(writer);
}
}
}
public static void ConvertNSetMemberValue(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, ref object fieldValue, CultureInfo culture)
{
if (fieldConfig.PI == null)
{
return;
}
if (fieldValue is ChoDynamicObject)
{
((ChoDynamicObject)fieldValue).DynamicObjectName = fn;
}
if (fieldConfig.ValueConverter != null)
{
fieldValue = fieldConfig.ValueConverter(fieldValue);
}
else
{
object[] fcParams = fieldConfig.PropConverterParams;
if (!fieldConfig.FormatText.IsNullOrWhiteSpace())
{
fcParams = new object[] { new object[] { fieldConfig.FormatText } }
}
;
if (fieldConfig.Converters.IsNullOrEmpty())
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, fieldConfig.PI.PropertyType, null, fieldConfig.PropConverters, fcParams, culture);
}
else
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, fieldConfig.PI.PropertyType, null, fieldConfig.Converters.ToArray(), fcParams, culture);
}
}
ChoType.SetPropertyValue(rec, fieldConfig.PI, fieldValue);
}
public static bool GetFallbackValue(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, CultureInfo culture, ref object fieldValue)
{
if (!fieldConfig.IsFallbackValueSpecified)
{
return(false);
}
if (!fieldConfig.FormatText.IsNullOrWhiteSpace())
{
fieldValue = ("{0:" + fieldConfig.FormatText + "}").FormatString(fieldValue);
}
else
{
if (fieldConfig.Converters.IsNullOrEmpty())
{
fieldValue = ChoConvert.ConvertTo(fieldConfig.FallbackValue, fieldConfig.FieldType, null, fieldConfig.PropConverters, fieldConfig.PropConverterParams, culture);
}
else
{
fieldValue = ChoConvert.ConvertTo(fieldConfig.FallbackValue, fieldConfig.FieldType, null, fieldConfig.Converters.ToArray(), null, culture);
}
}
return(true);
}
public static object ConvertTo(object value, Type targetType, object sourceObject, object[] converters, object[] parameters, CultureInfo culture)
{
Type origType = targetType;
targetType = targetType.IsNullableType() ? targetType.GetUnderlyingType() : targetType;
object obj1 = value;
if (targetType == (Type)null)
{
return(value);
}
//if (targetType == typeof(object))
// return value;
if (culture == null)
{
culture = ChoConvert.DefaultCulture;
}
Type type = value == null ? typeof(object) : value.GetType().GetUnderlyingType();
try
{
object[] objArray = (object[])null;
if (converters.IsNullOrEmpty())
{
converters = ChoTypeDescriptor.GetTypeConvertersForType(type);
}
if (converters != null && converters.Length > 0)
{
for (int index = 0; index < converters.Length; ++index)
{
object obj2 = converters[index];
if (parameters != null && parameters.Length > 0)
{
objArray = parameters[index] as object[];
}
if (obj2 is TypeConverter)
{
TypeConverter typeConverter = obj2 as TypeConverter;
if (typeConverter.CanConvertTo(targetType))
{
value = typeConverter.ConvertTo((ITypeDescriptorContext)null, culture, value, targetType);
}
}
else if (obj2 is IValueConverter)
{
value = ((IValueConverter)obj2).ConvertBack(value, targetType, (object)objArray, culture);
}
else if (obj2 is IChoValueConverter)
{
value = ((IChoValueConverter)obj2).ConvertBack(value, targetType, (object)objArray, culture);
}
}
if (obj1 != value)
{
return(value);
}
}
if (value == null)
{
return(origType.Default());
}
if (type == origType)
{
return(value);
}
if (targetType.IsAssignableFrom(value.GetType()) || targetType == value.GetType())
{
return(value);
}
if (value is IConvertible)
{
try
{
value = Convert.ChangeType(value, targetType, (IFormatProvider)culture);
if (obj1 != value)
{
return(value);
}
}
catch
{
}
}
if (ChoConvert.TryConvertXPlicit(value, targetType, "op_Explicit", ref value) ||
ChoConvert.TryConvertXPlicit(value, targetType, "op_Implicit", ref value))
{
//|| (!origType.IsNullableType() && ChoConvert.TryConvertToSpecialValues(value, targetType, culture, out value)))
// || ChoConvert.TryConvertToSpecialValues(value, targetType, culture, out value))
return(value);
}
if (targetType == typeof(
ChoDynamicObject))
{
dynamic ret = new ChoDynamicObject();
ret.Value = value;
return(ret);
}
object result = null;
if (origType.IsNullableType())
{
return(null);
}
else if (ChoConvert.TryConvertToSpecialValues(value, targetType, culture, out result))
{
return(result);
}
throw new ApplicationException("Object conversion failed.");
}
catch (Exception ex)
{
if (type.IsSimple())
{
throw new ApplicationException(string.Format("Can't convert '{2}' value from '{0}' type to '{1}' type.", (object)type, (object)targetType, value), ex);
}
throw new ApplicationException(string.Format("Can't convert object from '{0}' type to '{1}' type.", (object)type, (object)targetType), ex);
}
}
public IEnumerator <T> GetEnumerator()
{
if (_yamlStream != null || _textReader != null)
{
ChoYamlRecordReader rr = new ChoYamlRecordReader(typeof(T), Configuration);
if (_textReader != null)
{
_yamlStream = Create(_textReader);
}
rr.Reader = this;
rr.TraceSwitch = TraceSwitch;
rr.RowsLoaded += NotifyRowsLoaded;
rr.MembersDiscovered += MembersDiscovered;
rr.RecordFieldTypeAssessment += RecordFieldTypeAssessment;
var e = rr.AsEnumerable(_yamlStream).GetEnumerator();
return(ChoEnumeratorWrapper.BuildEnumerable <T>(() => e.MoveNext(), () => (T)ChoConvert.ChangeType <ChoRecordFieldAttribute>(e.Current, typeof(T)), () => Dispose()).GetEnumerator());
}
else if (_yamlObjects != null)
{
ChoYamlRecordReader rr = new ChoYamlRecordReader(typeof(T), Configuration);
rr.Reader = this;
rr.TraceSwitch = TraceSwitch;
rr.RowsLoaded += NotifyRowsLoaded;
rr.MembersDiscovered += MembersDiscovered;
rr.RecordFieldTypeAssessment += RecordFieldTypeAssessment;
var e = rr.AsEnumerable(_yamlObjects).GetEnumerator();
return(ChoEnumeratorWrapper.BuildEnumerable <T>(() => e.MoveNext(), () => (T)ChoConvert.ChangeType <ChoRecordFieldAttribute>(e.Current, typeof(T)), () => Dispose()).GetEnumerator());
}
else if (_yamlDocObjects != null)
{
ChoYamlRecordReader rr = new ChoYamlRecordReader(typeof(T), Configuration);
rr.Reader = this;
rr.TraceSwitch = TraceSwitch;
rr.RowsLoaded += NotifyRowsLoaded;
rr.MembersDiscovered += MembersDiscovered;
rr.RecordFieldTypeAssessment += RecordFieldTypeAssessment;
var e = rr.AsEnumerable(_yamlDocObjects).GetEnumerator();
return(ChoEnumeratorWrapper.BuildEnumerable <T>(() => e.MoveNext(), () => (T)ChoConvert.ChangeType <ChoRecordFieldAttribute>(e.Current, typeof(T)), () => Dispose()).GetEnumerator());
}
else
{
return(Enumerable.Empty <T>().GetEnumerator());
}
}
public IEnumerator <T> GetEnumerator()
{
ChoFixedLengthRecordReader rr = new ChoFixedLengthRecordReader(typeof(T), Configuration);
rr.Reader = this;
rr.TraceSwitch = TraceSwitch;
rr.RowsLoaded += NotifyRowsLoaded;
var e = rr.AsEnumerable(_textReader).GetEnumerator();
return(ChoEnumeratorWrapper.BuildEnumerable <T>(() => e.MoveNext(), () => (T)ChoConvert.ChangeType <ChoRecordFieldAttribute>(e.Current, typeof(T))).GetEnumerator());
}
public static object GetConvertedValue(this MemberInfo memberInfo, object value)
{
return(ChoConvert.ConvertFrom(value, memberInfo));
// return ChoConvert.ConvertTo(null, value, ChoType.GetMemberType(memberInfo),
//ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
}
private void LoadDefaults(Type declaringType)
{
ChoIniFile iniFile = GetIniSection(declaringType, "DEFAULT_VALUE");
var dict = new Dictionary <string, object>();
object defaultValue = null;
string memberName = null;
foreach (PropertyDescriptor pd in TypeDescriptor.GetProperties(declaringType).AsTypedEnumerable <PropertyDescriptor>().Where(pd => !pd.Attributes.OfType <ChoIgnoreMemberAttribute>().Any()))
{
try
{
memberName = pd.Name;
if (_turnOnMetaDataCache)
{
defaultValue = iniFile.GetValue(pd.Name, ChoType.GetDefaultValue(pd), _isLockedCache[declaringType]);
}
else
{
defaultValue = ChoType.GetDefaultValue(pd);
}
if (defaultValue is string)
{
defaultValue = ((string)defaultValue).ExpandProperties();
}
defaultValue = ChoConvert.ConvertFrom(defaultValue, pd.PropertyType);
dict.Add(pd.Name, defaultValue);
}
catch (Exception ex)
{
ChoETLFramework.WriteLog(ChoETLFramework.Switch.TraceError, "Error while converting default value '{0}' to '{1}' member type. {2}".FormatString(defaultValue, ChoType.GetMemberName(pd), ex.Message));
}
}
foreach (FieldInfo memberInfo in ChoType.GetFields(declaringType))
{
try
{
memberName = memberInfo.Name;
if (_turnOnMetaDataCache)
{
defaultValue = iniFile.GetValue(memberInfo.Name, ChoType.GetDefaultValue(memberInfo), _isLockedCache[declaringType]);
}
else
{
defaultValue = ChoType.GetDefaultValue(memberInfo);
}
if (defaultValue is string)
{
defaultValue = ((string)defaultValue).ExpandProperties();
}
defaultValue = ChoConvert.ConvertFrom(defaultValue, memberInfo.FieldType);
dict.Add(memberInfo.Name, defaultValue);
}
catch (Exception ex)
{
ChoETLFramework.WriteLog(ChoETLFramework.Switch.TraceError, "Error while converting default value '{0}' to '{1}' member type. {2}".FormatString(defaultValue, ChoType.GetMemberName(memberInfo), ex.Message));
}
}
_defaultsCache.Add(declaringType, dict);
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var crs = Writer.ContractResolverState;
if (crs == null)
{
var t = serializer.SerializeToJToken(value);
t.WriteTo(writer);
//serializer.Serialize(writer, value);
return;
}
var fc = crs.FieldConfig;
crs.Name = _fc == null?_mi.GetFullName() : crs.Name;
var rec = ChoType.GetMemberObjectMatchingType(crs.Name, crs.Record);
var name = ChoType.GetFieldName(crs.Name);
var st = ChoType.GetMemberAttribute(_mi, typeof(ChoSourceTypeAttribute)) as ChoSourceTypeAttribute;
if (st != null && st.Type != null)
{
_objType = st.Type;
}
if (_fc != null && _fc.SourceType != null)
{
_objType = _fc.SourceType;
}
if (RaiseBeforeRecordFieldWrite(rec, crs.Index, name, ref value))
{
if (_fc != null)
{
if (value != null && _objType != null)
{
value = ChoConvert.ConvertTo(value, _objType, null, _fc.PropConverters, _fc.PropConverterParams, _culture);
}
if (_fc.CustomSerializer == null)
{
if (_fc.ValueConverter == null)
{
var t = serializer.SerializeToJToken(value);
t.WriteTo(writer);
}
else
{
object retValue = _fc.ValueConverter(value);
ValidateOnWrite(ref retValue);
//ChoETLRecordHelper.DoMemberLevelValidation(retValue, _fc.Name, _fc, _validationMode);
JToken t = JToken.FromObject(retValue, serializer);
t.WriteTo(writer);
}
}
else
{
object retValue = _fc.CustomSerializer(writer);
ValidateOnWrite(ref retValue);
JToken t = JToken.FromObject(retValue, serializer);
t.WriteTo(writer);
}
}
else
{
if (value != null && _objType != null)
{
value = ChoConvert.ConvertTo(value, _objType, null, ChoTypeDescriptor.GetTypeConverters(_mi), ChoTypeDescriptor.GetTypeConverterParams(_mi), _culture);
}
if (ValidateOnWrite(ref value))
{
var t = serializer.SerializeToJToken(value);
t.WriteTo(writer);
}
else
{
JToken t = JToken.FromObject(null, serializer);
t.WriteTo(writer);
}
}
RaiseAfterRecordFieldWrite(rec, crs.Index, name, value);
}
else
{
JToken t = JToken.FromObject(null, serializer);
t.WriteTo(writer);
}
}
private bool FillRecord(ref object rec, Tuple <long, IDictionary <string, object> > pair)
{
long lineNo;
lineNo = pair.Item1;
var node = pair.Item2;
if (Configuration.LiteParsing && Configuration.IsDynamicObject && rec is ChoDynamicObject)
{
((ChoDynamicObject)rec).SetDictionary(node as IDictionary <string, object>);
return(true);
}
fieldValue = null;
fieldConfig = null;
pi = null;
object rootRec = rec;
foreach (KeyValuePair <string, ChoParquetRecordFieldConfiguration> kvp in Configuration.RecordFieldConfigurationsDict)
{
if (!Configuration.SupportsMultiRecordTypes && Configuration.IsDynamicObject)
{
if (Configuration.IgnoredFields.Contains(kvp.Key))
{
continue;
}
}
fieldValue = null;
fieldConfig = kvp.Value;
if (Configuration.PIDict != null)
{
// if FieldName is set
if (!string.IsNullOrEmpty(fieldConfig.FieldName))
{
// match using FieldName
Configuration.PIDict.TryGetValue(fieldConfig.FieldName, out pi);
}
if (pi == null)
{
// otherwise match usign the property name
Configuration.PIDict.TryGetValue(kvp.Key, out pi);
}
}
rec = GetDeclaringRecord(kvp.Value.DeclaringMember, rootRec);
if (!node.ContainsKey(kvp.Value.FieldName))
{
if (Configuration.ColumnCountStrict)
{
throw new ChoParserException("No matching '{0}' field found.".FormatString(fieldConfig.FieldName));
}
}
else
{
fieldValue = node[kvp.Value.FieldName];
}
if (!RaiseBeforeRecordFieldLoad(rec, pair.Item1, kvp.Key, ref fieldValue))
{
continue;
}
try
{
if (!Configuration.SupportsMultiRecordTypes && Configuration.IsDynamicObject)
{
}
else
{
if (pi != null)
{
kvp.Value.FieldType = pi.PropertyType;
}
else
{
kvp.Value.FieldType = typeof(string);
}
}
object v1 = node;
if (fieldConfig.CustomSerializer != null)
{
fieldValue = fieldConfig.CustomSerializer(v1);
}
else if (RaiseRecordFieldDeserialize(rec, pair.Item1, kvp.Key, ref v1))
{
fieldValue = v1;
}
else if (fieldConfig.PropCustomSerializer != null)
{
fieldValue = ChoCustomSerializer.Deserialize(v1, fieldConfig.FieldType, fieldConfig.PropCustomSerializer, fieldConfig.PropCustomSerializerParams, Configuration.Culture, fieldConfig.Name);
}
else
{
if (!node.ContainsKey(kvp.Value.FieldName))
{
if (Configuration.ColumnCountStrict)
{
throw new ChoParserException("No matching '{0}' field found.".FormatString(fieldConfig.FieldName));
}
}
else
{
fieldValue = node[kvp.Value.FieldName];
}
}
if (fieldConfig.IgnoreFieldValueMode == null)
{
if (fieldValue.IsObjectNullOrEmpty() && fieldConfig.IsDefaultValueSpecified)
{
fieldValue = fieldConfig.DefaultValue;
}
}
else
{
bool ignoreFieldValue = fieldValue.IgnoreFieldValue(fieldConfig.IgnoreFieldValueMode);
if (ignoreFieldValue && fieldConfig.IsDefaultValueSpecified)
{
fieldValue = fieldConfig.DefaultValue;
}
ignoreFieldValue = fieldValue.IgnoreFieldValue(fieldConfig.IgnoreFieldValueMode);
if (ignoreFieldValue)
{
continue;
}
}
if (!Configuration.SupportsMultiRecordTypes && Configuration.IsDynamicObject)
{
var dict = rec as IDictionary <string, Object>;
dict.ConvertNSetMemberValue(kvp.Key, kvp.Value, ref fieldValue, Configuration.Culture);
if ((Configuration.ObjectValidationMode & ChoObjectValidationMode.MemberLevel) == ChoObjectValidationMode.MemberLevel)
{
dict.DoMemberLevelValidation(kvp.Key, kvp.Value, Configuration.ObjectValidationMode);
}
}
else
{
if (Configuration.SupportsMultiRecordTypes)
{
ChoType.TryGetProperty(rec.GetType(), kvp.Key, out pi);
//*** TODO
//fieldConfig.PI = pi;
//fieldConfig.PropConverters = ChoTypeDescriptor.GetTypeConverters(fieldConfig.PI);
//fieldConfig.PropConverterParams = ChoTypeDescriptor.GetTypeConverterParams(fieldConfig.PI);
}
if (pi != null)
{
if (Configuration.LiteParsing)
{
ChoType.SetPropertyValue(rec, fieldConfig.PI,
fieldConfig.FieldType == null || fieldConfig.FieldType == typeof(string) ? fieldValue : Convert.ChangeType(fieldValue, fieldConfig.FieldType, Configuration.Culture));
}
else
{
rec.ConvertNSetMemberValue(kvp.Key, kvp.Value, ref fieldValue, Configuration.Culture);
}
}
else if (RecordType.IsSimple())
{
rec = ChoConvert.ConvertTo(fieldValue, RecordType, 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.SupportsMultiRecordTypes && 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 if (ex is ValidationException)
{
throw;
}
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 if (ex is ValidationException)
{
throw;
}
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 || ex is ValidationException)
{
if (fieldConfig.ErrorMode == ChoErrorMode.IgnoreAndContinue)
{
ChoETLFramework.WriteLog(TraceSwitch.TraceError, "Error [{0}] found. Ignoring field...".FormatString(ex.Message));
continue;
}
else
{
if (!RaiseRecordFieldLoadError(rec, pair.Item1, kvp.Key, ref fieldValue, ex))
{
if (ex is ValidationException)
{
throw;
}
throw new ChoReaderException($"Failed to parse '{fieldValue}' value for '{fieldConfig.FieldName}' field.", ex);
}
else
{
try
{
if (Configuration.IsDynamicObject)
{
var dict = rec as IDictionary <string, Object>;
dict.ConvertNSetMemberValue(kvp.Key, fieldConfig, ref fieldValue, Configuration.Culture);
}
else
{
if (pi != null)
{
rec.ConvertNSetMemberValue(kvp.Key, fieldConfig, ref fieldValue, Configuration.Culture);
}
else
{
throw new ChoMissingRecordFieldException("Missing '{0}' property in {1} type.".FormatString(kvp.Key, ChoType.GetTypeName(rec)));
}
}
}
catch { }
}
}
}
else
{
throw new ChoReaderException("Failed to assign '{0}' fallback value to '{1}' field.".FormatString(fieldValue, fieldConfig.FieldName), innerEx);
}
}
}
}
rec = rootRec;
return(true);
}
private static bool TryConvertXPlicit(object value, Type destinationType, string operatorMethodName, ref object result)
{
return(ChoConvert.TryConvertXPlicit(value, value.GetType(), destinationType, operatorMethodName, ref result) || ChoConvert.TryConvertXPlicit(value, destinationType, destinationType, operatorMethodName, ref result));
}
public static void ConvertNSetValue(this object target, PropertyDescriptor pd, object fv, CultureInfo culture, long index = 0)
{
PropertyInfo pi = pd.ComponentType.GetProperty(pd.Name);
IChoNotifyChildRecordRead callbackRecord = target as IChoNotifyChildRecordRead;
if (callbackRecord != null)
{
object state = fv;
bool retValue = ChoFuncEx.RunWithIgnoreError(() => callbackRecord.BeforeRecordFieldLoad(target, index, pd.Name, ref state), true);
if (retValue)
{
fv = state;
}
}
try
{
object[] PropConverters = ChoTypeDescriptor.GetTypeConverters(pi);
object[] PropConverterParams = ChoTypeDescriptor.GetTypeConverterParams(pi);
string formatText = null;
DisplayFormatAttribute dfAttr = pd.Attributes.OfType <DisplayFormatAttribute>().FirstOrDefault();
if (dfAttr != null && !dfAttr.DataFormatString.IsNullOrWhiteSpace())
{
formatText = dfAttr.DataFormatString;
}
object[] fcParams = PropConverterParams;
if (formatText.IsNullOrWhiteSpace())
{
fcParams = new object[] { new object[] { formatText } }
}
;
if (PropConverters.IsNullOrEmpty())
{
fv = ChoConvert.ConvertFrom(fv, pi.PropertyType, null, PropConverters, fcParams, culture);
}
else
{
fv = ChoConvert.ConvertFrom(fv, pi.PropertyType, null, PropConverters, fcParams, culture);
}
pd.SetValue(target, fv);
if (callbackRecord != null)
{
ChoFuncEx.RunWithIgnoreError(() => callbackRecord.AfterRecordFieldLoad(target, index, pd.Name, fv), true);
}
}
catch (Exception ex)
{
if (callbackRecord != null)
{
bool ret = ChoFuncEx.RunWithIgnoreError(() => callbackRecord.RecordFieldLoadError(target, index, pd.Name, fv, ex), false);
if (!ret)
{
if (ex is ValidationException)
{
throw;
}
throw new ChoReaderException($"Failed to parse '{fv}' value for '{pd.Name}' field in '{target.GetType().Name}' object.", ex);
}
}
}
}
private bool FillRecord(object rec, Tuple <int, string> pair)
{
int lineNo;
string line;
lineNo = pair.Item1;
line = pair.Item2;
object fieldValue = null;
string[] fieldValues = (from x in line.Split(Configuration.Delimiter, Configuration.StringSplitOptions, Configuration.QuoteChar)
select x).ToArray();
if (Configuration.ColumnCountStrict)
{
if (fieldValues.Length != Configuration.RecordFieldConfigurations.Count)
{
throw new ChoParserException("Incorrect number of field values found at line [{2}]. Expected [{0}] field values. Found [{1}] field values.".FormatString(Configuration.RecordFieldConfigurations.Count, fieldValues.Length, pair.Item1));
}
}
Dictionary <string, string> _fieldNameValues = ToFieldNameValues(fieldValues);
ValidateLine(pair.Item1, fieldValues);
ChoCSVRecordFieldConfiguration fieldConfig = null;
foreach (KeyValuePair <string, ChoCSVRecordFieldConfiguration> kvp in Configuration.RecordFieldConfigurationsDict)
{
fieldConfig = kvp.Value;
if (Configuration.CSVFileHeaderConfiguration.HasHeaderRecord)
{
if (_fieldNameValues.ContainsKey(fieldConfig.FieldName))
{
fieldValue = _fieldNameValues[fieldConfig.FieldName];
}
else if (Configuration.ColumnCountStrict)
{
throw new ChoParserException("No matching '{0}' field header found.".FormatString(fieldConfig.FieldName));
}
}
else
{
if (fieldConfig.FieldPosition - 1 < fieldValues.Length)
{
fieldValue = fieldValues[fieldConfig.FieldPosition - 1];
}
else if (Configuration.ColumnCountStrict)
{
throw new ChoParserException("Missing field value for {0} [Position: {1}] field.".FormatString(fieldConfig.FieldName, fieldConfig.FieldPosition));
}
}
fieldValue = CleanFieldValue(fieldConfig, fieldValue as string);
if (!RaiseBeforeRecordFieldLoad(rec, pair.Item1, kvp.Key, ref fieldValue))
{
continue;
}
try
{
bool ignoreFieldValue = fieldConfig.IgnoreFieldValue(fieldValue);
if (!ignoreFieldValue)
{
if (rec is ExpandoObject)
{
if (fieldConfig.FieldType != typeof(string))
{
fieldValue = ChoConvert.ConvertTo(fieldValue, fieldConfig.FieldType, Configuration.Culture);
}
var x = rec as IDictionary <string, Object>;
x.Add(kvp.Key, fieldValue);
}
else
{
if (ChoType.HasProperty(rec.GetType(), kvp.Key))
{
ChoType.ConvertNSetMemberValue(rec, kvp.Key, fieldValue);
fieldValue = ChoType.GetMemberValue(rec, kvp.Key);
if ((Configuration.ObjectValidationMode & ChoObjectValidationMode.MemberLevel) == ChoObjectValidationMode.MemberLevel)
{
ChoValidator.ValididateFor(rec, kvp.Key);
}
}
else
{
throw new ChoMissingRecordFieldException("Missing '{0}' property in {1} type.".FormatString(kvp.Key, ChoType.GetTypeName(rec)));
}
}
}
if (!RaiseAfterRecordFieldLoad(rec, pair.Item1, 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
{
ChoFallbackValueAttribute fbAttr = ChoTypeDescriptor.GetPropetyAttribute <ChoFallbackValueAttribute>(rec.GetType(), kvp.Key);
if (fbAttr != null)
{
if (!fbAttr.Value.IsNullOrDbNull())
{
ChoType.ConvertNSetMemberValue(rec, kvp.Key, fbAttr.Value);
}
}
else
{
throw;
}
}
catch
{
if (fieldConfig.ErrorMode == ChoErrorMode.IgnoreAndContinue)
{
continue;
}
else if (fieldConfig.ErrorMode == ChoErrorMode.ReportAndContinue)
{
if (!RaiseRecordFieldLoadError(rec, pair.Item1, kvp.Key, fieldValue, ex))
{
throw;
}
}
else
{
throw;
}
}
}
}
return(true);
}
public IEnumerator <T> GetEnumerator()
{
ChoParquetRecordReader rr = new ChoParquetRecordReader(typeof(T), Configuration);
if (_sr != null)
{
_parquetReader = Create(_sr);
}
rr.Reader = this;
rr.TraceSwitch = TraceSwitch;
rr.RowsLoaded += NotifyRowsLoaded;
rr.MembersDiscovered += MembersDiscovered;
rr.RecordFieldTypeAssessment += RecordFieldTypeAssessment;
var e = rr.AsEnumerable(_parquetReader).GetEnumerator();
return(ChoEnumeratorWrapper.BuildEnumerable <T>(() => e.MoveNext(), () => (T)ChoConvert.ChangeType <ChoRecordFieldAttribute>(e.Current, typeof(T)), () => Dispose()).GetEnumerator());
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
object retValue = null;
var crs = Reader.ContractResolverState;
if (crs == null)
{
return(serializer.Deserialize(reader, objectType));
}
var fc = crs.FieldConfig;
crs.Name = _fc == null?_mi.GetFullName() : crs.Name;
var rec = ChoType.GetMemberObjectMatchingType(crs.Name, crs.Record);
var name = ChoType.GetFieldName(crs.Name);
var st = ChoType.GetMemberAttribute(_mi, typeof(ChoSourceTypeAttribute)) as ChoSourceTypeAttribute;
if (st != null && st.Type != null)
{
_objType = st.Type;
}
if (_fc != null && _fc.SourceType != null)
{
_objType = _fc.SourceType;
}
retValue = reader;
if (!RaiseBeforeRecordFieldLoad(rec, crs.Index, name, ref retValue))
{
if (_fc != null)
{
if (_fc.CustomSerializer == null)
{
if (_fc.ValueConverter == null)
{
retValue = serializer.Deserialize(reader, objectType);
}
else
{
retValue = _fc.ValueConverter(serializer.Deserialize(reader, typeof(string)));
}
}
else
{
retValue = _fc.CustomSerializer(reader);
}
ValidateORead(ref retValue);
//ChoETLRecordHelper.DoMemberLevelValidation(retValue, _fc.Name, _fc, _validationMode);
if (retValue != null)
{
retValue = ChoConvert.ConvertFrom(retValue, objectType, null, _fc.PropConverters, _fc.PropConverterParams, _culture);
}
}
else
{
retValue = serializer.Deserialize(reader, objectType);
ValidateORead(ref retValue);
if (retValue != null)
{
retValue = ChoConvert.ConvertFrom(retValue, objectType, null, ChoTypeDescriptor.GetTypeConverters(_mi), ChoTypeDescriptor.GetTypeConverterParams(_mi), _culture);
}
}
}
if (!RaiseAfterRecordFieldLoad(rec, crs.Index, name, retValue))
{
return(null);
}
return(retValue == reader?serializer.Deserialize(reader, objectType) : retValue);
}
public static object ConvertFrom(object value, MemberInfo memberInfo, object sourceObject = null, CultureInfo culture = null)
{
ChoGuard.ArgumentNotNull(memberInfo, "MemberInfo");
return(ChoConvert.ConvertFrom(value, ChoType.GetMemberType(memberInfo), sourceObject, ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo), culture));
}
public IEnumerator <T> GetEnumerator()
{
ChoCSVRecordReader rr = new ChoCSVRecordReader(typeof(T), Configuration);
rr.Reader = this;
rr.TraceSwitch = TraceSwitch;
rr.RowsLoaded += NotifyRowsLoaded;
rr.MembersDiscovered += MembersDiscovered;
var e = _lines != null?rr.AsEnumerable(_lines).GetEnumerator() : rr.AsEnumerable(_textReader).GetEnumerator();
return(ChoEnumeratorWrapper.BuildEnumerable <T>(() => e.MoveNext(), () => (T)ChoConvert.ChangeType <ChoRecordFieldAttribute>(e.Current, typeof(T)), () => Dispose()).GetEnumerator());
}
public static object ConvertFrom(object value, PropertyInfo propertyInfo, object sourceObject = null, CultureInfo culture = null)
{
ChoGuard.ArgumentNotNull(propertyInfo, "PropertyInfo");
return(ChoConvert.ConvertFrom(value, propertyInfo.PropertyType, sourceObject, ChoTypeDescriptor.GetTypeConverters(propertyInfo), ChoTypeDescriptor.GetTypeConverterParams(propertyInfo), culture));
}
public IEnumerator <T> GetEnumerator()
{
ChoCSVRecordBuilder builder = new ChoCSVRecordBuilder(typeof(T), Configuration);
var e = builder.AsEnumerable(_txtReader).GetEnumerator();
return(ChoEnumeratorWrapper.BuildEnumerable <T>(() => e.MoveNext(), () => (T)ChoConvert.ChangeType <ChoRecordFieldAttribute>(e.Current, typeof(T))).GetEnumerator());
}
public static object ConvertFrom(object value, Type targetType, object sourceObject = null, object[] converters = null, object[] parameters = null, CultureInfo culture = null)
{
Type origType = targetType;
targetType = targetType.IsNullableType() ? targetType.GetUnderlyingType() : targetType;
object obj1 = value;
if (targetType == (Type)null)
{
return(value);
}
if (targetType == typeof(object))
{
return(value);
}
if (culture == null)
{
culture = ChoConvert.DefaultCulture;
}
if (value is ICollection && !typeof(ICollection).IsAssignableFrom(targetType))
{
value = ((IEnumerable)value).FirstOrDefault <object>();
}
if (typeof(IList).IsAssignableFrom(targetType) && !(value is IList))
{
value = new object[] { value };
}
Type type = value == null ? typeof(object) : value.GetType();
try
{
if (converters.IsNullOrEmpty())
{
converters = ChoTypeDescriptor.GetTypeConvertersForType(targetType);
}
if (converters != null && converters.Length > 0)
{
object[] objArray = (object[])null;
for (int index = 0; index < converters.Length; ++index)
{
object obj2 = converters[index];
if (parameters != null && parameters.Length > 0)
{
objArray = parameters[index] as object[];
}
if (obj2 is TypeConverter)
{
TypeConverter typeConverter = obj2 as TypeConverter;
if (typeConverter.CanConvertFrom(type))
{
value = typeConverter.ConvertFrom((ITypeDescriptorContext)null, culture, value);
}
}
else if (obj2 is IValueConverter)
{
value = ((IValueConverter)obj2).Convert(value, targetType, (object)objArray, culture);
}
else if (obj2 is IChoValueConverter)
{
value = ((IChoValueConverter)obj2).Convert(value, targetType, (object)objArray, culture);
}
}
//if (value != obj1)
// return value;
}
if (value == null)
{
return(origType.Default());
}
if (targetType.IsAssignableFrom(value.GetType()) || targetType == value.GetType())
{
return(value);
}
if (value is IConvertible)
{
try
{
value = Convert.ChangeType(value, targetType, (IFormatProvider)culture);
if (obj1 != value)
{
return(value);
}
}
catch
{
}
}
if (ChoConvert.TryConvertXPlicit(value, targetType, "op_Explicit", ref value) ||
ChoConvert.TryConvertXPlicit(value, targetType, "op_Implicit", ref value))
{
return(value);
}
object convValue = null;
if (origType.IsNullableType())
{
return(null);
}
else if (ChoConvert.TryConvertToSpecialValues(value, targetType, culture, out convValue))
{
return(convValue);
}
if (value is Array && typeof(IList).IsAssignableFrom(targetType))
{
if (typeof(Array).IsAssignableFrom(targetType))
{
MethodInfo convertMethod = typeof(ChoConvert).GetMethod("ConvertToArray",
BindingFlags.NonPublic | BindingFlags.Static);
MethodInfo generic = convertMethod.MakeGenericMethod(new[] { targetType.GetItemType() });
return(generic.Invoke(null, new object[] { value }));
}
else
{
MethodInfo convertMethod = typeof(ChoConvert).GetMethod("ConvertToList",
BindingFlags.NonPublic | BindingFlags.Static);
MethodInfo generic = convertMethod.MakeGenericMethod(new[] { targetType.GetItemType() });
return(generic.Invoke(null, new object[] { value }));
}
}
else if (value is IList && typeof(Array).IsAssignableFrom(targetType))
{
if (typeof(Array).IsAssignableFrom(targetType))
{
MethodInfo convertMethod = typeof(ChoConvert).GetMethod("ConvertListToArray",
BindingFlags.NonPublic | BindingFlags.Static);
MethodInfo generic = convertMethod.MakeGenericMethod(new[] { targetType.GetItemType() });
return(generic.Invoke(null, new object[] { value }));
}
else
{
MethodInfo convertMethod = typeof(ChoConvert).GetMethod("ConvertListToList",
BindingFlags.NonPublic | BindingFlags.Static);
MethodInfo generic = convertMethod.MakeGenericMethod(new[] { targetType.GetItemType() });
return(generic.Invoke(null, new object[] { value }));
}
}
throw new ApplicationException("Object conversion failed.");
}
catch (Exception ex)
{
if (type.IsSimple())
{
throw new ApplicationException(string.Format("Can't convert '{2}' value from '{0}' type to '{1}' type.", (object)type, (object)targetType, value), ex);
}
throw new ApplicationException(string.Format("Can't convert object from '{0}' type to '{1}' type.", (object)type, (object)targetType), ex);
}
}
public static void ConvertNSetMemberValue(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, ref object fieldValue, CultureInfo culture)
{
if (fieldConfig.PI == null)
{
return;
}
if (fieldValue is ChoDynamicObject)
{
((ChoDynamicObject)fieldValue).DynamicObjectName = fn;
}
if (fieldConfig.ValueConverter != null)
{
fieldValue = fieldConfig.ValueConverter(fieldValue);
}
else
{
if (fieldValue != null && fieldConfig.PI.PropertyType != null &&
fieldConfig.PI.PropertyType.IsAssignableFrom(fieldValue.GetType()))
{
}
else if (fieldConfig.PI.PropertyType.IsGenericType && fieldConfig.PI.PropertyType.GetGenericTypeDefinition() == typeof(Dictionary <,>)
/*&& typeof(string) == fieldConfig.PI.PropertyType.GetGenericArguments()[0]*/)
{
IDictionary dict = ChoType.GetPropertyValue(rec, fieldConfig.PI) as IDictionary;
if (dict == null)
{
dict = (IDictionary)Activator.CreateInstance(fieldConfig.FieldType);
ChoType.SetPropertyValue(rec, fieldConfig.PI, dict);
}
if (fieldConfig is ChoFileRecordFieldConfiguration && !((ChoFileRecordFieldConfiguration)fieldConfig).DictKey.IsNullOrWhiteSpace())
{
if (!dict.Contains(fn))
{
var valueType = fieldConfig.PI.PropertyType.GetGenericArguments()[1];
object[] fcParams = GetPropertyConvertersParams(fieldConfig);
if (fieldConfig.ValueConverters.IsNullOrEmpty())
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, valueType, null, null, fcParams, culture);
}
else
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, valueType, null, fieldConfig.ValueConverters.ToArray(), fcParams, culture);
}
dict.Add(fn, fieldValue);
}
}
else
{
object[] fcParams = GetPropertyConvertersParams(fieldConfig);
if (fieldConfig.Converters.IsNullOrEmpty())
{
if (fieldConfig.PropConverters.IsNullOrEmpty())
{
var keyType = fieldConfig.PI.PropertyType.GetGenericArguments()[0];
var valueType = fieldConfig.PI.PropertyType.GetGenericArguments()[1];
char itemSeparator = ';';
char keyValueSeparator = '=';
if (fieldConfig is ChoCSVRecordFieldConfiguration)
{
var fc = fieldConfig as ChoCSVRecordFieldConfiguration;
if (!fc.ItemSeparator.IsNull())
{
itemSeparator = fc.ItemSeparator;
}
if (!fc.KeyValueSeparator.IsNull())
{
keyValueSeparator = fc.KeyValueSeparator;
}
}
object key = null;
object value = null;
foreach (var kvp in ((string)fieldValue).ToKeyValuePairs(itemSeparator, keyValueSeparator))
{
key = null;
value = null;
if (fieldConfig.KeyConverters.IsNullOrEmpty())
{
key = ChoConvert.ConvertFrom(kvp.Key, keyType, null, null, fcParams, culture);
}
else
{
key = ChoConvert.ConvertFrom(kvp.Key, keyType, null, fieldConfig.KeyConverters.ToArray(), fcParams, culture);
}
if (fieldConfig.ValueConverters.IsNullOrEmpty())
{
value = ChoConvert.ConvertFrom(kvp.Value, valueType, null, null, fcParams, culture);
}
else
{
value = ChoConvert.ConvertFrom(kvp.Value, valueType, null, fieldConfig.ValueConverters.ToArray(), fcParams, culture);
}
if (key != null)
{
dict.Add(key, value);
}
}
}
else
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, fieldConfig.PI.PropertyType, null, fieldConfig.PropConverters, fcParams, culture);
}
}
else
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, fieldConfig.PI.PropertyType, null, fieldConfig.Converters.ToArray(), fcParams, culture);
}
}
return;
}
else if (typeof(IList).IsAssignableFrom(fieldConfig.PI.PropertyType))
{
var itemType = fieldConfig.PI.PropertyType.GetItemType();
IList list = ChoType.GetPropertyValue(rec, fieldConfig.PI) as IList;
if (list == null && !fieldConfig.FieldType.IsArray)
{
list = (IList)Activator.CreateInstance(fieldConfig.FieldType);
ChoType.SetPropertyValue(rec, fieldConfig.PI, list);
}
if (((ChoFileRecordFieldConfiguration)fieldConfig).ArrayIndex != null)
{
if (list != null)
{
if (itemType != null)
{
object[] fcParams = GetPropertyConvertersParams(fieldConfig);
if (fieldConfig.ItemConverters.IsNullOrEmpty())
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, itemType, null, null, fcParams, culture);
}
else
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, itemType, null, fieldConfig.ItemConverters.ToArray(), fcParams, culture);
}
}
if (list.IsFixedSize)
{
int ai = fieldConfig is ChoFileRecordFieldConfiguration ? ((ChoFileRecordFieldConfiguration)fieldConfig).ArrayIndex != null ? ((ChoFileRecordFieldConfiguration)fieldConfig).ArrayIndex.Value : -1 : -1;
if (ai >= 0 && ai < ((Array)list).Length)
{
((Array)list).SetValue(fieldValue, ai);
}
}
else
{
list.Add(fieldValue);
}
}
return;
}
else
{
object[] fcParams = GetPropertyConvertersParams(fieldConfig);
if (fieldConfig.Converters.IsNullOrEmpty())
{
if (fieldConfig.PropConverters.IsNullOrEmpty() && fieldValue is string)
{
List <object> result = new List <object>();
if (itemType != null)
{
char itemSeparator = ';';
if (fieldConfig is ChoCSVRecordFieldConfiguration)
{
var fc = fieldConfig as ChoCSVRecordFieldConfiguration;
if (!fc.ItemSeparator.IsNull())
{
itemSeparator = fc.ItemSeparator;
}
}
foreach (var item in ((string)fieldValue).SplitNTrim(itemSeparator))
{
if (fieldConfig.ItemConverters.IsNullOrEmpty())
{
result.Add(ChoConvert.ConvertFrom(item, itemType, null, null, fcParams, culture));
}
else
{
result.Add(ChoConvert.ConvertFrom(item, itemType, null, fieldConfig.ItemConverters.ToArray(), fcParams, culture));
}
}
}
if (fieldConfig.PI.PropertyType.IsArray)
{
fieldValue = result.ToArray();
}
else
{
fieldValue = result;
}
}
else
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, fieldConfig.PI.PropertyType, null, fieldConfig.PropConverters, fcParams, culture);
}
}
else
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, fieldConfig.PI.PropertyType, null, fieldConfig.Converters.ToArray(), fcParams, culture);
}
}
}
else
{
object[] fcParams = GetPropertyConvertersParams(fieldConfig);
if (fieldConfig.Converters.IsNullOrEmpty())
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, fieldConfig.PI.PropertyType, null, fieldConfig.PropConverters, fcParams, culture);
}
else
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, fieldConfig.PI.PropertyType, null, fieldConfig.Converters.ToArray(), fcParams, culture);
}
}
}
ChoType.SetPropertyValue(rec, fieldConfig.PI, fieldValue);
}
//internal static IEnumerator<object> LoadText(Type recType, string inputText, ChoXmlRecordConfiguration configuration, Encoding encoding, int bufferSize, TraceSwitch traceSwitch = null)
//{
// ChoXmlRecordReader rr = new ChoXmlRecordReader(recType, configuration);
// rr.TraceSwitch = traceSwitch == null ? ChoETLFramework.TraceSwitchOff : traceSwitch;
// return rr.AsEnumerable(new StreamReader(inputText.ToStream(), encoding, false, bufferSize)).GetEnumerator();
//}
public IEnumerator <T> GetEnumerator()
{
if (_xElements == null)
{
ChoXmlRecordReader rr = new ChoXmlRecordReader(typeof(T), Configuration);
//if (_textReader != null)
// _xmlReader = XmlReader.Create(_textReader, new XmlReaderSettings() { DtdProcessing = DtdProcessing.Ignore, XmlResolver = null }, new XmlParserContext(null, Configuration.NamespaceManager, null, XmlSpace.None));
rr.Reader = this;
rr.TraceSwitch = TraceSwitch;
rr.RowsLoaded += NotifyRowsLoaded;
rr.MembersDiscovered += MembersDiscovered;
var e = rr.AsEnumerable(_xmlReader).GetEnumerator();
return(ChoEnumeratorWrapper.BuildEnumerable <T>(() => e.MoveNext(), () => (T)ChoConvert.ChangeType <ChoRecordFieldAttribute>(e.Current, typeof(T))).GetEnumerator());
}
else
{
ChoXmlRecordReader rr = new ChoXmlRecordReader(typeof(T), Configuration);
rr.Reader = this;
rr.TraceSwitch = TraceSwitch;
rr.RowsLoaded += NotifyRowsLoaded;
rr.MembersDiscovered += MembersDiscovered;
var e = rr.AsEnumerable(_xElements).GetEnumerator();
return(ChoEnumeratorWrapper.BuildEnumerable <T>(() => e.MoveNext(), () => (T)ChoConvert.ChangeType <ChoRecordFieldAttribute>(e.Current, typeof(T))).GetEnumerator());
}
}
//internal static IEnumerator<object> LoadText(Type recType, string inputText, ChoJSONRecordConfiguration configuration, Encoding encoding, int bufferSize)
//{
// ChoJSONRecordReader rr = new ChoJSONRecordReader(recType, configuration);
// rr.TraceSwitch = ChoETLFramework.TraceSwitchOff;
// return rr.AsEnumerable(new StreamReader(inputText.ToStream(), encoding, false, bufferSize)).GetEnumerator();
//}
public IEnumerator <T> GetEnumerator()
{
if (_jObjects == null)
{
ChoJSONRecordReader rr = new ChoJSONRecordReader(typeof(T), Configuration);
if (_textReader != null)
{
_JSONReader = new JsonTextReader(_textReader);
}
rr.Reader = this;
rr.TraceSwitch = TraceSwitch;
rr.RowsLoaded += NotifyRowsLoaded;
rr.MembersDiscovered += MembersDiscovered;
var e = rr.AsEnumerable(_JSONReader).GetEnumerator();
return(ChoEnumeratorWrapper.BuildEnumerable <T>(() => e.MoveNext(), () => (T)ChoConvert.ChangeType <ChoRecordFieldAttribute>(e.Current, typeof(T)), () => Dispose()).GetEnumerator());
}
else
{
ChoJSONRecordReader rr = new ChoJSONRecordReader(typeof(T), Configuration);
rr.Reader = this;
rr.TraceSwitch = TraceSwitch;
rr.RowsLoaded += NotifyRowsLoaded;
rr.MembersDiscovered += MembersDiscovered;
var e = rr.AsEnumerable(_jObjects).GetEnumerator();
return(ChoEnumeratorWrapper.BuildEnumerable <T>(() => e.MoveNext(), () => (T)ChoConvert.ChangeType <ChoRecordFieldAttribute>(e.Current, typeof(T)), () => Dispose()).GetEnumerator());
}
}
private bool ToText(long index, object rec, out string recText)
{
if (typeof(IChoScalarObject).IsAssignableFrom(Configuration.RecordType))
{
rec = ChoActivator.CreateInstance(Configuration.RecordType, rec);
}
if (!Configuration.IsDynamicObject)
{
if (rec.ToTextIfCustomSerialization(out recText))
{
return(true);
}
//Check if KVP object
if (rec.GetType().IsKeyValueType())
{
recText = SerializeObject(rec);
return(true);
}
}
recText = null;
if (Configuration.UseYamlSerialization)
{
recText = new Serializer().Serialize(rec, rec.GetType());
return(true);
}
StringBuilder msg = new StringBuilder();
object fieldValue = null;
string fieldText = null;
ChoYamlRecordFieldConfiguration fieldConfig = null;
string fieldName = null;
if (Configuration.ColumnCountStrict)
{
CheckColumnsStrict(rec);
}
//bool firstColumn = true;
PropertyInfo pi = null;
bool isFirst = true;
object rootRec = rec;
Dictionary <string, object> output = new Dictionary <string, object>();
foreach (KeyValuePair <string, ChoYamlRecordFieldConfiguration> kvp in Configuration.RecordFieldConfigurationsDict.OrderBy(kvp => kvp.Value.Order))
{
//if (Configuration.IsDynamicObject)
//{
if (Configuration.IgnoredFields.Contains(kvp.Key))
{
continue;
}
//}
fieldConfig = kvp.Value;
fieldName = fieldConfig.FieldName;
fieldValue = null;
fieldText = String.Empty;
if (Configuration.PIDict != null)
{
Configuration.PIDict.TryGetValue(kvp.Key, out pi);
}
rec = GetDeclaringRecord(kvp.Value.DeclaringMember, rootRec);
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}' Yaml node.".FormatString(fieldConfig.FieldName));
}
}
else
{
if (pi == null)
{
if (!RecordType.IsSimple())
{
throw new ChoMissingRecordFieldException("No matching property found in the object for '{0}' Yaml 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 (rec is ChoDynamicObject)
{
}
if (kvp.Value.FieldType == null)
{
if (rec is ChoDynamicObject)
{
var dobj = rec as ChoDynamicObject;
kvp.Value.FieldType = dobj.GetMemberType(kvp.Key);
}
if (kvp.Value.FieldType == null)
{
if (ElementType == null)
{
kvp.Value.FieldType = typeof(object);
}
else
{
kvp.Value.FieldType = ElementType;
}
}
}
}
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;
//}
bool ignoreFieldValue = fieldValue.IgnoreFieldValue(fieldConfig.IgnoreFieldValueMode);
if (ignoreFieldValue)
{
fieldValue = fieldConfig.IsDefaultValueSpecified ? fieldConfig.DefaultValue : null;
}
if (!RaiseBeforeRecordFieldWrite(rec, index, kvp.Key, ref fieldValue))
{
return(false);
}
if (fieldConfig.ValueConverter != null)
{
fieldValue = fieldConfig.ValueConverter(fieldValue);
}
else if (RecordType.IsSimple())
{
fieldValue = new List <object> {
rec
}
}
;
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(ref 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
{
var ex1 = new ChoWriterException($"Failed to write '{fieldValue}' value for '{fieldConfig.FieldName}' member.", ex);
fieldValue = null;
throw ex1;
}
}
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
{
var ex1 = new ChoWriterException($"Failed to write '{fieldValue}' value for '{fieldConfig.FieldName}' member.", ex);
fieldValue = null;
throw ex1;
}
}
else
{
var ex1 = new ChoWriterException($"Failed to write '{fieldValue}' value for '{fieldConfig.FieldName}' member.", ex);
fieldValue = null;
throw ex1;
}
}
catch (Exception innerEx)
{
if (ex == innerEx.InnerException)
{
if (fieldConfig.ErrorMode == ChoErrorMode.IgnoreAndContinue)
{
continue;
}
else
{
if (!RaiseRecordFieldWriteError(rec, index, kvp.Key, ref fieldValue, 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);
}
}
}
bool isSimple = true;
if (fieldConfig.CustomSerializer != null)
{
fieldText = fieldConfig.CustomSerializer(fieldValue) as string;
}
else if (RaiseRecordFieldSerialize(rec, index, kvp.Key, ref fieldValue))
{
fieldText = fieldValue as string;
}
else if (fieldConfig.PropCustomSerializer != null)
{
fieldText = ChoCustomSerializer.Serialize(fieldValue, typeof(string), fieldConfig.PropCustomSerializer, fieldConfig.PropCustomSerializerParams, Configuration.Culture, fieldConfig.Name) as string;
}
else
{
Type ft = fieldValue == null ? typeof(object) : fieldValue.GetType();
//if (fieldConfig.IgnoreFieldValue(fieldValue))
// fieldText = null;
bool ignoreFieldValue = fieldValue.IgnoreFieldValue(fieldConfig.IgnoreFieldValueMode);
if (ignoreFieldValue)
{
fieldText = null;
}
else if (fieldValue == null)
{
//if (fieldConfig.FieldType == null || fieldConfig.FieldType == typeof(object))
//{
// if (fieldConfig.NullValue == null)
// fieldText = !fieldConfig.IsArray ? "null" : "[]";
// else
// fieldText = fieldConfig.NullValue;
//}
if (Configuration.NullValueHandling == ChoNullValueHandling.Ignore)
{
fieldText = null;
}
else if (Configuration.NullValueHandling == ChoNullValueHandling.Default)
{
fieldText = ChoActivator.CreateInstance(fieldConfig.FieldType).ToNString();
}
else if (Configuration.NullValueHandling == ChoNullValueHandling.Empty && fieldConfig.FieldType == typeof(string))
{
fieldText = String.Empty;
}
else
{
if (fieldConfig.NullValue == null)
{
}
else
{
fieldText = fieldConfig.NullValue;
}
}
}
else if (ft == typeof(string) || ft == typeof(char))
{
fieldText = NormalizeFieldValue(kvp.Key, fieldValue.ToString(), kvp.Value.Size, kvp.Value.Truncate, false, GetFieldValueJustification(kvp.Value.FieldValueJustification, kvp.Value.FieldType),
GetFillChar(kvp.Value.FillChar, kvp.Value.FieldType), false, kvp.Value.GetFieldValueTrimOption(kvp.Value.FieldType, Configuration.FieldValueTrimOption));
}
else if (ft == typeof(DateTime) || ft == typeof(TimeSpan))
{
fieldText = ChoConvert.ConvertTo(fieldValue, typeof(String), Configuration.Culture) as string;
}
else if (ft.IsEnum)
{
fieldText = ChoConvert.ConvertTo(fieldValue, typeof(String), Configuration.Culture) as string;
}
else if (ft == typeof(ChoCurrency))
{
fieldText = fieldValue.ToString();
}
else if (ft == typeof(bool))
{
fieldText = ChoConvert.ConvertTo(fieldValue, typeof(String), Configuration.Culture) as string;
}
else if (ft.IsNumeric())
{
fieldText = ChoConvert.ConvertTo(fieldValue, typeof(String), Configuration.Culture) as string;
}
else
{
isSimple = false;
}
}
object objValue = null;
if (isSimple)
{
objValue = fieldText;
}
else
{
Writer.ContractResolverState = new ChoContractResolverState
{
Name = kvp.Key,
Index = index,
Record = rec,
FieldConfig = kvp.Value
};
var json = JsonConvert.SerializeObject(fieldValue, Configuration.JsonSerializerSettings);
if (RecordType.IsSimple())
{
objValue = JsonConvert.DeserializeObject <IList <object> >(json);
}
else
{
objValue = JsonConvert.DeserializeObject <IDictionary <string, object> >(json);
}
}
if (!RecordType.IsSimple())
{
output.Add(fieldName, objValue);
}
else
{
fieldValue = objValue;
}
}
if (!RecordType.IsSimple())
{
recText = Configuration.YamlSerializer.Serialize(output, output.GetType());
}
else
{
recText = Configuration.YamlSerializer.Serialize(fieldValue, fieldValue.GetType());
}
return(true);
}
public IEnumerator <T> GetEnumerator()
{
CheckDisposed();
ChoAvroRecordReader rr = new ChoAvroRecordReader(typeof(T), Configuration);
rr.Reader = this;
rr.TraceSwitch = TraceSwitch;
rr.RowsLoaded += NotifyRowsLoaded;
rr.MembersDiscovered += MembersDiscovered;
rr.RecordFieldTypeAssessment += RecordFieldTypeAssessment;
if (typeof(T) == typeof(object))
{
IEnumerator <object> e = _avroReader != null?rr.AsEnumerable <Dictionary <string, object> >(_avroReader).GetEnumerator() : rr.AsEnumerable <Dictionary <string, object> >(_sr).GetEnumerator();
return(ChoEnumeratorWrapper.BuildEnumerable <T>(() => e.MoveNext(), () => (T)((object)e.Current), () => Dispose()).GetEnumerator());
}
else
{
IEnumerator <object> e = _avroReader != null?rr.AsEnumerable <T>(_avroReader).GetEnumerator() : rr.AsEnumerable <T>(_sr).GetEnumerator();
return(ChoEnumeratorWrapper.BuildEnumerable <T>(() => e.MoveNext(), () => (T)ChoConvert.ChangeType <ChoRecordFieldAttribute>(e.Current, typeof(T)), () => Dispose()).GetEnumerator());
}
}
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);
}
