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}");
}
}
}
