C# MulticastDelegate.DynamicInvoke方法代码示例

        static public void CallEvent(string objMgPath, string eventName, MulticastDelegate delgt, params object[] eventParams)
        {
            try
            {
                delgt.DynamicInvoke(eventParams);
                if (!PurviewMgr.IsMainHost)
                {
                    object[] newparams = new object[eventParams.Length];

                    for (int i = 0; i < eventParams.Length; i++)
                    {
                        if (eventParams[i] is IGameObj)
                        {
                            newparams[i] = new GameObjSyncInfo(((IGameObj)eventParams[i]).MgPath);
                        }
                        else
                        {
                            newparams[i] = eventParams[i];
                        }

                    }

                    // 通过网络协议传递给主机
                    SyncCasheWriter.SubmitNewEvent(objMgPath, eventName, newparams);
                }
            }
            catch (Exception ex)
            {
                Log.Write(ex.ToString());
            }
        }

 public override object Execute(MulticastDelegate dele, ParameterCollection parameters)
 {
     try
     {
         return dele.DynamicInvoke(parameters.AllParameterValues);
     }
     catch (Exception ex)
     {
         return this.ExecuteOnException(ex, parameters);
     }
 }

        public override object Execute(MulticastDelegate dele, ParameterCollection parameters)
        {
            try
            {
                return dele.DynamicInvoke(parameters.AllParameterValues);
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Black;
                Console.BackgroundColor = ConsoleColor.Red;

                Console.WriteLine(ex.Message);

                Console.ResetColor();

                throw;
            }
        }

        public override object Execute(MulticastDelegate dele, ParameterCollection parameters)
        {
            Console.ForegroundColor = ConsoleColor.Green;

            Console.WriteLine("Prefix: {0}", _prefix);
            Console.WriteLine("Suffix: {0}", _suffix);
            Console.WriteLine("Name: {0}", this.Name);

            if (_allTypes != null)
            {
                Console.WriteLine("All types: {0}", _allTypes);
            }

            Console.WriteLine("Intercepted {0}::{1}", dele.Target.GetType().FullName, dele.Method.Name);

            if (parameters.Dictionary.Count > 0)
            {
                Console.WriteLine("Args:");

                foreach (KeyValuePair<string, object> kvp in parameters.Dictionary)
                {
                    Console.WriteLine("  {0} -> {1}", kvp.Key, kvp.Value);
                }
            }

            Console.ResetColor();

            // invoke the intercepted method
            object result = dele.DynamicInvoke(parameters.AllParameterValues);

            Console.ForegroundColor = ConsoleColor.Green;

            if (dele.Method.ReturnType != typeof(void))
            {
                Console.WriteLine("Return:");
                Console.WriteLine("  {0}", result);
            }

            Console.ResetColor();

            return result;
        }

        public override object Execute(MulticastDelegate dele, ParameterCollection parameters)
        {
            object result = dele.DynamicInvoke(parameters.AllParameterValues);

            return this.ExecuteAfter(result, parameters);
        }

 protected void Emit(MulticastDelegate d, params object[] objs)
 {
     if(d != null)
         d.DynamicInvoke(objs);
 }

        /// <summary>Find integral using Lobatto Rule</summary>
        /// <param name="f">Function to integrate. Must be of the
        /// form y = f(x) where x and y are of type "double".</param>
        /// <param name="a">Lower bound of integral</param>
        /// <param name="b">Upper bound of integral</param>
        /// <returns>Area under funciton curve with an error of +- 1e-6</returns>
        /// 
        /// <remarks>
        /// Derived from "W. Gander and W. Gautschi: Adaptive Quadrature - 
        /// Revisited, BIT Vol. 40, No. 1, March 2000, pp. 84--101. CS technical 
        /// report: Report (gzipped, 82K). Programs: adaptsim.m, adaptlob.m", which
        /// can be found at: http://www.inf.ethz.ch/personal/gander/.
        /// 
        /// The defualt error of 1e-6 was chosen in order to give results
        /// comparible in speed and precision to Matlab R2009a.
        /// </remarks>
        public static double quadl(MulticastDelegate f, double a, double b)
        {
            double tol = 1e-6; // to have the same level of precision as Matlab
            // in the future, this could be an input?
            
            double m = (a + b) / 2.0;
            double h = (b - a) / 2.0;
            double alpha = Math.Sqrt(2.0 / 3.0);
            double beta = 1.0 / Math.Sqrt(5.0);

            double c1 = 0.942882415695480;
            double c2 = 0.641853342345781;
            double c3 = 0.236383199662150;

            double y1 = (double)f.DynamicInvoke(a),
                   y2 = (double)f.DynamicInvoke(m - c1 * h),
                   y3 = (double)f.DynamicInvoke(m - alpha * h),
                   y4 = (double)f.DynamicInvoke(m - c2 * h),
                   y5 = (double)f.DynamicInvoke(m - beta * h),
                   y6 = (double)f.DynamicInvoke(m - c3 * h),
                   y7 = (double)f.DynamicInvoke(m),
                   y8 = (double)f.DynamicInvoke(m + c3 * h),
                   y9 = (double)f.DynamicInvoke(m + beta * h),
                   y10= (double)f.DynamicInvoke(m + c2 * h),
                   y11= (double)f.DynamicInvoke(m + alpha * h),
                   y12= (double)f.DynamicInvoke(m + c1 * h),
                   y13= (double)f.DynamicInvoke(b);

            double fa = y1;
            double fb = y13;

            double i2 = (h / 6.0) * (y1 + y13 + 5 * (y5 + y9));
            double i1 = (h / 1470.0) * (77 * (y1 + y13) + 432 * (y3 + y11) + 625 * (y5 + y9) + 672 * y7);

            double i0 = h * (
                0.0158271919734802 * (y1 + y13) +
                0.0942738402188500 * (y2 + y12) +
                0.155071987336585 * (y3 + y11) +
                0.188821573960182 * (y4 + y10) +
                0.199773405226859 * (y5 + y9) +
                0.224926465333340 * (y6 + y8) +
                0.242611071901408 * y7);

            double s = (i0 >= 0) ? 1 : -1;

            double erri1 = Math.Abs(i1 - i0);
            double erri2 = Math.Abs(i2 - i0);

            double R = (erri2 == 0) ? 1 : erri1 / erri2;

            i0 = s * Math.Abs(i0) * tol / double.Epsilon;
            if (i0 == 0) i0 = b - a;

            return quadlStep(f, a, b, fa, fb, i0);
        }

        /// <summary>Recursive component of quadl</summary>
        /// <remarks>This funciton was also taken from Gander and Gautschi,
        /// http://www.inf.ethz.ch/personal/gander/ .</remarks>
        private static double quadlStep(MulticastDelegate f, double a, double b, double fa, double fb, double i0)
        {
            double h = (b - a) / 2.0;
            double m = (a + b) / 2.0;
            double alpha = Math.Sqrt(2.0 / 3.0);
            double beta = 1.0 / Math.Sqrt(5.0);

            double mll = m - alpha * h;
            double ml = m - beta * h;
            double mr = m + beta * h;
            double mrr = m + alpha * h;

            double fmll = (double)f.DynamicInvoke(mll),
                   fml  = (double)f.DynamicInvoke(ml),
                   fm   = (double)f.DynamicInvoke(m),
                   fmr  = (double)f.DynamicInvoke(mr),
                   fmrr = (double)f.DynamicInvoke(mrr);

            double i2 = (h / 6.0) * (fa + fb + 5 * (fml + fmr));
            double i1 = (h / 1470.0) * (77 * (fa + fb) + 432 * (fmll + fmrr) + 625 * (fml + fmr) + 672 * fm);

            if ((i0 + (i1 - i2) == i0) || (mll <= a) || (b <= mrr))
            {
                return i1;
            }
            else
            {
                return quadlStep(f, a, mll, fa, fmll, i0) +
                       quadlStep(f, mll, ml, fmll, fml, i0) +
                       quadlStep(f, ml, m, fml, fm, i0) +
                       quadlStep(f, m, mr, fm, fmr, i0) +
                       quadlStep(f, mr, mrr, fmr, fmrr, i0) +
                       quadlStep(f, mrr, b, fmrr, fb, i0);
            }
        }

        public override object Execute(MulticastDelegate dele, ParameterCollection parameters)
        {
            this.ExecuteBefore(parameters);

            return dele.DynamicInvoke(parameters.AllParameterValues);
        }