/// <summary>
/// Send query asynchronous
/// </summary>
/// <param name="requestType">Request type</param>
private void SendQueryAsync(ERequestResponseType requestType)
{
int index = (int)requestType;
threads[index] = new Thread(() => SendQuery(requestType));
requestsRequired.SetLastRequestTime(requestType);
threads[index].Start();
}
/// <summary>
/// Send query when expired
/// </summary>
/// <param name="requestType">Request type</param>
/// <param name="milliseconds">Milliseconds</param>
/// <returns>"true" if attempted sending query, othewrwise "false"</returns>
public bool SendQueryWhenExpiredAsync(ERequestResponseType requestType, uint milliseconds)
{
uint t = (uint)(DateTime.Now.Subtract(requestsRequired.GetLastRequestTime(requestType)).TotalMilliseconds);
bool ret = (t >= milliseconds);
if (ret)
{
SendQueryAsync(requestType);
}
return(ret);
}
/// <summary>
/// Abort thread
/// </summary>
/// <param name="requestType"></param>
private void AbortThread(ERequestResponseType requestType)
{
lock (threads)
{
int index = (int)requestType;
if (threads[index] != null)
{
threads[index].Abort();
threads[index] = null;
}
}
}
/// <summary>
/// Array element access operator
/// </summary>
/// <param name="requestType">Request type</param>
/// <returns>Request required</returns>
public bool this[ERequestResponseType requestType]
{
get
{
return(values[(int)requestType]);
}
set
{
if (available[(int)requestType])
{
values[(int)requestType] = value;
}
}
}
/// <summary>
/// Send query
/// </summary>
/// <param name="requestType">Request type</param>
/// <returns>Success</returns>
private bool SendQuery(ERequestResponseType requestType)
{
bool ret = false;
requestsRequired.SetLastRequestTime(requestType);
try
{
EndPoint endpoint = new IPEndPoint(IPAddress, Port);
using (MemoryStream stream = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(stream))
{
char op_code = RequestsRequired.GetOpCode(requestType);
writer.Write("SAMP".ToCharArray());
writer.Write(ipv4AddressUInt);
writer.Write(port);
writer.Write(op_code);
if (op_code == 'p')
{
Random r = new Random();
r.NextBytes(randomNumbers);
writer.Write(randomNumbers);
}
timestamp[0] = DateTime.Now;
}
if (socket.SendTo(stream.ToArray(), endpoint) > 0)
{
ret = true;
Receive();
}
}
}
catch (Exception e)
{
Console.Error.WriteLine(e);
}
return(ret);
}
/// <summary>
/// Fetch data asynchronous
/// </summary>
/// <param name="requestType">Request type</param>
public void FetchDataAsync(ERequestResponseType requestType)
{
AbortThread(requestType);
requestsRequired[requestType] = true;
SendQueryAsync(requestType);
}
/// <summary>
/// Is data fetched
/// </summary>
/// <param name="requestType">Request type</param>
/// <returns>Data fetched</returns>
public bool IsDataFetched(ERequestResponseType requestType)
{
return(!(requestsRequired[requestType]));
}
/// <summary>
/// Get last request time
/// </summary>
/// <param name="requestType">Request type</param>
/// <returns>Last request time</returns>
public DateTime GetLastRequestTime(ERequestResponseType requestType)
{
return(lastRequestTime[(int)requestType]);
}
/// <summary>
/// Get operation code
/// </summary>
/// <param name="requestType">Request type</param>
/// <returns>Operation code</returns>
public static char GetOpCode(ERequestResponseType requestType)
{
return(opCodes[(int)requestType]);
}
/// <summary>
/// Lock
/// </summary>
/// <param name="requestType">Request type</param>
public void Lock(ERequestResponseType requestType)
{
available[(int)requestType] = false;
values[(int)requestType] = false;
}
/// <summary>
/// Set last request time
/// </summary>
/// <param name="requestType">Request type</param>
public void SetLastRequestTime(ERequestResponseType requestType)
{
lastRequestTime[(int)requestType] = DateTime.Now;
}
