Delegate & Expression Tree 研究

一：

1.delcare a delegate:

public delegate void RemoteOperation();

public  static void DoSth()
    {
        Console.WriteLine("DoSth");
        Console.ReadLine();
    }

2.instantiate a delegate

RemoteOperation function = DoSth;

What done by Compiler automatically?

1）编译器会检查Delegate的Signature,确保正确的赋值。否则报错。

2)生成一个RemoteOperation的类，继承自MultiCastDelegate，如图：

 

Target:keep the reference of the object who implemented the Method.(如果是静态的Method,Target=null)

Method:keep MethodInfo object for this object.

内部是Delegate Array,支持Mutili-Method implementation.

3.Execute a delegate;

function();//function.Invoke();

调用之后，会依次调用Multi-Method。

foreach (var s in function.GetInvocationList())
        {
            Console.WriteLine(s.Method);
            Console.WriteLine(s.Target);
        }

二：Delegate执行可以实现异步调用。

BeginEnvoke/EndInvoke;

IAsyncResult BeginInvoke(AsyncCallback callback, object @object);

public virtual void EndInvoke(IAsyncResult result);

在MainProgram中调用BeginInvoke();然后再AsynCallback中调用EndInvoke();

for example;

1)main(); { ...IAsyncResult = function.BeginInvoke(CompleteNotifiy, function);...}

2)static void CompleteNotify(IAsyncResult result)

{

RemoteOperation handle  = (RemoteOperation)result.AsyncState;
handle.EndInvoke(result);

}

What's Expression Tree?

Simply speaking, an expression tree is nothing but the representation of a Lambda Expression in
terms of .NET objects. 

Now if you see the body of Expression
you can see there are three parts in the whole Expression :




 



 
 
ParameterExpression : An external parameter to the expression. Here
     it is X.


  
  
BinaryExpression  : As the inner expression x<5 is Binary, it
     produces a BinaryExpression. Each of the Binary Expression has two
     Expressions body within it. The properties Left and Right. In our case the
     Expression has one ParameterExpression and another ConstantExpression.
   
   
Left :
      Produces the left hand side of the BinaryExpression. In our case the left
      hand side represents the ParameterExpression the same object which is
      passed as X. 
Right :
      Right represents the other side of the expression which is in our case is
      a constant term. So Right represents a ConstantExpression for us.


    
    
NodeType : The nodetype gives you the idea what the BinaryExpression does.
      There are a lot of Binary types available. In our case it is
      LessThan. 
 Hence the entire decomposition
will look like :


 
 

  
  
ParameterExpression externalParam = myexpressiondelegate.Parameters[0];

  
  
BinaryExpression bbody = myexpressiondelegate.Body as BinaryExpression;

  
  
 ParameterExpression parambodyleft = bbody.Left as ParameterExpression;

  
  
ConstantExpression constRight = bbody.Right as ConstantExpression;

  
  
ExpressionType type = bbody.NodeType;

  
  

Expression<Func<int, int>> multiy = x =>x*5;
            ParameterExpression para = multiy.Parameters[0];
            BinaryExpression body1 = multiy.Body as BinaryExpression;
            ParameterExpression left = body1.Left as ParameterExpression;
            ConstantExpression right = body1.Right as ConstantExpression;
 
            BlockExpression newBody = Expression.Block(Expression.Add(left,right));
            Expression<Func<int,int>> lambdaExpression = Expression.Lambda<Func<int,int>>(newBody,para);
            var gg = lambdaExpression.Compile()(3);

            int result = multiy.Compile()(3);