public void Test12()
{
Order order1 = new Order { Customer = Hans, ID = 302, Freight = 2001.99m, OrderDate = DateTime.Now.AddMonths(-20) };
var assemblies = new Assembly[] { typeof(Order).Assembly, typeof(UnitTests).Assembly, typeof(ExpressionType).Assembly, typeof(IQueryable).Assembly };
var resolver = new ExpressionSerializationTypeResolver(assemblies, new Type[] { typeof(Customer), typeof(Order), typeof(Product), typeof(Supplier), typeof(Shipper) });
ExpressionSerializer serializer = new ExpressionSerializer(resolver);
IEnumerable<Customer> customers = GetCustomers().ToArray();
Expression<Func<int, IEnumerable<Order[]>>> e12 =
n =>
from c in customers//instance == null : IEnumerable.Where/.Select
where c.ID < n
select c.Orders.ToArray();
e12 = ( Expression<Func<int, IEnumerable<Order[]>>>)ObjectServices.Evaluator.PartialEval(e12);
MethodCallExpression m1 = ((MethodCallExpression)e12.Body).Arguments[0] as MethodCallExpression;
ConstantExpression cx = ((ConstantExpression)m1.Arguments[0]);
LambdaExpression lambdaarg = ((LambdaExpression)m1.Arguments[1]);
//Expression arg1 = ((MethodCallExpression)e12.Body).Arguments[1];
XElement xml12 = serializer.Serialize(e12);
Expression result12 = serializer.Deserialize( xml12);
Assert.AreEqual( e12.ToString(), result12.ToString());
Console.WriteLine(((result12 as Expression<Func<int, IEnumerable<Order[]>>>).Compile())(5));
}
public void PrimitiveTypeTest()
{
Expression<Func<int>> addExpr = () => 1 + 1;
var serializer = new ExpressionSerializer();
XElement addXml = serializer.Serialize(addExpr);
Expression<Func<int>> addExpResult = serializer.Deserialize<Func<int>>(addXml);
Func<int> addExpResultFunc = addExpResult.Compile();
Assert.AreEqual(2, addExpResultFunc()); // evaluates to 2
}
public void ComplexTypeTest()
{
Expression<Func<Customer, bool>> addExpr = (customer) => string.IsNullOrEmpty(customer.CustomerID);
var serializer = new ExpressionSerializer();
XElement addXml = serializer.Serialize(addExpr);
var addExpResult = serializer.Deserialize<Func<Customer, bool>>(addXml);
Func<Customer, bool> addExpResultFunc = addExpResult.Compile();
Assert.AreEqual(true, addExpResultFunc(new Customer() { CustomerID = "Allen" })); // evaluates to 2
}
public static IQueryable DeserializeQuery(this DataContext dc, XElement rootXml)
{
var resolver = new TypeResolver(assemblies: null, knownTypes: GetKnownTypesFromTables(dc) );
DLinqCustomExpressionXmlConverter customConverter = new DLinqCustomExpressionXmlConverter(dc, resolver);
ExpressionSerializer serializer = new ExpressionSerializer(resolver, new List<CustomExpressionXmlConverter> { customConverter });
Expression queryExpr = serializer.Deserialize(rootXml);
// Query kind is populated by the ResolveXmlFromExpression method
if (customConverter.QueryKind == null)
throw new Exception(string.Format("CAnnot deserialize into DLinq query for datacontext {0} - no Table found", dc));
return customConverter.QueryKind.Provider.CreateQuery(queryExpr);
}
//public static IQueryable DeserializeQuery(this DataContext dc, XElement rootXml)
public static IQueryable DeserializeQuery(this ObjectContext dc, XElement rootXml)
{
DLinqSerializationTypeResolver resolver = new DLinqSerializationTypeResolver(dc);
DLinqCustomExpressionXmlConverter customConverter = new DLinqCustomExpressionXmlConverter(dc, resolver);
ExpressionSerializer serializer = new ExpressionSerializer(resolver) { Converters = { customConverter } };
Expression queryExpr = serializer.Deserialize(rootXml);
// Query kind is populated by the ResolveXmlFromExpression method
if (customConverter.QueryKind == null)
throw new Exception(string.Format("CAnnot deserialize into DLinq query for datacontext {0} - no Table found", dc));
return customConverter.QueryKind.Provider.CreateQuery(queryExpr);
}
public List<Character> GetCharacters(XElement query)
{
var serializer = new ExpressionSerializer();
var expression = serializer.Deserialize<Func<Character, bool>>(query);
if (expression == null)
return null;
using (var db = new RevolutionEntities1())
{
return db.Characters.Where(expression).ToList();
}
}
// Very simple serialization example
public static void BasicExpressionSerialization()
{
Console.WriteLine("BASIC SAMPLE - Serialize/Deserialize Simple Expression:");
Expression<Func<int, int, int>> addExpr = (x, y) => x + y;
ExpressionSerializer serializer = new ExpressionSerializer();
XElement addXml = serializer.Serialize(addExpr);
Expression<Func<int,int,int>> addExpResult = serializer.Deserialize<Func<int,int,int>>(addXml);
Func<int, int, int> addExpResultFunc = addExpResult.Compile();
int result = addExpResultFunc(1, 2); // evaluates to 3
Console.WriteLine("Deserialized Expression Tree:");
Console.WriteLine(" " + addExpResult.ToString());
Console.WriteLine();
}
public static IQueryable DeserializeQuery(this DataContext dc, XElement rootXml)
{
var resolver = new TypeResolver(assemblies: null, knownTypes: GetKnownTypesFromTables(dc));
DLinqCustomExpressionXmlConverter customConverter = new DLinqCustomExpressionXmlConverter(dc, resolver);
ExpressionSerializer serializer = new ExpressionSerializer(resolver, new List <CustomExpressionXmlConverter> {
customConverter
});
Expression queryExpr = serializer.Deserialize(rootXml);
// Query kind is populated by the ResolveXmlFromExpression method
if (customConverter.QueryKind == null)
{
throw new Exception(string.Format("CAnnot deserialize into DLinq query for datacontext {0} - no Table found", dc));
}
return(customConverter.QueryKind.Provider.CreateQuery(queryExpr));
}
//public static IQueryable DeserializeQuery(this DataContext dc, XElement rootXml)
public static IQueryable DeserializeQuery(this ObjectContext dc, XElement rootXml)
{
DLinqSerializationTypeResolver resolver = new DLinqSerializationTypeResolver(dc);
DLinqCustomExpressionXmlConverter customConverter = new DLinqCustomExpressionXmlConverter(dc, resolver);
ExpressionSerializer serializer = new ExpressionSerializer(resolver)
{
Converters = { customConverter }
};
Expression queryExpr = serializer.Deserialize(rootXml);
// Query kind is populated by the ResolveXmlFromExpression method
if (customConverter.QueryKind == null)
{
throw new Exception(string.Format("CAnnot deserialize into DLinq query for datacontext {0} - no Table found", dc));
}
return(customConverter.QueryKind.Provider.CreateQuery(queryExpr));
}
// Serializing an expression tree representing a query expression
public static void ComplexExpressionSerializationSamples()
{
Console.WriteLine("COMPLEX SAMPLE - Serialize/Deserialize In-Memory Query Expression:");
Expression<Func<IEnumerable<int>>> queryExp = () => from i in Enumerable.Range(1, 10)
where i % 2 == 0
select i * i;
ExpressionSerializer serializer = new ExpressionSerializer();
XElement queryXml = serializer.Serialize(queryExp);
Expression<Func<IEnumerable<int>>> queryExpResult = serializer.Deserialize<Func<IEnumerable<int>>>(queryXml);
// Print out the expression tree: "(x, y) => x + y"
Console.WriteLine("Deserialized Expression Tree:");
Console.WriteLine(" " + queryExpResult.ToString());
// Call it
Func<IEnumerable<int>> f = queryExpResult.Compile();
IEnumerable<int> result = f();
Console.WriteLine("\nResults: ");
result.ToList().ForEach(n => Console.WriteLine(" " + n));
Console.WriteLine();
}
protected System.Tuple<Expression, Type> DeserializeExpression(XElement rootXml)
{
//move to ctor
BoxSerializationTypeResolver resolver = new BoxSerializationTypeResolver(this);
BoxCustomExpressionXmlConverter customConverter = new BoxCustomExpressionXmlConverter(resolver, RepoFinder.Mappings);
ExpressionSerializer serializer = new ExpressionSerializer(resolver) { Converters = { customConverter } };
return new System.Tuple<Expression, Type>(serializer.Deserialize(rootXml), customConverter.QueryKind.ElementType);
}
public void Tests1To11()
{
Order order1 = new Order { Customer = Hans, ID = 302, Freight = 2001.99m, OrderDate = DateTime.Now.AddMonths(-20) };
var assemblies = new Assembly[] { typeof(Order).Assembly, typeof(BaseTests).Assembly, typeof(ExpressionType).Assembly, typeof(IQueryable).Assembly };
var resolver = new TypeResolver(assemblies, new Type[] { typeof(Customer), typeof(Order), typeof(Product), typeof(Supplier), typeof(Shipper) });
ExpressionSerializer serializer = new ExpressionSerializer(resolver);
Console.WriteLine("\nTEST - 2");
Expression<Func<int>> e2 = () => 1;
XElement xml2 = serializer.Serialize(e2.Body);
Expression result2 = serializer.Deserialize(xml2);
Assert.AreEqual(e2.Body.ToString(), result2.ToString());
Console.WriteLine("\nTEST - 3");
Expression<Func<ExpressionType>> e3 = () => ExpressionType.Add;
XElement xml3 = serializer.Serialize(e3.Body);
Expression result3 = serializer.Deserialize(xml3);
Assert.AreEqual(e3.Body.ToString(), result3.ToString());
Console.WriteLine("\nTEST - 4");
Expression<Func<bool>> e4 = () => true;
XElement xml4 = serializer.Serialize(e4.Body);
Expression result4 = serializer.Deserialize(xml4);
Assert.AreEqual(e4.Body.ToString(), result4.ToString());
Console.WriteLine("\nTEST - 5");
Expression<Func<decimal, decimal>> e5 = d => d + 1m;
XElement xml5 = serializer.Serialize(e5.Body);
Expression result5 = serializer.Deserialize(xml5);
Assert.AreEqual(e5.Body.ToString(), result5.ToString());
Console.WriteLine("\nTEST - 6");
Expression<Func<decimal, decimal>> e6 = d => d + 1m;
XElement xml6 = serializer.Serialize(e6);
Expression result6 = serializer.Deserialize(xml6);
Assert.AreEqual(e6.ToString(), result6.ToString());
Console.WriteLine(((result6 as Expression<Func<decimal, decimal>>).Compile())(3));
Console.WriteLine("\nTEST - 7");
Expression<Func<string, int>> e7 = s => int.Parse(s);
XElement xml7 = serializer.Serialize(e7);
Expression result7 = serializer.Deserialize(xml7);
Assert.AreEqual(e7.ToString(), result7.ToString());
Console.WriteLine(((result7 as Expression<Func<string, int>>).Compile())("1234"));
Console.WriteLine("\nTEST - 8");
Expression<Func<string, string>> e8 = s => s.PadLeft(4);
XElement xml8 = serializer.Serialize(e8);
Expression result8 = serializer.Deserialize(xml8);
Assert.AreEqual(e8.ToString(), result8.ToString());
Console.WriteLine(((result8 as Expression<Func<string, string>>).Compile())("1"));
Console.WriteLine("\nTEST - 9");
Expression<Func<string, int>> e9 = s => Foo<string, int>(s, 1);
XElement xml9 = serializer.Serialize(e9);
Expression result9 = serializer.Deserialize(xml9);
Assert.AreEqual(e9.ToString(), result9.ToString());
Console.WriteLine(((result9 as Expression<Func<string, int>>).Compile())("abcdac"));
Console.WriteLine("\nTEST - 10");
Expression<Func<string, char[]>> e10 = s => s.Where(c => c != 'a').ToArray();
XElement xml10 = serializer.Serialize(e10);
Expression result10 = serializer.Deserialize(xml10);
Assert.AreEqual(e10.ToString(), result10.ToString());
Console.WriteLine(((result10 as Expression<Func<string, char[]>>).Compile())("abcdac"));
Console.WriteLine("\nTEST - 11");
Expression<Func<string, char[]>> e11 =
s =>
(from c in s
where c != 'a'
select (char)(c + 1)).ToArray();
XElement xml11 = serializer.Serialize(e11);
Expression result11 = serializer.Deserialize(xml11);
Assert.AreEqual(e11.ToString(), result11.ToString());
Console.WriteLine(((result11 as Expression<Func<string, char[]>>).Compile())("abcdac"));
Console.WriteLine("\nTEST - 19");
Expression<Func<object, string>> e19 = o => o as string;
XElement xml19 = serializer.Serialize(e19);
Expression result19 = serializer.Deserialize(xml19);
Assert.AreEqual(e19.ToString(), result19.ToString());
Console.WriteLine(((result19 as Expression<Func<object, string>>).Compile())(7));
Console.WriteLine("\nTEST - 20");
Expression<Func<object, bool>> e20 = o => o is string;
XElement xml20 = serializer.Serialize(e20);
Expression result20 = serializer.Deserialize(xml20);
Assert.AreEqual(e20.ToString(), result20.ToString());
Console.WriteLine(((result20 as Expression<Func<object, bool>>).Compile())(7));
Console.WriteLine("\nTEST - 21");
Expression<Func<IEnumerable<string>>> e21 = () => from m in typeof(string).GetMethods()
where !m.IsStatic
group m by m.Name into g
select g.Key + g.Count().ToString();
XElement xml21 = serializer.Serialize(e21);
Expression result21 = serializer.Deserialize(xml21);
Assert.AreEqual(e21.ToString(), result21.ToString());
Console.WriteLine(((result21 as Expression<Func<IEnumerable<string>>>).Compile())());
Console.WriteLine("\nTEST - 22 (may take a while)");
Expression<Func<IEnumerable<int>>> e22 = () => from a in Enumerable.Range(1, 13)
join b in Enumerable.Range(1, 13) on 4 * a equals b
from c in Enumerable.Range(1, 13)
join d in Enumerable.Range(1, 13) on 5 * c equals d
from e in Enumerable.Range(1, 13)
join f in Enumerable.Range(1, 13) on 3 * e equals 2 * f
join g in Enumerable.Range(1, 13) on 2 * (c + d) equals 3 * g
from h in Enumerable.Range(1, 13)
join i in Enumerable.Range(1, 13) on 3 * h - 2 * (e + f) equals 3 * i
from j in Enumerable.Range(1, 13)
join k in Enumerable.Range(1, 13) on 3 * (a + b) + 2 * j - 2 * (g + c + d) equals k
from l in Enumerable.Range(1, 13)
join m in Enumerable.Range(1, 13) on (h + i + e + f) - l equals 4 * m
where (4 * (l + m + h + i + e + f) == 3 * (j + k + g + a + b + c + d))
select a + b + c + d + e + f + g + h + i + j + k + l + m;
XElement xml22 = serializer.Serialize(e22);
Expression result22 = serializer.Deserialize(xml22);
Assert.AreEqual(e22.ToString(), result22.ToString());
Console.WriteLine(((result22 as Expression<Func<IEnumerable<int>>>).Compile())().FirstOrDefault());
Console.WriteLine("\nTEST - 23");
Expression<Func<int, int>> e23 = n => ((Func<int, int>)(x => x + 1))(n);
XElement xml23 = serializer.Serialize(e23);
Expression result23 = serializer.Deserialize(xml23);
Assert.AreEqual(e23.ToString(), result23.ToString());
Console.WriteLine(((result23 as Expression<Func<int, int>>).Compile())(7));
Console.WriteLine("\nTEST - 24");
Expression<Func<IEnumerable<int>>> e24 = () => from x in Enumerable.Range(1, 10)
from y in Enumerable.Range(1, 10)
where x < y
select x * y;
XElement xml24 = serializer.Serialize(e24);
Expression result24 = serializer.Deserialize(xml24);
Assert.AreEqual(e24.ToString(), result24.ToString());
Console.WriteLine(((result24 as Expression<Func<IEnumerable<int>>>).Compile())());
Console.WriteLine("\nTEST - 25");
Expression<Func<DateTime>> e25 = () => new DateTime(10000);
XElement xml25 = serializer.Serialize(e25);
Expression result25 = serializer.Deserialize(xml25);
Assert.AreEqual(e25.ToString(), result25.ToString());
Console.WriteLine(((result25 as Expression<Func<DateTime>>).Compile())());
}
public void BasicExpressionSerialization()
{
Type funcT1T2T3 = typeof(Func<>).Assembly.GetType("System.Func`3");
Debug.WriteLine("BASIC SAMPLE - Serialize/Deserialize Simple Expression:");
XElement addXml;
Expression<Func<int, int, int>> addExpr = (x, y) => x + y;
ExpressionSerializer serializer = new ExpressionSerializer();
Expression simplifiedAddExpr = Evaluator.PartialEval(addExpr);
//addXml = serializer.Serialize(simplifiedAddExpr); //does not seem necessary
addXml = serializer.Serialize(addExpr);
Expression<Func<int, int, int>> addExpResult = serializer.Deserialize<Func<int, int, int>>(addXml);
Func<int, int, int> addExpResultFunc = addExpResult.Compile();
int result = addExpResultFunc(1, 2); // evaluates to 3
Debug.WriteLine("Deserialized Expression Tree:");
Debug.WriteLine(" " + addExpResult.ToString());
}
private static object GetMergeFunc(string str, string mapreduce, Type itemType)
{
if (str == null) return null;
object result = null;
//if (mergeFuncCache.TryGetValue(str, out result)) return result;
//if (str == DefaultToken)
//{
// Expression<Func<IEnumerable<Datapoint>, double>> merge = x => x.Sum(y => y.Value);
// result = merge.Compile();
//}
//else if (str == "__average__")
//{
// Expression<Func<IEnumerable<Datapoint>, double>> merge = x => x.Sum(y => y.Value * (double)y.Count) / x.Sum(y => y.Count);
// result = merge.Compile();
//}
if (str == DefaultToken)
{
if (!mapreduce.StartsWith(QlHeader)) throw new Exception("QL based mapreduce expression must be used with __default__ merge specification");
var expr = EvoQLBuilder.GetMergeExpression(mapreduce.Substring(QlHeader.Length), itemType);
var type = expr == null ? null : expr.GetType();
var compileMethod = expr == null ? null : type.GetMethods().FirstOrDefault(x => x.Name == "Compile" && x.GetParameters().Length == 0);
result = compileMethod.Invoke(expr, new object[0]);
}
else
{
var serializer = new ExpressionSerializer(new TypeResolver(new Assembly[] { Assembly.GetAssembly(typeof(Entities.Thrift.ThriftMention)) }));
var expr = serializer.Deserialize<Func<IEnumerable<Datapoint>, double>>(XElement.Parse(str));
result = expr.Compile();
}
mergeFuncCache[str] = result;
return result;
}
private static object GetMapReduceFunc(string str, Type itemType, out Type resultType)
{
if (str == null)
{
resultType = null;
return null;
}
object result = null;
//if (reduceFuncCache.TryGetValue(str, out result)) return result;
if (str.StartsWith(QlHeader))
{
var expr = EvoQLBuilder.GetReduceExpression(str.Substring(QlHeader.Length), itemType);
var type = expr == null ? null : expr.GetType();
resultType = expr == null ? itemType : ReduceExpressionGeneration.GetTypeOfEnumerable( type.GetProperty("ReturnType").GetValue(expr, null) as Type );
var compileMethod = expr == null ? null : type.GetMethods().FirstOrDefault(x => x.Name == "Compile" && x.GetParameters().Length == 0);
result = compileMethod.Invoke(expr, new object[0]);
}
else
{
var serializer = new ExpressionSerializer(new TypeResolver(new Assembly[] { Assembly.GetAssembly(typeof(Mention)) }));
var expr = serializer.Deserialize<Func<IEnumerable<Mention>, IEnumerable<Datapoint>>>(XElement.Parse(str));
resultType = typeof(Datapoint);
result = expr.Compile();
}
reduceFuncCache[str] = result;
return result;
}
private static object GetFilterFunc(string str, Type itemType)
{
if (str == null) return null;
object result = null;
if (filterFuncCache.TryGetValue(str, out result)) return result;
if (str.StartsWith(QlHeader))
{
var expr = EvoQLBuilder.GetWhereExpression(str.Substring(QlHeader.Length), itemType);
var type = expr == null ? null : expr.GetType();
var compileMethod = expr == null ? null : type.GetMethods().FirstOrDefault(x => x.Name == "Compile" && x.GetParameters().Length == 0);
result = compileMethod.Invoke(expr, new object[0]);
}
else
{
var serializer = new ExpressionSerializer(new TypeResolver(new Assembly[] { Assembly.GetAssembly(typeof(Mention)) }));
var expr = serializer.Deserialize<Func<Mention, object[], bool>>(XElement.Parse(str));
result = expr.Compile();
}
filterFuncCache[str] = result;
return result;
}
public void TestExpresstion([FromBody] XElement s)
{
//XElement x = JsonConvert.DeserializeObject<XElement>(s);
var serializer = new ExpressionSerializer();
var newPredicate = serializer.Deserialize<Func<string, bool>>(s);
}
