SocketIOSharp
SocketIOSharp
is a Socket.IO protocol revision 4
client library based on Engine.IO
and WebSocket
protocol. It depends on WebSocketSharp to use WebSocket
protocol. Engine.IO
protocol is partly implemented by itself.
Installation
-
Command
Install-Package SocketIOSharp
in nuget package manager console.
Usage
Namespace
using SocketIOSharp.Client;
Constructor
SocketIOClient client = new SocketIOClient(SocketIOClient.Scheme.ws, host, port);
SocketIOClient.Scheme
public enum Scheme
{
ws,
wss
}
It is used to determine whether SocketIOClient
instance will connect to server using WebSocket
protocol or WebSocketSecure
protocol.
Options in constructor
public SocketIOClient(SocketIOClient.Scheme Scheme, string Host, int Port, bool JsonOnly = false, bool AutoReconnect = false, bool UseAckTimeout = false)
-
bool JsonOnly
is used to determine whetherSocketIOClient
instance will or will not acceptWebSocket
binary packet. -
bool AutoReconnect
is used to determine whetherSocketIOClient
instnace will or will not reconnect to server whenWebSocket.OnClose
is called. -
bool UseAckTimeout
is used to determine whetherSocketIOClient
instnace will or will not automatically remove timed out ack actions.
-
All options above can be changed after construct like
client.JsonOnly = false
. Default value of these arefalse
. -
If
JsonOnly
istrue
,SocketIOClient
instance will NOT handleWebSocket
binary packet. -
If
AutoReconnect
istrue
,SocketIOClient
instance will reconnect afterWebSocket.OnClose
is called. -
If
UseAckTimeout
istrue
,SocketIOClient
instance will automatically remove timed out ack actions.
Connect
client.Connect();
Disconnect
client.Close();
or
client.Dispose();
Since SocketIOClient
implements IDisposable
interface, it will be automatically disconnect when SocketIOClient.Dispose
is called.
Handlers
For convenient usage, it is implemented to can be used as Javascript
style.
Event handlers
client.On(SocketIOClient.Event.CONNECTION, (JToken[] Data) => // Type of argument is JToken[].
{
Console.WriteLine("Connected!");
});
client.On(SocketIOClient.Event.DISCONNECT, (Data) => // Argument can be used without type.
{
Console.WriteLine("Disconnected!");
});
client.On(SocketIOClient.Event.ERROR, (Data) =>
{
if (Data != null && Data.Length > 0 && Data[0] != null)
{
Console.WriteLine("Error : " + Data[0]);
}
else
{
Console.WrtieLine("Unkown Error");
}
});
client.On("message", (Data) =>
{
if (Data != null && Data.Length > 0 && Data[0] != null)
{
Console.WriteLine("Message : " + Data[0]);
}
});
client.On("CustomEvent", CustomEventHandler); // Handler can be method.
client.On(9001, ItsOverNineThousands); // Type of event is JToken. So, it can be a number.
client.Off(9001, ItsOverNineThousands); // Remove 9001 event handler.
ACK handlers
client.On("ACK1", (JToken[] Data, (JToken[] Data) => { Console.WriteLine("ACK : " + Data) } =>
{
// Type of first argument is JToken[].
// Type of second arguemtn is Action<JToken[]>.
Console.Write("On event ack1 : " + Data);
});
client.On("ACK2", (Data, AckAction) => // Second argument can be method.
{
Console.Write("On event ack2 : " + Data);
});
client.On("ACK3", CustomAckHandler); // Handler can be method.
client.On(42, LifeTheUniverseAndTheEverything); // Type of event is JToken. So, it can be a number.
client.Off(42, LifeTheUniverseAndTheEverything); // Remove 42 ack handler.
SocketIOClient.Event
public static class Event
{
public static readonly string CONNECTION = "connection";
public static readonly string DISCONNECT = "disconnect";
public static readonly string ERROR = "error";
}
These are the common basic Socket.IO
events.
Emit
client.Emit("Event without data and ack");
client.Emit("Event only with data", "Hello world");
client.Emit("Event only with ack, action as lambda", (Data) => Console.WriteLine("ACK : " + Data));
client.Emit("Event only with ack, action as method", Console.WriteLine);
client.Emit("Event with data and ack, action as lambda", 9001, (Data) => Console.WriteLine("ACK : " + Data));
client.Emit("Event with data and ack, action as method", 42, Console.WriteLine);
// Type of data is JToken. So, it can be a number.
Implemented features
- Fully implemented
Socket.IO
protocol includeshartbeat
. See Socket.IO protocol specifications for details. - Partly implemented
Engine.IO
protocol. For now,WebSocket
is the ONLY supported transport. And the packet typeupgrade
andnoop
is NOT supproted. See Engine.IO protocol specifications for details.
Planned features
- Fully implemented
Engine.IO
client (Working on here) - Transport without
WebSocket
Limitations
- Partly implemented Engine.IO : It implements part of
Engine.IO
only for processingSocket.IO
packet. Therefore, it can NOT be used asEngine.IO
client. - Only with WebSocket : Since it uses
Websocket
as transport, it can be used ONLY whenWebSocket
is avalible atSocket.IO
server. - Code style :
SocketIOSharp
is written in 2016 by a college student. It can be looked as old or odd style.
Maintenance
Welcome to report issue or create pull request. I will check it happily.
Dependencies
License
SocketIOSharp
is under The MIT License.