C# WebSocket类代码示例

    void Connect()
    {
        ws =  new WebSocket("ws://socket.nappers.jp:8888");

        // called when websocket messages come.
        ws.OnMessage += (sender, e) =>
        {
            string s = e.Data;
            Debug.Log(string.Format( "Receive {0}",s));
            messages.Add("> " + e.Data);
            if(messages.Count > 10){
                messages.RemoveAt(0);
            }
        };

        ws.OnError += (sender, e) =>
        {
            Debug.Log("OnError");
        };
        ws.OnClose += (sender, e) =>
        {
            Debug.Log("OnClose");

        };
        ws.OnOpen += (sender, e) =>
        {
            Debug.Log("OnOpen");

        };

        ws.Connect();
        Debug.Log("Connect to " + ws.Url);
    }

   internal HttpListenerWebSocketContext(
 HttpListenerContext context, Logger logger)
   {
       _context = context;
         _stream = WsStream.CreateServerStream (context);
         _websocket = new WebSocket (this, logger ?? new Logger ());
   }

        public override void SendCloseHandshake(WebSocket websocket, int statusCode, string closeReason)
        {
            int size = (string.IsNullOrEmpty(closeReason) ? 0 : Encoding.UTF8.GetMaxByteCount(closeReason.Length)) + 2;

            byte[] playloadData = new byte[size];

            int highByte = statusCode / 256;
            int lowByte = statusCode % 256;

            playloadData[0] = (byte)highByte;
            playloadData[1] = (byte)lowByte;

            // don't send close handshake now because the connection was closed already
            if (websocket.State == WebSocketState.Closed)
                return;

            if (!string.IsNullOrEmpty(closeReason))
            {
                int bytesCount = Encoding.UTF8.GetBytes(closeReason, 0, closeReason.Length, playloadData, 2);
                SendDataFragment(websocket, OpCode.Close, playloadData, 0, bytesCount + 2);
            }
            else
            {
                SendDataFragment(websocket, OpCode.Close, playloadData, 0, playloadData.Length);
            }
        }

    /// <summary>
    /// Start the Birb Client.
    /// </summary>
    /// <returns>Nothing right now.</returns>
    IEnumerator Start()
    {
        gameStateManager = GetComponent<GameStateManager>();
        Uri server = new Uri("ws://birb.herokuapp.com");
        Uri localhost = new Uri("ws://localhost:5000");
        socket = new WebSocket(server);
        callbacks = new Dictionary<BirbMessageCode, Callback>();
        yield return StartCoroutine(socket.Connect());
        int i = 0;

        // Testing
        //RunUnitTests();

        while (true)
        {
            string reply = socket.RecvString();
            if (reply != null)
            {
                Debug.Log("Received: " + reply);
                Process(reply);
            }
            if (socket.Error != null)
            {
                Debug.LogError("Error: " + socket.Error);
                break;
            }
            yield return 0;
        }
        socket.Close();
    }

    // -----------------------------------------------------------------
    /// <summary>
    ///
    /// </summary>
    void Connect()
    {
        ws = new WebSocket (WSAddress);

        ws.OnOpen += (sender, e) => {
            Debug.Log ("<color=lime>WebSocket Open</color>");
        };

        ws.OnMessage += (sender, e) => {

            lock (messageQueue.SyncRoot) {
                try {
                    messageQueue.Enqueue (e.Data.ToString ());
                } catch (System.Exception ex) {
                    Debug.Log (ex.ToString ());
                }
            }

            //Debug.Log ("<color=cyan>WebSocket Message Type: " + e.Type + ", Data: " + e.Data + "</color>");
        };

        ws.OnError += (sender, e) => {
            Debug.Log ("<color=red>WebSocket Error Message: " + e.Message + "</color>");
        };

        ws.OnClose += (sender, e) => {
            Debug.Log ("<color=orange>WebSocket Close</color>");
        };

        ws.Connect ();
    }

    void Connect()
    {
        //接続
        //ポートの指定はしなくても大丈夫だった。80で接続してるはず。
        ws =  new WebSocket(url);

        ws.OnOpen += (sender, e) => {
            //接続したら自分を制御用PCとしてサーバーに教える
            //SendSetPCMessage();
            print("Connected");
        };
        ws.OnMessage += (sender, e) => {
            string s = e.Data;
            //Debug.Log (s);
            Dictionary<string, object> dict = Json.Deserialize (s) as Dictionary<string, object>;
            //Debug.Log (dict["power"].GetType() );
            long val = (long)dict["power"];
            //Debug.Log ("val="+val);
            toColor = GetColor(val/divBy);

            value =  val/divBy;
        };
        ws.Connect();

        ws.OnClose += (sender, e) => {
            print("Closed");
        };

        ws.OnError += (sender, e) => {
            print("Error : " + e.Message);
        };
    }

        public override bool Connect()
        {
            //bool baseOk = base.Connect();
            //if (!baseOk)
            //{
            //    return false;
            //}


            State = PhotonSocketState.Connecting;

            if (websocketConnectionObject != null)
            {
                UnityEngine.Object.Destroy(websocketConnectionObject);
            }

            websocketConnectionObject = new GameObject("websocketConnectionObject");
            MonoBehaviour mb = websocketConnectionObject.AddComponent<MonoBehaviour>();
            // TODO: not hidden for debug
            //websocketConnectionObject.hideFlags = HideFlags.HideInHierarchy;
            UnityEngine.Object.DontDestroyOnLoad(websocketConnectionObject);

            this.sock = new WebSocket(new Uri(ServerAddress));
            mb.StartCoroutine(this.sock.Connect());

            mb.StartCoroutine(ReceiveLoop());
            return true;
        }

 void InitWebSocket()
 {
     _ws = new WebSocket ("wss://echo.websocket.org/");
     _ws.OnMessage += MessageCallback;
     _ws.OnError += ErrorCallback;
     _ws.Connect ();
 }

        public void Play()
        {
            var uri = new Uri(Server + "?user=" + Uri.EscapeDataString(UserName));

            using (var socket = new WebSocket(uri))
            {
                socket.Connect();

                while (!ShouldExit)
                {
                    var response = socket.Recv();

                    if (!response.StartsWith(ResponsePrefix))
                    {
                        Console.WriteLine("Something strange is happening on the server... Response:\n{0}", response);
                        ShouldExit = true;
                    }
                    else
                    {
                        var boardString = response.Substring(ResponsePrefix.Length);

                        var action = DoMove(new GameBoard(boardString));

                        socket.Send(action);
                    }
                }
            }
        }

    void Start() {
        ws = new WebSocket("ws://echo.websocket.org");

        ws.OnOpen += OnOpenHandler;
        ws.OnMessage += OnMessageHandler;
        ws.OnClose += OnCloseHandler;

        stateMachine.AddHandler(State.Running, () => {
            new Wait(this, 3, () => {
                ws.ConnectAsync();
            });
        });

        stateMachine.AddHandler(State.Connected, () => {
            stateMachine.Transition(State.Ping);
        });

        stateMachine.AddHandler(State.Ping, () => {
            new Wait(this, 3, () => {
               ws.SendAsync("This WebSockets stuff is a breeze!", OnSendComplete);
            });
        });

        stateMachine.AddHandler(State.Pong, () => {
            new Wait(this, 3, () => {
                ws.CloseAsync();
            });
        });

        stateMachine.Run();
    }

        public WebSocketFrame(WebSocket webSocket, WebSocketFrameTypes type, byte[] data, UInt64 pos, UInt64 length, bool isFinal, bool useExtensions)
        {
            this.Type = type;
            this.IsFinal = isFinal;
            this.UseExtensions = useExtensions;

            if (data != null)
            {
                this.Data = new byte[length];
                Array.Copy(data, (int)pos, this.Data, 0, (int)length);
            }
            else
                data = NoData;

            // First byte: Final Bit + Rsv flags + OpCode
            byte finalBit = (byte)(IsFinal ? 0x80 : 0x0);
            this.Header = (byte)(finalBit | (byte)Type);

            if (this.UseExtensions && webSocket != null && webSocket.Extensions != null)
            {
                for (int i = 0; i < webSocket.Extensions.Length; ++i)
                {
                    var ext = webSocket.Extensions[i];
                    if (ext != null)
                    {
                        this.Header |= ext.GetFrameHeader(this, this.Header);
                        this.Data = ext.Encode(this);
                    }
                }
            }
        }

        public override bool VerifyHandshake(WebSocket websocket, WebSocketCommandInfo handshakeInfo, out string description)
        {
            var challenge = handshakeInfo.Data;

            if (challenge.Length != challenge.Length)
            {
                description = m_Error_ChallengeLengthNotMatch;
                return false;
            }

            for (var i = 0; i < m_ExpectedChallenge.Length; i++)
            {
                if (challenge[i] != m_ExpectedChallenge[i])
                {
                    description = m_Error_ChallengeNotMatch;
                    return false;
                }
            }

            if (!handshakeInfo.Text.ParseMimeHeader(websocket.Items))
            {
                description = m_Error_InvalidHandshake;
                return false;
            }

            description = string.Empty;
            return true;
        }

	// Use this for initialization
	IEnumerator Start () {
		WebSocket w = new WebSocket(new Uri("ws://127.0.0.1:8080/websocket"));
		yield return StartCoroutine(w.Connect());

		int i = 0;
		w.SendString(PackMessage("Hi there", i));
		while (true)
		{
			string reply = w.RecvString();
			if (reply != null)
			{
				Message msg = UnpackMessage (reply);
				Debug.Log ("Received: " + msg.msg + ", " + msg.no);
				w.SendString (PackMessage ("Hi there", i));
			}
			if (w.error != null)
			{
				Debug.LogError ("Error: " + w.error);
				break;
			}

			++i;

			yield return 0;
		}
		w.Close();
	}

        /// <summary>
        /// Returns a handler for incoming Web stream requests.
        /// </summary>
        /// <param name="route">
        /// The handler.
        /// </param>
        /// <param name="controller">
        /// The controller.
        /// </param>
        /// <param name="args">
        /// The request parameters.
        /// </param>
        /// <returns>
        /// A handler for incoming Web stream requests.
        /// </returns>
        public static Func<IDictionary<string, object>, Task> WebSocketRequestHandler(
            this ControllerRoute route,
            object controller,
            IDictionary<string, string> args)
        {
            return async environment =>
            {
                using (var socket = new WebSocket(environment))
                {
                    Task incomingMessagePump;
                    Func<string, IObservable<string>> getObservable;
                    if (route.ObservableParameters != null)
                    {
                        // Route has observable parameters.
                        var observableParams = route.ObservableParameters.ToDictionary(_ => _, _ => new SingleSubscriptionObservable());
                        getObservable = name => observableParams[name].Observable;
                        incomingMessagePump = IncomingMessagePump(socket, observableParams);
                    }
                    else
                    {
                        // No observable parameters.
                        getObservable = _ => Observable.Empty<string>();
                        incomingMessagePump = Task.FromResult(0);
                    }

                    // Hook up the incoming and outgoing message pumps.
                    var outgoing = GetObservableFromHandler(() => route.Invoke(controller, args, getObservable));
                    var outgoingMessagePump = OutgoingMessagePump(outgoing, socket);

                    // Close the socket when both pumps finish.
                    await Task.WhenAll(outgoingMessagePump, incomingMessagePump);
                }
            };
        }

        IEnumerator Start()
        {
            _game = gameObject.GetComponent<MainProxy>();

            _state = ConnectionState.UNKNOWN;
            _socket = new WebSocket (new Uri ("ws://188.242.130.83:3000/echo"));
            yield return StartCoroutine (_socket.Connect ());
        }