public Server(ILogger logger, IDatabase database) { _logger = logger; _database = database; foreach (var method in GetType().GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)) { var attribute = method.GetCustomAttribute <PacketAttribute>(); if (attribute != null) { if (_packetMethods.ContainsKey(attribute.Header)) { throw new InvalidProgramException($"Duplicate headers of packet method '{method.Name}'. Overloading is not supported."); } var packetMethod = new PacketMethod(this, attribute.Header, method); var parameters = method.GetParameters(); foreach (var parameter in parameters) { if (string.Compare(parameter.Name, "client", true) == 0) { if (parameter.ParameterType != typeof(ServerClient)) { throw new InvalidProgramException($"Invalid dependency injection parameter type for method: {method.Name}"); } packetMethod.AddParameter(PacketMethodParameter.Client); } else if (string.Compare(parameter.Name, "requestId", true) == 0) { if (parameter.ParameterType != typeof(int)) { throw new InvalidProgramException($"Invalid dependency injection parameter type for method: {method.Name}"); } packetMethod.AddParameter(PacketMethodParameter.RequestId); } else if (string.Compare(parameter.Name, "buffer", true) == 0) { if (parameter.ParameterType != typeof(DataBuffer)) { throw new InvalidProgramException($"Invalid dependency injection parameter type for method: {method.Name}"); } packetMethod.AddParameter(PacketMethodParameter.Buffer); } else { throw new InvalidProgramException($"Invalid dependency parameter for method '{method.Name}': ({parameter.ParameterType.FullName}) {parameter.Name}"); } } packetMethod.UpdateParameters(); _packetMethods.Add(attribute.Header, packetMethod); } } }
public static bool AddPacketHandler(PacketType packetType, PacketMethod handler) { bool result = false; lock (PacketHandlers) { if (!PacketHandlers.ContainsKey(packetType)) { PacketHandlers.Add(packetType, handler); result = true; } } return(result); }
public bool AddLocalPacketHandler(PacketType packetType, PacketMethod handler, bool runasync) { bool result = false; lock (m_packetHandlers) { if (!m_packetHandlers.ContainsKey(packetType)) { m_packetHandlers.Add(packetType, new PacketProcessor { method = handler, Async = runasync }); result = true; } } return(result); }
/// <summary> /// Try to process a packet using registered packet handlers /// </summary> /// <param name="packet"></param> /// <returns>True if a handler was found which successfully processed the packet.</returns> bool ProcessPacketMethod(Packet packet) { bool result = false; PacketProcessor pprocessor; bool localHandler; lock (m_packetHandlers) { localHandler = m_packetHandlers.TryGetValue(packet.Type, out pprocessor); } if (localHandler) { //there is a local handler for this packet type if (pprocessor.Async) { object obj = new AsyncPacketProcess(this, pprocessor.method, packet); m_udpServer.FireAndForget(ProcessSpecificPacketAsync, obj); result = true; } else { result = pprocessor.method(this, packet); } return(result); } //there is not a local handler so see if there is a Global handler PacketMethod method = null; bool found; lock (PacketHandlers) { found = PacketHandlers.TryGetValue(packet.Type, out method); } if (found) { result = method(this, packet); } return(result); }
public bool AddLocalPacketHandler(PacketType packetType, PacketMethod handler) { bool result = false; lock (m_packetHandlers) { if (!m_packetHandlers.ContainsKey(packetType)) { m_packetHandlers.Add(packetType, handler); result = true; } } return result; }
public bool AddLocalPacketHandler(PacketType packetType, PacketMethod handler) { return(AddLocalPacketHandler(packetType, handler, true)); }
public AsyncPacketProcess(LLClientView pClientview, PacketMethod pMethod, Packet pPack) { ClientView = pClientview; Method = pMethod; Pack = pPack; }