我有一个C＃脚本，可以连接到服务器并发送/接收一些命令和响应。
const defaults= {}
module.exports= function(options) {
options=Object.assign({},defaults,options)
return function(hook) {
hook.params.sequelize= {
include:[hook.app.services.movie.Model]
}
}
}
我正在寻找响应中的关键字（returnValue = 0），并根据查询时根据该数据进行搜索。
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using UnityEngine;
using System.Collections;
// State object for receiving data from remote device.
public class StateObject
{
// Size of receive buffer.
public const int BufferSize = 256;
// Receive buffer.
public byte[] buffer = new byte[BufferSize];
// Received data string.
public StringBuilder sb = new StringBuilder();
// Client socket.
public Socket workSocket;
}
public class AsynchronousClient : MonoBehaviour
{
public GameObject chatContainer;
public GameObject messagePrefab;
// The port number for the remote device.
private const int port = 5002;
// ManualResetEvent instances signal completion.
private static readonly ManualResetEvent connectDone =
new ManualResetEvent(false);
private static readonly ManualResetEvent sendDone =
new ManualResetEvent(false);
private static readonly ManualResetEvent receiveDone =
new ManualResetEvent(false);
// The response from the remote device.
private static string response = string.Empty;
public void StartClient()
{
// Connect to a remote device.
try
{
// Establish the remote endpoint for the socket.
var ipAddress = IPAddress.Parse("localhost");
var remoteEP = new IPEndPoint(ipAddress, port);
// Create a TCP/IP socket.
var client = new Socket(ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
// Connect to the remote endpoint.
client.BeginConnect(remoteEP,
ConnectCallback, client);
connectDone.WaitOne();
var data1 =
"example request 1";
data1 += '\0';
var data2 =
"example request2";
data2 += '\0';
//Send test data to the remote device.
Send(client, data1);
Send(client, data2);
//sendDone.WaitOne();
// Receive the response from the remote device.
Receive(client);
// 10 saniye gozleyir sonra socket ve clienti close edir
//receiveDone.WaitOne(1000);
// yield return new WaitForSeconds(1);
// Write the response to the console.
// Release the socket.
// client.Shutdown(SocketShutdown.Both);
//client.Close();
}
catch (Exception e)
{
Debug.Log(e.ToString());
}
}
private void ConnectCallback(IAsyncResult ar)
{
try
{
// Retrieve the socket from the state object.
var client = (Socket)ar.AsyncState;
// Complete the connection.
client.EndConnect(ar);
Debug.Log("Socket connected to {0}" +
client.RemoteEndPoint);
// Signal that the connection has been made.
connectDone.Set();
}
catch (Exception e)
{
Debug.Log(e.ToString());
}
}
private void Receive(Socket client)
{
try
{
// Create the state object.
var state = new StateObject();
state.workSocket = client;
// Begin receiving the data from the remote device.
client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
ReceiveCallback, state);
}
catch (Exception e)
{
Debug.Log(e.ToString());
}
}
private void ReceiveCallback(IAsyncResult ar)
{
try
{
// Retrieve the state object and the client socket
// from the asynchronous state object.
var state = (StateObject)ar.AsyncState;
var client = state.workSocket;
// Read data from the remote device.
var bytesRead = client.EndReceive(ar);
if (bytesRead > 0)
{
// There might be more data, so store the data received so far.
string receieved = Encoding.ASCII.GetString(state.buffer, 1, bytesRead);
state.sb.Append(receieved);
Debug.Log(receieved);
var ok = "returnValue=\"0\"";
if (receieved.Contains(ok)){
Debug.Log("yehuuuuu");
}
// Get the rest of the data.
client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
ReceiveCallback, state);
}
else
{
// All the data has arrived; put it in response.
if (state.sb.Length > 1) response = state.sb.ToString();
// Signal that all bytes have been received.
receiveDone.Set();
}
}
catch (Exception e)
{
Debug.Log(e.ToString());
}
}
private void Send(Socket client, string data)
{
// Convert the string data to byte data using ASCII encoding.
var byteData = Encoding.ASCII.GetBytes(data);
// Begin sending the data to the remote device.
client.BeginSend(byteData, 0, byteData.Length, 0,
SendCallback, client);
}
private void SendCallback(IAsyncResult ar)
{
try
{
// Retrieve the socket from the state object.
var client = (Socket)ar.AsyncState;
// Complete sending the data to the remote device.
var bytesSent = client.EndSend(ar);
Debug.Log("Sent {0} bytes to server." + bytesSent);
// Signal that all bytes have been sent.
sendDone.Set();
}
catch (Exception e)
{
Debug.Log(e.ToString());
}
}
}
但是我需要做的是：我想在服务器之间来回发送/接收数据，并在不同的文件和位置中设置一些条件，如上面的“ if”。因此，我将拥有一个可以进行常规控制的文件，以及一个可以发送/接收数据的文件（还可以进行一些查询）。
我试图使用全局类在另一个文件中调用public函数，但是无法产生工作结果。我是否必须做一个新功能，使我可以在任何文件中与服务器之间收发数据？任何帮助将不胜感激。
答案 0 :(得分：0)
解决方法可能很多，因此您可能需要使用最佳判断。首先管理客户端本身。您可以有一个静态类来处理它，但要注意并发问题。
public static class RemoteClient
{
// Prepare and maintain
}
您还可以通过构造函数将客户端传递到将使用该客户端的对象中。
public class GameBehavior
{
private readonly AsynchronousClient _client;
public GameBehavior(AsynchronousClient client)
{
_client = client;
}
}
请记住，如果有多个事物正在访问客户端，那么您将需要一个支持多线程访问它的客户端。服务器代码也是如此。并发本身是知识的整个子领域，您真正需要从底层开始进行理解。