public static void SqlTrigger()
{
var context = SqlContext.TriggerContext;
if (context == null || context.TriggerAction != TriggerAction.Insert)
{
return;
}
using (
var con =
new SqlConnection(" context connection=true"))
{
con.Open();
using (var cmd = new SqlCommand("SELECT Name FROM INSERTED", con))
{
using (var reader = cmd.ExecuteReader())
{
var pipe = SqlContext.Pipe;
if (pipe == null)
{
return;
}
while (reader.Read())
{
pipe.Send(reader[0].ToString());
var sender = new SocketSender();
sender.MessageReceived += (o, message) => pipe.Send(message);
sender.Send(reader[0].ToString());
}
}
}
}
}
public Guid CreateSession(SocketSender socketSender)
{
var id = Guid.NewGuid();
sessions[id] = new Session(id, pluginProvider, socketSender);
return(id);
}
public IPlugin Create(HardwareDetails details, SocketSender socketSender)
{
var controllerType = details.ControllerType;
var boardName = details
.BoardName;
return(pluginCreators[controllerType][boardName]?.Invoke(details, socketSender));
}
public SocketConnection(EndPoint endpoint)
{
_socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
_endpoint = endpoint;
_sender = new SocketSender(_socket, PipeScheduler.ThreadPool);
_receiver = new SocketReceiver(_socket, PipeScheduler.ThreadPool);
Features.Set <IConnectionInherentKeepAliveFeature>(this);
}
public static void TransmitPacket(MemoryStream m, int connectionId)
{
m.Position = 0;
SocketSender.SendPacket(m, connectionId);
// Decode it
//m.Position = 0;
//LiteNetworkingGenerated.PacketReader.ReadPacket(m);
}
void OnEnable()
{
SocketReceiver.OnLeftRoom += OnLeftRoom;
SocketReceiver.OnGotPlayerList += OnGotPlayerList;
SocketReceiver.OnRoomReady += OnRoomReady;
SocketSender.Send("GetPlayerList", SocketLobby.Room.roomID);
}
public UdpSocket()
{
var socket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
m_Socket = socket;
m_Sender = new SocketSender(m_Socket);
m_Receiver = new SocketRecevier(m_Socket, SocketMessageFactory.Instance);
}
void Start()
{
connectButton.onClick.AddListener(() => {
connectButton.interactable = false;
SocketLobby.Instance.SetGameServerUrl(serverInput.text);
SocketSender.Send("Connect", SocketLobby.Instance.settings.gameServerUrl);
});
}
void UpdatePlayer()
{
UpdatePlayerData updatePlayerData = new UpdatePlayerData();
updatePlayerData.roomID = SocketLobby.Room.roomID;
updatePlayerData.player = player;
SocketLobby.Instance.SetPlayer(player);
SocketSender.Send("UpdatePlayer", JsonUtility.ToJson(updatePlayerData));
}
public void Start(string serverHost, int serverPort, int socketTimeout = 3000)
{
try
{
this.SocketSender = new SocketSender(serverHost, serverPort, socketTimeout);
}
catch
{
throw;
}
}
public void Cleanup()
{
if (this.Sender != null)
{
this.Sender = null;
}
if (this.Listener != null)
{
this.Listener.Stop();
}
}
void Start()
{
roomName.text = SocketLobby.Room.roomName;
leaveRoomButton.onClick.AddListener(() => {
leaveRoomButton.interactable = false;
leaveRoomLoading.SetActive(true);
SocketSender.Send("LeaveRoom", SocketLobby.Room.roomID);
});
}
public TcpConnection(EndPoint endPoint)
{
_socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
_endPoint = endPoint;
_sender = new SocketSender(_socket, PipeScheduler.ThreadPool);
_receiver = new SocketReceiver(_socket, PipeScheduler.ThreadPool);
// Add IConnectionInherentKeepAliveFeature to the tcp connection impl since Kestrel doesn't implement
// the IConnectionHeartbeatFeature
Features.Set <IConnectionInherentKeepAliveFeature>(this);
}
IEnumerator CountDown()
{
for (int i = countdown - 1; i > 0; i--)
{
yield return(new WaitForSeconds(1f));
startGameCountDownText.text = i.ToString();
}
yield return(new WaitForSeconds(1f));
SocketSender.Send("StartGame", SocketLobby.Room.roomID);
}
private static void Main()
{
var sender = new SocketSender();
sender.Error += Sender_Error;
sender.MessageReceived += Sender_MessageReceived;
while (true)
{
Console.Write("Message: ");
var message = Console.ReadLine();
sender.Send(message);
}
}
public async ValueTask OpenAsync(string host, string database, string userName, string password,
CancellationToken cancellationToken)
{
m_connectorState = ConnectorState.Connecting;
var socketTask = ConnectAsync(host);
var socket = socketTask.IsCompletedSuccessfully
? socketTask.Result
: await socketTask.ConfigureAwait(false);
var sendBufferBytes = m_arrayPool.Rent(512);
var receiveBufferBytes = m_arrayPool.Rent(512);
try
{
var sendBuffer = new Memory <byte>(sendBufferBytes);
var receiveBuffer = new Memory <byte>(sendBufferBytes);
var sender = new SocketSender(socket);
var sendStartupMessageTask =
SendStartupMessage(sender, sendBuffer, database, userName, cancellationToken);
if (!sendStartupMessageTask.IsCompletedSuccessfully)
{
await sendStartupMessageTask.ConfigureAwait(false);
}
var receiver = new SocketReceiver(socket);
var processStartupMessageResponseTask = ProcessStartupMessageResponse(sender, sendBuffer, receiver, receiveBuffer,
userName, password, cancellationToken);
if (!processStartupMessageResponseTask.IsCompletedSuccessfully)
{
await processStartupMessageResponseTask.ConfigureAwait(false);
}
m_connectorState = ConnectorState.ReadyForQuery;
m_connectionInfo = new ConnectionInfo();
m_connectionInfo.Host = host;
m_connectionInfo.Database = database;
m_connectionInfo.UserName = userName;
m_connectionInfo.Password = password;
m_socket = socket;
}
finally
{
m_arrayPool.Return(sendBufferBytes);
m_arrayPool.Return(receiveBufferBytes);
}
}
public void SetRoom(RoomData room)
{
this.room = room;
roomName.text = room.roomName;
roomPlayers.text = room.playerCount.ToString() + "/" + SocketLobby.Instance.settings.maxPlayersPerRoom.ToString();
joinRoomButton.onClick.AddListener(() => {
joinRoomButton.interactable = false;
transform.parent.parent.GetComponent <LobbyPanel>().joinRoomLoading.SetActive(true);
SocketSender.Send("JoinRoom", room.roomID);
});
}
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
// TODO: dispose managed state (managed objects).
}
device = null;
socketSender = null;
disposedValue = true;
}
}
public void TestSocketSender()
{
SocketSender _sender = new SocketSender(this.ServerHost, this.ServerPort, this.SocketTimeout);
var _data = _sender.Send(Encoding.Default.GetBytes(this.Send));
if (_data != null && _data.Length > 0)
{
this.ResponseReceived = Encoding.Default.GetString(_data);
}
bool _result = ManualResetEvent.WaitOne(this.SocketTimeout);
_sender = null;
Assert.AreEqual(true, _result, "Listener接收socket超时");
Assert.AreEqual(this.Send, this.SendReceived, string.Format("Client发送内容：{0}，Listener监听到内容：{1}", this.Send, this.SendReceived));
Assert.AreEqual(this.Response, this.ResponseReceived, string.Format("Listener响应内容：{0}，Client接收到响应：{1}", this.Response, this.ResponseReceived));
}
private void SendReceive(Socket client)
{
ISocketReceiver <string> _receiver = new SocketReceiver(_client, 1024, 128);
ISocketSender <string> _sender = new SocketSender(_client);
while (true)
{
if (client != null && !client.Connected)
{
break;
}
else if (client != null && client.Connected)
{
_sender.Send("", new ServerSenderAuthenticationLogic());
_receiver.Read(new ServerReceiverAuthenticationLogic());
}
Thread.Sleep(1000);
}
}
protected override void SendReceive()
{
ISocketSender sender = new SocketSender(_client);
ISocketReceiver receiver = new SocketReceiver(_client);
ILogic authen = new BaseSocketLogic(new SocketAuthenLogic(sender, receiver), _client);
ILogic biz = new BaseSocketLogic(new SocketBusinessLogic(sender, receiver), _client);
LogicFlowModel[] logics =
{
//new LogicFlowModel { Logic = authen, Seq = 3 },
new LogicFlowModel {
Logic = biz, Seq = 5
}
};
BaseLogicFlow logicMgr = new SocketLogicFlow(logics);
logicMgr.Execute();
}
void Start()
{
ui = GetComponent <SocketLobbyUI>();
ConfigData config = new ConfigData();
config.maxPlayersPerRoom = settings.maxPlayersPerRoom;
config.minPlayerToStartGame = settings.minPlayersToStartGame;
config.playerColors = settings.playerColors;
config.defaultPlayerColor = settings.defaultPlayerColorIndex;
SocketSender.Send("SetConfig", JsonUtility.ToJson(config));
ui.CreateTopPanel();
ui.CreateConnectPanel();
SocketReceiver.OnConnected += OnConnected;
SocketReceiver.OnDisconnected += OnDisconnected;
SocketReceiver.OnConnectionTimeout += OnConnectionTimeout;
SocketReceiver.OnStartedGame += OnStartedGame;
}
void Start()
{
roomNameInput.text = defaultRoomName;
createRoomButton.onClick.AddListener(() => {
roomNameInput.interactable = false;
createRoomButton.interactable = false;
createRoomLoading.SetActive(true);
SocketSender.Send("CreateRoom", roomNameInput.text == "" ? defaultRoomName : roomNameInput.text);
});
refreshButton.onClick.AddListener(() => {
refreshButton.interactable = false;
fetchRoomListLoading.SetActive(true);
SocketSender.Send("GetRoomList");
});
fetchRoomListLoading.SetActive(true);
SocketSender.Send("GetRoomList");
}
public static void Init()
{
Listener = new SocketListener();
Thread listenThread = new Thread(Listener.Listen);
listenThread.Start();
Sender = new SocketSender("localhost");
Listener.OnMessageRecieve += Listener_OnMessageRecieve;
try
{
SendMessageLoop();
}
catch (Exception e)
{
Console.WriteLine("[HashMessenger] " + e);
}
Listener.Dispose();
Sender.Dispose();
}
public async ValueTask Cancel(CancellationToken cancellationToken)
{
if (m_processId == 0)
{
ThrowHelper.ThrowPostgresException("Cancellation not supported on this database (no BackendKeyData was received during connection)");
}
var connectionInfo = m_connectionInfo;
await using var connector = new PgConnector(m_arrayPool);
var openTask = connector.OpenAsync(connectionInfo.Host, connectionInfo.Database, connectionInfo.UserName,
connectionInfo.Password, cancellationToken);
if (!openTask.IsCompletedSuccessfully)
{
await openTask.ConfigureAwait(false);
}
var cancelRequest = new CancelRequest(m_processId, m_secretKey);
var socket = connector.m_socket !;
var sender = new SocketSender(socket);
var sendTask = connector.WriteAndSendMessage(sender, cancelRequest, cancellationToken);
if (sendTask.IsCompletedSuccessfully)
{
await sendTask.ConfigureAwait(false);
}
// Now wait for the server to close the connection, better chance of the cancellation
// actually being delivered before we continue with the user's logic.
var waitTask = connector.WaitForDisconnect(socket, cancellationToken);
if (waitTask.IsCompletedSuccessfully)
{
await waitTask.ConfigureAwait(false);
}
}
public FakeSerialPlugin(HardwareDetails details, SocketSender socketSender)
{
this.socketSender = socketSender;
this.HardwareDetails = details;
}
private IPlugin CreateFakeSerialPlugin(HardwareDetails details, SocketSender socketSender)
{
return(new FakeSerialPlugin(details, socketSender));
}
public WriteSocketTests()
{
Services = new FakeServices();
Socket = new FakeSocket();
Sender = new SocketSender(Services, Socket);
}
public void Stop()
{
this.SocketSender = null;
}
void Awake()
{
_sender = new SocketSender();
_listener = new SocketListener();
}
