C# PhpCallback.Bind方法代码示例

		public static bool CreateClrThread(ScriptContext/*!*/context, PhpCallback/*!*/ callback, params object[] args)
		{
			if (callback == null)
				PhpException.ArgumentNull("callback");

			if (!callback.Bind())
				return false;

			object[] copies = (args != null) ? new object[args.Length] : ArrayUtils.EmptyObjects;

			for (int i = 0; i < copies.Length; i++)
				copies[i] = PhpVariable.DeepCopy(args[i]);

            return ThreadPool.QueueUserWorkItem(new Worker(context, copies).Run, callback);
		}

		private object InvokeFunctionCore(string name, params object[] args)
		{
			// check whether this function is allowed to be called
			PhpCallback callback;
			if (allFunctionsRegistered)
			{
				registeredFunctions.TryGetValue(name, out callback);
			}
			else
			{
				if (registeredFunctions.TryGetValue(name, out callback))
				{
					PhpException.Throw(PhpError.Warning, String.Format(Resources.HandlerNotAllowed, name));
					return null;
				}
			}

			// if the callback does not already exists, create it
			if (callback == null)
			{
				// parse name
				int index = name.IndexOf("::");
				switch (index)
				{
					case -1: callback = new PhpCallback(name); break;
					case 0: callback = new PhpCallback(name.Substring(2)); break;
					default: callback = new PhpCallback(name.Substring(0, index), name.Substring(index + 2)); break;
				}

				if (!callback.Bind()) return null;

				registeredFunctions[name] = callback;
			}

			// convert arguments
			for (int i = 0; i < args.Length; i++) args[i] = XsltConvertor.DotNetToPhp(args[i]);

			// invoke!
			return callback.Invoke(args);
		}

		public static bool Start(PhpCallback filter, int chunkSize, bool erase)
		{
			if (chunkSize != 0)
				PhpException.ArgumentValueNotSupported("chunkSize", "!= 0");
			if (!erase)
				PhpException.ArgumentValueNotSupported("erase", erase);

			ScriptContext context = ScriptContext.CurrentContext;

			context.BufferedOutput.IncreaseLevel();

			bool result = true;

			// skips filter setting if filter is not specified or valid:
			if (filter != null && (result = filter.Bind()))
				context.BufferedOutput.SetFilter(filter);

			context.IsOutputBuffered = true;
			return result;
		}

        public static bool Register(NamingContext namingContext, DTypeDesc caller, PhpCallback autoloadFunction, bool throwError, bool prepend)
        {
            if (autoloadFunction == null)
            {
                PhpException.ArgumentNull("autoloadFunction");
                return false;
            }

            if (autoloadFunction.Bind(!throwError, caller, namingContext))
            {
                var context = ScriptContext.CurrentContext;
                if (FindAutoloadFunction(context, autoloadFunction.ToPhpRepresentation()) != null)
                    return false;
                
                if (prepend)
                    context.SplAutoloadFunctions.AddFirst(autoloadFunction);
                else
                    context.SplAutoloadFunctions.AddLast(autoloadFunction);

                return true;
            }
            else
            {
                return false;
            }
        }

        ///// <summary>
        ///// Invoked from <c>ExtManager</c> in order to call a (user or system) function. See <c>call_user_function</c>,
        ///// <c>call_user_function_ex</c>, <c>zend_call_function</c> Zend API.
        ///// </summary>
        ///// <param name="target">Designation of the function/method to call.</param>
        ///// <param name="args">Arguments to be passed to the function.</param>
        ///// <returns>Return value of the function.</returns>
        ///// <remarks>
        ///// <p>
        ///// Obsolete: The reason why self is <c>ref</c> is that we need Remoting to
        ///// serialize and transfer the new state of the instance back to the caller.
        ///// </p>
        ///// <p>
        ///// The state is not transferred at all for user-classes (that are usually used for callbacks).
        ///// </p>
        ///// </remarks>
        //public object CallFunction(PhpCallback target, ref object[] args)
        //{
        //    this.callbackTarget = target;
        //    this.callbackArgs = args;

        //    callbackInvoked.Set();
        //    callbackHandled.WaitOne();

        //    return this.callbackRetValue;
        //}

		/// <summary>
		/// Checks whether the function/method designated by <paramref name="callback"/> is callable.
		/// </summary>
		/// <param name="callback">The callback.</param>
		/// <returns><B>true</B> if the <paramref name="callback"/> is callable, <B>false</B> otherwise.
		/// </returns>
		public static bool CheckCallbackDirect(PhpCallback callback)
		{
			return callback.Bind(true);
		}