public void CreateCustomSerialize_ReturnExpressionAsString()
{
var factory = new ComplexExpressionFactory();
factory.MemberReaders.Add(new MethodReader());
var test = new Test()
{
"value1",
};
var expression = test.AsExpression(factory);
var serialization = Utils.GetSerialization(expression);
serialization.ItemsSerialize.Add(new MethodSerialize());
var result = serialization.Serialize();
var expected = $"\"{test.GetType().Name}.{test.GetHashCode()}\"" + " + \"[0]: value1\" + \"Capacity: 4\" + \"Count: 1\" + \"HelloWorld(value1,value2): value1-value2\"";
Assert.Equal(5, expression.Count);
Assert.IsType <ComplexEntity>(expression[0]);
Assert.IsType <CollectionItemEntity>(expression[1]);
Assert.IsType <PropertyEntity>(expression[2]);
Assert.IsType <PropertyEntity>(expression[3]);
Assert.IsType <MethodEntity>(expression[4]);
Assert.Equal(expected, result);
}
public void SerializationComplex3()
{
var factory = new ComplexExpressionFactory();
factory.MemberReaders.Add(new MethodReader());
var model = new Model();
var expression = model.AsExpression(factory);
var serialization = expression.GetSerializer <ComplexEntityExpressionSerializer>();
serialization.ItemsSerialize.Add(new MethodSerialize());
System.Console.WriteLine(serialization.Serialize());
}
public IEnumerable <ComplexEntity> GetMembers(ComplexExpressionFactory factory, GraphExpression.Expression <object> expression, object entity)
{
if (entity is Test)
{
var method = entity
.GetType()
.GetMethods().Where(f => f.Name == "HelloWorld")
.First();
var parameters = new object[] { "value1", "value2" };
var methodValue = method.Invoke(entity, parameters);
yield return(new MethodEntity(expression, method, parameters, methodValue));
}
}
public void ComplexExpressionFactory()
{
var factory = new ComplexExpressionFactory();
factory.MemberReaders.Add(new MethodReader());
var model = new Model();
var expression = model.AsExpression(factory);
foreach (ComplexEntity item in expression)
{
var output = GetEntity(item);
if (item is MethodEntity method)
{
output = $"MethodEntity.{method.MethodInfo.Name}({method.Parameters[0]}, {method.Parameters[1]})";
}
System.Console.WriteLine(output);
}
}
/// <summary>
/// Creates a complex expression, that is, where entities can have different types. By default, the expression is inferred with the object type.
/// </summary>
/// <param name="entityRoot">Root entity of expression. All entity paths will be traversed via reflection and each entity in that path will be an item in the expression.</param>
/// <param name="factory">Enter this parameter to customize the build of the expression</param>
/// <param name="deep">Determines whether the expression constructed will be a deep one, that is, if it will navigate objects that have already been navigated, except for cyclic references.</param>
/// <returns>Return a complex expression</returns>
public static Expression <object> AsExpression(this object entityRoot, ComplexExpressionFactory factory = null, bool deep = false)
{
factory = factory ?? new ComplexExpressionFactory();
return(factory.Build(entityRoot, deep));
}
