Expression builder

Available as Nuget package

Introduction

Recently I had to create lambda functions on the fly. I could'nt use the various code providers like the CSharpCodeProvider, since there would have been too much code to write. So i started to explore the wonders of Expressions. But it's a steep hill to climb.

At the same time i were exploring fluent interfaces, then i managed to build this library with a somehow fluent interface.

Using the code

Debugging

For debugging purposes can be shown the source file that will be created by the function! Let the unit test explain this

public void CanBeCreatedAFunctionReturningVoid()
{
    const string expected =
@"public void Call(System.String first, System.String second)
{
  //No Operation;
}";
    var newExpression = Function.Create()
            .WithParameter<string>("first")
            .WithParameter<string>("second")
            .WithBody(CodeLine.Nop);

    AssertString.AreEqual(expected, newExpression.ToString());

    var lambda = newExpression.ToLambda<Action<string, string>>();
    Assert.IsNotNull(lambda);

    lambda("test", "another");
}

Creating a function

To define a new function these are the steps. We are creating a simple function, with a parameter and a return variable like

int MyFunction(int param)
{
    return param;
}

• Function.Create(): The starting point
• WithParameter("Parameter name"): A parameter is declared. Multiple parameters can be declared
• Returns("Return variable name"): The variable that will be returned

var newFunction = Function.Create()
        .WithParameter<int>("param")
        .Returns("param")

Than we can convert it to an expression and call it. The compile step will produce a method.

var newExpression = newFunction.ToExpression();
var method = newExpression.Compile();

var result = (int)method.invoke(2);
Assert.AreTrue(2,result);

Or it's possible to build a lambda expression. Than it would be possible to call it with compilation support

var lambda = newFunction.ToLambda<Func<int,int>>();

var result = lambda(2);
Assert.AreTrue(2,result);

Of course it's possible to omit parameters and return variable declarations.

In short, in order of possible usage

• Function.Create(): Create a new function
• WithParameter: Create a parameter with the given type and name
  • WithParameter("name")
  • WithParameter(typeof(DataType),"name")
• Returns("name"): Return the value of the variable
• In alternative
  • ToExpression(): Return a System.Linq.Expression, that should be compiled before the usage
  • ToLambda(): Creates a lambda, ready to use
  • ToString(): Create the pseudo code for the function

Function body

A body can be declared for the function. It will contain a series of CodeLine objects. CodeLine objects into the library implement the ICodeLine interface

var newFunction = Function.Create()
        .WithParameter<int>("param")
        .WithBody(
            //A list of CodeLines
        )
        .Returns("param")

In short, in order of possible usage

• Function.Create
• WithParameter
• WithBody(...): Setup the body of the function
• Returns

CodeLines

Variables

It is possible to declare new simple variables. They will be assigned automatically with a default value. Here we create a variable of type int named intVariable, with the default value of 0.

var newFunction = Function.Create()
    ...
    .WithBody(
        ...
        CodeLine.CreateVariable<int>("intVariable"),
        ...
    )
    ...

Two methods can be used

• CreateVariable<VariableType>("name")
• CreateVariable(typeof(VariableType),"name")

Assignment and constants

Values can be assigned to variables.

Let's start remembering that with assignments three roles are present

• L(eft) Value: The item receiving the value
• Operator: The assignment operator
• R(ight) Value: The source value

Inside the library the LValue and RValue are associated with two interfaces, and are produced by the "Operation" classes

• ILeftable: An object that can receive values, like the variables
• IRightable: An object that can provide values, like variables, constants and functions

For example let's assign to the variable intVariable a constant value with the AssignConst method. Then we will assign the value of intVariable to anotherVariable. Code line are not ILeftable or IRightable

var newFunction = Function.Create()
    ...
    .WithBody(
        ...
        CodeLine.CreateVariable<int>("intVariable"),
        CodeLine.CreateVariable<int>("anotherVariable"),
        CodeLine.AssignConstant("intVariable",2),
        CodeLine.Assign("anotherVariable","intVariable")
        ...
    )
    ...

The assignement can be made with several operations. The default is AssignementOperator.Assign in total they are

