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); }