public object ToType(Type conversionType, IFormatProvider provider) { if (conversionType == typeof(Value)) { return(this); } if (RawValue == null) { return(null); } if (conversionType == typeof(int)) { return(ToInt32(provider)); } if (conversionType == typeof(double)) { return(ToDouble(provider)); } if (RawValue == null) { throw new NullReferenceException(); } if (RawValue.GetType() == conversionType) { return(RawValue); } return(new TypeConverter().ConvertTo(RawValue, conversionType)); }
public bool CanBeNull() { if (SystemType == null && RawValue == null) { return(true); } return(SqlDataType.CanBeNull(SystemType ?? RawValue.GetType())); }
private void setPropertyType() { if (Property != null) { PropertyType = Property.PropertyType; } else if (RawValue != null) { PropertyType = RawValue.GetType(); } }
public string StringValue() { if (RawValue == null || RawValue as string == string.Empty) { return(string.Empty); } return(RawValue.ToString()); // I don't know what this is about. Why do we care if it's nullable or what it's type is? var type = RawValue.GetType(); return(type.IsNullable() ? type.GetInnerTypeFromNullable().ToString() : type.ToString()); }
public T GenericReturn <T>() { if (RawValue is T) { return((T)RawValue); } if (RawValue is string) { return(((string)RawValue).Convert <T>()); } //Is it a list if (typeof(T).HasElementType || typeof(IList).IsAssignableFrom(typeof(T))) { var subType = typeof(T).GetElementType() ?? typeof(T).GenericTypeArguments.FirstOrDefault(); Array data; //Convert from RawData to Array if (RawValue is IList) { var vals = (IList)RawValue; data = Array.CreateInstance(subType, vals.Count); for (var i = 0; i < vals.Count; i++) { var val = (Value)vals[i]; data.SetValue(val.ToType(subType, null), i); } } else { throw new NotSupportedException(); } //Convert from Array to T if (typeof(T).IsArray) { dynamic typedData = Array.CreateInstance(subType, data.Length); data.CopyTo(typedData, 0); return(typedData); } else if (typeof(IList).IsAssignableFrom(typeof(T))) { var listInstance = (IList)typeof(List <>) .MakeGenericType(subType) .GetConstructor(Type.EmptyTypes) ?.Invoke(null); if (listInstance == null) { throw new NotSupportedException(); } var converter = TypeDescriptor.GetConverter(subType); foreach (var i in data) { listInstance.Add(converter.ConvertTo(i, subType)); } return((T)listInstance); } else { throw new NotSupportedException(); } } try { return((T)ToType(typeof(T), null)); } catch (NotSupportedException) { var valo = RawValue?.GetType().Name ?? RawValue?.GetType().Name ?? "null"; throw new InvalidCastException( $"Cannot convert {valo} to {typeof(T).Name}"); } catch (NullReferenceException) { throw new InvalidCastException( $"Cannot convert Null to {typeof(T).Name}"); } }
public override string ToString() { string raw = null; if (Engine != null) { var e = this.Contains("convert_string").FirstOrDefault(); if (e != null) { var scopes = new ValueContainer(Engine); scopes.Push(Engine.Globals); scopes.NewStackBoundary(); dynamic ss = new Value(); ss.@this = this; scopes.Push(ss); dynamic scopeValue = new Value(scopes, Engine.GlobalContainer.FindValue("Scopes")); var expression = ((FunctionAbstract)e.RawValue).Lambda; var c = new FunctionCallExpression(expression, new List <Value>() { (Value)scopeValue }); dynamic res = Engine.RunExpressionCustomScope(c, scopes); return((string)res); } } if (IsNumber) { raw = RawValue.ToString(); } if (RawValue is string) { raw = $"\"{RawValue}\""; } if (RawValue is Expression) { raw = ((Expression)RawValue).ToString(); } if (IsBool) { raw = $"{RawValue}"; } if (RawValue is FunctionAbstract) { raw = ((FunctionAbstract)RawValue).ToString(); return(raw); } if (RawValue is Delegate) { raw = ((Delegate)RawValue).ToString(); } if (IsArray) { var v = (List <Value>)RawValue; raw = "[" + string.Join(",", v.Select(x => x.ToString())) + "]"; } var left = raw; var right = (Values?.Any() ?? false) ? $"({string.Join(",", Values.Keys)})" : null; if (left != null && right != null) { return($"{left}: {right}"); } if (left != null) { return(left); } if (right != null) { return(right); } if (RawValue.ToString() != RawValue.GetType().ToString()) { return(RawValue.ToString()); } return("null"); }