private Expression BindConcat(Expression[] args)
{
if (args.Length == 1)
{
var arg = args[0];
if (arg.NodeType == ExpressionType.NewArrayInit)
{
args = ((NewArrayExpression)arg).Expressions.ToArray();
}
else if (arg.NodeType == ExpressionType.MemberAccess)
{
var m = arg as MemberExpression;
var c = m.Expression as ConstantExpression;
if (c != null && c.Value != null)
{
var v = m.Member.GetGetter()(c.Value);
if (v != null)
{
if (v is string)
{
args[0] = Expression.Constant(v, Types.String);
}
else if (v is IEnumerable)
{
var result = new List <Expression>();
foreach (var item in v as IEnumerable)
{
if (item != null)
{
result.Add(Expression.Constant(item.ToString(), Types.String));
}
else
{
result.Add(Expression.Constant(null, Types.String));
}
}
args = result.ToArray();
}
else
{
args[0] = Expression.Constant(v.ToString(), Types.String);
}
}
}
}
}
var length = args.Length;
for (int i = 0; i < length; i++)
{
args[i] = Expressor.ToString(args[i]);
}
return(Expression.Call(MethodRepository.Concat, Expression.NewArrayInit(Types.String, args)));
}
private Expression BindJoin(MethodCallExpression m)
{
var separator = m.Arguments[0];
var args = new List <Expression>();
if (m.Arguments[1].NodeType == ExpressionType.NewArrayInit)
{
var items = ((NewArrayExpression)m.Arguments[1]).Expressions;
for (int i = 0; i < items.Count; i++)
{
args.Add(Expressor.ToString(items[i]));
if (i != items.Count - 1)
{
args.Add(separator);
}
}
}
else if (m.Arguments[1].NodeType == ExpressionType.Constant)
{
var c = (m.Arguments[1] as ConstantExpression);
var tmpItems = (c.Value as IEnumerable);
if (Types.IEnumerable.IsAssignableFrom(c.Type) && c.Type != Types.String)
{
if (tmpItems != null)
{
var items = tmpItems.Cast <object>().ToList();
for (int i = 0; i < items.Count; i++)
{
var value = items[i];
if (value != null)
{
args.Add(Expression.Constant(value.ToString()));
}
else
{
args.Add(Expression.Constant(null, Types.String));
}
if (i != items.Count - 1)
{
args.Add(separator);
}
}
}
if (args.Count == 0)
{
args.Add(Expression.Constant(null, Types.String));
}
}
}
return(Expression.Call(MethodRepository.Concat, Expression.NewArrayInit(Types.String, args.ToArray())));
}
protected override Expression VisitBinary(BinaryExpression b)
{
b = base.VisitBinary(b) as BinaryExpression;
switch (b.NodeType)
{
case ExpressionType.Add:
case ExpressionType.AddChecked:
if (b.Left.Type.Equals(typeof(String)))
{
return(Expression.Call(MethodRepository.Concat, Expression.NewArrayInit(Types.String, b.Left, Expressor.ToString(b.Right))));
}
if (b.Right.Type.Equals(typeof(String)))
{
return(Expression.Call(MethodRepository.Concat, Expression.NewArrayInit(Types.String, Expressor.ToString(b.Left), b.Right)));
}
return(b);
case ExpressionType.ArrayIndex:
if (b.Type == Types.Byte)
{
}
return(b);
case ExpressionType.Equal:
case ExpressionType.NotEqual:
default:
return(b);
}
}