internal void CallAfterConfigurationMemberPersist() { //if (!(ConfigObject is ChoConfigurableObject)) // return; if (AfterConfigurationObjectMemberPersist != null) { MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(GetType()); if (memberInfos == null || memberInfos.Length == 0) { return; } ChoPropertyInfoAttribute memberInfoAttribute = null; string name = null; foreach (MemberInfo memberInfo in memberInfos) { if (memberInfo.GetCustomAttribute <ChoIgnorePropertyAttribute>() != null) { continue; } object memberValue = ChoType.GetMemberValue(this, memberInfo.Name); memberInfoAttribute = (ChoPropertyInfoAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoPropertyInfoAttribute)); name = ChoType.GetMemberName(memberInfo, memberInfoAttribute); RaiseAfterConfigurationObjectMemberPersist(memberInfo.Name, name, memberValue); } } }
public static bool IsValidFor(this object @this, MemberInfo mi, out Exception aggEx) { aggEx = null; ChoGuard.ArgumentNotNullOrEmpty(@this, "Target"); if (@this == null) { return(true); } var results = new List <ValidationResult>(); object surrObj = ChoMetadataObjectCache.Default.GetMetadataObject(@this); if (surrObj is IChoValidatable) { ((IChoValidatable)surrObj).TryValidateFor(@this, mi.Name, results); } else { var context = new ValidationContext(@this, null, null); context.MemberName = mi.Name; Validator.TryValidateValue(ChoType.GetMemberValue(@this, mi), context, results, ChoTypeDescriptor.GetPropetyAttributes <ValidationAttribute>(ChoTypeDescriptor.GetProperty <ValidationAttribute>(@this.GetType(), mi.Name))); } if (results.Count > 0) { aggEx = new ApplicationException("Failed to validate '{0}' member. {2}{1}".FormatString(mi.Name, ToString(results), Environment.NewLine)); return(false); } else { return(true); } }
protected override bool PreInvoke(ChoMemberInfo memberInfo) { object oldValue = ChoType.GetMemberValue(this, memberInfo.Info); object newValue = memberInfo.Value; bool isEqual = IsMemeberValueEqualInternal(memberInfo.Info, oldValue, newValue); if (!isEqual) { if (memberInfo.DirtyOperation) { string propertyName = ChoType.GetMemberName(memberInfo.Info); try { bool handled = RaiseBeforeConfigurationObjectMemberLoaded(memberInfo.Name, propertyName, oldValue, ref newValue); memberInfo.Value = newValue; return(!handled); } catch (Exception ex) { if (!RaiseConfigurationObjectMemberLoadError(memberInfo.Name, propertyName, newValue, ex)) { throw; } } } return(true); } else { return(!isEqual); } }
public static object ConvertFrom(object target, MemberInfo memberInfo, CultureInfo culture) { ChoGuard.ArgumentNotNull(target, "Target"); ChoGuard.ArgumentNotNull(memberInfo, "MemberInfo"); Type objType = null; if (target is Type) { objType = target as Type; target = null; } else { objType = target.GetType(); } if (target == null) { return(ChoConvert.ConvertFrom(target, ChoType.GetMemberValue(objType, memberInfo.Name), ChoType.GetMemberType(memberInfo), ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo), culture)); } else { return(ChoConvert.ConvertFrom(target, ChoType.GetMemberValue(target, memberInfo.Name), ChoType.GetMemberType(memberInfo), ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo), culture)); } }
private void WireNotifyPropertyChangedMembersForChanges(Type type) { MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(type); if (memberInfos != null && memberInfos.Length > 0) { //Set member values INotifyPropertyChanged memberValue = null; ChoPropertyInfoAttribute memberInfoAttribute = null; foreach (MemberInfo memberInfo in memberInfos) { if (memberInfo.GetCustomAttribute <ChoIgnorePropertyAttribute>() != null) { continue; } memberInfoAttribute = (ChoPropertyInfoAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoPropertyInfoAttribute)); memberValue = ChoType.GetMemberValue(this, memberInfo.Name) as INotifyPropertyChanged; if (memberValue == null) { continue; } memberValue.PropertyChanged += MemberValuePropertyChanged; WireNotifyPropertyChangedMembersForChanges(memberValue.GetType()); } } }
private static void DoPostTypeMemberConversion(Type type) { bool hasError = false; foreach (MemberInfo memberInfo in ChoType.GetMemberInfos(type, typeof(ChoTypeConverterAttribute))) { object memberValue = null; try { memberValue = ChoType.GetMemberValue(null, memberInfo.Name); ChoType.SetMemberValue(null, memberInfo, ChoObject.ConvertValueToObjectMemberType(type, memberInfo, memberValue) /* ChoConvert.ChangeType(configObject, memberInfo) */); } catch (TargetInvocationException) { throw; } catch (ChoFatalApplicationException) { throw; } catch (Exception ex) { hasError = true; ChoConfigurationObjectErrorManagerService.SetObjectMemberError(type, memberInfo.Name, String.Format("[Value: {0}] - {1}", ChoString.ToString(memberValue), ex.Message)); ChoType.SetMemberDefaultValue(null, memberInfo.Name); } } if (hasError) { ChoConfigurationObjectErrorManagerService.SetObjectError(type, "Object has some validation errors."); } }
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 { if (target is ChoDynamicObject && ((ChoDynamicObject)target).DynamicObjectName == MemberName) { return(((ChoDynamicObject)target).GetText()); } throw new ApplicationException("Can't find '{0}' member in dynamic object.".FormatString(MemberName)); } } else { return(ChoType.GetMemberValue(target, MemberName)); // ChoConvert.ConvertTo(ChoType.GetMemberValue(target, MemberName), ProperyType); } }
public override string ToString() { StringBuilder msg = new StringBuilder(); foreach (PropertyInfo pi in GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)) { AppendToMsg(msg, ChoType.GetMemberValue(this, pi).ToNString()); } return(msg.ToString()); }
public static IEnumerable <object> AsList(this object target, bool flattenhierarchy = false, bool expandCollection = false) { if (target != null) { Type type = target.GetType(); foreach (MemberInfo memberInfo in ChoTypeMembersCache.GetAllMemberInfos(type)) { object memberValue = ChoType.GetMemberValue(target, memberInfo); if (!flattenhierarchy) { yield return(memberValue); } else { Type memberType = ChoType.GetMemberType(memberInfo); if (memberType.IsSimple()) { yield return(memberValue); } else if (typeof(ICollection).IsAssignableFrom(memberType)) { if (!expandCollection || memberValue == null) { yield return(memberValue); } else { if (((ICollection)memberValue).Count == 0) { yield return(null); } else { foreach (object value in (ICollection)memberValue) { yield return(value); } } } } else { foreach (Tuple <string, object> subItem in AsDictionary(memberValue, flattenhierarchy)) { yield return(subItem); } } } } } yield break; }
public static void ConvertNSetMemberValue(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, ref object fieldValue, CultureInfo culture) { if (fieldConfig.Converters.IsNullOrEmpty()) { ChoType.ConvertNSetMemberValue(rec, fn, fieldValue, culture); fieldValue = ChoType.GetMemberValue(rec, fn); } else { fieldValue = ChoConvert.ConvertFrom(fieldValue, ChoType.GetMemberType(rec.GetType(), fn), null, fieldConfig.Converters.ToArray(), null, culture); ChoType.SetMemberValue(rec, fn, fieldValue); } }
public static int Compare(object obj1, object obj2) { if (System.Object.ReferenceEquals(obj1, obj2)) { return(0); } if (obj1 == null) { return(-1); } if (obj2 == null) { return(1); } if (obj1.GetType().IsSimple()) { return(((IComparable)obj1).CompareTo(obj2)); } else { MemberInfo[] memberInfos = obj1.GetType().GetMembers(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.GetField | BindingFlags.GetProperty); if (memberInfos == null || memberInfos.Length == 0) { return(0); } else { int retValue = 0; foreach (MemberInfo memberInfo in memberInfos) { if (!ChoType.IsValidObjectMember(memberInfo)) { continue; } if (ChoType.GetMemberAttribute(memberInfo, typeof(ChoIgnoreCompareAttribute)) != null) { continue; } retValue += Compare(ChoType.GetMemberValue(obj1, memberInfo), ChoType.GetMemberValue(obj2, memberInfo)); } return(retValue); } } }
internal static NameValueCollection ToPersistableNameValueCollection(object target) { ChoGuard.ArgumentNotNull(target, "Target"); NameValueCollection nameValues = new NameValueCollection(); //Dictionary<string, MemberInfo> configMemberInfos = ChoType.GetMembersDictionary(target.GetType(), typeof(ChoConfigurationPropertyAttribute)); //MemberInfo[] memberInfos = ChoType.GetMembers(target.GetType(), typeof(ChoConfigurationPropertyAttribute)); MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(target.GetType()); if (memberInfos == null || memberInfos.Length == 0) { return(nameValues); } ChoPropertyInfoAttribute memberInfoAttribute = null; string name = null; foreach (MemberInfo memberInfo in memberInfos) { if (memberInfo.GetCustomAttribute <ChoIgnorePropertyAttribute>() != null) { continue; } object memberValue = ChoType.GetMemberValue(target, memberInfo.Name); memberInfoAttribute = (ChoPropertyInfoAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoPropertyInfoAttribute)); //if (memberInfoAttribute == null) continue; name = ChoType.GetMemberName(memberInfo, memberInfoAttribute); if (target is ChoConfigurableObject && ((ChoConfigurableObject)target).RaiseBeforeConfigurationObjectMemberPersist(memberInfo.Name, name, ref memberValue)) { nameValues.Add(name, memberValue == null ? null : memberValue.ToString()); } else { if (memberInfoAttribute != null && !memberInfoAttribute.Persistable) { continue; } memberValue = ChoType.GetMemberValue(target, memberInfo.Name); nameValues.Add(name, ChoString.ToString(ChoConvert.ConvertTo(target, memberValue, typeof(string), ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo), null), String.Empty, String.Empty)); } } return(nameValues); }
public override bool TryGetMember(GetMemberBinder binder, out object result) { result = null; MemberInfo memberInfo = ChoTypeMembersCache.GetMemberInfo(_type, binder.Name); if (memberInfo != null) { result = ChoType.GetMemberValue(_instance, memberInfo); return(true); } else { return(false); } }
public static object GetPersistableMemberValue(object target, MemberInfo memberInfo) { ChoGuard.ArgumentNotNull(target, "Target"); object memberValue = ChoType.GetMemberValue(target, memberInfo.Name); object persistValue = memberValue; string propertyName = ChoType.GetMemberName(memberInfo); if (target is ChoConfigurableObject && ((ChoConfigurableObject)target).RaiseBeforeConfigurationObjectMemberPersist(memberInfo.Name, propertyName, ref persistValue)) { return(persistValue); } return(memberValue); }
public static object GetObjectMemberValue(object target, MemberInfo memberInfo) { ChoGuard.ArgumentNotNull(target, "Target"); object memberValue = ChoType.GetMemberValue(target, memberInfo); if (memberValue == null) { ChoPropertyInfoAttribute memberInfoAttribute = ChoType.GetMemberAttribute <ChoPropertyInfoAttribute>(memberInfo); if (memberInfoAttribute != null) { memberValue = memberInfoAttribute.DefaultValue; } } return(memberValue); }
// If the type of the value to convert is string, parses the string // and returns the integer to set the value of the property to. // This example first extends the integer array that supplies the // standard values collection if the user-entered value is not // already in the array. public override object ConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) { value = ChoType.GetMemberValue(Target, DependentMemberName); object convertedObject = null; using (ChoBufferProfileEx outerProfile = new ChoBufferProfileEx(LogFileName, "Converting file to objects....")) { try { if (value.GetType() == typeof(string)) { convertedObject = GetObject(value as string, outerProfile); } else if (value.GetType() == typeof(string[])) { Hashtable convertedObjects = new Hashtable(); foreach (string fileName in (string[])value) { object element = GetObject(fileName, outerProfile); if (KeyName == InternalHashKey) { convertedObjects.Add(element.GetHashCode().ToString(), element); } else { convertedObjects.Add(ChoType.GetMemberValue(element, KeyName).ToString(), element); } } convertedObject = convertedObjects; } } catch (ChoFatalApplicationException) { throw; } catch (Exception ex) { outerProfile.Append(ex); } } return(convertedObject); }
private static string GetNFormatMemberValue(object target, MemberInfo memberInfo, bool collectErrMsgs, ChoMemberFormatterAttribute memberFormaterAttribute, ChoMemberItemFormatterAttribute memberItemFormaterAttribute, BindingFlags bindingFlags) { try { string memberText = null; object memberValue = ChoType.GetMemberValue(target, memberInfo); if (memberValue == target) { return(null); } //if (memberFormaterAttribute == null) //{ // object[] typeConverters = ChoTypeDescriptor.GetTypeConverters(memberInfo); // if (typeConverters != null && typeConverters.Length > 0) // { // if (typeConverters.Length == 1 && typeConverters[0].GetType() == typeof(System.ComponentModel.TypeConverter)) // { // } // else // { // object convertedValue = ChoConvert.ConvertTo(target, memberInfo, typeof(string)); //, typeConverters, ChoTypeDescriptor.GetTypeConverterParams(memberInfo), null); // return convertedValue == null ? String.Empty : convertedValue.ToString(); // //return memberText; // } // } //} memberText = ChoFormattableObject.ToString(memberValue, collectErrMsgs, memberFormaterAttribute, memberItemFormaterAttribute, bindingFlags); if (memberText.ContainsMultiLines()) { memberText = Environment.NewLine + memberText.Indent(); } return(memberText); } catch (ChoFatalApplicationException) { throw; } catch (Exception ex) { throw new ChoApplicationException(memberInfo.Name, ex); } }
private static void DoValidate <T>(T target, ChoValidationResults validationResults) { bool validationRoutineFound = false; bool canContinue = true; foreach (MethodInfo methodInfo in GetValidationRoutines(target.GetType())) { canContinue = false; validationRoutineFound = true; canContinue = (bool)ChoType.InvokeMethod(target, methodInfo.Name, new object[] { validationResults }); if (!canContinue) { break; } } //Do built-in attribute validations if (!validationRoutineFound) { MemberInfo[] memberInfos = ChoType.GetMembers(target.GetType()); foreach (MemberInfo memberInfo in memberInfos) { IChoSurrogateValidator validator = ChoCompositeValidatorBuilder.GetValidator(memberInfo); if (validator == null) { continue; } try { validator.Validate(memberInfo, ChoType.GetMemberValue(target, memberInfo.Name)); } catch (ChoFatalApplicationException) { throw; } catch (Exception ex) { validationResults.AddResult(new ChoValidationResult(ex.Message)); } } } }
public static void DoMemberLevelValidation(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, ChoObjectValidationMode vm) { if (rec is ExpandoObject) { ((IDictionary <string, object>)rec).DoMemberLevelValidation(fn, fieldConfig, vm); } else { if ((vm & ChoObjectValidationMode.MemberLevel) == ChoObjectValidationMode.MemberLevel) { if (fieldConfig.Validators.IsNullOrEmpty()) { ChoValidator.ValidateFor(rec, fn); } else { ChoValidator.ValidateFor(ChoType.GetMemberValue(rec, fn), fn, fieldConfig.Validators); } } } }
protected override bool PreInvoke(ChoMemberInfo memberInfo) { object oldValue = ChoType.GetMemberValue(this, memberInfo.Info); object newValue = memberInfo.Value; bool isEqual = IsMemeberValueEqualInternal(memberInfo.Info, oldValue, newValue); if (!isEqual) { if (memberInfo.DirtyOperation) { string propertyName = ChoType.GetMemberName(memberInfo.Info); try { bool cancel = RaiseBeforeConfigurationObjectMemberSet(memberInfo.Name, propertyName, oldValue, ref newValue); //if (!cancel) //{ // //memberInfo.Value = newValue; // ChoType.SetMemberValue(this, memberInfo.Info, newValue); // this.OnPropertyChanged(memberInfo.Name); //} return(!cancel); } catch (Exception ex) { if (!RaiseConfigurationObjectMemberSetError(memberInfo.Name, propertyName, newValue, ex)) { throw new ChoConfigurationObjectPostInvokeException("Error while setting configuration member value.", memberInfo.Exception); } } } return(true); } else { return(!isEqual); } }
public IEnumerable <KeyValuePair <string, object> > AsDictionary() { MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(GetType()); if (memberInfos != null && memberInfos.Length > 0) { //Set member values string name; ChoPropertyInfoAttribute memberInfoAttribute = null; foreach (MemberInfo memberInfo in memberInfos) { if (memberInfo.GetCustomAttribute <ChoIgnorePropertyAttribute>() != null) { continue; } memberInfoAttribute = (ChoPropertyInfoAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoPropertyInfoAttribute)); name = ChoType.GetMemberName(memberInfo); yield return(new KeyValuePair <string, object>(name, ChoType.GetMemberValue(GetType(), memberInfo))); } } }
// If the type of the value to convert is string, parses the string // and returns the integer to set the value of the property to. // This example first extends the integer array that supplies the // standard values collection if the user-entered value is not // already in the array. public override object ConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) { value = ChoType.GetMemberValue(Target, DependentMemberName); object convertedObject = null; using (ChoBufferProfileEx outerProfile = new ChoBufferProfileEx(LogFileName, "Converting file to objects....")) { try { if (value.GetType() == typeof(string)) { convertedObject = GetObject(value as string, outerProfile); } else if (value.GetType() == typeof(string[])) { ChoNotNullableArrayList convertedObjects = new ChoNotNullableArrayList(); foreach (string fileName in (string[])value) { convertedObjects.Add(GetObject(fileName, outerProfile)); } convertedObject = convertedObjects.ToArray(ObjElementType); } } catch (ChoFatalApplicationException) { throw; } catch (Exception ex) { outerProfile.Append(ex); } } return(convertedObject); }
private static string GetNFormatMemberValue(object target, MemberInfo memberInfo, bool collectErrMsgs, ChoMemberFormatterAttribute memberFormaterAttribute, ChoMemberItemFormatterAttribute memberItemFormaterAttribute, BindingFlags bindingFlags) { try { string memberText = null; object memberValue = ChoType.GetMemberValue(target, memberInfo); if (memberValue == target) { return(null); } if (memberFormaterAttribute == null) { object[] typeConverters = ChoTypeDescriptor.GetTypeConverters(memberInfo); if (typeConverters != null && typeConverters.Length > 0) { memberText = (string)ChoConvert.ConvertTo(target, memberValue, typeof(string), typeConverters, ChoTypeDescriptor.GetTypeConverterParams(memberInfo), null); return(memberText); } } memberText = ChoFormattableObject.ToString(memberValue, collectErrMsgs, memberFormaterAttribute, memberItemFormaterAttribute, bindingFlags); if (memberText.ContainsMultiLines()) { memberText = Environment.NewLine + memberText.Indent(); } return(memberText); } catch (ChoFatalApplicationException) { throw; } catch (Exception ex) { throw new ChoApplicationException(memberInfo.Name, ex); } }
public static bool IsValidFor(this object @this, MemberInfo mi, out Exception aggEx) { aggEx = null; ChoGuard.ArgumentNotNullOrEmpty(@this, "Target"); if (@this == null) { return(true); } var results = new List <ValidationResult>(); if (@this is IChoValidatable) { ((IChoValidatable)@this).TryValidateFor(mi.Name, results); } else { //if (ChoObjectMemberMetaDataCache.Default.IsRequired(mi) && ChoType.GetMemberValue(@this, mi) == null) // results.Add(new ValidationResult("Null value found for {0} member.".FormatString(mi.Name))); var context = new ValidationContext(@this, null, null); context.MemberName = mi.Name; Validator.TryValidateValue(ChoType.GetMemberValue(@this, mi), context, results, ChoType.GetAttributes <ValidationAttribute>(mi)); } if (results.Count > 0) { aggEx = new ApplicationException("Failed to validate '{0}' member. {2}{1}".FormatString(mi.Name, ToString(results), Environment.NewLine)); return(false); } else { return(true); } }
private static void DoValidate(object target, ChoValidationResults validationResults) { bool canContinue = true; foreach (MethodInfo methodInfo in GetValidationRoutines(target.GetType())) { canContinue = false; canContinue = (bool)ChoType.InvokeMethod(target, methodInfo.Name, validationResults); if (!canContinue) { break; } } //Do built-in attribute validations if (canContinue) { MemberInfo[] memberInfos = ChoType.GetMembers(target.GetType()); foreach (MemberInfo memberInfo in memberInfos) { foreach (ChoMemberAttribute memberAttribute in ChoType.GetMemberAttributesByBaseType(memberInfo, typeof(ChoMemberAttribute))) { try { memberAttribute.Validate(ChoType.GetMemberValue(target, memberInfo.Name), false); } catch (Exception ex) { validationResults.AddResult(ex.Message); } } } } }
public object GetValue(object target) { if (MemberInfo != null) { return(ChoType.GetMemberValue(target, MemberInfo)); } else if (target is ExpandoObject) { 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(ChoType.GetMemberValue(target, MemberName)); } }
void ChoRegistrySectionInfo_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e) { if (RegistryValueKindDictEx.ContainsKey(e.PropertyName) && RegistryValueKindDictEx[e.PropertyName] == RegistryValueKind.ExpandString) { string expandedStringMemberName = e.PropertyName + EXPAND_KEY_POSTFIX; MemberInfo memberInfo = ChoType.GetMemberInfo(sender.GetType(), expandedStringMemberName); if (memberInfo != null) { object expandString = ChoType.GetMemberValue(sender, e.PropertyName);; if (expandString != null && expandString is string) { ChoType.SetMemberValue(sender, expandedStringMemberName, Environment.ExpandEnvironmentVariables(expandString as string)); } else { ChoType.SetMemberValue(sender, expandedStringMemberName, null); } } //Console.WriteLine(sender.ToString()); } }
private object GetPropertyValue(string propertyName) { object target = GetTargetState(); Match match = Regex.Match(propertyName, _matchString); if (!match.Success) { return(propertyName); } string className = match.Groups["class"].ToString(); string memberName = match.Groups["member"].ToString(); string assemblyName = match.Groups["assembly"].ToString(); if (String.Compare(className, THIS, true) == 0) { if (className != THIS || target == null) { return(propertyName); } //Call the object member, return the value return(ChoType.GetMemberValue(target.GetType(), target, memberName)); } else { //Call the object shared member, return the value Type objType = null; string typeName = null; try { if (String.IsNullOrEmpty(assemblyName)) { typeName = className; } else { typeName = String.Format("{0}, {1}", className, assemblyName); } objType = ChoType.GetType(typeName); if (objType == null) { string typeName1 = ChoTypeFactory.Me[typeName]; if (!String.IsNullOrEmpty(typeName1)) { objType = ChoType.GetType(typeName1); } } } catch (ChoFatalApplicationException) { throw; } catch (Exception ex) { throw new ApplicationException(String.Format("Failed to load {0} type.", typeName), ex); } if (objType == null) { throw new ApplicationException(String.Format("Failed to load {0} type.", typeName)); } return(ChoType.GetMemberValue(objType, null, memberName)); } }
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); }
private bool ExtractNPopulateValues(ref bool hasErrors, ref bool isDirty) { bool isModfied = false; object oldValue = null; object newValue = null; object origValue = null; object defaultValue = null; object fallbackValue = null; bool isConfigmemberDefined = false; //MemberInfo[] memberInfos = ChoType.GetMembers(ConfigObject.GetType(), typeof(ChoConfigurationPropertyAttribute)); MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(ConfigObject.GetType()); if (memberInfos != null && memberInfos.Length > 0) { //Set member values string name; ChoPropertyInfoAttribute memberInfoAttribute = null; foreach (MemberInfo memberInfo in memberInfos) { if (memberInfo.GetCustomAttribute <ChoIgnorePropertyAttribute>() != null) { continue; } memberInfoAttribute = (ChoPropertyInfoAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoPropertyInfoAttribute)); //if (memberInfoAttribute == null) continue; oldValue = null; newValue = null; origValue = null; defaultValue = null; fallbackValue = null; name = ChoType.GetMemberName(memberInfo); isConfigmemberDefined = ConfigSection.HasConfigMemberDefined(name); oldValue = ChoType.GetMemberValue(ConfigObject, memberInfo.Name); object configFallbackValue = null; object configDefaultValue = null; bool isDefaultValueSpecified = ChoConfigurationMetaDataManager.TryConfigDefaultValue(this, name, memberInfoAttribute, out configDefaultValue); ChoConfigurationMetaDataManager.TryConfigFallbackValue(this, name, memberInfoAttribute, out configFallbackValue); if (configFallbackValue == null) { if (isDefaultValueSpecified) { defaultValue = origValue = newValue = configDefaultValue; } } else { fallbackValue = origValue = newValue = configFallbackValue; } if (!isConfigmemberDefined) { if (!isDirty) { isDirty = memberInfoAttribute != null && memberInfoAttribute.Persistable ? true : false; } } else { origValue = newValue = ConfigSection[name]; } try { object newConvertedValue = ChoConvert.ConvertFrom(ConfigObject, newValue, ChoType.GetMemberType(memberInfo), ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo)); newValue = newConvertedValue; } catch { } ChoConfigurableObject configObject = ConfigObject as ChoConfigurableObject; if (configObject != null) { if (!configObject.IsMemeberValueEqualInternal(memberInfo, oldValue, newValue)) { if (!configObject.RaiseBeforeConfigurationObjectMemberLoaded(memberInfo.Name, name, origValue, ref newValue)) { try { //ChoType.SetMemberValue(ConfigObject, memberInfo.Name, newValue != null ? ChoConvert.ConvertFrom(ConfigObject, newValue, // ChoType.GetMemberType(memberInfo), ChoTypeConvertersCache.GetTypeConverters(memberInfo)) : null); SetConfigPropertyValue(newValue, memberInfo); if (!_firstTime) { isModfied = true; } configObject.RaiseAfterConfigurationObjectMemberLoaded(memberInfo.Name, name, newValue); ChoConfigurationObjectErrorManagerService.ResetObjectMemberError(ConfigObject, memberInfo.Name); } catch (Exception innerEx) { if (!configObject.RaiseConfigurationObjectMemberLoadError(memberInfo.Name, name, origValue, innerEx)) { if (Silent) { if (_firstTime) { AssignToFallbackOrDefaultValue(defaultValue, fallbackValue, memberInfo); } ChoConfigurationObjectErrorManagerService.SetObjectMemberError(ConfigObject, memberInfo.Name, String.Format(Resources.ConfigConstructMsg, ChoString.ToString(origValue), innerEx.Message)); } else { throw new ChoConfigurationConstructionException(String.Format(Resources.ConfigConstructExceptionMsg, ChoString.ToString(origValue), ConfigObject.GetType().FullName, memberInfo.Name), innerEx); } } } } } } else { try { //ChoType.SetMemberValue(ConfigObject, memberInfo.Name, newValue != null ? ChoConvert.ConvertFrom(ConfigObject, newValue, // ChoType.GetMemberType(memberInfo), ChoTypeConvertersCache.GetTypeConverters(memberInfo)) : null); SetConfigPropertyValue(newValue, memberInfo); if (!_firstTime) { isModfied = true; } ChoConfigurationObjectErrorManagerService.ResetObjectMemberError(ConfigObject, memberInfo.Name); } catch (Exception innerEx) { if (Silent) { if (_firstTime) { AssignToFallbackOrDefaultValue(defaultValue, fallbackValue, memberInfo); } ChoConfigurationObjectErrorManagerService.SetObjectMemberError(ConfigObject, memberInfo.Name, String.Format(Resources.ConfigConstructMsg, ChoString.ToString(origValue), innerEx.Message)); } else { throw new ChoConfigurationConstructionException(String.Format(Resources.ConfigConstructExceptionMsg, ChoString.ToString(origValue), ConfigObject.GetType().FullName, memberInfo.Name), innerEx); } } } } } return(isModfied); }