Added XML documentation comments to WebSocket.cs

README.md

@@ -1,10 +1,10 @@
 # websocket-sharp #
 
-**websocket-sharp** is a C# implementation of WebSocket protocol client & server.
+**websocket-sharp** is a C# implementation of the WebSocket protocol client & server.
 
 ## Usage ##
 
-### WebSocket Client ###
+### The WebSocket client ###
 
 #### Step 1 ####
 
@@ -15,11 +15,11 @@ using WebSocketSharp;
 using WebSocketSharp.Frame;
 ```
 
-`WebSocket` class exists in `WebSocketSharp` namespace, WebSocket data frame resources (e.g. `WsFrame` class) exist in `WebSocketSharp.Frame` namespace.
+The `WebSocket` class exists in the `WebSocketSharp` namespace, the WebSocket frame resources (e.g. `WsFrame` class) exist in the `WebSocketSharp.Frame` namespace.
 
 #### Step 2 ####
 
-Creating a instance of `WebSocket` class.
+Creating a instance of the `WebSocket` class.
 
 ```cs
 using (WebSocket ws = new WebSocket("ws://example.com"))
@@ -28,15 +28,15 @@ using (WebSocket ws = new WebSocket("ws://example.com"))
 }
 ```
 
-`WebSocket` class inherits `IDisposable` interface, so you can use `using` statement.
+The `WebSocket` class inherits the `IDisposable` interface, so you can use the `using` statement.
 
 #### Step 3 ####
 
-Setting `WebSocket` event handlers.
+Setting the `WebSocket` events.
 
 ##### WebSocket.OnOpen event #####
 
-`WebSocket.OnOpen` event is emitted immediately after WebSocket connection has been established.
+The `WebSocket.OnOpen` event occurs when the WebSocket connection has been established.
 
 ```cs
 ws.OnOpen += (sender, e) =>
@@ -45,11 +45,11 @@ ws.OnOpen += (sender, e) =>
 };
 ```
 
-`e` has come across as `EventArgs.Empty`, so there is no operation on `e`.
+The `e` has come across as the `EventArgs.Empty`, so there is no operation on the `e`.
 
 ##### WebSocket.OnMessage event #####
 
-`WebSocket.OnMessage` event is emitted each time WebSocket data frame is received.
+The `WebSocket.OnMessage` event occurs when the `WebSocket` receives a data frame.
 
 ```cs
 ws.OnMessage += (sender, e) =>
@@ -58,7 +58,7 @@ ws.OnMessage += (sender, e) =>
 };
 ```
 
-**Frame type** of received WebSocket data frame is stored in `e.Type` (`WebSocketSharp.MessageEventArgs.Type`, its type is `WebSocketSharp.Frame.Opcode`), so you check it out and you determine which item you should operate.
+The `e.Type` (`WebSocketSharp.MessageEventArgs.Type`, its type is `WebSocketSharp.Frame.Opcode`) contains the **Frame type** of the data frame, so you check it out and you determine which item you should operate.
 
 ```cs
 switch (e.Type)
@@ -74,13 +74,13 @@ switch (e.Type)
 }
 ```
 
-If `e.Type` is `Opcode.TEXT`, you operate `e.Data` (`WebSocketSharp.MessageEventArgs.Data`, its type is `string`).
+If the `e.Type` is `Opcode.TEXT`, you operate the `e.Data` (`WebSocketSharp.MessageEventArgs.Data`, its type is `string`).
 
-If `e.Type` is `Opcode.BINARY`, you operate `e.RawData` (`WebSocketSharp.MessageEventArgs.RawData`, its type is `byte[]`).
+If the `e.Type` is `Opcode.BINARY`, you operate the `e.RawData` (`WebSocketSharp.MessageEventArgs.RawData`, its type is `byte[]`).
 
 ##### WebSocket.OnError event #####
 
-`WebSocket.OnError` event is emitted when some error is occurred.
+The `WebSocket.OnError` event occurs when the `WebSocket` gets an error.
 
 ```cs
 ws.OnError += (sender, e) =>
