private void TestExpression(Expression <Func <Test, bool> > expression, ReadFieldOn readFieldOn) { var initialValue = 42; var actualValue = -1; // Initialize fields SetFields(initialValue); // Serialize expression var settings = new FactorySettings { AllowPrivateFieldAccess = true }; var serializer = new ExpressionSerializer(new JsonSerializer()); var value = serializer.SerializeText(expression, settings); // Modify fields SetFields(actualValue); // Deserialize expression var actualExpression = (Expression <Func <Test, bool> >)serializer.DeserializeText(value, new ExpressionContext { AllowPrivateFieldAccess = true }); var func = actualExpression.Compile(); // Set expected value. int expectedValue = readFieldOn == ReadFieldOn.Serialization ? initialValue : actualValue; // Assert Assert.IsTrue(func(new Test { IntProperty = expectedValue })); }
/// <summary> /// 取得规则组的表达式 /// </summary> /// <param name="ruleGroupId">规则组ID</param> /// <returns></returns> private string GetExpressionStr(Guid ruleGroupId, string userName, string groupId) { // 规则信息 var ruleGroup = _context.Set <RuleGroup>().Find(ruleGroupId); var rules = _context.Set <Rule>().AsNoTracking().Where(rule => rule.RuleGroupId == ruleGroupId); var ruleConditions = _context.Set <RuleCondition>().AsNoTracking().Where(condition => condition.RuleGroupId == ruleGroupId); // 生成表达式 var topRule = rules.Where(rule => rule.UpRuleId.Equals(new Guid())).FirstOrDefault(); var entityType = EntityTypeFinder.FindEntityType(ruleGroup.DbContext, ruleGroup.Entity); var expressionGroup = new ExpressionGroup(entityType); var keyValuePairs = new Dictionary <string, string> { }; keyValuePairs.Add("UserName", userName); keyValuePairs.Add("GroupId", groupId); MakeExpressionGroup(topRule, rules, ruleConditions, entityType, keyValuePairs, ref expressionGroup); // 生成过滤表达式 Expression lambda = expressionGroup.GetLambda(); // 表达式序列化 var serializer = new ExpressionSerializer(new JsonSerializer()) { AutoAddKnownTypesAsListTypes = true }; serializer.AddKnownType(typeof(Core.Expressions.ExpressionType)); return(serializer.SerializeText(lambda)); }
public void SerializeLambdaWithEnumTest() { foreach (var serializer in new ITextSerializer[] { new JsonSerializer(), new XmlSerializer() }) { serializer.AddKnownType(typeof(Gender)); var expressionSerializer = new ExpressionSerializer(serializer); var fish = new[] { new ItemWithEnum { Gender = Gender.Male }, new ItemWithEnum { Gender = Gender.Female }, new ItemWithEnum(), new ItemWithEnum { Gender = Gender.Female } }; var some = Gender.Female; Expression <Func <ItemWithEnum, bool> > expectedExpression = f => f.Gender == some; var expected = fish.Where(expectedExpression.Compile()).Count(); var serialized = expressionSerializer.SerializeText(expectedExpression); // throws SerializationException var actualExpression = (Expression <Func <ItemWithEnum, bool> >)expressionSerializer.DeserializeText(serialized); var actual = fish.Where(actualExpression.Compile()).Count(); Assert.Equal(expected, actual); } }
public T Get <T>(Expression <Func <dynamic, bool> > query) { var serializer = new ExpressionSerializer(new JsonSerializer()); var serializedExpression = serializer.SerializeText(query); return((T)Server.Retrieve(serializedExpression, typeof(T).FullName)); }
private static Expression SerializeDeserializeExpressionAsText(Expression expression, ISerializer serializer) { var expressionSerializer = new ExpressionSerializer(serializer); var serialized = expressionSerializer.SerializeText(expression); return(expressionSerializer.DeserializeText(serialized)); }
public void SerializeDeserializeListAsXml() { var guid1 = Guid.NewGuid(); var guid2 = Guid.NewGuid(); var guid3 = Guid.NewGuid(); var list = new List <Guid> { guid1, guid2 }; Expression <Func <Test, bool> > expression = test => list.Contains(test.Id); var serializer = new ExpressionSerializer(new XmlSerializer()) { AutoAddKnownTypesAsListTypes = true }; var value = serializer.SerializeText(expression); var actualExpression = (Expression <Func <Test, bool> >)serializer.DeserializeText(value); var func = actualExpression.Compile(); Assert.IsTrue(func(new Test { Id = guid1 }), "one failed."); Assert.IsTrue(func(new Test { Id = guid2 }), "two failed."); Assert.IsFalse(func(new Test { Id = guid3 }), "three failed."); }
public void SerializeLambdaWithNullableTest() { foreach (var textSerializer in new ITextSerializer[] { new JsonSerializer(), new XmlSerializer() }) { var serializer = new ExpressionSerializer(textSerializer); var fish = new[] { new Fish { Count = 0 }, new Fish { Count = 1 }, new Fish(), new Fish { Count = 1 } }; int?count = 1; Expression <Func <Fish, bool> > expectedExpression = f => f.Count == count; var expected = fish.Where(expectedExpression.Compile()).Count(); var serialized = serializer.SerializeText(expectedExpression); var actualExpression = (Expression <Func <Fish, bool> >)serializer.DeserializeText(serialized); var actual = fish.Where(actualExpression.Compile()).Count(); Assert.Equal(expected, actual); } }
public void SerializeDeserializeListAsJson() { var list = new List <string> { "one", "two" }; Expression <Func <Test, bool> > expression = test => list.Contains(test.Code); var serializer = new ExpressionSerializer(new JsonSerializer()) { AutoAddKnownTypesAsListTypes = true }; var value = serializer.SerializeText(expression); var actualExpression = (Expression <Func <Test, bool> >)serializer.DeserializeText(value); var func = actualExpression.Compile(); Assert.IsTrue(func(new Test { Code = "one" }), "one failed."); Assert.IsTrue(func(new Test { Code = "two" }), "two failed."); Assert.IsFalse(func(new Test { Code = "three" }), "three failed."); }
public void LetExpressionTests() { var expressions = new List <Expression>(); Expression <Func <IEnumerable <int>, IEnumerable <int> > > intExpr = c => from x in c let test = 8 where x == test select x; expressions.Add(intExpr); Expression <Func <IEnumerable <string>, IEnumerable <string> > > strExpr = c => from x in c let test = "bar" where x == test select x; expressions.Add(strExpr); foreach (var textSerializer in new ITextSerializer[] { new JsonSerializer(), new XmlSerializer() }) { var serializer = new ExpressionSerializer(textSerializer); foreach (var expected in expressions) { var serialized = serializer.SerializeText(expected); var actual = serializer.DeserializeText(serialized); ExpressionAssert.AreEqual(expected, actual); } } }
private static void DoSerializeThenDeserialize <T>(Expression <Func <T, bool> > predicate) { var expressionSerializer = new ExpressionSerializer(new JsonSerializer()); var serialized = expressionSerializer.SerializeText(predicate); expressionSerializer.DeserializeText(serialized); }
public void SerializeWithDateTimeLocalTest() { foreach (var textSerializer in new ITextSerializer[] { new JsonSerializer(), new XmlSerializer() }) { var serializer = new ExpressionSerializer(textSerializer); var yarrs = new[] { new Yarr { Date = new DateTime(3000, 1, 1) }, new Yarr { Date = new DateTime(2000, 1, 1) }, new Yarr(), new Yarr { Date = DateTime.Now.AddYears(1) } }; var date = DateTime.Now; Expression <Func <Yarr, bool> > expectedExpression = f => f.Date > date; var expected = yarrs.Where(expectedExpression.Compile()).Count(); var serialized = serializer.SerializeText(expectedExpression); var actualExpression = (Expression <Func <Yarr, bool> >)serializer.DeserializeText(serialized); var actual = yarrs.Where(actualExpression.Compile()).Count(); Assert.Equal(expected, actual); } }
public override void WriteJson(JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer) { var expressionSerializer = new ExpressionSerializer(new Serialize.Linq.Serializers.JsonSerializer()); var result = expressionSerializer.SerializeText((Expression)value); writer.WriteValue(result); }
public void DefaultExpressionsCanBeSerialized() { var defaultValue = Expression.Default(typeof(int)); var expressionSerializer = new ExpressionSerializer(new JsonSerializer()); expressionSerializer.SerializeText(defaultValue); }
public void DefaultExpressionsCanBeDeserialized() { var expected = Expression.Default(typeof(int)); var expressionSerializer = new ExpressionSerializer(new JsonSerializer()); var actual = expressionSerializer.DeserializeText(expressionSerializer.SerializeText(expected)); ExpressionAssert.AreEqual(expected, actual); }
public override Task <ISendStrategy> GetInputSendStrategy() { int joinFieldIndex = ((HashRippleJoinPredicate)predicate).JoinFieldIndex; Expression <Func <TexeraTuple, int> > exp = tuple => tuple.FieldList[joinFieldIndex].GetHashCode(); var serializer = new ExpressionSerializer(new JsonSerializer()); return(Task.FromResult(new Shuffle(inputGrains, serializer.SerializeText(exp)) as ISendStrategy)); }
public override string GetHashFunctionAsString(Guid from) { Expression <Func <TexeraTuple, int> > exp = tuple => tuple.FieldList[0].GetStableHashCode(); var serializer = new ExpressionSerializer(new JsonSerializer()); var hashFunc = serializer.SerializeText(exp); return(hashFunc); }
public void SerializeArrayAsJson() { var list = new [] { "one", "two" }; Expression <Func <Test, bool> > expression = test => list.Contains(test.Code); var serializer = new ExpressionSerializer(new JsonSerializer()); var value = serializer.SerializeText(expression); Assert.IsNotNull(value); }
public void SerializeNewObjWithoutParameters() { var serializer = new ExpressionSerializer(new JsonSerializer()); Expression <Func <List <int>, List <int> > > exp = l => new List <int>(); var result = serializer.SerializeText(exp); Assert.IsNotNull(result); }
public void SerializeFuncExpressionsWithoutParameters() { var serializer = new ExpressionSerializer(new JsonSerializer()); Expression <Func <bool> > exp = () => false; var result = serializer.SerializeText(exp); Assert.IsNotNull(result); }
private void SerialzeAndDeserializeDateTimeJson(DateTime dt) { Expression <Func <DateTime> > actual = () => dt; actual = actual.Update(Expression.Constant(dt), new List <ParameterExpression>()); var serialized = _jsonExpressionSerializer.SerializeText(actual); var expected = _jsonExpressionSerializer.DeserializeText(serialized); ExpressionAssert.AreEqual(expected, actual); }
public Subscription(Expression <Func <TEvent, bool> > canHandle) { var expressionSerializer = new ExpressionSerializer(new Serialization.JsonSerializer()); var func = canHandle.Compile(); CanHandleExpression = expressionSerializer.SerializeText(canHandle); CanHandleFunc = (ev) => func(ev as TEvent); EventType = typeof(TEvent); }
public Subscription() { var expressionSerializer = new ExpressionSerializer(new Serialization.JsonSerializer()); Expression <Func <TEvent, bool> > exp = (ev) => ev.GetType() == typeof(TEvent); CanHandleExpression = expressionSerializer.SerializeText(exp); CanHandleFunc = (ev) => ev.GetType() == typeof(TEvent); EventType = typeof(TEvent); }
public void ExpressionTest() { Expression <Func <int, bool> > exp1 = v => (v > 0 && v > 100) || v != 0; var serializer = new ExpressionSerializer(new JsonSerializer()); var data = serializer.SerializeText(exp1); Console.WriteLine(data.Length); var exp2 = serializer.DeserializeText(data); Console.WriteLine("exp2:" + exp2.ToJson()); }
private static async Task <IEnumerable <Siteprm> > QuerySiteprms(Expression <Func <Siteprm, bool> > query, CancellationToken cancellationToken) { var serializer = new ExpressionSerializer(new Serialize.Linq.Serializers.JsonSerializer()); string value = serializer.SerializeText(query); var queryNode = query.ToExpressionNode(); var response = await _httpClient.PostAsync("api/ReferenceData", new StringContent(value, System.Text.Encoding.UTF8, "application/json")); //var response = await _httpClient.PostAsync("api/ReferenceData", queryNode, _formatters[0], _mediaTypeJson, cancellationToken); response.EnsureSuccessStatusCode(); return(await response.Content.ReadAsAsync <IEnumerable <Siteprm> >(_formatters, cancellationToken)); }
public void SerializeListAsJson() { var list = new List <string> { "one", "two" }; Expression <Func <Test, bool> > expression = test => list.Contains(test.Code); var serializer = new ExpressionSerializer(new JsonSerializer()) { AutoAddKnownTypesAsListTypes = true }; var value = serializer.SerializeText(expression); Assert.IsNotNull(value); }
public void NullableDecimalTest() { foreach (var textSerializer in CreateTextSerializers()) { var serializer = new ExpressionSerializer(textSerializer); var expected = Expression.Constant(0m, typeof(Decimal?)); var text = serializer.SerializeText(expected); TestContext.WriteLine("{0} serializes to text with length {1}: {2}", expected, text.Length, text); var actual = serializer.DeserializeText(text); Assert.IsNotNull(actual, "Input expression was {0}, but output is null for '{1}'", expected, textSerializer.GetType()); ExpressionAssert.AreEqual(expected, actual); } }
static void Main(string[] args) { // No need to do this : ExpressionExtensions.AssemblyLoader = new NetCoreAppAssemblyLoader(); Expression expression = Expression.Parameter(typeof(Person), "x"); // Serialize expression var serializer = new ExpressionSerializer(new JsonSerializer()); string value = serializer.SerializeText(expression); Console.WriteLine("value:" + value); // Deserialize expression var actualExpression = serializer.DeserializeText(value); Console.WriteLine("actualExpression:" + actualExpression.ToJson()); }
public override string GetHashFunctionAsString(Guid from) { int joinFieldIndex; if (from.Equals(InnerTableID)) { joinFieldIndex = InnerTableIndex; } else { joinFieldIndex = OuterTableIndex; } Expression <Func <TexeraTuple, int> > exp = tuple => tuple.FieldList[joinFieldIndex].GetStableHashCode(); var serializer = new ExpressionSerializer(new JsonSerializer()); return(serializer.SerializeText(exp)); }
public void TestExpressionSerialization() { var serializer = new ExpressionSerializer(new Serialize.Linq.Serializers.JsonSerializer()); var @event = new MajorEventOccured() { Severity = Severity.Error, Message = "Oh no!" }; Expression <Func <MajorEventOccured, bool> > exp2 = (s) => true; var serialized = serializer.SerializeText(exp2); var exp = serializer.DeserializeText(serialized); var func = (exp as Expression <Func <MajorEventOccured, bool> >).Compile(); Assert.True(func(@event)); }
static void Main(string[] args) { Expression expression = Expression.Parameter(typeof(Person), "x"); // Serialize expression var serializer = new ExpressionSerializer(new JsonSerializer()); string value = serializer.SerializeText(expression); Console.WriteLine("value:" + value); // This is needed for NETStandard 1.x and NETCoreApp 1.x var expressionContext = new ExpressionContext(new NetCoreAppAssemblyLoader()); // Deserialize expression var actualExpression = serializer.DeserializeText(value, expressionContext); Console.WriteLine("actualExpression:" + actualExpression.ToJson()); }