static void bst_GetAllBooksCompleted(object sender, WS.GetAllBooksCompletedEventArgs e)
 {
     foreach (var book in e.Result)
     {
         Console.WriteLine("{0}\t{1}",book.BookName,book.BookPrice);
     };
 }

    public bool Logout(string pSession)
    {

        try
        {
            WS ws = new WS();
            return ws.Logout(pSession);
        }
        catch (Exception ex)
        {
            hzyMessage.ErrorMessage = ex.Message;
            HZY.COM.Common.Log.WirteLogWS(ex, "");
            return false;
        }
    }

    public string Login(string pAppName, string pCompany, string pEnv, string pLoginEnv, string pUserName, string pPassword)
    {

        hzyMessage = new HZYmessage();
        try
        {
            WS ws = new WS();
            return ws.Login(pEnv, pLoginEnv, pUserName, pPassword);
        }
        catch (Exception ex)
        {
            hzyMessage.ErrorMessage = ex.Message;
            HZY.COM.Common.Log.WirteLogWS(ex,"");
            return "";
        }
    }

        public MessageWindow(CS classStyle, WS style, WS_EX exStyle, Rect location, string name, WndProc callback)
        {
            // A null callback means just use DefWindowProc.
            _wndProcCallback = callback;
            _className = "MessageWindowClass+" + Guid.NewGuid().ToString();

            var wc = new WNDCLASSEX
            {
                cbSize = Marshal.SizeOf(typeof(WNDCLASSEX)),
                style = classStyle,
                lpfnWndProc = s_WndProc,
                hInstance = NativeMethods.GetModuleHandle(null),
                hbrBackground = NativeMethods.GetStockObject(StockObject.NULL_BRUSH),
                lpszMenuName = "",
                lpszClassName = _className,
            };

            NativeMethods.RegisterClassEx(ref wc);

            GCHandle gcHandle = default(GCHandle);
            try
            {
                gcHandle = GCHandle.Alloc(this);
                IntPtr pinnedThisPtr = (IntPtr)gcHandle;

                Handle = NativeMethods.CreateWindowEx(
                    exStyle,
                    _className,
                    name,
                    style,
                    (int)location.X,
                    (int)location.Y,
                    (int)location.Width,
                    (int)location.Height,
                    IntPtr.Zero,
                    IntPtr.Zero,
                    IntPtr.Zero,
                    pinnedThisPtr);
            }
            finally
            {
                gcHandle.Free();
            }
            
            _dispatcher = Dispatcher.CurrentDispatcher;
        }

        public void LookupAllExplicit()
        {
            var x = new WS();
            var y = new DbW();
            var z = new DbR();
            var w = new UI();

            var needs = new Needs();
            needs.Set<IWebService>(x);
            needs.Set<IDatabaseCommand>(y);
            needs.Set<IDatabaseQuery>(z);
            needs.Set<IUserInterface>(w);

            Expect.Some(z, needs.Get<IDatabaseQuery>());
            Expect.Some(y, needs.Get<IDatabaseCommand>());
            Expect.Some(w, needs.Get<IUserInterface>());
            Expect.Some(x, needs.Get<IWebService>());
        }

    private void Check()
    {

        string strSession_ID, strMenuID;
        string strReturn = "";
        strSession_ID = Request["SessionID"];
        strMenuID = Request["MenuID"];

        if (strSession_ID == null || strSession_ID == "")
        {
            strReturn = "缺少参数：SessionID";

        }
        else if (strMenuID == null || strMenuID == "")
        {
            strReturn = "缺少参数：MenuID";

        }
        else
        {

            System.Threading.Thread.Sleep(5000);

            WS ws = new WS();
            strReturn = ws.CheckUser_Authorization(strSession_ID, strMenuID, "", "");
        }

        if (Request["jsoncallback"] != null)
        {
            Response.Write(Request["jsoncallback"]);
        }
        //Response.Write("({\"msg\":\""+strReturn+"\"})");
        Response.Write("var msg={msg:\"" + strReturn + "\"};");
        //Response.Write(strReturn);
        //Response.Write("var ojb = {msg:'js跨域请求成功'};");
        Response.End();
    }

        /// <summary>Add and remove a native WindowStyle from the HWND.</summary>
        /// <param name="removeStyle">The styles to be removed.  These can be bitwise combined.</param>
        /// <param name="addStyle">The styles to be added.  These can be bitwise combined.</param>
        /// <returns>Whether the styles of the HWND were modified as a result of this call.</returns>
        private bool _ModifyStyle(WS removeStyle, WS addStyle)
        {
            Assert.IsNotDefault(_hwnd);
            var dwStyle = (WS)NativeMethods.GetWindowLongPtr(_hwnd, GWL.STYLE).ToInt32();
            var dwNewStyle = (dwStyle & ~removeStyle) | addStyle;
            if (dwStyle == dwNewStyle)
            {
                return false;
            }

            NativeMethods.SetWindowLongPtr(_hwnd, GWL.STYLE, new IntPtr((int)dwNewStyle));
            return true;
        }

        public static bool _ModifyStyle(this IntPtr _hwnd, WS removeStyle, WS addStyle)
        {
            var dwStyle = GetWindowLong(_hwnd, GWL.STYLE);

            var dwNewStyle = (dwStyle & ~removeStyle) | addStyle;
            if (dwStyle == dwNewStyle)
            {
                return false;
            }

            SetWindowLong(_hwnd, GWL.STYLE, dwNewStyle);
            return true;
        }

 internal static extern int SetWindowLong(IntPtr hWnd, GWL nIndex, WS dwNewLong);

 public static WS SetWindowLong(this IntPtr hWnd, WS dwNewLong)
 {
     return (WS) SetWindowLong(hWnd, (int) GWL.STYLE, (int) dwNewLong);
 }

 private static extern bool _AdjustWindowRectEx(ref RECT lpRect, WS dwStyle, [MarshalAs(UnmanagedType.Bool)] bool bMenu, WS_EX dwExStyle);

        public static RECT AdjustWindowRectEx(RECT lpRect, WS dwStyle, bool bMenu, WS_EX dwExStyle)
        {
            // Native version modifies the parameter in place.
            if (!_AdjustWindowRectEx(ref lpRect, dwStyle, bMenu, dwExStyle))
            {
                HRESULT.ThrowLastError();
            }

            return lpRect;
        }

 public static extern HWND CreateWindowEx(WS_EX dwExStyle, string lpClassName, string lpWindowName, WS dwStyle, int x, int y, int nWidth, int nHeight, HWND hWndParent, IntPtr hMenu, IntPtr hInstance, IntPtr lpParam);

 public static extern bool AdjustWindowRectEx(ref RECT lpRect, WS style, bool bMenu, WS_EX exStyle);

 /// <summary>
 ///
 /// </summary>
 /// <param name="hwnd"></param>
 /// <param name="value"></param>
 public static void SetWindowStyle(IntPtr hwnd, WS value)
 {
     NativeMethods.SetWindowLong(hwnd, GWL.STYLE, (int)value);
 }

        public static StrongHWND CreateWindowEx(WS_EX dwExStyle, string lpClassName, string lpWindowName, WS dwStyle, int x, int y, int nWidth, int nHeight, HWND hWndParent, IntPtr hMenu, IntPtr hInstance, IntPtr lpParam)
        {
            HWND hwnd = NativeMethods.CreateWindowEx(dwExStyle, lpClassName, lpWindowName, dwStyle, x, y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam);

            return new StrongHWND(hwnd.DangerousGetHandle());
        }

 internal static bool xModifyHwndStyle(IntPtr hwnd, WS removeStyle, WS addStyle)
 {
     WS ws = (WS)GetWindowLongPtr(hwnd, GWL.STYLE).ToInt32();
     WS ws2 = (ws & ~removeStyle) | addStyle;
     if (ws == ws2)
     {
         return false;
     }
     SetWindowLongPtr(hwnd, GWL.STYLE, new IntPtr((int)ws2));
     return true;
 }

        private bool _ModifyStyle(WS removeStyle, WS addStyle)
        {
            Assert.IsNotDefault(_hwnd);
            var intPtr = NativeMethods.GetWindowLongPtr(_hwnd, GWL.STYLE);
            var dwStyle = (WS)(Environment.Is64BitProcess ? intPtr.ToInt64() : intPtr.ToInt32());
            var dwNewStyle = (dwStyle & ~removeStyle) | addStyle;
            if (dwStyle == dwNewStyle)
            {
                return false;
            }

            NativeMethods.SetWindowLongPtr(_hwnd, GWL.STYLE, new IntPtr((int)dwNewStyle));
            return true;
        }

        public static IntPtr CreateWindowEx(
            WS_EX dwExStyle,
            string lpClassName,
            string lpWindowName,
            WS dwStyle,
            int x,
            int y,
            int nWidth,
            int nHeight,
            IntPtr hWndParent,
            IntPtr hMenu,
            IntPtr hInstance,
            IntPtr lpParam)
        {
            IntPtr ret = _CreateWindowEx(dwExStyle, lpClassName, lpWindowName, dwStyle, x, y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam);
            if (IntPtr.Zero == ret)
            {
                HRESULT.ThrowLastError();
            }

            return ret;
        }

 public static extern IntPtr CreateWindowEx(int dwExStyle, string lpClassName, string lpWindowName, WS style,
     int x, int y, int width, int height, IntPtr hwndParent,
     IntPtr hmenu, IntPtr hInstance, IntPtr lpParam);