public void Start(int Port = 1337)
{
ServerSocket.OnNetworkExceptionOccurred += (x, y) => OnServerExceptionOccurred?.Start(this, new OnServerExceptionOccurredEventArgs(y.Exception));
ServerSocket.OnNetworkClientConnected += OnNetworkClientConnected;
ServerSocket.Listen(Port);
}
private void RegisterFunctions()
{
foreach (MethodInfo SharedMethod in typeof(T).GetMethods())
{
if (SharedMethod.GetCustomAttribute(typeof(NLCCall)) is NLCCall NLCAttribute)
{
if (RemotingMethods.ContainsKey(NLCAttribute.Identifier))
{
OnServerExceptionOccurred?.Start(this, new OnServerExceptionOccurredEventArgs(new Exception($"Method with identifier {NLCAttribute.Identifier} already exists!")));
continue;
}
var IsAsync = SharedMethod.GetCustomAttribute(typeof(AsyncStateMachineAttribute)) is AsyncStateMachineAttribute;
var ReturnType = SharedMethod.ReturnType;
var HasAsyncResult = ReturnType.IsGenericType && ReturnType.GetGenericTypeDefinition() == typeof(Task <>);
if (!HasAsyncResult && IsAsync && ReturnType != typeof(Task))
{
throw new Exception($"Shared function {NLCAttribute.Identifier} is asynchronous but does not return a Task!");
}
RemotingMethods.Add(NLCAttribute.Identifier, new RemotingMethod()
{
Method = Helpers.CreateMethodWrapper(typeof(T), SharedMethod),
WithContext = NLCAttribute.WithContext,
HasAsyncResult = HasAsyncResult
});
}
}
}
private async void OnNetworkMessageReceived(object sender, OnNetworkMessageReceivedEventArgs e)
{
if (e.Message.Header != NetworkHeader.HEADER_CALL && e.Message.Header != NetworkHeader.HEADER_MOVE)
{
OnServerExceptionOccurred?.Start(this, new OnServerExceptionOccurredEventArgs(new Exception("Invalid message type received!")));
return;
}
var RemoteEndPoint = ((NLCSocket)sender).BaseSocket.RemoteEndPoint;
object Result = null;
NetworkHeader ResultHeader;
if (!RemotingMethods.TryGetValue(e.Message.Tag, out var TargetMethod))
{
OnServerExceptionOccurred?.Start(this, new OnServerExceptionOccurredEventArgs(new Exception("Client attempted to invoke invalid function!")));
ResultHeader = NetworkHeader.NONE;
}
else
{
var Parameters = new List <object>();
if (TargetMethod.WithContext)
{
Parameters.Add(RemoteEndPoint);
}
Parameters.AddRange((object[])e.Message.Data);
TimeSpan Duration = default(TimeSpan);
try
{
var sw = Stopwatch.StartNew();
Result = await TargetMethod.Method.InvokeWrapper(TargetMethod.HasAsyncResult, Clients[RemoteEndPoint].SharedClass, Parameters.ToArray());
sw.Stop();
Duration = sw.Elapsed;
ResultHeader = NetworkHeader.HEADER_RETURN;
}
catch (Exception ex)
{
OnServerExceptionOccurred?.Start(this, new OnServerExceptionOccurredEventArgs(ex));
ResultHeader = NetworkHeader.HEADER_ERROR;
}
OnServerMethodInvoked?.Start(this, new OnServerMethodInvokedEventArgs(RemoteEndPoint, e.Message.Tag, Duration, ResultHeader == NetworkHeader.HEADER_ERROR));
}
var Event = new NetworkEvent(ResultHeader, e.Message.CallbackGuid, null, Result);
await((NLCSocket)sender).BlockingSend(Event);
}
private void NetworkExceptionOccurred(object sender, OnNetworkExceptionOccurredEventArgs e) => OnServerExceptionOccurred?.Start(this, new OnServerExceptionOccurredEventArgs(e.Exception));
