private static ChoTypePropertyInfo GetTypePropertyInfo(Type type, PropertyInfo pi) { if (_typeCache.ContainsKey(type)) { return(_typeCache[type][pi]); } lock (_padLock) { if (_typeCache.ContainsKey(type)) { return(_typeCache[type][pi]); } Dictionary <PropertyInfo, ChoTypePropertyInfo> dict = new Dictionary <PropertyInfo, ChoTypePropertyInfo>(); foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(type)) { PropertyInfo lpi = pd.ComponentType.GetProperty(pd.Name); object[] propConverters = ChoTypeDescriptor.GetTypeConverters(pi); object[] propConverterParams = ChoTypeDescriptor.GetTypeConverterParams(pi); int? size = null; string formatText = null; string nullValueText = null; if (pd.Attributes.OfType <ChoFileRecordFieldAttribute>().Any()) { var fa = pd.Attributes.OfType <ChoFileRecordFieldAttribute>().First(); size = fa.SizeInternal; formatText = fa.FormatText; nullValueText = fa.NullValue; } else { StringLengthAttribute slAttr = pd.Attributes.OfType <StringLengthAttribute>().FirstOrDefault(); if (slAttr != null && slAttr.MaximumLength > 0) { size = slAttr.MaximumLength; } DisplayFormatAttribute dfAttr = pd.Attributes.OfType <DisplayFormatAttribute>().FirstOrDefault(); if (dfAttr != null && !dfAttr.DataFormatString.IsNullOrWhiteSpace()) { formatText = dfAttr.DataFormatString; } if (dfAttr != null && !dfAttr.NullDisplayText.IsNullOrWhiteSpace()) { nullValueText = dfAttr.NullDisplayText; } if (formatText.IsNullOrWhiteSpace()) { propConverterParams = new object[] { new object[] { formatText } } } ; } dict.Add(lpi, new ChoTypePropertyInfo { FormatText = formatText, PropConverterParams = propConverterParams, PropConverters = propConverters, Size = size, NullValueText = nullValueText }); } _typeCache.Add(type, dict); return(_typeCache[type][pi]); } }
private bool FillRecord(object rec, Tuple <long, string> pair) { long lineNo; string line; lineNo = pair.Item1; line = pair.Item2; if (line.Length != Configuration.RecordLength) { throw new ChoParserException("Incorrect record length [Length: {0}] found. Expected record length: {1}".FormatString(line.Length, Configuration.RecordLength)); } object fieldValue = null; ChoFixedLengthRecordFieldConfiguration fieldConfig = null; PropertyInfo pi = null; object rootRec = rec; foreach (KeyValuePair <string, ChoFixedLengthRecordFieldConfiguration> kvp in Configuration.RecordFieldConfigurationsDict) { fieldValue = null; fieldConfig = kvp.Value; if (Configuration.PIDict != null) { Configuration.PIDict.TryGetValue(kvp.Key, out pi); } rec = GetDeclaringRecord(kvp.Value.DeclaringMember, rootRec); try { if (fieldConfig.StartIndex + fieldConfig.Size > line.Length) { if (Configuration.ColumnCountStrict) { throw new ChoParserException("Missing '{0}' field value.".FormatString(kvp.Key)); } } else { fieldValue = line.Substring(fieldConfig.StartIndex, fieldConfig.Size.Value); } if (!Configuration.SupportsMultiRecordTypes && Configuration.IsDynamicObject) { if (kvp.Value.FieldType == null) { kvp.Value.FieldType = Configuration.MaxScanRows == -1 ? DiscoverFieldType(fieldValue as string, Configuration) : typeof(string); } } else { if (pi != null) { kvp.Value.FieldType = pi.PropertyType; } else { kvp.Value.FieldType = typeof(string); } } fieldValue = CleanFieldValue(fieldConfig, kvp.Value.FieldType, fieldValue as string); if (!RaiseBeforeRecordFieldLoad(rec, pair.Item1, kvp.Key, ref fieldValue)) { continue; } bool ignoreFieldValue = fieldConfig.IgnoreFieldValue(fieldValue); if (ignoreFieldValue) { fieldValue = fieldConfig.IsDefaultValueSpecified ? fieldConfig.DefaultValue : null; } 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); fieldConfig.PI = pi; fieldConfig.PropConverters = ChoTypeDescriptor.GetTypeConverters(fieldConfig.PI); fieldConfig.PropConverterParams = ChoTypeDescriptor.GetTypeConverterParams(fieldConfig.PI); } if (pi != null) { rec.ConvertNSetMemberValue(kvp.Key, kvp.Value, ref fieldValue, Configuration.Culture); } else if (!Configuration.SupportsMultiRecordTypes) { 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 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) { continue; } else { if (!RaiseRecordFieldLoadError(rec, pair.Item1, kvp.Key, fieldValue, ex)) { if (ex is ValidationException) { throw; } 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); }
protected virtual void LoadNCacheMembers(IEnumerable <ChoRecordFieldConfiguration> fcs) { if (!IsDynamicObject) { object defaultValue = null; object fallbackValue = null; foreach (var fc in fcs) { if (!PDDict.ContainsKey(fc.Name)) { continue; } fc.PD = PDDict[fc.Name]; fc.PI = PIDict[fc.Name]; //Load default value defaultValue = ChoType.GetRawDefaultValue(PDDict[fc.Name]); if (defaultValue != null) { fc.DefaultValue = defaultValue; fc.IsDefaultValueSpecified = true; } //Load fallback value fallbackValue = ChoType.GetRawFallbackValue(PDDict[fc.Name]); if (fallbackValue != null) { fc.FallbackValue = fallbackValue; fc.IsFallbackValueSpecified = true; } //Load Converters fc.PropConverters = ChoTypeDescriptor.GetTypeConverters(fc.PI); fc.PropConverterParams = ChoTypeDescriptor.GetTypeConverterParams(fc.PI); } PropertyNames = PDDict.Keys.ToArray(); } //Validators HasConfigValidators = (from fc in fcs where fc.Validators != null select fc).FirstOrDefault() != null; if (!HasConfigValidators) { if (!IsDynamicObject) { foreach (var fc in fcs) { if (!PDDict.ContainsKey(fc.Name)) { continue; } fc.Validators = ChoTypeDescriptor.GetPropetyAttributes <ValidationAttribute>(fc.PD).ToArray(); } } } ValDict = (from fc in fcs select new KeyValuePair <string, ValidationAttribute[]>(fc.Name, fc.Validators)).GroupBy(i => i.Key).Select(g => g.First()).ToDictionary(kvp => kvp.Key, kvp => kvp.Value); }
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 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); } }
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 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 static bool TryConvertTo(object value, MemberInfo memberInfo, Type targetType, object sourceObject, CultureInfo culture, out object output) { output = (object)null; ChoGuard.ArgumentNotNull((object)memberInfo, "MemberInfo"); try { output = ChoConvert.ConvertTo(value, targetType, sourceObject, ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo), culture); return(true); } catch { return(false); } }
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); } } } }
public static object ConvertTo(object value, MemberInfo memberInfo, Type targetType, object sourceObject = null, CultureInfo culture = null) { ChoGuard.ArgumentNotNull((object)memberInfo, "MemberInfo"); return(ChoConvert.ConvertTo(value, targetType, sourceObject, ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo), culture, memberInfo.Name)); }
protected virtual void LoadNCacheMembers(IEnumerable <ChoRecordFieldConfiguration> fcs) { if (!IsDynamicObject) { string name = null; object defaultValue = null; object fallbackValue = null; foreach (var fc in fcs) { //if (fc is ChoFileRecordFieldConfiguration) // name = ((ChoFileRecordFieldConfiguration)fc).FieldName; //else name = fc.Name; fc.PD = PDDict.ContainsKey(name) ? PDDict[name] : (PDDict.Any(p => p.Value.Name == name) ? PDDict.Where(p => p.Value.Name == name).Select(p => p.Value).FirstOrDefault() : null); fc.PI = PIDict.ContainsKey(name) ? PIDict[name] : (PIDict.Any(p => p.Value.Name == name) ? PIDict.Where(p => p.Value.Name == name).Select(p => p.Value).FirstOrDefault() : null); if (fc.PD == null || fc.PI == null) { continue; } //Load default value defaultValue = ChoType.GetRawDefaultValue(fc.PD); if (defaultValue != null) { fc.DefaultValue = defaultValue; fc.IsDefaultValueSpecified = true; } //Load fallback value fallbackValue = ChoType.GetRawFallbackValue(fc.PD); if (fallbackValue != null) { fc.FallbackValue = fallbackValue; fc.IsFallbackValueSpecified = true; } //Load Converters fc.PropConverters = ChoTypeDescriptor.GetTypeConverters(fc.PI); fc.PropConverterParams = ChoTypeDescriptor.GetTypeConverterParams(fc.PI); //Load Custom Serializer fc.PropCustomSerializer = ChoTypeDescriptor.GetCustomSerializer(fc.PI); fc.PropCustomSerializerParams = ChoTypeDescriptor.GetCustomSerializerParams(fc.PI); if (fc.SourceType == null) { fc.SourceType = fc.GetSourceTypeFromConvertersIfAny(); } } PropertyNames = PDDict.Keys.ToArray(); } //Validators HasConfigValidators = (from fc in fcs where fc.Validators != null select fc).FirstOrDefault() != null; if (!HasConfigValidators) { if (!IsDynamicObject) { string name = null; foreach (var fc in fcs) { if (fc is ChoFileRecordFieldConfiguration) { name = ((ChoFileRecordFieldConfiguration)fc).FieldName; } else { name = fc.Name; } if (!PDDict.ContainsKey(name)) { continue; } fc.Validators = ChoTypeDescriptor.GetPropetyAttributes <ValidationAttribute>(fc.PD).ToArray(); } } } ValDict = (from fc in fcs select new KeyValuePair <string, ValidationAttribute[]>(fc is ChoFileRecordFieldConfiguration ? ((ChoFileRecordFieldConfiguration)fc).FieldName : fc.Name, fc.Validators)) .GroupBy(i => i.Key).Select(g => g.First()).ToDictionary(kvp => kvp.Key, kvp => kvp.Value); }
public static object ConvertTo(object value, Type targetType, CultureInfo culture = null) { if (value == null) { return(ChoConvert.ConvertTo(value, targetType, value, (object[])null, (object[])null, culture)); } Type origType = targetType; Type type = value == null ? typeof(object) : value.GetType(); if (type == origType) { return(value); } return(ChoConvert.ConvertTo(value, targetType, value, ChoTypeDescriptor.GetTypeConverters(value.GetType()), ChoTypeDescriptor.GetTypeConverterParams(value.GetType()), culture)); }