public static ulong EnumToUInt64(object value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
TypeCode typeCode = Convert.GetTypeCode(value);
switch (typeCode)
{
case TypeCode.SByte:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
return((ulong)Convert.ToInt64(value, CultureInfo.InvariantCulture));
case TypeCode.Byte:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
return(Convert.ToUInt64(value, CultureInfo.InvariantCulture));
//case TypeCode.String:
default:
return(ConversionService.ChangeType <ulong>(value));
}
}
public static List <T> SplitToList <T>(this string thisString, params char[] separators)
{
var list = new List <T>();
if (thisString != null)
{
foreach (string s in thisString.Split(separators))
{
T item = ConversionService.ChangeType <T>(s);
list.Add(item);
}
}
return(list);
}
/// <summary>
/// Gets a typed property value.
/// </summary>
/// <typeparam name="T">The expected type.</typeparam>
/// <param name="name">The property name.</param>
/// <param name="defaultValue">The default value if the property value is not defined.</param>
/// <returns>The property value or the default value.</returns>
public virtual T GetPropertyValue <T>(string name, T defaultValue)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
object obj;
if (_values.TryGetValue(name, out obj))
{
return(ConversionService.ChangeType(obj, defaultValue));
}
return(defaultValue);
}
/// <summary>
/// Gets a typed property value.
/// </summary>
/// <param name="name">The property name.</param>
/// <param name="type">The expected type.</param>
/// <param name="defaultValue">The default value if the property value is not defined.</param>
/// <returns>The property value or the default value.</returns>
public virtual object GetPropertyValue(string name, Type type, object defaultValue)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
defaultValue = ConversionService.ChangeType(defaultValue, type);
object obj;
if (_values.TryGetValue(name, out obj))
{
return(ConversionService.ChangeType(obj, type, defaultValue));
}
return(defaultValue);
}
/// <summary>
/// Constructs the current instance.
/// </summary>
/// <param name="name">The property name.</param>
/// <param name="type">The property type.</param>
/// <param name="attributes">The property custom attributes.</param>
protected virtual void Construct(string name, Type type, IEnumerable <Attribute> attributes)
{
_type = type;
var ro = Attributes.GetAttribute <ReadOnlyAttribute>();
if (ro != null)
{
_isReadOnly = ro.IsReadOnly;
}
var dv = Attributes.GetAttribute <DefaultValueAttribute>();
if (dv != null)
{
HasDefaultValue = true;
_defaultValue = ConversionService.ChangeType(dv.Value, _type);
}
else
{
_defaultValue = ConversionService.ChangeType(null, _type);
}
}
public static object EnumToObject(Type enumType, object value)
{
if (enumType == null)
{
throw new ArgumentNullException("enumType");
}
if (!enumType.IsEnum)
{
throw new ArgumentException(null, "enumType");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
Type underlyingType = Enum.GetUnderlyingType(enumType);
if (underlyingType == typeof(long))
{
return(Enum.ToObject(enumType, ConversionService.ChangeType <long>(value)));
}
if (underlyingType == typeof(ulong))
{
return(Enum.ToObject(enumType, ConversionService.ChangeType <ulong>(value)));
}
if (underlyingType == typeof(int))
{
return(Enum.ToObject(enumType, ConversionService.ChangeType <int>(value)));
}
if ((underlyingType == typeof(uint)))
{
return(Enum.ToObject(enumType, ConversionService.ChangeType <uint>(value)));
}
if (underlyingType == typeof(short))
{
return(Enum.ToObject(enumType, ConversionService.ChangeType <short>(value)));
}
if (underlyingType == typeof(ushort))
{
return(Enum.ToObject(enumType, ConversionService.ChangeType <ushort>(value)));
}
if (underlyingType == typeof(byte))
{
return(Enum.ToObject(enumType, ConversionService.ChangeType <byte>(value)));
}
if (underlyingType == typeof(sbyte))
{
return(Enum.ToObject(enumType, ConversionService.ChangeType <sbyte>(value)));
}
throw new ArgumentException(null, "enumType");
}
public static string Format(object obj, string format, IFormatProvider formatProvider)
{
if (obj == null)
{
return(string.Empty);
}
if (string.IsNullOrEmpty(format))
{
return(obj.ToString());
}
if ((format.StartsWith("*")) ||
(format.StartsWith("#")))
{
char sep1 = ' ';
char sep2 = ':';
if (format.Length > 1)
{
sep1 = format[1];
}
if (format.Length > 2)
{
sep2 = format[2];
}
var sb = new StringBuilder();
foreach (PropertyInfo pi in obj.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
if (!pi.CanRead)
{
continue;
}
if (pi.GetIndexParameters().Length > 0)
{
continue;
}
object value;
try
{
value = pi.GetValue(obj, null);
}
catch
{
continue;
}
if (sb.Length > 0)
{
if (sep1 != ' ')
{
sb.Append(sep1);
}
sb.Append(' ');
}
if (format[0] == '#')
{
sb.Append(DecamelizationService.Decamelize(pi.Name));
}
else
{
sb.Append(pi.Name);
}
sb.Append(sep2);
sb.Append(ConversionService.ChangeType(value, string.Format("{0}", value), formatProvider));
}
return(sb.ToString());
}
if (format.StartsWith("Item[", StringComparison.CurrentCultureIgnoreCase))
{
string enumExpression;
int exprPos = format.IndexOf(']', 5);
if (exprPos < 0)
{
enumExpression = string.Empty;
}
else
{
enumExpression = format.Substring(5, exprPos - 5).Trim();
// enumExpression is a lambda like expression with index as the variable
// ex: {0: Item[index < 10]} will enum all objects with index < 10
// errrhh... so far, since lambda cannot be parsed at runtime, we do nothing...
}
var enumerable = obj as IEnumerable;
if (enumerable != null)
{
format = format.Substring(6 + enumExpression.Length);
string expression;
string separator;
if (format.Length == 0)
{
expression = null;
separator = ",";
}
else
{
int pos = format.IndexOf(',');
if (pos <= 0)
{
separator = ",";
// skip '.'
expression = format.Substring(1);
}
else
{
separator = format.Substring(pos + 1);
expression = format.Substring(1, pos - 1);
}
}
return(ConcatenateCollection(enumerable, expression, separator, formatProvider));
}
}
else if (format.IndexOf(',') >= 0)
{
var sb = new StringBuilder();
foreach (string propName in format.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
PropertyInfo pi = obj.GetType().GetProperty(propName, BindingFlags.Instance | BindingFlags.Public);
if ((pi == null) || (!pi.CanRead))
{
continue;
}
if (pi.GetIndexParameters().Length > 0)
{
continue;
}
object value;
try
{
value = pi.GetValue(obj, null);
}
catch
{
continue;
}
if (sb.Length > 0)
{
sb.Append(' ');
}
sb.Append(pi.Name);
sb.Append(':');
sb.AppendFormat(formatProvider, "{0}", value);
}
return(sb.ToString());
}
int pos2 = format.IndexOf(':');
if (pos2 > 0)
{
object inner = DataBindingEvaluator.Eval(obj, format.Substring(0, pos2), false);
if (inner == null)
{
return(string.Empty);
}
return(string.Format(formatProvider, "{0:" + format.Substring(pos2 + 1) + "}", inner));
}
return(DataBindingEvaluator.Eval(obj, format, formatProvider, null, false));
}