void IRemoteHubAdapter <byte[]> .RemoveOnMessageReceivedCallback(OnMessageReceivedCallback <byte[]> callback)
{
lock (adapterSidePrivateMessageCallbackHelper)
{
adapterSidePrivateMessageCallbackHelper.RemoveCallback(callback);
}
}
/// <inheritdoc/>
public void AddOnMessageReceivedCallback(OnMessageReceivedCallback <T> callback)
{
lock (privateMessageCallbackHelper)
{
privateMessageCallbackHelper.AddCallback(callback);
}
}
/// <inheritdoc/>
public void RemoveOnMessageReceivedCallback(OnMessageReceivedCallback <T> callback)
{
lock (privateMessageCallbackHelper)
{
privateMessageCallbackHelper.RemoveCallback(callback);
}
}
public void RemoveCallback(OnMessageReceivedCallback <T> callback)
{
lock (callbackLock)
{
dispatcher = dispatcher.RemoveCallback(callback);
}
}
public override OnMessageReceivedCallbackDispatcherBase <T> RemoveCallback(OnMessageReceivedCallback <T> callback)
{
if (callback == null)
{
return(this);
}
var index = Array.IndexOf(callbacks, callback);
if (index == -1)
{
return(this);
}
int length = callbacks.Length;
if (length == 2)
{
return(new OnMessageReceivedCallbackOneDispatcher <T>(callbacks[1 - index]));
}
var removed = new OnMessageReceivedCallback <T> [length - 1];
if (index != 0)
{
Array.Copy(callbacks, removed, index);
}
if (index != length - 1)
{
Array.Copy(callbacks, index + 1, removed, index, length - 1 - index);
}
return(new OnMessageReceivedCallbackMultipleDispatcher <T>(removed));
}
/// <summary>
/// Initializes an instance of RemoteHubSwitchDirect.
/// </summary>
/// <param name="clientId">Client id of the local RemoteHub.</param>
/// <param name="onMessageReceivedCallback">The callback to be used for dealing received private message.</param>
/// <param name="encoding">The encoder for converting between string and byte array. Default value is Encoding.Default. Will be ignored if type is not string.</param>
public RemoteHubSwitchDirect(Guid clientId, OnMessageReceivedCallback <T> onMessageReceivedCallback, Encoding encoding = null)
{
this.clientId = clientId;
clientTable.AddOrUpdate(clientId);
clientSidePrivateMessageCallbackHelper = new PrivateMessageCallbackHelper <T>(onMessageReceivedCallback);
adapterSidePrivateMessageCallbackHelper = new PrivateMessageCallbackHelper <byte[]>(null);
valueConverter = ValueConverter <T> .Create(encoding);
}
/// <summary>
/// Initializes an instance of RemoteHubOverRedis.
/// </summary>
/// <param name="clientId">Client id of the local RemoteHub.</param>
/// <param name="redisConfiguration">The string configuration to use for Redis multiplexer.</param>
/// <param name="onMessageReceivedCallback">The callback to be used for dealing received private message.</param>
/// <param name="mainChannelName">Main channel name. Default value is "RemoteHub".</param>
/// <param name="privateChannelNamePrefix">Prefix in naming of the private channel. Default value is "RemoteHubPrivate_".</param>
/// <param name="redisDb">The id to get a database for. Used in getting Redis database. Default value is 0.</param>
/// <param name="clientTimeToLive">Time to live (TTL) value of the host in seconds. Any records of hosts expired will be removed. Default value is 30 seconds.</param>
/// <param name="clientRefreshingInterval">Interval between refresh command sending operations in seconds. Default value is 15 seconds.</param>
public RemoteHubOverRedis(Guid clientId, string redisConfiguration,
OnMessageReceivedCallback <T> onMessageReceivedCallback,
string mainChannelName = "RemoteHub", string privateChannelNamePrefix = "RemoteHubPrivate_", int redisDb = 0,
int clientTimeToLive = 30, int clientRefreshingInterval = 15)
{
redisAdapter = new RedisAdapter <T>(redisConfiguration, onMessageReceivedCallback, mainChannelName, privateChannelNamePrefix, redisDb, clientTimeToLive, clientRefreshingInterval);
this.clientId = clientId;
redisAdapter.AddClient(clientId);
}
public static OnMessageReceivedCallbackDispatcherBase <T> Create(OnMessageReceivedCallback <T> callback)
{
if (callback == null)
{
return(new OnMessageReceivedCallbackNoneDispatcher <T>());
}
else
{
return(new OnMessageReceivedCallbackOneDispatcher <T>(callback));
}
}
public override OnMessageReceivedCallbackDispatcherBase <T> RemoveCallback(OnMessageReceivedCallback <T> callback)
{
if (callback == null && callback != this.callback)
{
return(this);
}
else
{
return(new OnMessageReceivedCallbackNoneDispatcher <T>());
}
}
public override OnMessageReceivedCallbackDispatcherBase <T> AddCallback(OnMessageReceivedCallback <T> callback)
{
if (callback == null)
{
return(this);
}
else
{
return(new OnMessageReceivedCallbackOneDispatcher <T>(callback));
}
}
public override OnMessageReceivedCallbackDispatcherBase <T> AddCallback(OnMessageReceivedCallback <T> callback)
{
if (callback == null || callback == this.callback)
{
return(this);
}
else
{
return(new OnMessageReceivedCallbackMultipleDispatcher <T>(new OnMessageReceivedCallback <T>[] { this.callback, callback }));
}
}
public override OnMessageReceivedCallbackDispatcherBase <T> AddCallback(OnMessageReceivedCallback <T> callback)
{
if (callback == null)
{
return(this);
}
var index = Array.IndexOf(callbacks, callback);
if (index == -1)
{
return(this);
}
int length = callbacks.Length;
var combined = new OnMessageReceivedCallback <T> [length + 1];
Array.Copy(callbacks, combined, length);
return(new OnMessageReceivedCallbackMultipleDispatcher <T>(combined));
}
/// <summary>
/// Initializes an instance of RedisAdapter.
/// </summary>
/// <param name="redisConfiguration">The string configuration to use for Redis multiplexer.</param>
/// <param name="onMessageReceivedCallback">The callback to be used for dealing received private message. Default value is null.</param>
/// <param name="mainChannelName">Main channel name. Default value is "RemoteHub".</param>
/// <param name="privateChannelNamePrefix">Prefix in naming of the private channel. Default value is "RemoteHubPrivate_".</param>
/// <param name="redisDb">The id to get a database for. Used in getting Redis database. Default value is 0.</param>
/// <param name="clientTimeToLive">Time to live (TTL) value of the host in seconds. Any records of hosts expired will be removed. Default value is 30 seconds.</param>
/// <param name="clientRefreshingInterval">Interval between refresh command sending operations in seconds. Default value is 15 seconds.</param>
public RedisAdapter(string redisConfiguration, OnMessageReceivedCallback <T> onMessageReceivedCallback = null,
string mainChannelName = "RemoteHub", string privateChannelNamePrefix = "RemoteHubPrivate_", int redisDb = 0,
int clientTimeToLive = 30, int clientRefreshingInterval = 15)
: base(redisConfiguration, mainChannelName, privateChannelNamePrefix, redisDb, clientTimeToLive, clientRefreshingInterval)
{
privateMessageCallbackHelper = new PrivateMessageCallbackHelper <T>(onMessageReceivedCallback);
var type = typeof(T);
if (type == typeof(string))
{
ValueConverter <string> client = new ValueConverterOfString();
valueConverter = __refvalue(__makeref(client), ValueConverter <T>);
}
else if (type == typeof(byte[]))
{
ValueConverter <byte[]> client = new ValueConverterOfByteArray();
valueConverter = __refvalue(__makeref(client), ValueConverter <T>);
}
else
{
throw new NotSupportedException("Only string and byte array are supported.");
}
}
public OnMessageReceivedCallbackOneDispatcher(OnMessageReceivedCallback <T> callback)
{
this.callback = callback;
}
internal static extern void MessageListenerHelper_SetOnMessageReceivedCallback(
HandleRef self,
/* from(MessageListenerHelper_OnMessageReceivedCallback_t) */ OnMessageReceivedCallback callback,
/* from(void *) */ IntPtr callback_arg);
internal static extern int onMessageReceivedCallback(OnMessageReceivedCallback cb);
internal static extern void MessageListenerHelper_SetOnMessageReceivedCallback(
HandleRef self,
/* from(MessageListenerHelper_OnMessageReceivedCallback_t) */ OnMessageReceivedCallback callback,
/* from(void *) */ IntPtr callback_arg);
public override OnMessageReceivedCallbackDispatcherBase <T> RemoveCallback(OnMessageReceivedCallback <T> callback)
{
return(this);
}
private static extern int onMessageReceivedCallback(OnMessageReceivedCallback cb);
private void Listen(object stream)
{
try
{
if (IsSecure)
{
while (Active)
{
SslStream nStream = (SslStream)stream;
Message m = MessageHelpers.GetMessage(nStream);
switch (m.MessageType)
{
case MessageType.Message:
OnMessageReceivedCallback?.Invoke(m);
break;
case MessageType.Status:
OnMessageStatusReceivedCallback?.Invoke(m);
break;
case MessageType.Transfer:
OnMessageTransferReceivedCallback?.Invoke(m);
break;
case MessageType.Whisper:
OnMessageWhisperReceivedCallback?.Invoke(m);
break;
case MessageType.Initialize:
OnMessageInitReceivedCallback?.Invoke(m);
break;
case MessageType.Request:
OnMessageRequestReceivedCallback?.Invoke(m);
break;
case MessageType.Infomation:
OnMesssageInformationReceivedCallback?.Invoke(m);
break;
}
OnMessageAnyReceivedCallback?.Invoke(m);
}
}
else
{
NetworkStream nStream = (NetworkStream)stream;
while (Active)
{
Message m = MessageHelpers.GetMessage(nStream);
switch (m.MessageType)
{
case MessageType.Message:
OnMessageReceivedCallback?.Invoke(m);
break;
case MessageType.Status:
OnMessageStatusReceivedCallback?.Invoke(m);
break;
case MessageType.Transfer:
OnMessageTransferReceivedCallback?.Invoke(m);
break;
case MessageType.Whisper:
OnMessageWhisperReceivedCallback?.Invoke(m);
break;
case MessageType.Initialize:
OnMessageInitReceivedCallback?.Invoke(m);
break;
case MessageType.Request:
OnMessageRequestReceivedCallback?.Invoke(m);
break;
case MessageType.Infomation:
OnMesssageInformationReceivedCallback?.Invoke(m);
break;
}
OnMessageAnyReceivedCallback?.Invoke(m);
}
}
}
catch (Exception e)
{
OnErrorCallback?.Invoke(e);
}
}
/// <summary>
/// Initializes an instance of RemoteHubOverStream.
/// </summary>
/// <param name="clientId">Client id of the local RemoteHub.</param>
/// <param name="inputStream">Stream for reading.</param>
/// <param name="outputStream">Stream for writing.</param>
/// <param name="onMessageReceivedCallback">The callback to be used for dealing received private message.</param>
/// <param name="refreshingIntervalInSeconds">The interval in seconds before sending a data package for keeping it alive when streams are idle. Default value is 60 seconds.</param>
/// <param name="encoding">The encoder for converting between string and byte array. Default value is Encoding.Default. Will be ignored if type is not string.</param>
public RemoteHubOverStream(Guid clientId, Stream inputStream, Stream outputStream, OnMessageReceivedCallback <T> onMessageReceivedCallback, int refreshingIntervalInSeconds = 60, Encoding encoding = null)
{
streamAdapter = new StreamAdapter <T>(inputStream, outputStream, onMessageReceivedCallback, refreshingIntervalInSeconds, encoding);
this.clientId = clientId;
streamAdapter.AddClient(clientId);
}
public PrivateMessageCallbackHelper(OnMessageReceivedCallback <T> initializingCallback)
{
dispatcher = OnMessageReceivedCallbackDispatcherBase <T> .Create(initializingCallback);
}
public abstract OnMessageReceivedCallbackDispatcherBase <T> RemoveCallback(OnMessageReceivedCallback <T> callback);
internal static extern void MessageListenerHelper_SetOnMessageReceivedCallback(HandleRef self, OnMessageReceivedCallback callback, IntPtr callback_arg);
private static extern int onMessageReceivedCallback(OnMessageReceivedCallback cb);
/// <summary>
/// Initializes an instance of StreamAdapter.
/// </summary>
/// <param name="inputStream">Stream for reading.</param>
/// <param name="outputStream">Stream for writing.</param>
/// <param name="onMessageReceivedCallback">The callback to be used for dealing received private message. Default value is null.</param>
/// <param name="refreshingIntervalInSeconds">The interval in seconds before sending a data package for keeping it alive when streams are idle. Default value is 60 seconds.</param>
/// <param name="encoding">The encoder for converting between string and byte array. Default value is Encoding.Default. Will be ignored if type is not string.</param>
public StreamAdapter(Stream inputStream, Stream outputStream, OnMessageReceivedCallback <T> onMessageReceivedCallback = null, int refreshingIntervalInSeconds = 60, Encoding encoding = null)
: base(inputStream, outputStream, refreshingIntervalInSeconds)
{
privateMessageCallbackHelper = new PrivateMessageCallbackHelper <T>(onMessageReceivedCallback);
valueConverter = ValueConverter <T> .Create(encoding);
}