public static bool SetFallbackValue(this IDictionary <string, object> dict, string fn, ChoRecordFieldConfiguration fieldConfig, CultureInfo culture, ref object fallbackValue)
{
//Set Fallback value to member
if (fieldConfig.IsFallbackValueSpecified)
{
if (fieldConfig.Converters.IsNullOrEmpty())
{
fallbackValue = ChoConvert.ConvertFrom(fieldConfig.FallbackValue, fieldConfig.FieldType, null, fieldConfig.PropConverters, fieldConfig.PropConverterParams, culture);
}
else
{
fallbackValue = ChoConvert.ConvertFrom(fieldConfig.FallbackValue, fieldConfig.FieldType, null, fieldConfig.Converters.ToArray(), null, culture);
}
dict.AddOrUpdate(fn, fallbackValue);
}
return(fieldConfig.IsFallbackValueSpecified);
}
public static void ConvertNSetMemberValue(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, ref object fieldValue, CultureInfo culture)
{
if (fieldConfig.ValueConverter != null)
{
fieldValue = fieldConfig.ValueConverter(fieldValue);
}
else
{
if (fieldConfig.Converters.IsNullOrEmpty())
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, fieldConfig.PI.PropertyType, null, fieldConfig.PropConverters, fieldConfig.PropConverterParams, culture);
}
else
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, fieldConfig.PI.PropertyType, null, fieldConfig.Converters.ToArray(), null, culture);
}
}
ChoType.SetPropertyValue(rec, fieldConfig.PI, fieldValue);
}
public static bool SetFallbackValue(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, CultureInfo culture)
{
if (rec is ExpandoObject)
{
return(((IDictionary <string, object>)rec).SetFallbackValue(fn, fieldConfig, culture));
}
object fieldValue = null;
//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.ConvertFrom(FallbackValue, ChoType.GetMemberInfo(rec.GetType(), fn), null, culture);
}
else
{
fieldValue = ChoConvert.ConvertFrom(FallbackValue, ChoType.GetMemberType(rec.GetType(), fn), null, fieldConfig.Converters.ToArray(), null, culture);
}
ChoType.SetMemberValue(rec, fn, fieldValue);
}
return(FallbackValueExists);
}
public static void ConvertNSetMemberValue(this IDictionary <string, object> dict, string fn, ChoRecordFieldConfiguration fieldConfig, ref object fieldValue, CultureInfo culture)
{
if (fieldConfig.ValueConverter != null)
{
fieldValue = fieldConfig.ValueConverter(fieldValue);
}
else
{
if (fieldConfig.Converters.IsNullOrEmpty())
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, fieldConfig.FieldType, null, fieldConfig.PropConverters, fieldConfig.PropConverterParams, culture);
}
else
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, fieldConfig.FieldType, null, fieldConfig.Converters.ToArray(), null, culture);
}
}
dict.AddOrUpdate(fn, fieldValue);
}
public object CleanValue(string name, object value)
{
var m1 = ChoType.GetMembers(GetType()).Where(m => !ChoType.IsReadOnlyMember(m) &&
(m.GetCustomAttribute <ChoPropertyAttribute>() != null && m.GetCustomAttribute <ChoPropertyAttribute>().Name == name) || m.Name == name).FirstOrDefault();
if (m1 == null)
{
return(value);
}
value = ChoConvert.ConvertFrom(value, m1);
var attr = ChoType.GetMemberAttribute <ChoPropertyAttribute>(m1);
if (value != null && value is string)
{
string mv = value as string;
if (attr != null)
{
switch (attr.TrimOption)
{
case ChoPropertyValueTrimOption.Trim:
mv = mv.Trim();
break;
case ChoPropertyValueTrimOption.TrimEnd:
mv = mv.TrimEnd();
break;
case ChoPropertyValueTrimOption.TrimStart:
mv = mv.TrimStart();
break;
}
}
return(mv);
}
return(value);
}
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 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 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));
}
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);
}
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 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, 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 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 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 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 (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 = Activator.CreateInstance(fieldConfig.PI.PropertyType) as IDictionary;
//ChoType.SetPropertyValue(rec, fieldConfig.PI, dict);
}
if (dict != null)
{
if (!dict.Contains(fn))
{
dict.Add(fn, fieldValue);
}
}
return;
}
else if (typeof(IList).IsAssignableFrom(fieldConfig.PI.PropertyType))
{
IList list = ChoType.GetPropertyValue(rec, fieldConfig.PI) as IList;
if (list != null)
{
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 = 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);
}