@@ -88,11 +88,11 @@ ws.OnError += (sender, e) =>
   ...
 };
 ```
-Error message is stored in `e.Message` (`WebSocketSharp.ErrorEventArgs.Message`, its type is `string`), so you operate it.
+The `e.Message` (`WebSocketSharp.ErrorEventArgs.Message`, its type is `string`) contains the error message, so you operate it.
 
 ##### WebSocket.OnClose event #####
 
-`WebSocket.OnClose` event is emitted when WebSocket connection is closed.
+The `WebSocket.OnClose` event occurs when the `WebSocket` receives a Close frame or the `Close` method is called.
 
 ```cs
 ws.OnClose += (sender, e) =>
@@ -101,11 +101,12 @@ ws.OnClose += (sender, e) =>
 };
 ```
 
-Close status code is stored in `e.Code` (`WebSocketSharp.CloseEventArgs.Code`, its type is `WebSocketSharp.Frame.CloseStatusCode`) and reason of close is stored in `e.Reason` (`WebSocketSharp.CloseEventArgs.Reason`, its type is `string`), so you operate them.
+The `e.Code` (`WebSocketSharp.CloseEventArgs.Code`, its type is `WebSocketSharp.Frame.CloseStatusCode`) contains the close status code  
+and the `e.Reason` (`WebSocketSharp.CloseEventArgs.Reason`, its type is `string`) contains the reason why closes, so you operate them.
 
 #### Step 4 ####
 
-Connecting to server using WebSocket.
+Connecting to the WebSocket server.
 
 ```cs
 ws.Connect();
@@ -113,31 +114,31 @@ ws.Connect();
 
 #### Step 5 ####
 
-Sending data.
+Sending a data.
 
 ```cs
 ws.Send(data);
 ```
 
-`WebSocket.Send` method is overloaded.
+The `Send` method is overloaded.
 
-`data` types are `string`, `byte[]` and `FileInfo` class.
+The types of `data` are `string`, `byte[]` or `FileInfo` class.
 
 #### Step 6 ####
 
-Closing WebSocket connection.
+Closing the WebSocket connection.
 
 ```cs
 ws.Close(code, reason);
 ```
 
-If you want to close WebSocket connection explicitly, you can use `Close` method.
+If you want to close the WebSocket connection explicitly, you can use the `Close` method.
 
-Type of `code` is `WebSocketSharp.Frame.CloseStatusCode`, type of `reason` is `string`.
+The type of `code` is `WebSocketSharp.Frame.CloseStatusCode`, the type of `reason` is `string`.
 
-`WebSocket.Close` method is overloaded (In addition `Close()` and `Close(code)` exist).
+The `Close` method is overloaded. (In addition, the `Close()` and `Close(code)` methods exist.)
 
-### WebSocket Server ###
+### The WebSocket server ###
 
 #### Step 1 ####
 
@@ -147,11 +148,11 @@ Required namespace.
 using WebSocketSharp.Server;
 ```
 
-`WebSocketServer`, `WebSocketServer<T>` and `WebSocketService` classes exist in `WebSocketSharp.Server` namespace.
+The `WebSocketServer`, `WebSocketServer<T>` and `WebSocketService` classes exist in the `WebSocketSharp.Server` namespace.
 
 #### Step 2 ####
 
-Creating a class that inherits `WebSocketService` class.
+Creating a class that inherits the `WebSocketService` class.
 
 For example, if you want to provide the echo service,
 
@@ -169,7 +170,7 @@ public class Echo : WebSocketService
 }
 ```
 
-For example, if you want to provide the chat service,
+Or if you want to provide the chat service,
 
 ```cs
 using System;
@@ -185,19 +186,19 @@ public class Chat : WebSocketService
 }
 ```
 
