public void Remove(LuaState luaState)
        {
            if (!translators.ContainsKey (luaState))
                return;

            translators.Remove (luaState);
        }

        public ObjectTranslator Find(LuaState luaState)
        {
            if (!translators.ContainsKey(luaState))
                return null;

            return translators [luaState];
        }

        public ObjectTranslator Find(LuaState luaState)
        {
            if (translators.ContainsKey (luaState))
                return translators [luaState];

            LuaState main = LuaCore.LuaNetGetMainState (luaState);

            if (translators.ContainsKey (main))
                return translators [main];

            return null;
        }

        /*
         * Calls the method. Receives the arguments from the Lua stack
         * and returns values in it.
         */
        int Call(LuaState luaState)
        {
            var methodToCall = _Method;
            object targetObject = _Target;
            bool failedCall = true;
            int nReturnValues = 0;

            if (!LuaLib.LuaCheckStack (luaState, 5))
                throw new LuaException ("Lua stack overflow");

            bool isStatic = (_BindingType & BindingFlags.Static) == BindingFlags.Static;
            SetPendingException (null);

            if (methodToCall == null) { // Method from name
                if (isStatic)
                    targetObject = null;
                else
                    targetObject = _ExtractTarget (luaState, 1);

                if (_LastCalledMethod.cachedMethod != null) { // Cached?
                    int numStackToSkip = isStatic ? 0 : 1; // If this is an instance invoe we will have an extra arg on the stack for the targetObject
                    int numArgsPassed = LuaLib.LuaGetTop (luaState) - numStackToSkip;
                    MethodBase method = _LastCalledMethod.cachedMethod;

                    if (numArgsPassed == _LastCalledMethod.argTypes.Length) { // No. of args match?
                        if (!LuaLib.LuaCheckStack (luaState, _LastCalledMethod.outList.Length + 6))
                            throw new LuaException ("Lua stack overflow");

                        object [] args = _LastCalledMethod.args;

                        try {
                            for (int i = 0; i < _LastCalledMethod.argTypes.Length; i++) {

                                MethodArgs type = _LastCalledMethod.argTypes [i];

                                int index = i + 1 + numStackToSkip;

                                Func<int, object> valueExtractor = (currentParam) => {
                                    return type.extractValue (luaState, currentParam);
                                };

                                if (_LastCalledMethod.argTypes [i].isParamsArray) {
                                    int count = index - _LastCalledMethod.argTypes.Length;
                                    Array paramArray = _Translator.TableToArray (valueExtractor, type.paramsArrayType, index, count);
                                    args [_LastCalledMethod.argTypes [i].index] = paramArray;
                                } else {
                                    args [type.index] = valueExtractor (index);
                                }

                                if (_LastCalledMethod.args [_LastCalledMethod.argTypes [i].index] == null &&
                                    !LuaLib.LuaIsNil (luaState, i + 1 + numStackToSkip))
                                    throw new LuaException (string.Format("argument number {0} is invalid",(i + 1)));
                            }

                            if ((_BindingType & BindingFlags.Static) == BindingFlags.Static)
                                _Translator.Push (luaState, method.Invoke (null, _LastCalledMethod.args));
                            else {
                                if (method.IsConstructor)
                                    _Translator.Push (luaState, ((ConstructorInfo)method).Invoke (_LastCalledMethod.args));
                                else
                                    _Translator.Push (luaState, method.Invoke (targetObject, _LastCalledMethod.args));
                            }

                            failedCall = false;
                        } catch (TargetInvocationException e) {
                            // Failure of method invocation
                            return SetPendingException (e.GetBaseException ());
                        } catch (Exception e) {
                            if (_Members.Length == 1) // Is the method overloaded?
                                // No, throw error
                                return SetPendingException (e);
                        }
                    }
                }

                // Cache miss
                if (failedCall) {
                    // System.Diagnostics.Debug.WriteLine("cache miss on " + methodName);
                    // If we are running an instance variable, we can now pop the targetObject from the stack
                    if (!isStatic) {
                        if (targetObject == null) {
                            _Translator.ThrowError (luaState, String.Format ("instance method '{0}' requires a non null target object", _MethodName));
                            LuaLib.LuaPushNil (luaState);
                            return 1;
                        }

                        LuaLib.LuaRemove (luaState, 1); // Pops the receiver
                    }

                    bool hasMatch = false;
                    string candidateName = null;

                    foreach (var member in _Members) {
                        candidateName = member.ReflectedType.Name + "." + member.Name;
                        var m = (MethodInfo)member;
                        bool isMethod = _Translator.MatchParameters (luaState, m, ref _LastCalledMethod);
//.........这里部分代码省略.........

 /*
  * Pushes this table into the Lua stack
  */
 internal void Push(LuaState luaState)
 {
     LuaLib.LuaGetRef (luaState, _Reference);
 }

 public static void LuaGetField(LuaState luaState, int stackPos, string meta)
 {
     LuaCore.LuaGetField (luaState, stackPos, meta);
 }

 public static void LuaError(LuaState luaState)
 {
     LuaCore.LuaError (luaState);
 }

 public static void LuaCreateTable(LuaState luaState, int narr, int nrec)
 {
     LuaCore.LuaCreateTable (luaState, narr, nrec);
 }

 public static void LuaCall(LuaState luaState, int nArgs, int nResults)
 {
     LuaCore.LuaCall (luaState, nArgs, nResults);
 }

 public static void LuaSetTop(LuaState luaState, int newTop)
 {
     LuaCore.LuaSetTop (luaState, newTop);
 }

 public static void LuaSetTable(LuaState luaState, int index)
 {
     LuaCore.LuaSetTable (luaState, index);
 }

 public static void LuaSetMetatable(LuaState luaState, int objIndex)
 {
     LuaCore.LuaSetMetatable (luaState, objIndex);
 }

 public static void LuaReplace(LuaState luaState, int index)
 {
     LuaCore.LuaReplace (luaState, index);
 }

 public static int LuaRef(LuaState luaState, int lockRef)
 {
     return lockRef != 0 ? LuaLRef (luaState, (int)LuaIndexes.Registry) : 0;
 }

 public static void LuaRawSetI(LuaState luaState, int tableIndex, int index)
 {
     LuaCore.LuaRawSetI (luaState, tableIndex, index);
 }

 public static void LuaUnref(LuaState luaState, int reference)
 {
     LuaCore.LuaLUnref (luaState, (int)LuaIndexes.Registry, reference);
 }

 public static void LuaAtPanic(LuaState luaState, LuaNativeFunction panicf)
 {
     LuaCore.LuaAtPanic (luaState, (LuaNativeFunction)panicf);
 }

 public static bool LuaToBoolean(LuaState luaState, int index)
 {
     return LuaCore.LuaToBoolean (luaState, index) != 0;
 }

 public static bool LuaCheckStack(LuaState luaState, int extra)
 {
     return LuaCore.LuaCheckStack (luaState, extra) != 0;
 }

 public static LuaNativeFunction LuaToCFunction(LuaState luaState, int index)
 {
     return LuaCore.LuaToCFunction (luaState, index);
 }