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