C# StatusCode类代码示例

        public void OnStatusChanged(StatusCode statusCode)
        {
            DebugReturn("OnStatusChanged():" + (StatusCode) statusCode);

            //handle returnCodes for connect, disconnect and errors (non-operations)
            switch ((StatusCode) statusCode)
            {
                case StatusCode.Connect:
                    this.DebugReturn("Connect(ed)");
                    this.peer.OpJoin(this.lobbyName); // The LobbyHandler simply joins the lobby to get updates from it
                    break;
                case StatusCode.Disconnect:
                    this.DebugReturn("Disconnect(ed) Peer.state: " + peer.PeerState);
                    break;
                case StatusCode.ExceptionOnConnect:
                    this.DebugReturn("ExceptionOnConnect(ed) Peer.state: " + peer.PeerState);
                    break;
                case StatusCode.Exception:
                    this.DebugReturn("Exception(ed) Peer.state: " + peer.PeerState);
                    break;
                default:
                    this.DebugReturn("OnStatusChanged: " + statusCode);
                    break;
            }
        }

        /// <summary>Initializes a new instance of the FormMain class.</summary>
        public FormMain(bool startLogging)
        {
            // This call is required by the designer
            InitializeComponent();

            // Initialize private variables
            p_CurrentIP = "-";
            p_CurrentStatus = StatusCode.None;
            p_ElapsedSeconds = 0;
            p_StartLogging = startLogging;
            p_StartupTime = DateTime.Now;
            p_TimerLog = null;

            // Initialize FormMain properties
            this.ClientSize = new Size(660, 480);
            this.Font = SystemFonts.MenuFont;

            // Initialize tray icon
            IconMain.ContextMenu = MenuMain;

            // Initialize Menu/ToolBar
            MenuShowSuccessful.Checked = Settings.Default.ShowSuccessful;
            MenuShowStatusChanges.Checked = Settings.Default.ShowStatusChanges;
            MenuShowErrors.Checked = Settings.Default.ShowErrors;
            ToolBarShowSuccessful.Pushed = MenuShowSuccessful.Checked;
            ToolBarShowStatusChanges.Pushed = MenuShowStatusChanges.Checked;
            ToolBarShowErrors.Pushed = MenuShowErrors.Checked;
        }

        public Response(StatusCode code, string contentType, string content, string redirectoinPath)
        {
          //  throw new NotImplementedException();
            // TODO: Add headlines (Content-Type, Content-Length,Date, [location if there is redirection])
            int content_length = content.Length;
            string content_length_string = content_length.ToString();
            DateTime date = DateTime.Now;
            string date_string = date.ToString();

            headerLines.Add("Content-Type"+ contentType);
            headerLines.Add("Content-Length"+ content_length_string);
            headerLines.Add("Date" + date_string);
            if (redirectoinPath!="")
            {
                headerLines.Add("Redirection Path" + redirectoinPath);
            }
            // TODO: Create the request string
            string status_line=GetStatusLine(code);
            string header_line = "";
            for (int i = 0; i < headerLines.Count; i++)
            {
                header_line += headerLines[i]+ " ";
            }
            //header_line += "\r\n";
            responseString = status_line + header_line + "\r\n" + content;

        }

 /// <summary>
 /// Sends error page to the client
 /// </summary>
 /// <param name="statusCode">Status code</param>
 /// <param name="message">Error message</param>
 public void SendError(StatusCode statusCode, string message)
 {
     string page = GetErrorPage(statusCode, message);
     SendHeader("text/html", page.Length, statusCode);
     SendToClient(page);
     End();
 }

 public void OnStatusChanged(StatusCode statusCode)
 {
     switch (statusCode)
     {
         case StatusCode.Connect:
             {
                 Peer.EstablishEncryption();
                 break;
             }
         case StatusCode.Disconnect:
         case StatusCode.DisconnectByServer:
         case StatusCode.DisconnectByServerLogic:
         case StatusCode.DisconnectByServerUserLimit:
         case StatusCode.TimeoutDisconnect:
         case StatusCode.Exception:
         case StatusCode.ExceptionOnConnect:
             {
                 Controller.OnDisconnected("" + statusCode);
                 State = new Disconnected(this);
                 break;
             }
         case StatusCode.EncryptionEstablished:
             {
                 State = new Connected(this);
                 break;
             }
         default:
             {
                 Controller.OnUnexpectedStatusCode(statusCode);
                 break;
             }
     }
 }

 public void OnStatusChanged(StatusCode statusCode)
 {
     Debug.Log("OnStatusChanged:" + statusCode.ToString());
     switch (statusCode)
     {
         case StatusCode.Connect:
             stopwatch.Stop();
             Debug.Log(string.Format("连线成功,耗时：{0}秒",stopwatch.Elapsed.TotalSeconds.ToString()));
             stopwatch.Reset();
             break;
         case StatusCode.Disconnect:
             Debug.Log("断线");
             break;
         case StatusCode.DisconnectByServerUserLimit:
             Debug.Log("人数达上线");
             break;
         case StatusCode.ExceptionOnConnect:
             Debug.Log("连线时意外错误");
             break;
         case StatusCode.DisconnectByServer:
             Debug.Log("被Server强制断线");
             break;
         case StatusCode.TimeoutDisconnect:
             Debug.Log("超时断线");
             break;
         case StatusCode.Exception:
         case StatusCode.ExceptionOnReceive:
             Debug.Log("其他例外");
             break;
     }
 }

 public void OnStatusChanged(StatusCode statusCode)
 {
     Debug.Log (statusCode.ToString ());
     switch (statusCode)
     {
     case StatusCode.Connect: 					// connect success
         Debug.Log("connect success");
         break;
     case StatusCode.Disconnect: 				// disconnected
         Debug.Log("disconnect from server");
         break;
     case StatusCode.DisconnectByServerUserLimit: //  limit on connected user
         Debug.Log ("room full");
         break;
     case StatusCode.ExceptionOnConnect:			//	error on connection
         Debug.Log("connection error");
         break;
     case StatusCode.DisconnectByServer:			// disconnected by server
         Debug.Log("disconnect by server");
         break;
     case StatusCode.TimeoutDisconnect:			// disconnected while timeout
         Debug.Log("time out");
         break;
     case StatusCode.Exception:					// other exception
     case StatusCode.ExceptionOnReceive:
         Debug.Log("unexpect error");
         break;
     }
 }

    public void OnPeerStatusCallback(Game game, StatusCode returnCode)
    {
        switch (returnCode)
        {
            case StatusCode.Connect:
                {
                    break;
                }

            case StatusCode.Disconnect:
            case StatusCode.DisconnectByServer:
            case StatusCode.DisconnectByServerLogic:
            case StatusCode.DisconnectByServerUserLimit:
            case StatusCode.TimeoutDisconnect:
                {
                    game.SetDisconnected(returnCode);
                    break;
                }

            default:
                {
                    game.DebugReturn(DebugLevel.ERROR, returnCode.ToString());
                    break;
                }
        }
    }

    private void Patrolling()
    {
        if (statusCode != StatusCode.Patrol)
        {
            statusCode = StatusCode.Patrol;
            nav.ResetPath();
        }
        nav.speed = patrolSpeed;

        if (nav.destination == lastPlayerSighting.resetPosition || nav.remainingDistance < nav.stoppingDistance)
        {
            patrolTimer += Time.deltaTime;

            if (patrolTimer > patrolWaitTime)
            {
                if (wayPointIndex == patrolWayPoints.Length - 1)
                {
                    wayPointIndex = 0;
                }
                else
                {
                    wayPointIndex++;
                }

                patrolTimer = 0f;
            }
        }
        else
        {
            patrolTimer = 0f;
        }

        nav.destination = patrolWayPoints[wayPointIndex].position;
    }

        /// <summary>
        /// The on peer status callback.
        /// </summary>
        /// <param name="game">
        /// The mmo game.
        /// </param>
        /// <param name="returnCode">
        /// The return code.
        /// </param>
        public void OnPeerStatusCallback(Game game, StatusCode returnCode)
        {
            switch (returnCode)
            {
                case StatusCode.Connect:
                    {
                        InterestArea camera;
                        game.TryGetCamera(0, out camera);
                        camera.ResetViewDistance();
                        game.Avatar.SetInterestAreaAttached(true);
                        game.SetConnected();

                        //Operations.Authenticate(game, game.Avatar.Token);
                        break;
                    }

                case StatusCode.Disconnect:
                case StatusCode.DisconnectByServer:
                case StatusCode.DisconnectByServerLogic:
                case StatusCode.DisconnectByServerUserLimit:
                case StatusCode.TimeoutDisconnect:
                    {
                        game.SetDisconnected(returnCode);
                        break;
                    }

                default:
                    {
                        game.DebugReturn(DebugLevel.ERROR, returnCode.ToString());
                        break;
                    }
            }
        }

    private void Chasing()
    {
        if (statusCode != StatusCode.Chasing)
        {
            statusCode = StatusCode.Chasing;
            nav.Resume();
        }
        Vector3 sightingPosDelta = enemySight.personalLastSighting - transform.position;
        if (sightingPosDelta.sqrMagnitude > 4f)
        {
            nav.destination = enemySight.personalLastSighting;
        }

        nav.speed = chaseSpeed;

        if (nav.remainingDistance < nav.stoppingDistance)
        {
            chaseTimer += Time.deltaTime;

            if (chaseTimer >= chaseWaitTime)
            {
                lastPlayerSighting.position = lastPlayerSighting.resetPosition;
                enemySight.personalLastSighting = lastPlayerSighting.resetPosition;
                chaseTimer = 0f;
            }
        }
        else
        {
            chaseTimer = 0f;
        }
    }

 /// <summary>
 /// ctor for product purchases
 /// </summary>
 public Receipt(Product product, StatusCode status, string storeReceipt)
 {
     PurchaseType = PurchaseType.Product;
     Product = product;
     Status = status;
     StoreReceipt = storeReceipt;
 }

        private void Execute()
        {
            if (Interlocked.Exchange(ref flag, 1) == 0)
            {
                System.Threading.Tasks.Task.Factory.StartNew(() =>
                 {
                     try
                     {

                         Status = StatusCode.Running;
                         Message = "Running";
                         if (initialize != null)
                             initialize();
                         Status = StatusCode.Success;
                         Message = "Success";

                     }
                     catch (Exception ex)
                     {
                         Thread.VolatileWrite(ref flag, 0);
                         Message = ex.ToString();
                         Status = StatusCode.Failure;
                     }
                 });
            }
        }

        public override void OnPeerStatusCallback(ClientConnection client, StatusCode returnCode)
        {
            switch (returnCode)
            {
                case StatusCode.DisconnectByServerUserLimit:
                case StatusCode.Disconnect:
                case StatusCode.DisconnectByServer:
                case StatusCode.DisconnectByServerLogic:
                case StatusCode.TimeoutDisconnect:
                    {
                        if (log.IsInfoEnabled)
                        {
                            log.InfoFormat("{0}", returnCode);
                        }

                        Counters.ConnectedClients.Decrement();
                        WindowsCounters.ConnectedClients.Decrement();

                        client.State = Disconnected.Instance;
                        client.OnDisconnected();
                        break;
                    }

                default:
                    {
                        log.WarnFormat("Connected: OnPeerStatusCallback: unexpected return code {0}", returnCode);
                        break;
                    }
            }
        }

 /// <summary>
 /// Creates a response to the specified request with the specified response code.
 /// The destination endpoint of the response is the source endpoint of the request.
 /// The response has the same token as the request.
 /// Type and ID are usually set automatically by the <see cref="CoAP.Stack.ReliabilityLayer"/>.
 /// </summary>
 public static Response CreateResponse(Request request, StatusCode code)
 {
     Response response = new Response(code);
     response.Destination = request.Source;
     response.Token = request.Token;
     return response;
 }