public void AnonymousTypeTupletizer_Constant_Simple0() { var x = new { }; var a = Expression.Constant(x); var b = Expression.Constant("bar"); var t = AnonymousTypeTupletizer.Tupletize(a, b); var eq = new ExpressionEqualityComparer(); Assert.IsTrue(eq.Equals(b, t)); }
public void AnonymousTypeTupletizer_Constant_Simple2() { var x = new { a = 42, b = "bar" }; var a = Expression.Constant(x); var b = Expression.Constant(new Tuple <int, string>(42, "bar")); var t = AnonymousTypeTupletizer.Tupletize(a, Expression.Constant(value: null)); var eq = new ExpressionEqualityComparer(); Assert.IsTrue(eq.Equals(b, t)); }
public void AnonymousTypeTupletizer_Constant_Simple9() { var x = new { a = 42, b = "bar", c = 12.34, d = false, e = 'a', f = 49.95m, g = 0.1f, h = (byte)128, i = new TimeSpan(1, 2, 3) }; var a = Expression.Constant(x); var b = Expression.Constant(new Tuple <int, string, double, bool, char, decimal, float, Tuple <byte, TimeSpan> >(42, "bar", 12.34, false, 'a', 49.95m, 0.1f, new Tuple <byte, TimeSpan>(128, new TimeSpan(1, 2, 3)))); var t = AnonymousTypeTupletizer.Tupletize(a, Expression.Constant(value: null)); var eq = new ExpressionEqualityComparer(); Assert.IsTrue(eq.Equals(b, t)); }
public void AnonymousTypeTupletizer_Constant_Null() { var x = new { a = 42 }; var a = Expression.Constant(value: null, x.GetType()); var b = Expression.Constant(value: null, typeof(Tuple <int>)); var t = AnonymousTypeTupletizer.Tupletize(a, Expression.Constant(value: null)); var eq = new ExpressionEqualityComparer(); Assert.IsTrue(eq.Equals(b, t)); }
public void AnonymousTypeTupletizer_Nested3() { Expression <Func <int> > f = () => new { a = new { b = new { a = new { b = 42 } } } }.a.b.a.b; var a = f.Body; Expression <Func <int> > g = () => new Tuple <Tuple <Tuple <Tuple <int> > > >(new Tuple <Tuple <Tuple <int> > >(new Tuple <Tuple <int> >(new Tuple <int>(42)))).Item1.Item1.Item1.Item1; var b = g.Body; var t = AnonymousTypeTupletizer.Tupletize(a, Expression.Constant(value: null)); var eq = new ExpressionEqualityComparer(); Assert.IsTrue(eq.Equals(b, t)); }
public void AnonymousTypeTupletizer_Nested1() { Expression <Func <object> > f = () => new { a = 42, b = new { c = "bar", d = false }, e = 12.34, f = new { g = 'a' } }; var a = f.Body; Expression <Func <object> > g = () => new Tuple <int, Tuple <string, bool>, double, Tuple <char> >(42, new Tuple <string, bool>("bar", false), 12.34, new Tuple <char>('a')); var b = g.Body; var t = AnonymousTypeTupletizer.Tupletize(a, Expression.Constant(value: null)); var eq = new ExpressionEqualityComparer(); Assert.IsTrue(eq.Equals(b, t)); }
public void AnonymousTypeTupletizer_NoChange() { foreach (var e in new Expression[] { Expression.Constant(1), (Expression <Func <int> >)(() => DateTime.Now.Year), (Expression <Func <TimeSpan> >)(() => new TimeSpan(1, 2, 3)), (Expression <Func <IEnumerable <int>, IEnumerable <string> > >)(xs => from x in xs where x % 2 == 0 select x.ToString()) }) { var t = AnonymousTypeTupletizer.Tupletize(e, Expression.Constant(value: null)); Assert.AreSame(e, t); } }
public void AnonymousTypeTupletizer_Simple15_Accessor3() { Expression <Func <char> > f = () => new { a = 42, b = "bar", c = 3.14, d = false, e = 49.95m, f = DateTime.Now, g = new TimeSpan(1, 2, 3), h = Guid.NewGuid(), i = (byte)128, j = 12.34f, k = 24, l = true, m = "foo", n = (object)null, o = 'a' }.o; var a = f.Body; Expression <Func <char> > g = () => new Tuple <int, string, double, bool, decimal, DateTime, TimeSpan, Tuple <Guid, byte, float, int, bool, string, object, Tuple <char> > >(42, "bar", 3.14, false, 49.95m, DateTime.Now, new TimeSpan(1, 2, 3), new Tuple <Guid, byte, float, int, bool, string, object, Tuple <char> >(Guid.NewGuid(), 128, 12.34f, 24, true, "foo", null, new Tuple <char>('a'))).Rest.Rest.Item1; var b = g.Body; var t = AnonymousTypeTupletizer.Tupletize(a, Expression.Constant(value: null)); var eq = new ExpressionEqualityComparer(); Assert.IsTrue(eq.Equals(b, t)); }
public void AnonymousTypeTupletizer_Simple10() { Expression <Func <object> > f = () => new { a = 42, b = "bar", c = 3.14, d = false, e = 49.95m, f = DateTime.Now, g = new TimeSpan(1, 2, 3), h = Guid.NewGuid(), i = (byte)128, j = 12.34f }; var a = f.Body; Expression <Func <object> > g = () => new Tuple <int, string, double, bool, decimal, DateTime, TimeSpan, Tuple <Guid, byte, float> >(42, "bar", 3.14, false, 49.95m, DateTime.Now, new TimeSpan(1, 2, 3), new Tuple <Guid, byte, float>(Guid.NewGuid(), 128, 12.34f)); var b = g.Body; var t = AnonymousTypeTupletizer.Tupletize(a, Expression.Constant(value: null)); var eq = new ExpressionEqualityComparer(); Assert.IsTrue(eq.Equals(b, t)); }
public void AnonymousTypeTupletizer_Simple8_Accessor2() { Expression <Func <Guid> > f = () => new { a = 42, b = "bar", c = 3.14, d = false, e = 49.95m, f = DateTime.Now, g = new TimeSpan(1, 2, 3), h = Guid.NewGuid() }.h; var a = f.Body; Expression <Func <Guid> > g = () => new Tuple <int, string, double, bool, decimal, DateTime, TimeSpan, Tuple <Guid> >(42, "bar", 3.14, false, 49.95m, DateTime.Now, new TimeSpan(1, 2, 3), new Tuple <Guid>(Guid.NewGuid())).Rest.Item1; var b = g.Body; var t = AnonymousTypeTupletizer.Tupletize(a, Expression.Constant(value: null)); var eq = new ExpressionEqualityComparer(); Assert.IsTrue(eq.Equals(b, t)); }
public void AnonymousTypeTupletizer_Simple2() { Expression <Func <object> > f = () => new { a = 42, b = "bar" }; var a = f.Body; Expression <Func <object> > g = () => new Tuple <int, string>(42, "bar"); var b = g.Body; var t = AnonymousTypeTupletizer.Tupletize(a, Expression.Constant(value: null)); var eq = new ExpressionEqualityComparer(); Assert.IsTrue(eq.Equals(b, t)); }
public void AnonymousTypeTupletizer_Simple1_Accessor() { Expression <Func <int> > f = () => new { a = 42 }.a; var a = f.Body; Expression <Func <int> > g = () => new Tuple <int>(42).Item1; var b = g.Body; var t = AnonymousTypeTupletizer.Tupletize(a, Expression.Constant(value: null)); var eq = new ExpressionEqualityComparer(); Assert.IsTrue(eq.Equals(b, t)); }
public void AnonymousTypeTupletizer_NoChange() { foreach (var e in new Expression[] { Expression.Constant(1), #pragma warning disable IDE0004 // Remove Unnecessary Cast. (Only unnecessary on C# 10 or later.) (Expression <Func <int> >)(() => DateTime.Now.Year), (Expression <Func <TimeSpan> >)(() => new TimeSpan(1, 2, 3)), #pragma warning restore IDE0004 (Expression <Func <IEnumerable <int>, IEnumerable <string> > >)(xs => from x in xs where x % 2 == 0 select x.ToString()) }) { var t = AnonymousTypeTupletizer.Tupletize(e, Expression.Constant(value: null)); Assert.AreSame(e, t); } }
public void AnonymousTypeTupletizer_Simple2_GetHashCode() { Expression <Func <bool> > f = () => new { a = 42, b = "bar" }.GetHashCode() == new { a = 42, b = "bar" }.GetHashCode(); var a = f.Body; Expression <Func <bool> > g = () => new Tuple <int, string>(42, "bar").GetHashCode() == new Tuple <int, string>(42, "bar").GetHashCode(); var b = g.Body; var t = AnonymousTypeTupletizer.Tupletize(a, Expression.Constant(value: null)); var eq = new ExpressionEqualityComparer(); Assert.IsTrue(eq.Equals(b, t)); Assert.IsTrue(a.Evaluate <bool>()); Assert.IsTrue(b.Evaluate <bool>()); Assert.IsTrue(t.Evaluate <bool>()); }
public void AnonymousTypeTupletizer_Simple2_ToString() { Expression <Func <string> > f = () => new { a = 42, b = "bar" }.ToString(); var a = f.Body; Expression <Func <string> > g = () => new Tuple <int, string>(42, "bar").ToString(); var b = g.Body; var t = AnonymousTypeTupletizer.Tupletize(a, Expression.Constant(value: null)); var eq = new ExpressionEqualityComparer(); Assert.IsTrue(eq.Equals(b, t)); Assert.AreEqual("{ a = 42, b = bar }", a.Evaluate <string>()); Assert.AreEqual("(42, bar)", b.Evaluate <string>()); Assert.AreEqual("(42, bar)", t.Evaluate <string>()); }
public void AnonymousTypeTupletizer_ManOrBoy() { var expr = (from x in Enumerable.Empty <object>().AsQueryable() group x by x into g let a = g.OfType <bool>() let b = g.OfType <string>() let z = Enumerable.Zip(a, b, (x, y) => new { x, y }) from t in z select t.x ? t.y : "null") .Expression; var res = AnonymousTypeTupletizer.Tupletize(expr, Expression.Constant(value: null)); var csharp = CompilerGeneratedNameEliminator.Prettify(res).ToCSharpString(); Assert.AreEqual( StripWhitespace(@" __c0.GroupBy<object, object>((object x) => x) .Select<IGrouping<object, object>, Tuple<IGrouping<object, object>, IEnumerable<bool>>>( (IGrouping<object, object> g) => new Tuple<IGrouping<object, object>, IEnumerable<bool>>( g, g.OfType<bool>())) .Select<Tuple<IGrouping<object, object>, IEnumerable<bool>>, Tuple<Tuple<IGrouping<object, object>, IEnumerable<bool>>, IEnumerable<string>>>( (Tuple<IGrouping<object, object>, IEnumerable<bool>> t) => new Tuple<Tuple<IGrouping<object, object>, IEnumerable<bool>>, IEnumerable<string>>( t, t.Item1.OfType<string>())) .Select<Tuple<Tuple<IGrouping<object, object>, IEnumerable<bool>>, IEnumerable<string>>, Tuple<Tuple<Tuple<IGrouping<object, object>, IEnumerable<bool>>, IEnumerable<string>>, IEnumerable<Tuple<bool, string>>>>( (Tuple<Tuple<IGrouping<object, object>, IEnumerable<bool>>, IEnumerable<string>> t) => new Tuple<Tuple<Tuple<IGrouping<object, object>, IEnumerable<bool>>, IEnumerable<string>>, IEnumerable<Tuple<bool, string>>>( t, t.Item1.Item2.Zip<bool, string, Tuple<bool, string>>( t.Item2, (bool x, string y) => new Tuple<bool, string>(x, y)))) .SelectMany<Tuple<Tuple<Tuple<IGrouping<object, object>, IEnumerable<bool>>, IEnumerable<string>>, IEnumerable<Tuple<bool, string>>>, Tuple<bool, string>, string>( (Tuple<Tuple<Tuple<IGrouping<object, object>, IEnumerable<bool>>, IEnumerable<string>>, IEnumerable<Tuple<bool, string>>> t) => t.Item2, (Tuple<Tuple<Tuple<IGrouping<object, object>, IEnumerable<bool>>, IEnumerable<string>>, IEnumerable<Tuple<bool, string>>> t, Tuple<bool, string> t0) => t0.Item1 ? t0.Item2 : ""null"")"), StripWhitespace(csharp) );
public override Expression Normalize(Expression expression) { // // NB: Typical Reaqtor clients talk to some service APIs on a front-end service that does // further analysis of the expression tree (after deserialization) prior to sending it // to one or more query evaluator nodes. For example, a query may get split to run across // multiple nodes. Here, we bind directly to the query engine, so a few more steps are // involved to make this happen: // // - The engine stores definitions in "tuple normal form" such that all operators can be // defined as unary. E.g. t => t.Item1.Where(t.Item2) rather than (xs, f) => xs.Where(f). // - The client refers to types in the IReactive*Proxy space with async APIs but the // engine has synchronous symmetric APIs in the IReactive* space. We map types across. // var normalized = base.Normalize(expression); var erased = AnonymousTypeTupletizer.Tupletize(normalized, Expression.Constant(null), excludeVisibleTypes: true); return(erased); }
public void ExpressionMemberAllowListScanner_ManOrBoyTest1() { var ws = new ExpressionMemberAllowListScanner { DeclaringTypes = { typeof(Queryable), typeof(string), typeof(int), typeof(Tuple <, >), } }; var e = (from x in new[] { 1, 2, 3 }.AsQueryable() where x > 0 let y = x * x let z = x.ToString() select z.ToUpper()) .Expression; e = AnonymousTypeTupletizer.Tupletize(e, Expression.Constant(value: null)); Assert.AreSame(e, ws.Visit(e)); }