public static void RegisterAllPacketNestedTypesInAssembly(Assembly assembly, NetPacketProcessor packetProcessor) { System.Collections.Generic.IEnumerable <Type> nestedTypes = AssembliesUtils.GetTypesWithAttributeInAssembly <RegisterNestedTypeAttribute>(assembly); foreach (Type type in nestedTypes) { Log.Info($"Registering Nested Type: {type.Name}"); if (type.IsClass) { MethodInfo registerMethod = packetProcessor.GetType().GetMethods() .Where(m => m.Name == nameof(NetPacketProcessor.RegisterNestedType)) .FirstOrDefault(m => m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType.Name.Equals(typeof(Func <>).Name)) .MakeGenericMethod(type); MethodInfo delegateMethod = packetProcessor.GetType().GetMethod(nameof(NetPacketProcessor.CreateNestedClassInstance)).MakeGenericMethod(type); Type funcType = typeof(Func <>).MakeGenericType(type); Delegate callback = Delegate.CreateDelegate(funcType, packetProcessor, delegateMethod); registerMethod.Invoke(packetProcessor, new object[] { callback }); } else if (type.IsValueType) { MethodInfo method = typeof(NetPacketProcessor).GetMethod(nameof(NetPacketProcessor.RegisterNestedType), Type.EmptyTypes); MethodInfo generic = method.MakeGenericMethod(type); generic.Invoke(packetProcessor, null); } else { Log.Error($"Could not register nested type: {type.Name}. Must be a class or struct."); } } }
public static void RegisterAllPacketNestedTypes(NetPacketProcessor packetProcessor) { var nestedTypes = AssembliesUtils.GetTypesWithAttribute <RegisterNestedTypeAttribute>(); foreach (Type type in nestedTypes) { Console.WriteLine($"Registering Nested Type: {type.Name}"); if (type.IsClass) { // TODO: Find a better way to get the "NetPacketProcessor.RegisterNestedType" that as the Func<T> param instead of by index. MethodInfo registerMethod = packetProcessor.GetType() .GetMethods() .Where(m => m.Name == nameof(NetPacketProcessor.RegisterNestedType)) .ToArray()[2] .MakeGenericMethod(type); MethodInfo delegateMethod = packetProcessor.GetType().GetMethod(nameof(NetPacketProcessor.CreateNestedClassInstance)).MakeGenericMethod(type); var funcType = typeof(Func <>).MakeGenericType(type); var callback = Delegate.CreateDelegate(funcType, packetProcessor, delegateMethod); registerMethod.Invoke(packetProcessor, new object[] { callback }); } else if (type.IsValueType) { MethodInfo method = typeof(NetPacketProcessor).GetMethod(nameof(NetPacketProcessor.RegisterNestedType), Type.EmptyTypes); MethodInfo generic = method.MakeGenericMethod(type); generic.Invoke(packetProcessor, null); } else { Log.Error($"Could not register nested type: {type.Name}. Must be a class or struct."); } } }
public static void RegisterAllPacketProcessorsInCallingAssembly(NetPacketProcessor packetProcessor) { var processors = Assembly.GetCallingAssembly().GetTypes() .Where(t => t.GetCustomAttributes(typeof(RegisterPacketProcessorAttribute), true).Length > 0); foreach (Type type in processors) { var packetProcessorInterface = type.GetInterfaces().FirstOrDefault(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IPacketProcessor <>)); if (packetProcessorInterface != null) { Type packetType = packetProcessorInterface.GetGenericArguments().FirstOrDefault(); Console.WriteLine($"Registering {type.Name} to process packet of type: {packetType.Name}"); // Create instance of the processor Type delegateType = typeof(Action <,>).MakeGenericType(packetType, typeof(NebulaConnection)); object processor = Activator.CreateInstance(type); Delegate callback = Delegate.CreateDelegate(delegateType, processor, type.GetMethod("ProcessPacket")); // Register our processor callback to the PacketProcessor Type subscribeGenericType = typeof(Action <,>).MakeGenericType(packetType, typeof(NebulaConnection)); // TODO: Find a better way to get the "SubscribeReusable" that as the Action<T, TUserData> param. MethodInfo method = packetProcessor.GetType().GetMethods().Where(m => m.Name == "SubscribeReusable").ToArray()[1]; MethodInfo generic = method.MakeGenericMethod(packetType, typeof(NebulaConnection)); generic.Invoke(packetProcessor, new object[] { callback }); } } }
public static void RegisterAllPacketProcessorsInCallingAssembly(NetPacketProcessor packetProcessor) { var processors = Assembly.GetCallingAssembly().GetTypes() .Where(t => t.GetCustomAttributes(typeof(RegisterPacketProcessorAttribute), true).Length > 0); MethodInfo method = packetProcessor.GetType().GetMethods() .Where(m => m.Name == nameof(NetPacketProcessor.SubscribeReusable)) .Where(m => m.IsGenericMethod && m.GetGenericArguments().Length == 2) .FirstOrDefault(); foreach (Type type in processors) { var packetProcessorInterface = type.GetInterfaces().FirstOrDefault(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IPacketProcessor <>)); if (packetProcessorInterface != null) { Type packetType = packetProcessorInterface.GetGenericArguments().FirstOrDefault(); Console.WriteLine($"Registering {type.Name} to process packet of type: {packetType.Name}"); // Create instance of the processor Type delegateType = typeof(Action <,>).MakeGenericType(packetType, typeof(NebulaConnection)); object processor = Activator.CreateInstance(type); Delegate callback = Delegate.CreateDelegate(delegateType, processor, type.GetMethod(nameof(IPacketProcessor <object> .ProcessPacket))); // Register our processor callback to the PacketProcessor Type subscribeGenericType = typeof(Action <,>).MakeGenericType(packetType, typeof(NebulaConnection)); MethodInfo generic = method.MakeGenericMethod(packetType, typeof(NebulaConnection)); generic.Invoke(packetProcessor, new object[] { callback }); } else { Log.Warn($"{type.FullName} registered, but doesn't implement {typeof(IPacketProcessor<>).FullName}"); } } }
public static void RegisterAllPacketProcessorsInAssembly(Assembly assembly, NetPacketProcessor packetProcessor, bool isMasterClient) { System.Collections.Generic.IEnumerable <Type> processors = assembly.GetTypes() .Where(t => t.GetCustomAttributes(typeof(RegisterPacketProcessorAttribute), true).Length > 0); MethodInfo method = packetProcessor.GetType().GetMethods() .Where(m => m.Name == nameof(NetPacketProcessor.SubscribeReusable)) .Where(m => m.IsGenericMethod && m.GetGenericArguments().Length == 2) .FirstOrDefault(); bool isAPIAssemblies = NebulaModAPI.TargetAssemblies.Contains(assembly); foreach (Type type in processors) { if (IsSubclassOfRawGeneric(typeof(BasePacketProcessor <>), type)) { Type packetType = type.BaseType.GetGenericArguments().FirstOrDefault(); if (isAPIAssemblies) { Log.Info($"Registering {type.Name} to process packet of type: {packetType.Name}"); } else { Log.Debug($"Registering {type.Name} to process packet of type: {packetType.Name}"); } // Create instance of the processor Type delegateType = typeof(Action <,>).MakeGenericType(packetType, typeof(INebulaConnection)); object processor = Activator.CreateInstance(type); Delegate callback = Delegate.CreateDelegate(delegateType, processor, type.GetMethod(nameof(BasePacketProcessor <object> .ProcessPacket), new Type[] { packetType, typeof(INebulaConnection) })); // Initialize processor type.BaseType.GetMethod("Initialize", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(processor, new object[] { isMasterClient }); // Register our processor callback to the PacketProcessor Type subscribeGenericType = typeof(Action <,>).MakeGenericType(packetType, typeof(INebulaConnection)); MethodInfo generic = method.MakeGenericMethod(packetType, typeof(INebulaConnection)); generic.Invoke(packetProcessor, new object[] { callback }); } else { Log.Warn($"{type.FullName} registered, but doesn't implement {typeof(BasePacketProcessor<>).FullName}"); } } }