-If you override `onMessage` method, it is bound to server side `WebSocket.OnMessage` event.
+If you override the `onMessage` method, it is bound to the server side `WebSocket.OnMessage` event.
 
-In addition, if you override `onOpen`, `onError` and `onClose` methods, each of them is bound to `WebSocket.OnOpen`, `WebSocket.OnError` and `WebSocket.OnClose` events.
+In addition, if you override the `onOpen`, `onError` and `onClose` methods, each of them is bound to the `WebSocket.OnOpen`, `WebSocket.OnError` and `WebSocket.OnClose` events.
 
 #### Step 3 ####
 
-Creating a instance of `WebSocketServer<T>` class if you want single WebSocket service server.
+Creating a instance of the `WebSocketServer<T>` class if you want the single WebSocket service server.
 
 ```cs
 var wssv = new WebSocketServer<Echo>("ws://example.com:4649");
 ```
 
-Creating a instance of `WebSocketServer` class if you want multi WebSocket service server.
+Creating a instance of the `WebSocketServer` class if you want the multi WebSocket service server.
 
 ```cs
 var wssv = new WebSocketServer(4649);
@@ -205,22 +206,22 @@ wssv.AddService<Echo>("/Echo");
 wssv.AddService<Chat>("/Chat");
 ```
 
-You can add to your `WebSocketServer` any WebSocket service and a matching path to that service by using `WebSocketServer.AddService<T>` method.
+You can add to your `WebSocketServer` any WebSocket service and a matching path to that service by using the `WebSocketServer.AddService<T>` method.
 
-Type of `T` inherits `WebSocketService` class, so you can use a class that was created in **Step 2**.
+The type of `T` inherits `WebSocketService` class, so you can use a class that was created in **Step 2**.
 
-If you create a instance of WebSocket Server without port number, WebSocket Server set **80** or **443** to port number automatically.
+If you create a instance of the `WebSocketServer` class without port number, `WebSocketServer` set **80** to port number automatically.  
 So it is necessary to run with root permission.
 
     $ sudo mono example2.exe
 
 #### Step 4 ####
 
-Setting WebSocketServer event handler.
+Setting the event.
 
 ##### WebSocketServer&lt;T>.OnError event #####
 
-`WebSocketServer<T>.OnError` event is emitted when some error is occurred.
+The `WebSocketServer<T>.OnError` event occurs when the `WebSocketServer<T>` gets an error.
 
 ```cs
 wssv.OnError += (sender, e) =>
@@ -229,15 +230,15 @@ wssv.OnError += (sender, e) =>
 };
 ```
 
-Error message is stored in `e.Message` (`WebSocketSharp.ErrorEventArgs.Message`, its type is `string`), so you operate it.
+The `e.Message` (`WebSocketSharp.ErrorEventArgs.Message`, its type is `string`) contains the error message, so you operate it.
 
 ##### WebSocketServer.OnError event #####
 
-Same as `WebSocketServer<T>.OnError` event.
+Same as the `WebSocketServer<T>.OnError` event.
 
 #### Step 5 ####
 
-Starting server.
+Starting the server.
 
 ```cs
 wssv.Start();
@@ -245,17 +246,17 @@ wssv.Start();
 
 #### Step 6 ####
 
-Stopping server.
+Stopping the server.
 
 ```cs
 wssv.Stop();
 ```
 
-### HTTP Server with WebSocket ###
+### The HTTP server with the WebSocket ###
 
-I modified System.Net.HttpListener, System.Net.HttpListenerContext and some others of [Mono] to create the HTTP server that the connection can be upgraded to the WebSocket connection if the HTTP server received a WebSocket request.
+I modified the `System.Net.HttpListener`, `System.Net.HttpListenerContext` and some other classes of [Mono] to create the HTTP server that can upgrade the connection to the WebSocket connection when receives a WebSocket request.
 
-You can add to your `HttpServer` any WebSocket service and a matching path to that service by using `HttpServer.AddService<T>` method.
+You can add to your `HttpServer` any WebSocket service and a matching path to that service by using the `HttpServer.AddService<T>` method.
 
 ```cs
 var httpsv = new HttpServer(4649);
