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());
}
