static void main(string[] args)
        {
            Console.WriteLine("***** Simple Delegate Example*****\n");

            // instantiate an instance of "simpleMathClass" see above
            SimpleMath m = new SimpleMath();

            // so now lets add the add method of the instance of 'simpleMath' to it.
            // 'BinaryOp is a delegates that takes 2 ints as parameters and returns an int as a result.
            BinaryOp b = new BinaryOp(m.Add);



            //invoke Add() method directly using delegate object
            Console.WriteLine("Direct invocation... 10+10 is {0}", b(10, 10));
            Console.ReadLine();

            //invoke Add() method indirectly using delegate object
            Console.WriteLine("Indirect invocation,.... 10 + 10 is {0}", b.Invoke(10, 10));
            Console.ReadLine();

            // Change the target method on the fly
            b = new BinaryOp(m.Substract);
            Console.WriteLine("Replace add with subtract");
            Console.ReadLine();

            //invoke the substract method by direactly invoking that delegate
            Console.WriteLine("Direct invocation.... 15 - 5 is {0}", b(15, 5));
            Console.ReadLine();

        }

        static void Main(string[] args)
        {
            Console.WriteLine("***** Async Delegate Invocation *****");

            // Print out the ID of the executing thread.
            Console.WriteLine("Main() invoked on thread {0}.",
              Thread.CurrentThread.ManagedThreadId);

            BinaryOp b = new BinaryOp(Add);
            IAsyncResult iftAR = b.BeginInvoke(10, 10, null, null);

            // This message will keep printing until
            // the Add() method is finished.
            while (!iftAR.IsCompleted)
            {
                Console.WriteLine("Doing more work in Main()!");
                Thread.Sleep(1000);
            }

            // Now we know the Add() method is complete.
            int answer = b.EndInvoke(iftAR);

            Console.WriteLine("10 + 10 is {0}.", answer);
            Console.ReadLine();
        }

        static void Main(string[] args)
        {
            BinaryOp opCode = new BinaryOp(Add);
            Console.WriteLine("Threading!");
            Thread t = System.Threading.Thread.CurrentThread;
            Console.WriteLine(t.IsAlive);
            AppDomain ad = Thread.GetDomain();
            Console.WriteLine(ad.FriendlyName);
            System.Runtime.Remoting.Contexts.Context ctx = Thread.CurrentContext;

            Console.WriteLine("\nMain() thread id: {0}", Thread.CurrentThread.ManagedThreadId);
            //Console.WriteLine("waits till Add completes, delegate sum: {0}", opCode.Invoke(10, 30));
            //IAsyncResult iAsync = opCode.BeginInvoke(10, 50, null, null);
            //the called thread informs the primary thread that it hascompleted
            IAsyncResult iAsync = opCode.BeginInvoke(10, 50, new AsyncCallback(AddComplete), "author: naynish c");
            Console.WriteLine("Add called async");
            //keeps on asking if the call is complete
            Console.WriteLine("Check if Add is complete {0}", iAsync.IsCompleted);
            //waits for 200 milliseconds and asks if the call is complete
            iAsync.AsyncWaitHandle.WaitOne(200);
            Console.WriteLine("Check if Add is complete {0}", iAsync.IsCompleted);
            //Console.WriteLine("Sum: {0}", opCode.EndInvoke(iAsync));
            Console.WriteLine("Check if Add is complete {0}", iAsync.IsCompleted);
            ThreadProperties.Basics();
            Console.ReadLine();
        }

 public ExprBinary(Ctx ctx, BinaryOp op, TypeReference type, Expr left, Expr right)
     : base(ctx) {
     this.Op = op;
     this.type = type;
     this.Left = left;
     this.Right = right;
 }

        static void WaitCall()
        {
            Console.WriteLine("***** Async Delegate Review *****");
            // Print out the ID of the executing thread.
            Console.WriteLine("Main() invoked on thread {0}.",
            Thread.CurrentThread.ManagedThreadId);
            // Invoke Add() in a asynchronous manner.
            BinaryOp b = new BinaryOp(Add);

            IAsyncResult res = b.BeginInvoke(10, 10, null, null);

            //while (!res.IsCompleted)
            //{
            //    Console.WriteLine("Doing more work in Main()!");
            //    Thread.Sleep(1000);
            //}
            while (!res.AsyncWaitHandle.WaitOne(1000, true))
            {
                Console.WriteLine("Doing more work in Main()!");
            }

            //Obtain results from Add
            int answer = b.EndInvoke(res);
            Console.WriteLine("10 + 10 is {0}.", answer);
        }

 static void Main(string[] args)
 {
     Console.WriteLine("***** Async Delegate Invocation *****");
     Console.WriteLine("Main() invoked on thread {0}", Thread.CurrentThread.ManagedThreadId);
     BinaryOp b = new BinaryOp(Add);
     IAsyncResult iftAR = b.BeginInvoke(10, 10, new AsyncCallback(AddComplete), "Main() thanks you for adding these numbers.");
     // using the member method or property of IAsyncResult
     // involve in Async process.
     //while (!iftAR.IsCompleted)
     //{
     //    Console.WriteLine("Doing more work in Main()");
     //    Thread.Sleep(1000);
     //}
     //while (!iftAR.AsyncWaitHandle.WaitOne(1000, true))
     //{
     //    Console.WriteLine("Doing more work in Main()");
     //}
     while (!isDone)
     {
         Thread.Sleep(1500);
         Console.WriteLine("Woring more work in Main()");
     }
     // 让第二个线程通知访问线程，当第二个线程的工作完成时。
     // 向BeginInvoke中传入AsyncCallback delegate，在BeginInvoke的异步调用结束时，
     // AsyncCallback委托会访问一个特殊的方法。
     // AsyncCallback委托的原型：     public delegate void AsyncCallback(IAsyncResult ar);
     //int answer = b.EndInvoke(iftAR);
     //Console.WriteLine("10 + 10 is {0}", answer);
     Console.WriteLine("Async work is complete!!");
     Console.ReadLine();
 }

 public static void Main()
 {
     BinaryOp b = new BinaryOp(SimpleMath.Add);
     // b(10,5) �ϸ� �����δ� b.Invoke(15,5) �� ����
     Console.WriteLine("b(10,5) = {0}",b(10,5)); // = 15
     b = new BinaryOp(SimpleMath.Subtract);
     Console.WriteLine("b(10,5) = {0}", b(10,5)); // = 5
 }

        public BinaryExpression(AbstractExpression exp, BinaryOp op, string yVarName)
        {
            _xExp = exp;
            _yVarName = yVarName;

            _op = op;
            _scenario = Scenario.ExpVar;
        }

 //Fold arithmetic and bitwise operations
 public override void Visit(BinaryOp<int, TypedExpression<int>> node)
 {
     if (node.Left is Number && node.Right is Number) {
         Console.WriteLine("Folding {0} into {1}", node, node.TypedValue);
         int pos = node.Parent.ChildNodes.IndexOf(node);
         node.Parent[pos] = new Number(node.TypedValue);
     }
 }

        public void AddOperation()
        {
            var d = new BinaryOp(SimpleMath.Add); //static method
            //var d2 = new BinaryOp(SimpleMath.SquareNumber); // <-- compile-time error! it is type safe!

            DisplayDelegateInfo(d);
            Console.WriteLine("10 + 10 is {0}", d(10, 10));
            Console.WriteLine("10 + 10 is {0}", d.Invoke(10, 10)); // it is equivalent
        }

 private static void DelegateSync()
 {
     Console.WriteLine("***** Synch Delegate Review *****");
     Console.WriteLine("Main() invoked on thread {0}.", Thread.CurrentThread.ManagedThreadId);
     BinaryOp b = new BinaryOp(Add);
     int answer = b(10, 10);
     Console.WriteLine("Doing more work in Main()");
     Console.WriteLine("10 + 10 is {0}", answer);
     Console.ReadLine();
 }

		public static void Main (string[] args)
		{
			Console.WriteLine ("**Simple Delegate Example**\n");

			BinaryOp binary = new BinaryOp(SimpleMath.Add);// create BinaryOp delegate obj 'points to' SimpleMath.Add
			DisplayDelegateInfo(binary);
			//invoke Add()
			Console.WriteLine("10 + 10 = {0}", BinaryOp(10, 10));
			Console.ReadLine();
		}

        public static int Test_1() {
            var s = new BinaryOp(Substract);
            s += Summ;
            s += Substract;
            s += Summ;
            Console.WriteLine($"s(5,7) = {s(5, 7)}");
            s -= Summ;
            Console.WriteLine($"s(5,7) = {s(5, 7)}");

            return 0;
        }

        static void Main(string[] args)
        {
            Console.WriteLine("***** Simple Delegate Example *****\n");

            BinaryOp b = new BinaryOp(SimpleMath.Add);
            Console.WriteLine("10 + 10 is {0}", b(10, 10));

            DisplayDelegateInfo(b);

            Console.ReadLine();
        }

        static void Main(string[] args) {
            BinaryOp b = new BinaryOp(SimpleMath.Add);
            Console.WriteLine("10 + 10 is {0}", b(10,10));
            Console.WriteLine("10 + 10 is {0}", b.Invoke(10, 10));  //Also ok
            Console.WriteLine();
            DisplayDelegateInfo(b);

            SimpleMath m = new SimpleMath();
            BinaryOp bInst = new BinaryOp(m.Subtract);
            DisplayDelegateInfo(bInst);

            Console.ReadLine();
        }

        public BinaryOperation()
        {
            Console.WriteLine("***********Sync Delegate Review**********");
            ReadThread("Constructor Invoked");

            BinaryOp binOp = new BinaryOp(Addition);
            int x = 10;
            int y = 20;

            //UseBeginInvoke(binOp, x, y);
            //UseBasicCall(binOp, x, y);
            UseASyncCallBack(binOp, x, y);
        }

        static void Main(string[] args)
        {
            // Create a BinaryOp delegate object that "points to" Simple.Add().
            SimpleMath m = new SimpleMath();
            BinaryOp b = new BinaryOp(m.Add);

            // Invoke Add() method indirectly using delegate object.
            Console.WriteLine("10 + 10 is {0}", b(10,10));

            // Display the methods that the delegate is pointing to. And, display the classes defining those methods
            DisplayDeleateInfo(b);

            Console.ReadLine();
        }

 static void Main(string[] args)
 {
     AddSubtractTwoNumbers asm = new AddSubtractTwoNumbers();
     BinaryOp a = new BinaryOp(asm.AddMethod);
     a(10, 5);
     //BinaryOp b = new BinaryOp(asm.SubtractMethod);
     a += asm.SubtractMethod;
     a(10, 5);
     //Console.WriteLine("10 + 5 equals {0}", a(10,5));
     //Console.WriteLine("10 - 5 equals {0}", a(10, 5));
     //GetDelegateDetails(a);
     //Console.WriteLine();
     //GetDelegateDetails(a);
     Console.ReadKey();
 }

        static void Main(string[] args)
        {
            Console.WriteLine("***** Simple Delegate Example *****\n");

            // Create a BinaryOp delegate object that
            // "points to" SimpleMath.Add().
            SimpleMath m = new SimpleMath();
            BinaryOp b = new BinaryOp(m.Add);

            // Invoke Add() method indirectly using delegate object.
            Console.WriteLine("10 + 10 is {0}", b(10, 10));

            DisplayDelegateInfo(b);
            Console.ReadKey();
        }

        static void Main(string[] args) {
            Console.WriteLine("Async callback delegate");
            Console.WriteLine("Main invoked on thread {0}", Thread.CurrentThread.ManagedThreadId);

            BinaryOp b = new BinaryOp(Add);

            IAsyncResult iftAR = b.BeginInvoke(10, 10, new AsyncCallback(AddComplete), "custom state object");

            while (!isDone) {
                Thread.Sleep(1000);
                Console.WriteLine("-> Doing more work in main");
            }
            Console.WriteLine("Done...");
            Console.ReadLine();
        }