public static bool Equals(Expose left, Expose right)
{
object lv = ReferenceEquals(left, null) ? null : left.Value;
object rv = ReferenceEquals(right, null) ? null : right.Value;
return(ReferenceEquals(lv, null) ? ReferenceEquals(rv, null) : Expose.Equals(left, rv));
}
static bool TryInvoke(string methodName, object instance, IEnumerable <MethodInfo> methodInfos, Type[] genericTypes, object[] args, out Expose result)
{
bool isGeneric = genericTypes != null && 0 < genericTypes.Length;
foreach (MethodInfo methodInfo in methodInfos)
{
MethodInfo mi = methodInfo;
if (mi.Name != methodName || isGeneric && !mi.IsGenericMethod)
{
continue;
}
try
{
if (isGeneric)
{
mi = mi.GetGenericMethodDefinition().MakeGenericMethod(genericTypes);
}
if (IsInvokable(mi, args))
{
result = Expose.FromObject(mi.Invoke(instance, args));
return(true);
}
}
catch
{
}
}
result = null;
return(false);
}
public static bool Equals(Expose left, object right)
{
try
{
return((bool)left.Call("op_Equality", right).Value);
}
catch
{ }
try
{
return(ToDecimal(left) == ToDecimal(right));
}
catch
{ }
try
{
return((bool)left.Call("Equals", right).Value);
}
catch
{ }
object lv = ReferenceEquals(left, null) ? null : left.Value;
object rv = right;
return(ReferenceEquals(lv, null) ? ReferenceEquals(rv, null) : lv.Equals(rv));
}
static Expose Addition(Expose left, object right)
{
try
{
if (IsNumber(left) && IsNumber(right))
{
var d = ToDecimal(left) + ToDecimal(right);
return(Expose.FromObject(ToDecimal(left) + ToDecimal(right)));
}
return(Expose.FromType(left.Type).Call("op_Addition", left.Value, right));
}
catch
{
}
object lv = ReferenceEquals(left, null) ? null : left.Value;
if (lv is string || right is string)
{
string ls = ReferenceEquals(lv, null) ? "" : lv.ToString();
string rs = ReferenceEquals(right, null) ? "" : right.ToString();
return(Expose.FromObject(ls + rs));
}
try
{
return(Expose.FromObject(ToDecimal(left) + ToDecimal(right)));
}
catch
{
}
return(null);
}
public Expose Get(string memberName)
{
var pi = Type.GetProperty(memberName, Flag | BindingFlags.GetProperty);
if (pi != null)
{
return(Expose.FromObject(pi.GetValue(Value)));
}
var fi = Type.GetField(memberName, Flag | BindingFlags.GetField);
if (fi != null)
{
return(Expose.FromObject(fi.GetValue(Value)));
}
// Get with indexer
try
{
return(Get(new[] { memberName }));
}
catch
{
throw new MissingMemberException(Type.Name, memberName);
}
}
public Expose Get(object[] index)
{
var pi = Type.GetProperty(Type.GetCustomAttribute <DefaultMemberAttribute>().MemberName, index.Select(x => x.GetType()).ToArray());
if (pi != null)
{
return(Expose.FromObject(pi.GetValue(Value, index)));
}
throw new MissingMemberException(Type.Name, "Indexer");
}
public IEnumerator GetEnumerator()
{
if (Value is IEnumerable)
{
foreach (object o in Value as IEnumerable)
{
yield return(Expose.FromObject(o));
}
}
yield break;
}
static bool TryInvoke(string methodName, object instance, IEnumerable <MethodInfo> methodInfos, object[] args, out Expose result)
{
var methodInfo = methodInfos.FirstOrDefault(x => x.Name == methodName && IsInvokable(x, args));
if (methodInfo != null)
{
result = Expose.FromObject(methodInfo.Invoke(instance, args));
return(true);
}
result = null;
return(false);
}
public Expose Call(string methodName, params object[] args)
{
args = args.Select(x => x is Expose ? ((Expose)x).Value : x).ToArray();
// Find method
if (TryInvoke(methodName, Value, Type.GetMethods(Flag | BindingFlags.InvokeMethod), args, out Expose result))
{
return(result);
}
// Find event
var fi = Type.GetField(methodName, Flag | BindingFlags.SetField);
if (fi != null)
{
var del = fi.GetValue(Value) as MulticastDelegate;
if (del != null && IsInvokable(del.Method, args))
{
object lastResult = null;
foreach (var h in del.GetInvocationList())
{
lastResult = h.Method.Invoke(h.Target, args);
}
return(Expose.FromObject(lastResult));
}
}
// Find operator method
args = new[] { Value }.Concat(args).ToArray();
if (TryInvoke(methodName, null, Type.GetMethods(Flag | BindingFlags.InvokeMethod), args, out result))
{
return(result);
}
// Find extension method
if (Value != null &&
TryInvoke(methodName, null, s_extensionMethods.Where(x => Is(Type, x.Key)).SelectMany(x => x.Value), null, args, out result))
{
if (
TryInvoke(methodName, null, s_extensionMethods.Where(x => Is(Type, x.Key)).SelectMany(x => x.Value), null, args, out result) ||
TryInvoke(methodName, null, s_extensionMethods.Where(x => Is(Type, x.Key)).SelectMany(x => x.Value), new[] { Type }, args, out result)
)
{
return(result);
}
}
throw new MissingMemberException(Type.Name, methodName);
}
static Expose Subtraction(Expose left, object right)
{
try
{
return(Expose.FromType(left.Type).Call("op_Subtraction", left.Value, right));
}
catch
{ }
try
{
return(Expose.FromObject(ToDecimal(left) - ToDecimal(right)));
}
catch
{ }
return(null);
}
static bool LessThan(Expose left, object right)
{
try
{
return((bool)Expose.FromType(left.Type).Call("op_LessThan", left.Value, right).Value);
}
catch
{ }
try
{
return(ToDecimal(left) < ToDecimal(right));
}
catch
{
return(Expose.Compare(left, right) < 0);
}
}
public static bool operator !=(object left, Expose right)
{
return(!Expose.Equals(right, left));
}
public static Expose operator -(object left, Expose right)
{
return(Subtraction(Expose.FromObject(left), right.Value));
}
public static Expose operator -(Expose left, Expose right)
{
return(Expose.Subtraction(left, right.Value));
}
public static Expose operator +(object left, Expose right)
{
return(Addition(Expose.FromObject(left), right.Value));
}
public static Expose operator +(Expose left, Expose right)
{
return(Expose.Addition(left, right.Value));
}
static Expose DoOperation(Expose left, object right, Operation op)
{
try
{
return(Expose.FromType(left.Type).Call(op.ToString(), left.Value, right));
}
catch
{ }
try
{
switch (op)
{
case Operation.op_Addition:
return(Expose.FromObject(ToDecimal(left) + ToDecimal(right)));
case Operation.op_Subtraction:
return(Expose.FromObject(ToDecimal(left) - ToDecimal(right)));
case Operation.op_Equality:
return(Expose.FromObject(ToDecimal(left) == ToDecimal(right)));
case Operation.op_Inequality:
return(Expose.FromObject(ToDecimal(left) != ToDecimal(right)));
case Operation.op_GreaterThan:
return(Expose.FromObject(ToDecimal(left) > ToDecimal(right)));
case Operation.op_LessThan:
return(Expose.FromObject(ToDecimal(left) < ToDecimal(right)));
case Operation.op_GreaterThanOrEqual:
return(Expose.FromObject(ToDecimal(left) <= ToDecimal(right)));
case Operation.op_LessThanOrEqual:
return(Expose.FromObject(ToDecimal(left) >= ToDecimal(right)));
case Operation.op_BitwiseAnd:
return(Expose.FromObject(ToInt(left) & ToInt(right)));
case Operation.op_BitwiseOr:
return(Expose.FromObject(ToInt(left) | ToInt(right)));
case Operation.op_Division:
return(Expose.FromObject(ToDecimal(left) / ToDecimal(right)));
case Operation.op_Modulus:
return(Expose.FromObject(ToDecimal(left) % ToDecimal(right)));
case Operation.op_Multiply:
return(Expose.FromObject(ToDecimal(left) * ToDecimal(right)));
case Operation.op_LeftShift:
return(Expose.FromObject(ToInt(left) << ToInt(right)));
case Operation.op_RightShift:
return(Expose.FromObject(ToInt(left) >> ToInt(right)));
case Operation.op_ExclusiveOr:
return(Expose.FromObject(ToInt(left) ^ ToInt(right)));
case Operation.op_UnaryNegation:
break;
case Operation.op_UnaryPlus:
break;
case Operation.op_LogicalNot:
break;
case Operation.op_OnesComplement:
break;
case Operation.op_False:
break;
case Operation.op_True:
break;
case Operation.op_Increment:
break;
case Operation.op_Decrement:
break;
}
}
catch
{ }
return(null);
}
public static bool operator !=(Expose left, object right)
{
return(!Expose.Equals(left, right));
}
public static bool operator ==(Expose left, Expose right)
{
return(Expose.Equals(left, right));
}
public static int Compare(Expose left, object right)
{
return(Compare_Impl(ReferenceEquals(left, null) ? null : left.Value, right));
}
public static int Compare(Expose left, Expose right)
{
return(Compare_Impl(
ReferenceEquals(left, null) ? null : left.Value,
ReferenceEquals(right, null) ? null : right.Value));
}
public bool Equals(Expose other)
{
return(Equals(this, other));
}
