SocketJack 1.0.2.60001

SocketJack

Fast, Efficient, 100% Managed, Built-in Peer to Peer, Generic, Extensible TCP Client & Server that transmits .NET objects with Type Saftey.

SocketJack automatically serializes Public Properties utilizing a type white-list for security.

SocketJack comes with System.Text.Json support built in.

SocketJack exposes the ISerializer interface which can be used to add another serializer.

The SocketJack.NewtonsoftJson nuget package has been deprecated, and WILL NOT be updated.

SocketJack.NewtonsoftJson Nuget Package

PM> NuGet\Install-Package  SocketJack.NewtonsoftJson

v1.0.3 Pending Features

I'm working on built-in Bitmap, I/O aka File support, and bandwidth throttling. The SSL/Compression/Buffering took a lot of my time, and my rescue just had 9 puppies. Also, I have an idea to improve receiving bandwidth compute times which will take a bit of work to implement.

v1.0.2.60001 Release Notes

Added

• SSL Support
• Compression
• Chat Test
• Generic Callbacks
• Blacklist
• RemoteIdentity.Tag
• Upload buffer

Fixed

• PeerServer Accepting
• Compression Options
• DefaultOptions Initialization
• PeerRedirect Type Checking
• PeerRedirect Vulnerability
• Non-Generic OnReceive not being called
• Buffering
• Race conditions
• Re-introduced segments for stability

Updated

• Tests UI
• Tests compatibility w/ compression & SSL
• Multi-CPU Support at Runtime
• Host Caching for Improved Connection Performance
• Standardized Type, Method, And Function Naming
• Fully Thread Safe and Concurrent w\ThreadManager Class to handle all Tcp Threading

Getting Started

Default Options

TcpClient & TcpServer will inherit properties set to SocketJack.Management.DefaultOptions by default.

Your application will remain open in the background unless you dispose Clients & Servers, or can just do this on Application Exit

    ThreadManager.Shutdown();

Building an application with SocketJack

public class MyApp {
    SocketJack.Networking.Client.TcpClient TcpClient = new Client.TcpClient();
    SocketJack.Networking.Server.TcpServer TcpServer = new Server.TcpServer(Port);

    private const string Host = "127.0.0.1";
    private const int Port = 7474;

    // Handle all incoming objects
    private void TcpServer_OnReceive(ref ReceivedEventArgs e) {
        // Avoid switch cases or if statements when you have a lot of objects to handle.
    }

    private void TcpClient_OnConnected(ConnectedEventArgs e) {
        // Send the server an authorization request
        TcpClient.Send(new AuthorizationRequest());
    }

    private void Server_AuthorizationRequest(ReceivedEventArgs<AuthorizationRequest> args) {
        // Handle the auth request on the server
        // Note: This is just used as an example.
    }

    private void Client_AuthorizationRequest(ReceivedEventArgs<AuthorizationRequest> args) {
        // Handle the auth request on the client
        // Note: This is just used as an example.
    }

    public async void Start_MyApp() {
        // Start the server.
        TcpServer.RegisterCallback<AuthorizationRequest>(Server_AuthorizationRequest);
        TcpServer.OnReceive += TcpServer_OnReceive;
        TcpServer.Listen();

        // Start the client.
        TcpClient.RegisterCallback<AuthorizationRequest>(Client_AuthorizationRequest);
        TcpClient.OnConnected += TcpClient_OnConnected;
        // Connect function timeout is 3 seconds by default.
        await TcpClient.Connect("127.0.0.1", Port);
    }
}

Logging

TcpClient.Logging = true;
TcpClient.LogToOutput = true;
TcpClient.LogReceiveEvents = true;
TcpClient.LogSendEvents = true;

Peer to peer functionality

Built for faster latency and direct communication between clients. P2P TcpServer is automatically port forwarded using Mono.NAT UPNP.

Send another client on the server an object WITHOUT extra code or exposing their IP address.

PeerRedirect can be canceled on the server inside the TcpServer.OnReceive by setting e.CancelPeerRedirect to True.

Connect to the main server then, anytime after the TcpClient.OnIdentified Event start a P2P server.

private  async  void  MyTcpClient_PeerConnected(object sender, PeerIdentification RemotePeer) {
    // Make sure it's not your own client.
    if (MyTcpClient.RemoteIdentity != null && RemotePeer.ID != MyTcpClient.RemoteIdentity.ID) {
        TcpServer P2P_Server = await RemotePeer.StartServer("ExampleServer");
        P2P_Server.Logging = true;
        P2P_Server.LogReceiveEvents = true;
        P2P_Server.LogSendEvents = true;
        P2P_Server.OnReceive += P2PServer_OnReceive;
        P2P_Server.OnDisconnected += P2PServer_OnDisconnected;
        P2P_Server.OnError += P2PServer_OnError;
    }
}

Then, on the other Remote Client Accept by handling the TcpClient_PeerConnectionRequest Event.

private async void MyTcpClient_PeerConnectionRequest(object sender, P2PServer Server) {
    // CHANGE THIS - Add UI which allows the user to accept the connection.
    TcpClient P2P_Client = await Server.Accept(true, "ExampleClient");
    P2P_Client.Logging = true;
    P2P_Client.LogReceiveEvents = true;
    P2P_Client.LogSendEvents = true;
    P2P_Client.OnReceive += P2PClient_OnReceive;
    P2P_Client.OnConnected += P2PClient_OnConnected;
    P2P_Client.OnDisconnected += P2PClient_OnDisconnected;
    P2P_Client.OnError += P2PClient_OnError;
}

TcpClient.Send(PeerIdentification, Object)

Contributing

Pull requests are welcome. For major changes, please open an issue first

to discuss what you would like to change.

License

MIT