• Assign
• SumAssign
• SubtractAssign: Does not work for strings
• MultiplyAssign: Does not work for strings

While the complete CodeLines are

• AssignConstant
  • AssignConstant("name",value,operator): Assign the value to the "name" variable
  • AssignConstant(ILeftable,value,operator): Assign the value to the ILeftable variable
• Assign
  • Assign("name1","name2",operator)
  • Assign(ILeftable,"name2",operator)
  • Assign("name1",IRightable,operator)
  • Assign(ILeftable,IRightable,operator)

Operation

A particular concept is the "Operation". We will add the L or R values into the description to specify where an operation can be placed. The type IOperation means that the value can be both an ILeftable or an IRightable

• Variable("VariableName"): (LR) retrieves a variable instance given the name
• Constant(value): (R) generate an instance of a constant value
• Null: (R) The null constant
• Cast: (R) To cast the operation passed to it
  • Cast("name",toType)
  • Cast(IOperation,toType)
  • Cast<toType>("name")
  • Cast<toType>(IOperation)
  • CastConst(value,toType)
  • CastConst<toType>(value)
• Invoke: (-) Invoke a method with a void return type. This is the only Operation that is not rightable or leftable
  • Invoke("name","MethodName",IOperation[]): Invoke the MethodName method on the "name" variable passing the IOperation parameters
  • Invoke(IOperation,"MethodName",IOperation[]): Using the IOperation variable
  • Invoke<Type>("MethodName",IOperation[]): Invoke a static method on type
  • Invoke(Type,"MethodName",IOperation[]): Invoke a static method on type
• InvokeReturn: (R) Invoke a method with a return type
  • InvokeReturn("name","MethodName",IOperation[]): Invoke the MethodName method on the "name" variable passing the IOperation parameters
  • InvokeReturn(IOperation,"MethodName",IOperation[]): Using the IOperation variable
  • InvokeReturn<Type>("MethodName",IOperation[]): Invoke a static method on type
  • InvokeReturn(Type,"MethodName",IOperation[]): Invoke a static method on type
• Set: (-) Invoke a setter on the variable
  • Set("name","Property",IOperation): Invoke the setter on property passing the IOperation as parameter
  • Set(IOperation,"Property",IOperation):Using the IOperation variable
• Get: (R) Invoke a getter on the variable
  • Get("name","Property"): Invoke the getter on property
  • Get(IOperation,"Property"):Using the IOperation variable

Just to give an example

var newExpression = Function.Create()
        .WithParameter<int>( "first")
        .WithParameter<string>( "second")
        .WithBody(
            CodeLine.Assign("second", Operation.InvokeReturn("first", "ToString")),
            CodeLine.AssignConstant("second", "another", AssignementOperator.SumAssign)
        )
        .Returns("second")
        .ToExpression();
Assert.IsNotNull(newExpression);


var extMethodExpr = newExpression.Compile();
var result = extMethodExpr.DynamicInvoke(22, "b");
Assert.AreEqual("22another",result);

Lambda operations

Lambda function can be invoked too

• Func: (R) Func<P1,R>( Func<P1,R>,IOperation): Calling a lambda with one parameter and a return variable Func<P1,P2,R>( Func<P1,P2,R>,IOperation,IOperation): Calling a lambda with two parameter and a return variable
• Action: Action( Action,IOperation): Calling a lambda with one parameter and a return variable Action<P1,P2>( Action<P1,P2>,IOperation,IOperation): Calling a lambda with two parameter and a return variable

Just a sample:

            
var newExpression = Function.Create()
    .WithParameter<string>("first")
    .WithParameter<string>("second")
    .WithBody(
            CodeLine.CreateVariable<string>( "result"),
            CodeLine.Assign("result",
                Operation.Func<object, string, string>(
                    //The lambda expression
                    (a, b) =>
                    {
                        return string.Format("{0}-{1}",a,b);
                    },
                Operation.Variable("first"),
                Operation.Variable("second"))
            )
    )

Conditions

Condition are particular operation with return type of bool.

