Client events

A list of all events that can be invoked of a client. At the end is an example of creating a client and binding the events.

/// <summary>
/// Event that is triggered when the client receives an object from the server.
/// </summary>
public event ObjectReceivedDelegate ObjectReceived;

/// <summary>
/// Gives insight in the state of the current FileTransfer to the server.
/// </summary>
public event MessageUpdateFileTransferDelegate MessageUpdateFileTransfer;

/// <summary>
/// Gives insight in the state of the current message.
/// </summary>
public event MessageUpdateDelegate MessageUpdate;

/// <summary>
/// Event that is triggered when a client receives a file or a part of a file.
/// </summary>
public event FileReceiverDelegate FileReceiver;

/// <summary>
/// Event that is triggered when a client receives a folder or a part of a folder.
/// </summary>
public event FolderReceiverDelegate FolderReceiver;

/// <summary>
/// Event that is triggered when the client successfully has submitted a transmission of data.
/// The bool represents if the client has terminated after the message.
/// </summary>
public event MessageSubmittedDelegate MessageSubmitted;

/// <summary>
/// Event that is triggered when the client has disconnected from the server.
/// Format = SimpleSocketClient
/// </summary>
public event DisconnectedFromServerDelegate DisconnectedFromServer;

/// <summary>
/// Event that is triggered when a client fails to send a message to the server
/// </summary>
public event MessageFailedDelegate MessageFailed;

/// <summary>
/// Event that is triggered when a client gives an error.
/// </summary>
public event ClientErrorThrownDelegate ClientErrorThrown;

/// <summary>
/// Event that receives logs.
/// </summary>
public event ClientLogsDelegate ClientLogs;

public delegate void ConnectedToServerDelegate(SimpleSocketClient client);

public delegate void MessageReceivedDelegate(SimpleSocketClient client, string msg);

public delegate void MessageWithMetadataReceivedDelegate(SimpleSocketClient client, object message, IDictionary<object,object> metadata, Type ObjectType);

public delegate void BytesReceivedDelegate(SimpleSocketClient client, byte[] messageBytes);

public delegate void ObjectReceivedDelegate(SimpleSocketClient client, object obj, Type objType);

public delegate void MessageUpdateFileTransferDelegate(SimpleSocketClient client, string origin, string remoteSaveLoc, double percentageDone, MessageState state);

public delegate void MessageUpdateDelegate(SimpleSocketClient client, string message, string header, MessageType messageType, MessageState state);

public delegate void FileReceiverDelegate(SimpleSocketClient client, int currentPart, int totalPart, string location, MessageState state);

public delegate void FolderReceiverDelegate(SimpleSocketClient client, int currentPart, int totalPart, string location, MessageState state);

public delegate void MessageSubmittedDelegate(SimpleSocketClient client, bool close);

public delegate void DisconnectedFromServerDelegate(SimpleSocketClient client);

public delegate void MessageFailedDelegate(SimpleSocketClient client, byte[] payLoad, Exception ex);

public delegate void ClientErrorThrownDelegate(SimpleSocketClient client, Exception ex);

public delegate void ClientLogsDelegate(SimpleSocketClient client, string message);

public delegate void AuthenticationFailed();

public delegate void AuthenticationSuccess();

private SimpleSocketClient _client;
private static void Start() {
        _client = new SimpleSocketTcpClient();
        BindEvents();
        _client.StartClient("127.0.0.1", 13000);
}
private static void BindEvents()
{
	_client.AuthSuccess += ClientOnAuthSuccess;
	_client.AuthFailed += ClientOnAuthFailed;
	_client.FileReceiver += ClientOnFileReceiver;
	_client.FolderReceiver += ClientOnFolderReceiver;
	_client.DisconnectedFromServer += Disconnected;
	_client.MessageUpdateFileTransfer += ClientOnMessageUpdateFileTransfer;
	_client.MessageUpdate += ClientOnMessageUpdate;
	_client.ConnectedToServer += ConnectedToServer;
	_client.ClientErrorThrown += ErrorThrown;
	_client.MessageReceived += ServerMessageReceived;
	_client.MessageSubmitted += ClientMessageSubmitted;
	_client.MessageFailed += MessageFailed;
	_client.MessageWithMetadataReceived += MessageWithMetaData;
	_client.ObjectReceived += ClientOnObjectReceived;
}

private static void ClientOnAuthFailed()
{
}

private static void ClientOnAuthSuccess()
{
}

private static void ClientOnObjectReceived(SimpleSocketClient a, object obj, Type objType)
{
}

private static void ClientOnMessageUpdate(SimpleSocketClient a, string msg, string header, MessageType msgType, MessageState state)
{
}

private static void ClientOnMessageUpdateFileTransfer(SimpleSocketClient a, string origin, string loc, double percentageDone, MessageState state)
{
}

private static void ClientOnFolderReceiver(SimpleSocketClient a, int currentPart, int totalParts, string loc, MessageState state)
{
}

private static void ClientOnFileReceiver(SimpleSocketClient a, int currentPart, int totalParts, string loc, MessageState state)
{
}

private static void MessageWithMetaData(SimpleSocket a, object msg, IDictionary<object, object> dict, Type objectType)
{
}

private static void ErrorThrown(SimpleSocket socketClient, Exception error)
{
}

private static void ConnectedToServer(SimpleSocket a)
{
}

private static void ServerMessageReceived(SimpleSocket a, string msg)
{
}

private static void Disconnected(SimpleSocket a)
{
}

private static void ClientMessageSubmitted(SimpleSocket a, bool close)
{
}

private static void MessageFailed(SimpleSocket tcpClient, byte[] messageData, Exception exception)
{
}