public void Send(byte[] data, Instance address = null, SocketMessageType type = SocketMessageType.Data)
{
var buffer = EndPointMessage.Write(new EndPointMessage()
{
SenderName = instance.Id.ToString(),
SenderEndPoint = endPoint,
Type = type,
Data = data
});
if (type == SocketMessageType.Login)
{
Instance.DBTable.Load();
}
foreach (Instance item in Instance.DBTable)
{
if (address == null || item == address)
{
if (item.Active.Value && item.EndPoint != null && !item.EndPoint.Equals(endPoint) && !IPAddress.Loopback.Equals(item.EndPoint.Address))
{
Send(buffer, item.EndPoint);
}
}
}
}
public JsonSocketMessage(Encoding encoding, SocketMessageType messageType)
{
Encoding = encoding;
MessageType = messageType;
_eof = Encoding.GetBytes("<EOF>");
}
protected MessageWebSocketConnection(string uri,
IWampBinding <TMessage> binding, SocketMessageType messageType)
{
mUri = uri;
mBinding = binding;
mSocketMessageType = messageType;
}
/// <summary>
/// 输出消息
/// </summary>
/// <param name="o"></param>
/// <param name="type"></param>
/// <param name="message"></param>
protected void LogOutEvent(Object sender, SocketMessageType type, string message)
{
if (MessageOut != null)
{
MessageOut.BeginInvoke(sender, new LogOutEventArgs(type, message), new AsyncCallback(CallBackEvent), MessageOut);
}
}
/// <summary>Parses raw message text from stream.</summary>
/// <param name="rawMessage">Message text.</param>
/// <returns>Parsed message</returns>
public static SocketMessage Parse(string rawMessage)
{
if (rawMessage == null)
{
throw new ArgumentNullException(nameof(rawMessage));
}
if (string.IsNullOrWhiteSpace(rawMessage))
{
throw new ArgumentException("Raw message cannot be empty", nameof(rawMessage));
}
// get msg type
SocketMessageType msgType = ParseMessageType(rawMessage, out int parserIndex);
// get payload
JToken payload = ParsePayload(rawMessage, out int payloadIndex);
// get binary count
int binaryCount = ParseBinaryCount(rawMessage, ref parserIndex, payloadIndex);
// get message id
uint?id = ParseMessageID(rawMessage, ref parserIndex, payloadIndex);
// return results
SocketMessage result = new SocketMessage(msgType, id, payload, binaryCount);
result._rawMessage = rawMessage;
return(result);
}
public SocketMessage(int connectionID, SocketMessageType messageType, byte[] bytes, int taskID)
{
ConnectionID = connectionID;
MessageType = messageType;
Bytes = bytes;
TaskID = taskID;
}
/// <summary>Creates a new Socket.IO protocol message.</summary>
/// <param name="type">Type of SocketIO message.</param>
/// <param name="id">ID of the message in case of events.</param>
/// <param name="payload">Raw JSON payload.</param>
/// <param name="binaryCount">Count of binary messages that will be sent after this message.</param>
public SocketMessage(SocketMessageType type, uint?id, JToken payload, int binaryCount = 0)
{
this.Type = type;
this.ID = id;
this.Payload = payload;
this.BinaryMessagesCount = binaryCount;
}
public static string Process(SocketMessageType msgType, object data)
{
//ISocketConverter converter = GetConverter(msgType);
string message = JsonConvert.SerializeObject(data);
return(Process(msgType, message));
}
public SocketMessage(string connectionId, SocketMessageType messageType, byte[] data, int sessionId)
{
ConnectionId = connectionId;
MessageType = messageType;
Data = new Buffer(data, 0, data.Length);
SessionId = sessionId;
}
public SocketMessage(string connectionId, SocketMessageType messageType, Buffer data, int sessionId)
{
ConnectionId = connectionId;
MessageType = messageType;
Data = data;
SessionId = sessionId;
}
public virtual Task Send(ArraySegment <byte> data,
SocketMessageType messageType,
bool EndOfMessage)
{
var bIsHighPrority = true; // puts it at the begining of the Q
return(makeSendTask(data, messageType, EndOfMessage, bIsHighPrority));
}
public virtual Task Post(ArraySegment <byte> data,
SocketMessageType messageType,
bool EndOfMessage)
{
var bIsHighPrority = false; // puts it at the end of the Q
return(makeSendTask(data, messageType, EndOfMessage, bIsHighPrority));
}
public static SocketMessage Create(SocketMessageType SocketMessageType, IDto dto, string memberName, int paramsCount, object value)
{
return(new SocketMessage(value)
{
MessageType = SocketMessageType,
DtoGuid = dto?.DtoGuid ?? Guid.Empty,
MemberName = memberName,
ParametersCount = paramsCount
});
}
public virtual Task PostToAll(byte[] buffer, SocketMessageType messageType)
{
var postAllTasks = new List <Task>();
foreach (var session in m_sessions.Values)
{
postAllTasks.Add(Task.Factory.StartNew(() => { session.Post(buffer, messageType); }));
}
return(Task.WhenAll(postAllTasks));
}
protected virtual Task makeSendTask(ArraySegment <byte> data,
SocketMessageType messageType,
bool EndOfMessage,
bool isHighPriority)
{
var lt = new LeveledTask(() => m_SendAsync(data, (int)messageType, EndOfMessage, m_root_factory_working_token).Wait());
lt.QueueId = m_SessionId;
lt.IsHighPriority = isHighPriority;
lt.Start(m_Scheduler);
return(lt);
}
private static ISocketConverter GetConverter(SocketMessageType msgType)
{
ISocketConverter converter = null;
switch (msgType)
{
case SocketMessageType.Message:
converter = new MessageConverter();
break;
}
if (converter == null)
{
throw new UnkonwMessageTypeException();
}
return(converter);
}
public void Send(byte[] data, IInstance address = null, SocketMessageType type = SocketMessageType.Data, bool checkState = false)
{
var buffer = EndPointMessage.Write(new EndPointMessage()
{
SenderName = instance.Id.ToString(),
SenderEndPoint = endPoint,
Type = type,
Data = data
});
if (type == SocketMessageType.Login)
{
Instance.DBTable.Load();
}
foreach (IInstance item in Instance.DBTable)
{
if (CheckAddress(item, address, checkState))
{
Send(buffer, item.EndPoint, item);
}
}
}
public MessageTypeAttribute(SocketMessageType messageType)
{
MessageType = messageType;
}
public SocketMessageUpdate(SocketMessageType type, object message)
{
Type = type;
Message = message;
}
public SocketPortData(SocketMessageType DataType, ClientSocketControl ClientSocketCtrl)
{
this._DataType = DataType;
this._ClientSocketCtrl = ClientSocketCtrl;
}
public static string Process(SocketMessageType msgType, string message)
{
ISocketConverter converter = GetConverter(msgType);
return(converter.Process(message));
}
public LogOutEventArgs(SocketMessageType messclass, string str)
{
messClass = messclass;
mess = str;
}
public SocketErrorMessage(int connectionID, SocketMessageType messageType, int errorcode, string message, int taskID = 0)
: base(connectionID, messageType, null, taskID)
{
ErrorCode = errorcode;
Message = message;
}
public virtual Task Post(byte[] data, SocketMessageType messageType)
{
var arraySegement = new ArraySegment <byte>(data);
return(Post(arraySegement, messageType, true));
}
public JsonSocketMessage(SocketMessageType messageType)
: this(Encoding.ASCII, messageType)
{
}