• Multiple conditions
  • And(Condition[]): (R) The and of the conditions listed
  • Or(Condition[]): (R) The or of the conditions listed

The single compare conditionst has the following operators

• Equal
• Different
• Greater: Does not work for strings
• GreaterEqual: Does not work for strings
• Smaller: Does not work for strings
• SmallerEqual: Does not work for strings

• ReferenceEqual

• Comparaison operators

  • Compare("name1","name2",operator)
  • Compare(ILeftable,"name2",operator)
  • Compare("name1",IRightable,operator)
  • Compare(ILeftable,IRightable,operator)

If and While

If operator includes various kind of items.

• If(Condition): Verifiy a condition
• Then(CodeLine[])
• ElseIf(CodeLine[])
• Else(CodeLine[])

var newExpression = Function.Create()
        .WithParameter<int>("first")
        .WithBody(
                CodeLine.CreateIf(Condition.CompareConst("first", 3))
                .Then(CodeLine.AssignConstant("first", 2))
                .Else(CodeLine.AssignConstant("first", 1))
        )

The while will be simpler, and kinda obvious...

• While(Condition)
• Do(CodeLine[])

Utility classes

ReflectionUtil

A small utility class with utility methods through reflection

• string TypeToString(type): Return a string that describe the type including generics
• MethodCallDescriptor GetMethod(type, methodName,available paramTypes): Given a type, a method name and a list of types passed as parameters return the matching method info and the default values for the parameters not present into the paramTypes
• MethodCallDescriptor GetConstructor(Type type, List paramTypes): The same of GetMethod but for constructors

ExpressionUtil

A small utility class with utility methods through expressions

• IEnumerable<LambdaPropertyDescriptor> GetPropertyInfos(propertyLambda): Given a lambda expression for a property (or group of property) return the list of types/names of items present.
• Func<TSource, object, bool> GetComparer(propertyLambda, ComparaisonOperator): Given a lambda and a comparison type creates a lambda that compare an instance value with the passed value.

Some example will clarify :)

    public class FirstLevel
    {
        public SecondLevel First { get; set; }
        public int Other { get; set; }
    }

    public class SecondLevel
    {
        public string Second { get; set; }
    }
    
    var type = ExpressionUtil.GetPropertyInfos<FirstLevel>((a) => a.First.Second).ToArray();
    Assert.AreEqual(2, type.Length);
    Assert.AreEqual(typeof(string), type[1].DataType);
    Assert.AreEqual(typeof(SecondLevel), type[0].DataType);
    Assert.AreEqual("Second", type[1].Name);
    Assert.AreEqual("First", type[0].Name);

Class Wrapper

It is possible to create a wrapper for a class. This can be useful. Instead of getting mad (and slow) with reflection, a cache can be built on startup containing all the ClassWrapperDescriptors Then to apply the various method it would be as easy as creating an instance of a new ClassWrapper passing the instance of the object to wrap to the ClassWrapperDescriptor.

Note that to invoke the methods the parameters must respect the order of the called method. Note even that if the lasts parameters are not passed, they would be considered optional and if the method allow this behaviour, it will assign to them a default value.

public class SampleClass
{
    public string StringProperty { get; set; }

    public void VoidMethod()
    {
        
    }
}

public void Main()
{
    //Create an instance
    var newObject = new SampleClass();
    TestMethod(newObject)
}

public void TestMethod(object instance)
{
    //Create the wrapper descriptor for the given type
    var classWrapperDescriptor = new ClassWrapperDescriptor(instance.GetType());
    //Load the data into the descriptor
    classWrapperDescriptor.Load();
    
    //Create a wrapper
    var classWrapper = classWrapperDescriptor.CreateWrapper(instance);
    
    //Set the propery StringProperty
    classWrapper.Set("StringProperty","test");
    
    //Retrieve the value of StringPropery
    var result = classWrapper.Get<string>("StringProperty");
    
    //And so on with the methods
}

Inisders view

More to come shortly! As soon as i have the time to write how everything works here!

Licensing

Copyright (C) 2013-2014 Kendar.org

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Download

See Nuget.org for the latest changes. Or the repository on Github.

Last modified on: May 02, 2015