@@ -284,7 +285,7 @@ Examples of using **websocket-sharp**.
 
 ### Example3 ###
 
-[Example3] starts the HTTP server that the connection can be upgraded to the WebSocket connection.
+[Example3] starts the HTTP server that can upgrade the connection to the WebSocket connection.
 
 Please access [http://localhost:4649](http://localhost:4649) to do WebSocket Echo Test with your web browser after [Example3] running.
 
@@ -326,7 +327,7 @@ Licensed under the **[MIT License]**.
 [MIT License]: http://www.opensource.org/licenses/mit-license.php
 [Mono]: http://www.mono-project.com/
 [RFC 6455]: http://tools.ietf.org/html/rfc6455
-[The WebSocket API]: http://dev.w3.org/html5/websockets
+[The WebSocket API]: http://www.w3.org/TR/websockets/
 [The WebSocket API 日本語訳]: http://www.hcn.zaq.ne.jp/___/WEB/WebSocket-ja.html
 [The WebSocket Protocol]: http://tools.ietf.org/html/rfc6455
 [The WebSocket Protocol 日本語訳]: http://www.hcn.zaq.ne.jp/___/WEB/RFC6455-ja.html

websocket-sharp/Ext.cs

@@ -518,20 +518,13 @@ namespace WebSocketSharp {
 
     public static string ToString<T>(this T[] array, string separater)
     {
-      int len;
-      StringBuilder sb;
-
-      len = array.Length;
+      var len = array.Length;
       if (len == 0)
-      {
         return String.Empty;
-      }
 
-      sb = new StringBuilder();
+      var sb = new StringBuilder();
       for (int i = 0; i < len - 1; i++)
-      {
         sb.AppendFormat("{0}{1}", array[i].ToString(), separater);
-      }
       sb.Append(array[len - 1].ToString());
 
       return sb.ToString();

websocket-sharp/Server/WebSocketService.cs

@@ -53,7 +53,17 @@ namespace WebSocketSharp.Server
 
     #endregion
 
-    #region Properties
+    #region Protected Property
+
+    protected SessionManager sessions {
+      get {
+        return _sessions;
+      }
+    }
+
+    #endregion
+
+    #region Public Properties
 
     public string ID        { get; private set; }
     public bool   IsBound   { get; private set; }

websocket-sharp/WebSocket.cs

@@ -2,7 +2,7 @@
 /**
  * WebSocket.cs
  *
- * A C# implementation of a WebSocket protocol client.
+ * A C# implementation of the WebSocket interface.
  * This code derived from WebSocket.java (http://github.com/adamac/Java-WebSocket-client).
  *
  * The MIT License
@@ -36,15 +36,22 @@ using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Net.Sockets;
+using System.Security.Cryptography;
 using System.Text;
 using System.Threading;
-using System.Security.Cryptography;
 using WebSocketSharp.Frame;
 using WebSocketSharp.Net;
 using WebSocketSharp.Net.Sockets;
 
 namespace WebSocketSharp {
 
+  /// <summary>
+  /// Implements the WebSocket interface.
+  /// </summary>
+  /// <remarks>
+  /// The WebSocket class provides methods and properties for two-way communication with a remote host
+  /// with the WebSocket protocol (RFC 6455).
+  /// </remarks>
   public class WebSocket : IDisposable
   {
     #region Private Const Fields
@@ -59,11 +66,10 @@ namespace WebSocketSharp {
 
     private string                          _base64key;
     private HttpListenerContext             _baseContext;
-    private string                          _binaryType;
     private WebSocketContext                _context;
     private System.Net.IPEndPoint           _endPoint;
-    private AutoResetEvent                  _exitMessageLoop;
     private string                          _extensions;
+    private AutoResetEvent                  _exitMessageLoop;
     private Object                          _forClose;
     private Object                          _forSend;
     private bool                            _isClient;
@@ -83,13 +89,11 @@ namespace WebSocketSharp {
 
     private WebSocket()
     {
-      _binaryType          = String.Empty;
       _extensions          = String.Empty;
       _forClose            = new Object();
       _forSend             = new Object();
       _protocol            = String.Empty;
       _readyState          = WsState.CONNECTING;
-      _receivePong         = new AutoResetEvent(false);
       _unTransmittedBuffer = new SynchronizedCollection<WsFrame>();
     }
 
@@ -136,6 +140,18 @@ namespace WebSocketSharp {
 
     #region Public Constructors
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="WebSocketSharp.WebSocket"/> class with the specified WebSocket URL and subprotocols.
+    /// </summary>
+    /// <param name='url'>
+    /// A <see cref="string"/> that contains the WebSocket URL.
+    /// </param>
+    /// <param name='protocols'>
+    /// An array of <see cref="string"/> that contains the WebSocket subprotocols if any.
+    /// </param>
+    /// <exception cref='ArgumentException'>
+    /// <paramref name="url"/> is not valid WebSocket URL.
+    /// </exception>
     public WebSocket(string url, params string[] protocols)
       : this()
     {
@@ -151,6 +167,30 @@ namespace WebSocketSharp {
       _isSecure  = uri.Scheme == "wss" ? true : false;
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="WebSocketSharp.WebSocket"/> class with the specified WebSocket URL, OnOpen, OnMessage, OnError, OnClose event handlers and subprotocols.
+    /// </summary>
+    /// <param name='url'>
+    /// A <see cref="string"/> that contains the WebSocket URL.
+    /// </param>
+    /// <param name='onOpen'>
+    /// An OnOpen event handler.
+    /// </param>
+    /// <param name='onMessage'>
+    /// An OnMessage event handler.
+    /// </param>
+    /// <param name='onError'>
+    /// An OnError event handler.
+    /// </param>
+    /// <param name='onClose'>
+    /// An OnClose event handler.
+    /// </param>
+    /// <param name='protocols'>
+    /// An array of <see cref="string"/> that contains the WebSocket subprotocols if any.
+    /// </param>
+    /// <exception cref='ArgumentException'>
+    /// <paramref name="url"/> is not valid WebSocket URL.
+    /// </exception>
     public WebSocket(
       string                         url,
       EventHandler                   onOpen,
@@ -172,28 +212,43 @@ namespace WebSocketSharp {
 
     #region Properties
 
-    public string BinaryType {
-      get { return _binaryType; }
-    }
-
+    /// <summary>
+    /// Gets the amount of untransmitted data.
+    /// </summary>
+    /// <value>
+    /// The number of bytes of untransmitted data.
+    /// </value>
     public ulong BufferedAmount {
       get {
-        ulong bufferedAmount = 0;
-
         lock (_unTransmittedBuffer.SyncRoot)
         {
+          ulong bufferedAmount = 0;
           foreach (WsFrame frame in _unTransmittedBuffer)
             bufferedAmount += frame.PayloadLength;
-        }
 
-        return bufferedAmount;
+          return bufferedAmount;
+        }
       }
     }
 
+    /// <summary>
+    /// Gets the extensions selected by the server.
+    /// </summary>
+    /// <value>
+    /// A <see cref="string"/> that contains the extensions if any. By default, <c>String.Empty</c>. (Currently this will only ever be the <c>String.Empty</c>.)
+    /// </value>
     public string Extensions {
-      get { return _extensions; }
+      get {
+        return _extensions;
+      }
     }
 
+    /// <summary>
+    /// Gets a value indicating whether a connection is alive.
+    /// </summary>
+    /// <value>
+    /// <c>true</c> if the connection is alive; otherwise, <c>false</c>.
+    /// </value>
     public bool IsAlive {
       get {
         if (_readyState != WsState.OPEN)
@@ -203,18 +258,40 @@ namespace WebSocketSharp {
       }
     }
 
+    /// <summary>
+    /// Gets a value indicating whether a connection is secure.
+    /// </summary>
+    /// <value>
+    /// <c>true</c> if the connection is secure; otherwise, <c>false</c>.
+    /// </value>
     public bool IsSecure {
       get {
         return _isSecure;
       }
     }
 
+    /// <summary>
+    /// Gets the subprotocol selected by the server.
+    /// </summary>
+    /// <value>
+    /// A <see cref="string"/> that contains the subprotocol if any. By default, <c>String.Empty</c>.
+    /// </value>
     public string Protocol {
-      get { return _protocol; }
+      get {
+        return _protocol;
+      }
     }
 
+    /// <summary>
+    /// Gets the state of the connection.
+    /// </summary>
+    /// <value>
+    /// A <see cref="WebSocketSharp.WsState"/>. By default, <c>WsState.CONNECTING</c>.
+    /// </value>
     public WsState ReadyState {
-      get { return _readyState; }
+      get {
+        return _readyState;
+      }
 
       private set {
         _readyState = value;
@@ -234,10 +311,24 @@ namespace WebSocketSharp {
       }
     }
 
-    public SynchronizedCollection<WsFrame> UnTransmittedBuffer {
-      get { return _unTransmittedBuffer; }
+    /// <summary>
+    /// Gets the untransmitted WebSocket frames.
+    /// </summary>
+    /// <value>
+    /// A <c>IList&lt;WsFrame&gt;</c> that contains the untransmitted WebSocket frames.
+    /// </value>
+    public IList<WsFrame> UnTransmittedBuffer {
+      get {
+        return _unTransmittedBuffer;
+      }
     }
 
+    /// <summary>
+    /// Gets or sets the WebSocket URL.
+    /// </summary>
+    /// <value>
+    /// A <see cref="Uri"/> that contains the WebSocket URL.
+    /// </value>
     public Uri Url {
       get { return _uri; }
       set {
@@ -252,10 +343,25 @@ namespace WebSocketSharp {
 
     #region Events
 
-    public event EventHandler                   OnOpen;
+    /// <summary>
+    /// Occurs when the WebSocket connection has been established.
+    /// </summary>
+    public event EventHandler OnOpen;
+
+    /// <summary>
+    /// Occurs when the WebSocket receives a data frame.
+    /// </summary>
     public event EventHandler<MessageEventArgs> OnMessage;
-    public event EventHandler<ErrorEventArgs>   OnError;
-    public event EventHandler<CloseEventArgs>   OnClose;
+
+    /// <summary>
+    /// Occurs when the WebSocket gets an error.
+    /// </summary>
+    public event EventHandler<ErrorEventArgs> OnError;
+
+    /// <summary>
+    /// Occurs when the WebSocket receives a Close frame or the Close method is called.
+    /// </summary>
+    public event EventHandler<CloseEventArgs> OnClose;
 
     #endregion
 
@@ -318,7 +424,6 @@ namespace WebSocketSharp {
     private void close(CloseStatusCode code, string reason)
     {
       var data = new List<byte>(((ushort)code).ToBytes(ByteOrder.BIG));
-
       if (!String.IsNullOrEmpty(reason))
       {
         var buffer = Encoding.UTF8.GetBytes(reason);
@@ -947,6 +1052,7 @@ namespace WebSocketSharp {
 
     private void startMessageThread()
     {
+      _receivePong     = new AutoResetEvent(false);
       _exitMessageLoop = new AutoResetEvent(false);
       Action messageInvoker = () =>
       {
@@ -975,21 +1081,42 @@ namespace WebSocketSharp {
 
     #region Public Methods
 
+    /// <summary>
+    /// Sends a Close frame and closes the WebSocket connection and releases all associated resources.
+    /// </summary>
     public void Close()
     {
       Close(CloseStatusCode.NORMAL);
     }
 
+    /// <summary>
+    /// Sends a Close frame and closes the WebSocket connection and releases all associated resources.
+    /// </summary>
+    /// <param name='code'>
+    /// A <see cref="WebSocketSharp.Frame.CloseStatusCode"/>.
+    /// </param>
     public void Close(CloseStatusCode code)
     {
       Close(code, String.Empty);
     }
 
+    /// <summary>
+    /// Sends a Close frame and closes the WebSocket connection and releases all associated resources.
+    /// </summary>
+    /// <param name='code'>
+    /// A <see cref="WebSocketSharp.Frame.CloseStatusCode"/>.
+    /// </param>
+    /// <param name='reason'>
+    /// A <see cref="string"/> that contains the reason why closes.
+    /// </param>
     public void Close(CloseStatusCode code, string reason)
     {
       close(code, reason);
     }
 
+    /// <summary>
+    /// Establishes a connection.
+    /// </summary>
     public void Connect()
     {
       if (_readyState == WsState.OPEN)
@@ -1018,32 +1145,74 @@ namespace WebSocketSharp {
       }
     }
 
+    /// <summary>
+    /// Sends a Close frame and closes the WebSocket connection and releases all associated resources.
+    /// </summary>
+    /// <remarks>
+    /// Call <see cref="Dispose"/> when you are finished using the <see cref="WebSocketSharp.WebSocket"/>. The
+    /// <see cref="Dispose"/> method leaves the <see cref="WebSocketSharp.WebSocket"/> in an unusable state. After
+    /// calling <see cref="Dispose"/>, you must release all references to the <see cref="WebSocketSharp.WebSocket"/> so
+    /// the garbage collector can reclaim the memory that the <see cref="WebSocketSharp.WebSocket"/> was occupying.
+    /// </remarks>
     public void Dispose()
     {
       Close(CloseStatusCode.AWAY);
     }
 
+    /// <summary>
+    /// Sends a Ping frame.
+    /// </summary>
+    /// <returns>
+    /// <c>true</c> if the WebSocket receives a Pong frame in a time; otherwise, <c>false</c>.
+    /// </returns>
     public bool Ping()
     {
       return Ping(String.Empty);
     }
 
+    /// <summary>
+    /// Sends a Ping frame with a message.
+    /// </summary>
+    /// <param name='data'>
+    /// A <see cref="string"/> that contains the message data to be sent.
+    /// </param>
+    /// <returns>
+    /// <c>true</c> if the WebSocket receives a Pong frame in a time; otherwise, <c>false</c>.
+    /// </returns>
     public bool Ping(string data)
     {
       return ping(data, 5 * 1000);
     }
 
+    /// <summary>
+    /// Sends a Text data frame.
+    /// </summary>
+    /// <param name='data'>
+    /// A <see cref="string"/> that contains the text data to be sent.
+    /// </param>
     public void Send(string data)
     {
       var buffer = Encoding.UTF8.GetBytes(data);
       send(Opcode.TEXT, buffer);
     }
 
+    /// <summary>
+    /// Sends a Binary data frame.
+    /// </summary>
+    /// <param name='data'>
+    /// An array of <see cref="byte"/> that contains the binary data to be sent.
+    /// </param>
     public void Send(byte[] data)
     {
       send(Opcode.BINARY, data);
     }
 
+    /// <summary>
+    /// Sends a Binary data frame.
+    /// </summary>
+    /// <param name='file'>
+    /// A <see cref="FileInfo"/> that contains the binary data to be sent.
+    /// </param>
     public void Send(FileInfo file)
     {
       using (FileStream fs = file.OpenRead())