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 override bool TrySetMember(SetMemberBinder binder, object value)
{
MemberInfo memberInfo = ChoTypeMembersCache.GetMemberInfo(_type, binder.Name);
if (memberInfo == null)
{
return(false);
}
try
{
//object newConvertedValue = ChoConvert.ConvertFrom(_instance, value, ChoType.GetMemberType(memberInfo),
// ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
object newConvertedValue = ChoConvert.ConvertFrom(value, memberInfo, _instance);
ChoType.SetMemberValue(_instance, memberInfo, newConvertedValue);
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
Trace.TraceError(ex.ToString());
return(false);
}
if (!(_instance is INotifyPropertyChanged))
{
PropertyChangedEventHandler propertyChanged = PropertyChanged;
if (propertyChanged != null)
{
propertyChanged(this, new PropertyChangedEventArgs(binder.Name));
}
}
return(true);
}
private static object ConvertTo(object value, Type targetType, object sourceObject, object[] converters, object[] parameters, CultureInfo culture)
{
object srcValue = value;
if (targetType == null)
{
return(value);
}
object output = null;
if (TryChangeType(value, targetType, culture, out output))
{
return(output);
}
if (targetType == typeof(object))
{
return(value);
}
if (value == null)
{
return(ChoTypeEx.Default(targetType));
}
targetType = targetType.IsNullableType() ? targetType.GetUnderlyingType() : targetType;
if (targetType.IsAssignableFrom(value.GetType()))
{
return(value);
}
if (targetType == value.GetType())
{
return(value);
}
if (culture == null)
{
culture = DefaultCulture;
}
Exception innerException = null;
Type sourceType = value.GetType();
try
{
object obj2 = null;
object[] parameter = null;
if (converters != null && converters.Length > 0)
{
//object[] objArray = (object[])null;
for (int i = 0; i < converters.Length; i++)
{
obj2 = converters[i];
if ((parameters != null) && (parameters.Length > 0))
{
parameter = parameters[i] as object[];
}
if (obj2 is ChoParameterizedTypeConverter)
{
((ChoParameterizedTypeConverter)obj2).Target = sourceObject;
}
if (obj2 is TypeConverter)
{
TypeConverter converter = obj2 as TypeConverter;
if (converter.CanConvertTo(targetType))
{
value = converter.ConvertTo(null, culture, value, targetType);
}
}
else if (obj2 is IChoValueConverter)
{
value = ((IChoValueConverter)obj2).ConvertBack(value, targetType, parameter, culture);
}
else if ((obj2 is IChoMultiValueConverter) && (value is object[]))
{
value = ((IChoMultiValueConverter)obj2).ConvertBack(value as object[], targetType, parameter, culture);
}
else if (obj2 is IValueConverter)
{
value = ((IValueConverter)obj2).ConvertBack(value, targetType, parameter, culture);
}
}
if (srcValue != value)
{
return(value);
}
}
//Convert using IConvertable
if (value is IConvertible)
{
try
{
value = Convert.ChangeType(value, targetType, culture);
if (srcValue != value)
{
return(value);
}
}
catch (Exception innEx)
{
innerException = innEx;
}
}
if (TryConvertXPlicit(value, targetType, ExplicitOperatorMethodName, ref value))
{
return(value);
}
if (TryConvertXPlicit(value, targetType, ImplicitOperatorMethodName, ref value))
{
return(value);
}
if (ChoConvert.TryConvertToSpecialValues(value, targetType, culture, out value))
{
return(value);
}
throw new ChoApplicationException("Object conversion failed.");
}
catch (Exception ex)
{
if (ChoTypeEx.IsSimple(sourceType))
{
throw new ChoApplicationException(string.Format("Can't convert '{2}' value from '{0}' type to '{1}' type.", (object)sourceType, (object)targetType, value), ex);
}
else
{
throw new ChoApplicationException(string.Format("Can't convert object from '{0}' type to '{1}' type.", (object)sourceType, (object)targetType), ex);
}
}
}
internal static Dictionary <string, object> ToPersistableDictionaryCollection(ChoBaseConfigurationElement configElement, Type itemType)
{
ChoGuard.ArgumentNotNull(configElement, "ConfigElement");
object target = configElement.ConfigObject;
ChoGuard.ArgumentNotNull(target, "Target");
Dictionary <string, object> dict = new Dictionary <string, object>();
//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(dict);
}
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));
name = ChoType.GetMemberName(memberInfo, memberInfoAttribute);
if (target is ChoConfigurableObject && ((ChoConfigurableObject)target).RaiseBeforeConfigurationObjectMemberPersist(memberInfo.Name, name, ref memberValue))
{
dict.Add(name, memberValue);
}
else
{
if (memberInfoAttribute != null && !memberInfoAttribute.Persistable)
{
continue;
}
memberValue = ChoType.GetMemberValue(target, memberInfo.Name);
Type memberType = ChoConfigurationMetaDataManager.GetSourceType(configElement, name, memberInfoAttribute);
if (memberType == null)
{
if (itemType == typeof(Object))
{
memberType = ChoType.GetMemberType(memberInfo);
}
else
{
memberType = itemType;
}
}
dict.Add(name, ChoConvert.ConvertTo(target, memberValue, memberType,
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo), null));
}
}
return(dict);
}
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));
}
