public static object GetNConvertMemberValue(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, CultureInfo culture, object fieldValue)
{
if (rec is ExpandoObject)
{
if (fieldConfig.Converters.IsNullOrEmpty())
{
fieldValue = ChoConvert.ConvertTo(fieldValue, typeof(string), culture);
}
else
{
fieldValue = ChoConvert.ConvertTo(fieldValue, typeof(string), null, fieldConfig.Converters.ToArray(), null, culture);
}
}
else
{
if (fieldConfig.Converters.IsNullOrEmpty())
{
fieldValue = ChoConvert.ConvertTo(fieldValue, ChoType.GetMemberInfo(rec.GetType(), fn), typeof(string), null, culture);
}
else
{
fieldValue = ChoConvert.ConvertTo(fieldValue, typeof(string), null, fieldConfig.Converters.ToArray(), null, culture);
}
}
return(fieldValue);
}
public IDictionary <string, object> GetDefaults()
{
IDictionary <string, object> dict = new Dictionary <string, object>();
ChoPropertyAttribute attr = null;
object memberValue = null;
string propName = null;
//scan through members and load them
foreach (var prop in ChoType.GetMembers(GetType()).Where(m => m.GetCustomAttribute <ChoIgnoreMemberAttribute>() != null && !ChoType.IsReadOnlyMember(m)))
{
attr = ChoType.GetMemberAttribute <ChoPropertyAttribute>(prop);
try
{
propName = attr != null && !attr.Name.IsNullOrWhiteSpace() ? attr.Name : prop.Name;
memberValue = ChoType.GetDefaultValue(ChoType.GetMemberInfo(GetType(), prop.Name));
if (memberValue != null && memberValue is string)
{
string mv = memberValue 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;
}
}
memberValue = mv;
}
if (!dict.ContainsKey(propName))
{
dict.Add(propName, memberValue);
}
}
catch (Exception ex)
{
//ChoLog.Error("{0}: Error getting default value for '{1}' property. {2}".FormatString(NName, prop.Name, ex.Message));
SetDefaultValue(prop, false);
}
}
return(dict);
}
public virtual void SetParams(string cmdParams)
{
foreach (Tuple <string, string> tuple in ChoStringEx.ToKeyValuePairs(cmdParams, ';', '='))
{
MemberInfo memberInfo = ChoType.GetMemberInfo(this.GetType(), tuple.Item1);
if (memberInfo != (MemberInfo)null && ChoType.GetAttribute <BrowsableAttribute>(memberInfo, false) == null)
{
ChoType.ConvertNSetMemberValue((object)this, tuple.Item1, (object)DenormalizeString(tuple.Item2));
}
}
}
public static bool IsValidFor(this object @this, string mn, out Exception aggEx)
{
ChoGuard.ArgumentNotNullOrEmpty(mn, "MemberName");
aggEx = null;
MemberInfo mi = ChoType.GetMemberInfo(@this.GetType(), mn);
if (mi != null)
{
return(IsValidFor(@this, mi, out aggEx));
}
else
{
return(true);
}
}
private static MemberInfo CheckNExtractMemberInfo(object target, string memberName)
{
ChoGuard.ArgumentNotNull(target, "Target");
MemberInfo memberInfo = ChoType.GetMemberInfo(target.GetType(), memberName);
if (memberInfo == null)
{
throw new NullReferenceException(String.Format("Can't find {0} member in {1} type.", memberName, target.GetType().FullName));
}
if (memberInfo.MemberType != MemberTypes.Field &&
memberInfo.MemberType != MemberTypes.Property)
{
throw new ChoApplicationException(String.Format("Member `{0}` is not a field/property in {1} type.", memberName, target.GetType().FullName));
}
return(memberInfo);
}
public virtual string GetParams()
{
StringBuilder stringBuilder = new StringBuilder();
foreach (Tuple <string, object> tuple in ChoObjectEx.AsDictionary((object)this, false, false))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(";");
}
MemberInfo memberInfo = ChoType.GetMemberInfo(this.GetType(), tuple.Item1);
if (memberInfo != (MemberInfo)null && ChoType.GetAttribute <BrowsableAttribute>(memberInfo, false) == null)
{
stringBuilder.AppendFormat(ChoStringEx.FormatString("{0}={1}", (object)tuple.Item1, NormalizeString(tuple.Item2 != null ? tuple.Item2.ToString() : string.Empty)));
}
}
return(stringBuilder.ToString());
}
public static void SetDefaultValue(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, CultureInfo culture)
{
if (rec is ExpandoObject)
{
((IDictionary <string, object>)rec).SetDefaultValue(fn, fieldConfig, culture);
return;
}
object fieldValue = null;
//Set default value to member
try
{
bool defaultValueExists = true;
object defaultValue = null;
if (fieldConfig.IsDefaultValueSpecified)
{
defaultValue = fieldConfig.DefaultValue;
}
else if (ChoType.HasDefaultValue(ChoTypeDescriptor.GetProperty(rec.GetType(), fn)))
{
defaultValue = ChoType.GetRawDefaultValue(ChoTypeDescriptor.GetProperty(rec.GetType(), fn));
}
else
{
defaultValueExists = false;
}
if (defaultValueExists)
{
if (fieldConfig.Converters.IsNullOrEmpty())
{
fieldValue = ChoConvert.ConvertFrom(defaultValue, ChoType.GetMemberInfo(rec.GetType(), fn), null, culture);
}
else
{
fieldValue = ChoConvert.ConvertFrom(defaultValue, ChoType.GetMemberType(rec.GetType(), fn), null, fieldConfig.Converters.ToArray(), null, culture);
}
ChoType.SetMemberValue(rec, fn, fieldValue);
}
}
catch { }
}
internal ChoMemberInfo(object target, Type type, IMethodMessage methodCallMsg)
{
_methodMsg = methodCallMsg;
_target = target;
MethodCallMsg = _methodMsg as MethodCallMessageWrapper;
if (_methodMsg.MethodName == "FieldSetter" || (_methodMsg.MethodName.StartsWith("set_") &&
_methodMsg.MethodName != "set_Dirty"))
{
_dirtyOperation = true;
}
if (_methodMsg.MethodName == "FieldSetter" || _methodMsg.MethodName == "FieldGetter")
{
_name = _methodMsg.Args[1] as string;
_memberType = MemberTypes.Field;
}
else if (_methodMsg.MethodName.StartsWith("get_"))
{
_name = _methodMsg.MethodName.Replace("get_", String.Empty);
_memberType = MemberTypes.Property;
}
else if (_methodMsg.MethodName.StartsWith("set_"))
{
_name = _methodMsg.MethodName.Replace("set_", String.Empty);
_memberType = MemberTypes.Property;
}
else
{
_name = _methodMsg.MethodName;
}
//_memberInfo = ChoType.GetMember(_target.GetType(), Name);
_memberInfo = ChoType.GetMemberInfo(type, Name);
if (_dirtyOperation)
{
//Set Converted value
Value = ChoConvert.ConvertFrom(_target, Value, ChoType.GetMemberType(_memberInfo),
ChoTypeDescriptor.GetTypeConverters(_memberInfo), ChoTypeDescriptor.GetTypeConverterParams(_memberInfo));
//Value = ChoConvert.ConvertFrom(_target, Value, ChoType.GetMemberType(_target.GetType(), _name),
// ChoType.GetTypeConverters(ChoType.GetMember(_target.GetType(), _name), typeof(ChoTypeConverterAttribute)));
}
}
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);
}
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());
}
}
protected virtual object GetDefaultValue(string name)
{
return(ChoType.GetRawDefaultValue(ChoType.GetMemberInfo(GetType(), name)));
}
