public static void RegisterLogicMsg(this IMsgReceiver self, string msgName,VoidDelegate.WithParams callback,QMsgChannel channel = QMsgChannel.Global)
        {
            if (CheckStrNullOrEmpty (msgName)||CheckDelegateNull(callback)) {
                return;
            }

            // 添加消息通道
            if (!mMsgHandlerDict.ContainsKey (channel)) {
                mMsgHandlerDict [channel] = new Dictionary<string, List<QMsgHandler>> ();
            }

            // 略过
            if (!mMsgHandlerDict[channel].ContainsKey (msgName)) {
                mMsgHandlerDict[channel] [msgName] = new List<QMsgHandler> ();
            }

            // 看下这里
            var handlers = mMsgHandlerDict [channel][msgName];

            // 略过
            // 防止重复注册
            foreach (var handler in handlers) {
                if (handler.receiver == self && handler.callback == callback) {
                    Debug.LogWarning ("RegisterMsg:" + msgName + " ayready Register");
                    return;
                }
            }

            // 再看下这里
            handlers.Add (new QMsgHandler (self, callback));
        }

        public static void OnClick(this Transform trans,VoidDelegate.WithGo callback)
        {
            QFramework.UI.UGUIEventListener.Get (trans.gameObject);

            var listener = QFramework.UI.UGUIEventListener.CheckAndAddListener (trans.gameObject);
            listener.onClick += callback;
        }

	public static GoTween MakeTween(
		Transform TheTransform, 
		Vector3 Position, 
		Quaternion Rotation, 
		float MoveTime = 0.5f, 
		bool IsLocal = false, 
		GoEaseType Ease = GoEaseType.Linear,
		VoidDelegate OnCompleteFunction = null
		)
	{
		GoTweenConfig Config = new GoTweenConfig();
		Config.addTweenProperty(new PositionTweenProperty(Position, false, IsLocal));
		//Config.addTweenProperty(new EulerAnglesTweenProperty(Rotation, false, IsLocal));
		Config.addTweenProperty(new RotationQuaternionTweenProperty(Rotation, false, IsLocal));
		Config.setEaseType(Ease);
		if(OnCompleteFunction != null){
			Config.onComplete(c => {
				OnCompleteFunction();
			});
		}
		GoTween NewTween = new GoTween(TheTransform, MoveTime, Config);
		Go.addTween(NewTween);
		
		return NewTween;
	}

 public static Vector2 ScrollView(Vector2 scrollPosition, VoidDelegate callback)
 {
     var newScrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);
     callback();
     EditorGUILayout.EndScrollView();
     return newScrollPosition;
 }

        public static void OnClick(this GameObject go,VoidDelegate.WithGo callback)
        {
            QFramework.UI.UGUIEventListener.Get (go);

            var listener = QFramework.UI.UGUIEventListener.CheckAndAddListener (go);
            listener.onClick += callback;
        }

 public static void InvokeIfRequired(Control c, VoidDelegate d)
 {
     if (c.InvokeRequired)
         c.Invoke(d);
     else
         d.Invoke();
 }

        public void Move(int numNodes, VoidDelegate callback)
        {
            _nodesLeft = numNodes;
            _callback = callback;

            StartMoving();
        }

 private bool Init(UnityEngine.Object obj, EditorFeatures requirements)
 {
     this.editor = Editor.CreateEditor(obj);
     if (this.editor == null)
     {
         return false;
     }
     if (((requirements & EditorFeatures.PreviewGUI) > EditorFeatures.None) && !this.editor.HasPreviewGUI())
     {
         return false;
     }
     MethodInfo method = this.editor.GetType().GetMethod("OnSceneDrag", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
     if (method != null)
     {
         this.OnSceneDrag = (VoidDelegate) Delegate.CreateDelegate(typeof(VoidDelegate), this.editor, method);
     }
     else
     {
         if ((requirements & EditorFeatures.OnSceneDrag) > EditorFeatures.None)
         {
             return false;
         }
         this.OnSceneDrag = new VoidDelegate(this.DefaultOnSceneDrag);
     }
     return true;
 }

        /// <summary>
        /// Executes NASM on the output file. It is assumed the output file now exists.
        /// </summary>
        /// <param name="inputFilePath">Path to the ASM file to process.</param>
        /// <param name="outputFilePath">Path to output the object file to.</param>
        /// <param name="OnComplete">Handler to call once NASM has completed. Default: null.</param>
        /// <param name="state">The state object to use when calling the OnComplete handler. Default: null.</param>
        /// <returns>True if execution completed successfully. Otherwise false.</returns>
        public override bool ExecuteAssemblyCodeCompiler(string inputFilePath, string outputFilePath, VoidDelegate OnComplete = null, object state = null)
        {
            bool OK = true;

            //Compile the .ASM file to .BIN file
            string ToolPath = Path.Combine(Options.ToolsPath, @"MIPS\mips-linux-gnu-as.exe");
            //Delete an existing output file so we start from scratch
            if (File.Exists(outputFilePath))
            {
                File.Delete(outputFilePath);
            }
            if (!File.Exists(inputFilePath))
            {
                throw new NullReferenceException("ASM file does not exist! Path: \"" + inputFilePath + "\"");
            }

            string inputCommand = String.Format("-mips32 -Os -EL -o \"{1}\" \"{2}\"",
                                                  "elf",
                                                  outputFilePath,
                                                  inputFilePath,
                                                  "ELF");

            //Logger.LogMessage(inputFilePath, 0, inputCommand);

            OK = Utilities.ExecuteProcess(Path.GetDirectoryName(outputFilePath), ToolPath, inputCommand, "MIPS:GCC",
                                                  false,
                                                  null,
                                                  OnComplete,
                                                  state);

            return OK;
        }

        public static void OnClick(this MonoBehaviour behaviour,VoidDelegate.WithGo callback)
        {
            QFramework.UI.UGUIEventListener.Get (behaviour.gameObject);

            var listener = QFramework.UI.UGUIEventListener.CheckAndAddListener (behaviour.gameObject);
            listener.onClick += callback;
        }

    public static int Main()
    {
        RunGetFncSecTest();

        int retVal = 100;
        VoidDelegate md = new VoidDelegate(FunctionPtr.Method);
        Console.WriteLine("\r\nTesting Marshal.GetFunctionPointerForDelegate().");

        try
        {
            Marshal.GetFunctionPointerForDelegate<Object>(null);
            retVal = 0;
            Console.WriteLine("Failure - did not receive an exception while passing null as the delegate");
        }
        catch (ArgumentNullException e)
        {
            Console.WriteLine("Pass - threw the right exception passing null as the delegate");
        }
        catch (Exception e)
        {
            retVal = 0;
            Console.WriteLine("Failure - receive an incorrect exception while passing null as the delegate");
            Console.WriteLine(e);
        }
        RunGetDelForFcnPtrTest();
        return retVal;
    }

 /// <summary>
 /// Black magic that lets us ignore issues where something is wrong 
 /// without surrounding every single line in a try-catch.
 /// <para>
 /// Don't try this at home folks.
 /// </para>
 /// Source: http://stackoverflow.com/questions/117173/c-try-catch-every-line-of-code-without-individual-try-catch-blocks
 /// </summary>
 public static void Try(VoidDelegate v)
 {
     try
     {
         v();
     }
     catch { }
 }

 public LogBrowser()
 {
     closeDelegate = new VoidDelegate(this.Close);
      InitializeComponent();
      sqLiteConnection.Open();
      logDataAdapter.Fill(logDataSet);
      serversDataAdapter.Fill(serverDataSet);
 }

 public static bool Foldout(bool toggle, GUIContent label, VoidDelegate callback)
 {
     var rect = GUILayoutUtility.GetRect(new GUIContent("\t" + label.text), GUIStyle.none);
     bool result = EditorGUI.Foldout(rect, toggle, label, true);
     if (result)
         callback();
     return result;
 }

 // Token: 0x060024FA RID: 9466
 // RVA: 0x0001CDB8 File Offset: 0x0001AFB8
 public Class523(VoidDelegate voidDelegate_1, Delegate2 delegate2_1)
     : base(false)
 {
     Class115.bool_31 = true;
     this.voidDelegate_0 = voidDelegate_1;
     this.delegate2_0 = delegate2_1;
     this.thread_0 = Class115.smethod_87(new VoidDelegate(this.method_0));
 }

        public SensorNetServer()
        {
            InitializeComponent();

             descriptionUpdater = new VoidDelegate(UpdateServerDescription);
             closeDelegate = new VoidDelegate(this.Close);

             log.Name = "log";
             log.LogMessage += new LogMessageEventHandler(log_LogMessage);
             log.Start();
             #region copy data files

             if (!Directory.Exists(Application.UserAppDataPath))
             {
            Directory.CreateDirectory(Application.UserAppDataPath );
             }
             if (!File.Exists(Application.UserAppDataPath + "\\" + SensorNetConfig.ServerDatabase))
             {
            File.Copy(Application.StartupPath + "\\" + SensorNetConfig.ServerDatabase,
               Application.UserAppDataPath + "\\" + SensorNetConfig.ServerDatabase);
             }
             database = DatabaseHelper.ConnectToSQL("Data Source=\"" + Application.UserAppDataPath +
            "\\" + SensorNetConfig.ServerDatabase + "\"");
             #endregion

             #region Regestry data setup

             RegistryKey registryKey = Registry.CurrentUser.CreateSubKey(SensorNetConfig.ConfigKeyName);

             bool createNewConfig = true;

             object regKey = registryKey.GetValue("ServerID");

             if (regKey != null)
             {
            Guid serverID = new Guid((string)regKey);
            CurrentServerData = DatabaseHelper.GetServerByID(database, serverID);
            if (CurrentServerData != null)
            {
               createNewConfig = false;
            }
             }

             if (createNewConfig)
             {
            // Show server config before starting server (which is automatically done when config box is closed)
            Bitmap serverPic = new Bitmap(Application.StartupPath + "/defaultImage.jpg");
            CurrentServerData = new ServerConfigData(Guid.Empty, "New Server", "Location", "Description", JpegImage.GetBytes(serverPic));
            configMenuItem_Click(this, new EventArgs());
             }
             else
             {
            //If config isn't needed, start now
            registryKey.Close();
            StartServer();
             }
             #endregion
        }

 public RunHelper(VoidDelegate start, VoidDelegate end, DebugDelegate deb, string name)
 {
     OnStart = start;
     OnEnd = end;
     Name = name;
     OnDebug = deb;
     bw.DoWork += new System.ComponentModel.DoWorkEventHandler(bw_DoWork);
     bw.WorkerReportsProgress = false;
 }

	public void MoveTo(Vector3 position, VoidDelegate onArrival = null) {
		Tween.toWithSpeed(transform.position, position, 3f, Tween.EaseType.easeInOutSine,
			(Tween tween) => { transform.position = (Vector3)tween.Value; }, 
			(Tween tween) => {
				if (onArrival != null)
					onArrival();
			}
		);
	}

 public static void DumpTime(VoidDelegate dv)
 {
     Stopwatch watch = new Stopwatch();
     watch.Reset();
     watch.Start();
     dv();
     watch.Stop();
     LogMgr.Log("Cost Time =  " + watch.ElapsedMilliseconds.ToString() + " ms");
     LogMgr.Log("Cost Time Span =  " + watch.Elapsed.ToString());
 }

    public void PushFunc(VoidDelegate func, int timeMS)
    {
        if(dictVoidFunc.ContainsKey(func))
        {
            Debug.LogWarning("void func is already exist...");
            return;
        }

        dictVoidFunc.Add(func, new VoidTimeParam(timeMS, func));
    }