public void GivenExpressionHasSerializerWhenSerializeCalledThenShouldSerialize() { var serialized = target.Serialize(Expression.Constant(5), new SerializationState()); Assert.NotNull(serialized); Assert.Equal(ExpressionType.Constant, (ExpressionType)serialized.Type); }
private static void Binary() { GC.Collect(); Console.WriteLine("Binary"); var ser = new ExpressionSerializer(new BinaryObjectSerializer(), ExpressionFactory.Instance); var N = 10000; var M = 10000; var e = (Expression <Func <IEnumerable <int> > >)(() => Enumerable.Range(0, 10).Where(x => x > 0).Select(x => x * x)); Console.WriteLine(" Serialize"); var sw = Stopwatch.StartNew(); var gc = GarbageCollectionWatch.StartNew(); var res = default(byte[]); for (var i = 0; i < N; i++) { #if USE_SLIM res = ser.Serialize(e.ToExpressionSlim()); #else res = ser.Serialize(e); #endif } Console.WriteLine(" Elapsed (ms): " + sw.Elapsed.TotalMilliseconds / M); Console.WriteLine(" " + gc.Elapsed); Console.WriteLine(" Length (bytes): " + res.Length); Console.WriteLine(" Deserialize"); sw.Restart(); gc.Restart(); for (var i = 0; i < M; i++) { #if USE_SLIM e = (Expression <Func <IEnumerable <int> > >)ser.Deserialize(res).ToExpression(); #else e = (Expression <Func <IEnumerable <int> > >)ser.Deserialize(res); #endif } Console.WriteLine(" Elapsed (ms): " + sw.Elapsed.TotalMilliseconds / M); Console.WriteLine(" " + gc.Elapsed); Console.WriteLine(); }
static void Main(string[] args) { const string fileName = "sumRange.bin"; ExpressionSerializer serializer = new ExpressionSerializer( new TypeResolver(new[] { Assembly.GetExecutingAssembly() }) ); serializer.Serialize(sumRange).Save(fileName); Expression <Func <int, int, int> > deserializedSumRange = serializer.Deserialize <Func <int, int, int> >( XElement.Load(fileName) ); Func <int, int, int> funcSumRange = deserializedSumRange.Compile(); Console.WriteLine( "Deserialized func returned: {0}", funcSumRange(1, 4) ); Console.ReadKey(); }
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)); }
private static void bench() { var sw = Stopwatch.StartNew(); for (var i = 0; i < 5_000_000; i++) { //Expression<Func<string, string, int>> exp = (x, y) => x.Length + y.Length; //exp.Compile()("a", "b"); //Func<string, string, int> foo = (x, y) => x.Length + y.Length; //foo("a", "b"); //new Context().Eval("(x,y) => x.length + y.length").As<Function>().Call(new Arguments { "a", "b" }); Expression <Func <string, string, long> > exp = (x, y) => x.Length + y.Length; var serializer = new ExpressionSerializer(); var deserializer = new ExpressionDeserializer(); var serialized = serializer.Serialize(exp); var deserialized = (LambdaExpression)deserializer.Deserialize(serialized); var value = new ExpressionEvaluator().Eval(deserialized.Body, new[] { new Parameter(deserialized.Parameters[0], "a"), new Parameter(deserialized.Parameters[1], "b"), }); } sw.Stop(); Console.WriteLine(sw.Elapsed); }
public static string SerializeExpression(linq.Expression expr) { var typeResolver = new TypeResolver(assemblies: AppDomain.CurrentDomain.GetAssemblies(), knownTypes: null); var serializer = new ExpressionSerializer(typeResolver); var retVal = serializer.Serialize(expr).ToString(); return(retVal); }
private void OnSerializing(StreamingContext context) { var cleanedExpression = ExpressionUtility.Ensure(_predicate); var serializer = new ExpressionSerializer(); var xmlElement = serializer.Serialize(cleanedExpression); _serializedPredicate = xmlElement.ToString(); }
public async void Serialize(Expression <Func <Customer, bool> > lambda, string expectedResult) { var serializer = new ExpressionSerializer(); var result = await serializer.Serialize(lambda); //Console.WriteLine(result); Assert.Equal(expectedResult, result); }
public static XElement SerializeQuery(this Expression expression) { ExpressionSerializer serializer = new ExpressionSerializer() { Converters = { new BoxedExpressionXmlConverter() } }; return(serializer.Serialize(expression)); }
public void Null_Expression() { var ser = new ExpressionSerializer(new BinaryObjectSerializer(), ExpressionFactory.Instance); var arr = ser.Serialize(expression: null); var otp = ser.Deserialize(arr); Assert.IsNull(otp); }
public static XElement SerializeQuery(this IQueryable query) { DLinqSerializationTypeResolver resolver = new DLinqSerializationTypeResolver(null); ExpressionSerializer serializer = new ExpressionSerializer(resolver) { Converters = { new DLinqCustomExpressionXmlConverter(null, resolver) } }; return(serializer.Serialize(query.Expression)); }
public AdHocSpecification(Expression <Func <T, bool> > specification) { var cleanedExpression = ExpressionUtility.Ensure(specification); //this.specification = specification; var serializer = new ExpressionSerializer(); var serializedExpression = serializer.Serialize(cleanedExpression); serializedExpressionXml = serializedExpression.ToString(); }
public void Serialize <T>(T dto) { if (typeof(Expression).IsAssignableFrom(typeof(T))) { _expressionSerializer.Serialize(_client.GetStream(), (Expression)(object)dto); } MemoryStream ms = new MemoryStream(2048); BsonSerializer.Serialize <T>(new BsonBinaryWriter((_client.GetStream())), dto); }
private static void AssertRoundtrip(params Expression[] expressions) { var equ = new ExpressionEqualityComparer(() => new Comparator()); foreach (var e in expressions) { var ser = new ExpressionSerializer(new BinaryObjectSerializer(), ExpressionFactory.Instance); #if USE_SLIM var arr = ser.Serialize(e.ToExpressionSlim()); var otp = ser.Deserialize(arr).ToExpression(); #else var arr = ser.Serialize(e); var otp = ser.Deserialize(arr); #endif Assert.IsTrue(equ.Equals(e, otp), e.ToString()); } }
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 Deserialize() { _jsonSerializer = new CustomBonsaiSerializer(); _binarySerializer = new ExpressionSerializer(new BinaryObjectSerializer(), ExpressionFactory.Instance); var expr = (Expression <Func <IEnumerable <int> > >)(() => Enumerable.Range(0, 10).Where(x => x > 0).Select(x => x * x)); _json = _jsonSerializer.Serialize(expr.ToExpressionSlim()); _binary = _binarySerializer.Serialize(expr.ToExpressionSlim()); }
public void ExternalTypesSerialization() { var serializer = new ExpressionSerializer(); var deserializer = new ExpressionDeserializer(); var list = new List<int>(); Expression<Func<List<int>, int>> expression = l => l.Count; var serialized = serializer.Serialize(expression); var deserialized = deserializer.Deserialize(serialized); }
public static string ToXml <T>(this Expression <T> exp) { var s = new ExpressionSerializer(new TypeResolver( new Assembly[] { Assembly.GetExecutingAssembly(), Assembly.GetCallingAssembly() })); var x = s.Serialize(exp); return(x.ToString()); }
public void GetObjectData(SerializationInfo info, StreamingContext context) { var resolver = new TypeResolver(App.Plugins, new[] { typeof(Expression) }); var serializer = new ExpressionSerializer(resolver) { Converters = { new XmlConverter(null, resolver) } }; var rootEl = serializer.Serialize(_expression); info.AddValue("expression", rootEl.ToString()); }
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 void ExpressionSerializer_ArgumentChecking() { var ser = new ExpressionSerializer(new BinaryObjectSerializer()); Assert.ThrowsException <ArgumentNullException>(() => _ = new ExpressionSerializer(serializer: null)); Assert.ThrowsException <ArgumentNullException>(() => _ = new ExpressionSerializer(serializer: null, ExpressionFactory.Instance)); Assert.ThrowsException <ArgumentNullException>(() => _ = new ExpressionSerializer(new BinaryObjectSerializer(), expressionFactory: null)); #if !USE_SLIM Assert.ThrowsException <ArgumentNullException>(() => ser.Serialize(default(Stream), Expression.Constant(1))); #endif Assert.ThrowsException <ArgumentNullException>(() => ser.Deserialize(default(Stream))); Assert.ThrowsException <ArgumentNullException>(() => ser.Deserialize(default(byte[]))); }
public static JsonElement GetSerializedFragment <TSerializer, TExpression>( TExpression expression, JsonSerializerOptions options = null) where TExpression : Expression where TSerializer : SerializableExpression { var state = options == null ? new SerializationState() : options.ToSerializationState(); var json = JsonSerializer.Serialize( ExpressionSerializer.Serialize(expression, state) as TSerializer, options); return(JsonDocument.Parse(json).RootElement); }
public AdHocSpecification(Expression <Func <T, bool> > specification) { if (specification == null) { this.serializedExpressionXml = string.Empty; } else { var cleanedExpression = ExpressionUtility.Ensure(specification); var serializer = new ExpressionSerializer(); var serializedExpression = serializer.Serialize(cleanedExpression); this.serializedExpressionXml = serializedExpression.ToString(); } }
// 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 void BasicExpressionSerialization() { 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 void Old() { var x = Expression.Parameter(typeof(int)); var i = typeof(Interlocked).GetMethods().Single(m => m.Name == "Exchange" && m.GetParameters().Last().ParameterType == typeof(int)); Expression.Block(new[] { x }, Expression.Call(instance: null, i, x, Expression.Constant(1))); var ser = new ExpressionSerializer(new BinaryObjectSerializer(), ExpressionFactory.Instance); var inp = Expression.Constant(42); var arr = ser.Serialize(inp); var otp = ser.Deserialize(arr); var equ = new ExpressionEqualityComparer(); Console.WriteLine(equ.Equals(inp, otp)); }
/// <summary> /// This is the main entry point for your service replica. /// This method executes when this replica of your service becomes primary and has write status. /// </summary> /// <param name="cancellationToken">Canceled when Service Fabric needs to shut down this service replica.</param> protected override async Task RunAsync(CancellationToken cancellationToken) { _serializer = Serialization.CreateSerializer(); //This is essentially mapping types to objects. The IGoodVibesValidator just enforces that you use the interface for some semblance //of control. That said, you can quite eaisily break this if you are so inclined //var validators = await this.StateManager.GetOrAddAsync<IReliableDictionary<ComparableType, IGoodVibesValidator>>(ValidatorDictionary); var validators = await this.StateManager.GetOrAddAsync <IReliableDictionary <string, List <XElement> > >(SerializedValidatorDictionary); using (var tx = this.StateManager.CreateTransaction()) { if (await validators.GetCountAsync(tx) == 0) { List <XElement> values = new List <XElement>(); //Expression<Func<ReportBase, ValidationMessage>> expr1 = ReportValidationRules.RatingRule; //Expression<Func<ReportBase, ValidationMessage>> expr2 = ReportValidationRules.PosterRule; //Expression<Func<ReportBase, ValidationMessage>> expr3 = ReportValidationRules.LocationRule; //values.Add(_serializer.Serialize(expr1)); //values.Add(_serializer.Serialize(expr2)); //values.Add(_serializer.Serialize(expr3)); ReportValidationRules.ReportRules.ForEach(x => values.Add(_serializer.Serialize(x))); await validators.AddAsync(tx, typeof(ReportBase).AssemblyQualifiedName, values); } await tx.CommitAsync(); } //using (var tx = this.StateManager.CreateTransaction()) //{ // if (await validators.GetCountAsync(tx) != 0) // { // var val = await validators.TryGetValueAsync(tx, typeof(SurfReport).AssemblyQualifiedName); // if (val.HasValue) // { // XElement x = val.Value.FirstOrDefault(); // var serializedValidator = _serializer.Deserialize<Func<ReportBase, ValidationMessage>>(x); // var test = new SurfReport(Ratings.None, "ben", "dfs", DateTime.Now, null, 0, 0); // var godIHopeThisJustFuckingWorksForOnce = serializedValidator.Compile()(test); // } // } //} }
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()); }
public void NotSupportedExpressions() { var binder = Binder.Convert(CSharpBinderFlags.None, typeof(int), typeof(Tests)); var es = new Expression[] { Expression.DebugInfo(Expression.SymbolDocument("foo"), 1, 2, 3, 4), Expression.Dynamic(binder, typeof(int), Expression.Constant(42)), new MyNode(), }; foreach (var e in es) { Assert.ThrowsException <NotSupportedException>(() => { var ser = new ExpressionSerializer(new BinaryObjectSerializer(), ExpressionFactory.Instance); ser.Serialize(e); }); } }
static void Main(string[] args) { //hubsTest(); //return; //experiments(); //return; var f = new Func <int, int, int>((x, y) => x + y); //var invokeMethod = f.Invoke(); return; //var a = 2; //var b = 2; //var c = 2; var prmA = Expression.Parameter(typeof(SomeObject), "obj"); var prmB = Expression.Parameter(typeof(string), "b"); var prmC = Expression.Parameter(typeof(long), "c"); var obj = new SomeObject(); Expression <Func <long> > exp = () => 1; var body2 = Expression.Block(Expression.Assign(Expression.PropertyOrField(prmA, nameof(SomeObject.Property)), Expression.Constant(1))); var serializer = new ExpressionSerializer(); var deserializer = new ExpressionDeserializer(); var serialized = serializer.Serialize(exp); var deserialized = (LambdaExpression)deserializer.Deserialize(serialized); var prms = new[] { new Parameter(prmA, obj), }; // var value = new ExpressionEvaluator().Eval(deserialized.Body, prms); var value = new ExpressionEvaluator().Eval(body2, prms); //bench(); }
public static XElement SerializeQuery(this IQueryable query) { DLinqSerializationTypeResolver resolver = new DLinqSerializationTypeResolver(null); ExpressionSerializer serializer = new ExpressionSerializer(resolver) { Converters = { new DLinqCustomExpressionXmlConverter(null, resolver) } }; return serializer.Serialize(query.Expression); }