Updated example.

Replaced InnerNetObjectAttribute with IgnoreInnerNetObjectAttribute, now automatically registers InnerNetObjects.
Added more methods to load prefab.

Author: D1GQ

Reactor.Example/ExampleInnerNetObject.cs

@@ -1,43 +1,71 @@
 using System;
+using System.Threading.Tasks;
 using Hazel;
 using InnerNet;
 using Reactor.Networking.Attributes;
-using UnityEngine;
 
 namespace Reactor.Example;
 
-[InnerNetObject]
+// The `IgnoreInnerNetObject` attribute is used to prevent this custom InnerNetObject
+// from being automatically registered by Reactor.
+[IgnoreInnerNetObject]
 public class ExampleInnerNetObject : InnerNetObject
 {
-    // Method one of retrieving a prefab.
-    // Be sure to only use one method!
+    // The `InnerNetObjectPrefab` attribute is used to define how the prefab for this
+    // custom InnerNetObject is retrieved. The prefab is a template object that is used
+    // when spawning instances of this object in the game.
+    // There are three examples provided for retrieving the prefab:
+
+    // Example 1: Directly assign a prefab
+    // This is the simplest method, where the prefab is assigned directly to a static field or property.
+    [InnerNetObjectPrefab]
+    public static InnerNetObject? PrefabField;
+    // or
+    [InnerNetObjectPrefab]
+    public static InnerNetObject? PrefabProperty { get; set; }
+
+    // Example 2: Retrieve the prefab via a static method
+    // This method allows for more complex logic to retrieve the prefab.
+    // The method must be static and return an InnerNetObject (or a GameObject with an InnerNetObject component).
     [InnerNetObjectPrefab]
-    public static InnerNetObject GetPrefabByInnerNetObject()
+    public static InnerNetObject GetPrefab()
     {
         throw new NotImplementedException($"GetPrefab prefab retrieval not implemented!");
     }
 
-    // Method two of retrieving a prefab.
-    // Be sure to only use one method!
+    // Example 3: Retrieve the prefab asynchronously
+    // This method is similar to Example 2 but allows for asynchronous operations,
+    // such as loading assets from disk.
     [InnerNetObjectPrefab]
-    public static GameObject GetPrefabByGameObject()
+    public static async Task<InnerNetObject> GetPrefabAsync()
     {
         throw new NotImplementedException($"GetPrefab prefab retrieval not implemented!");
     }
 
-    // Must be defined; in InnerNetObject, the method is abstract, so if not, an error will be thrown.
+    // The `HandleRpc` method is required abstract to handle Remote Procedure Calls (RPCs) for this object.
+    // RPCs are used to communicate between clients and the server.
+    // The `callId` parameter identifies the type of RPC, and the `reader` parameter provides the data.
     public override void HandleRpc(byte callId, MessageReader reader)
     {
+        // Implement logic to handle specific RPCs based on the `callId`.
+        // For example, you might switch on `callId` to handle different types of RPCs.
     }
 
-    // Must be defined; in InnerNetObject, the method is abstract, so if not, an error will be thrown.
+    // The `Serialize` method is required abstract to serialize the state of this object into a `MessageWriter`.
+    // This is used to synchronize the object's state across the network.
+    // The `initialState` parameter indicates whether this is the first time the object is being serialized.
     public override bool Serialize(MessageWriter writer, bool initialState)
     {
+        // Implement logic to write the object's state to the `writer`.
+        // Return `true` if the state was serialized successfully, otherwise `false`.
         return false;
     }
 
-    // Must be defined; in InnerNetObject, the method is abstract, so if not, an error will be thrown.
+    // The `Deserialize` method is required abstract to deserialize the state of this object from a `MessageReader`.
+    // This is used to update the object's state based on data received from the network.
+    // The `initialState` parameter indicates whether this is the first time the object is being deserialized.
     public override void Deserialize(MessageReader reader, bool initialState)
     {
+        // Implement logic to read the object's state from the `reader`.
     }
 }

Reactor/Networking/Attributes/InnerNetObjectAttribute.cs Reactor/Networking/Attributes/IgnoreInnerNetObjectAttribute.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using System.Threading.Tasks;
 using BepInEx.Unity.IL2CPP;
 using HarmonyLib;
 using InnerNet;
@@ -10,16 +11,16 @@
 namespace Reactor.Networking.Attributes;
 
 /// <summary>
-/// Automatically registers a custom <see cref="InnerNetObject"/>.
+/// Ignores registering <see cref="InnerNetObject"/>.
 /// </summary>
 [AttributeUsage(AttributeTargets.Class)]
-public sealed class InnerNetObjectAttribute : Attribute
+public sealed class IgnoreInnerNetObjectAttribute : Attribute
 {
     private static readonly HashSet<Assembly> _registeredAssemblies = new();
-    private static readonly HashSet<MethodInfo> _registeredMethods = new();
+    private static readonly HashSet<MemberInfo> _registeredMembers = new();
 
     /// <summary>
-    /// Registers all <see cref="InnerNetObject"/>s annotated with <see cref="InnerNetObjectAttribute"/> in the specified <paramref name="assembly"/>.
+    /// Registers all <see cref="InnerNetObject"/>s annotated with out <see cref="IgnoreInnerNetObjectAttribute"/> in the specified <paramref name="assembly"/>.
     /// </summary>
     /// <remarks>This is called automatically on plugin assemblies so you probably don't need to call this.</remarks>
     /// <param name="assembly">The assembly to search.</param>
@@ -30,31 +31,41 @@ public static void Register(Assembly assembly)
 
         foreach (var type in assembly.GetTypes())
         {
-            var attribute = type.GetCustomAttribute<InnerNetObjectAttribute>();
+            if (!type.IsSubclassOf(typeof(InnerNetObject))) continue;
 
-            if (attribute != null)
-            {
-                if (!type.IsSubclassOf(typeof(InnerNetObject)))
-                {
-                    throw new InvalidOperationException($"Type {type.FullDescription()} has {nameof(InnerNetObjectAttribute)} but doesn't extend {nameof(InnerNetObject)}.");
-                }
+            var attribute = type.GetCustomAttribute<IgnoreInnerNetObjectAttribute>();
 
+            if (attribute == null)
+            {
                 try
                 {
-                    var methods = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
-
-                    var prefabMethod = methods.FirstOrDefault(method =>
-                        method.GetCustomAttribute<InnerNetObjectPrefabAttribute>() != null &&
-                        (method.ReturnType == typeof(GameObject) || method.ReturnType == typeof(InnerNetObject)) &&
-                        method.IsStatic);
+                    var members = type.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
 
-                    if (prefabMethod != null)
+                    var prefabMember = members.FirstOrDefault(member =>
                     {
-                        _registeredMethods.Add(prefabMethod);
+                        if (member is MethodInfo method)
+                        {
+                            return method.IsStatic && (method.ReturnType == typeof(GameObject) || method.ReturnType == typeof(InnerNetObject) || method.ReturnType == typeof(Task<GameObject>) || method.ReturnType == typeof(Task<InnerNetObject>));
+                        }
+                        else if (member is FieldInfo field)
+                        {
+                            return field.IsStatic && (field.FieldType == typeof(GameObject) || field.FieldType == typeof(InnerNetObject));
+                        }
+                        else if (member is PropertyInfo property)
+                        {
+                            return property.GetMethod?.IsStatic == true && (property.PropertyType == typeof(GameObject) || property.PropertyType == typeof(InnerNetObject));
+                        }
+
+                        return false;
+                    });
+
+                    if (prefabMember != null)
+                    {
+                        _registeredMembers.Add(prefabMember);
                     }
                     else
                     {
-                        Warning($"Failed to register InnerNetObject, static prefab return method not found.");
+                        Warning($"Failed to register InnerNetObject, static prefab return member not found.");
                     }
                 }
                 catch (Exception ex)
@@ -65,19 +76,51 @@ public static void Register(Assembly assembly)
         }
     }
 
-    internal static void LoadRegistered()
+    internal static async Task LoadRegisteredAsync()
     {
-        if (_registeredMethods.Count > 0) // Increase array length by one because of beginning if check in InnerNetClient.CoHandleSpawn()
+        if (_registeredMembers.Count > 0) // Increase array length by one because of beginning if check in InnerNetClient.CoHandleSpawn()
         {
             var innerNetClient = AmongUsClient.Instance;
             var list2 = innerNetClient.SpawnableObjects.ToList();
             list2.Add(new());
             innerNetClient.SpawnableObjects = list2.ToArray();
         }
 
-        foreach (var prefabMethod in _registeredMethods)
+        foreach (var prefabMember in _registeredMembers)
         {
-            var prefab = prefabMethod.Invoke(null, null);
+            object? prefab = null;
+
+            if (prefabMember is MethodInfo method)
+            {
+                if (method.ReturnType == typeof(Task<GameObject>) || method.ReturnType == typeof(Task<InnerNetObject>))
+                {
+                    if (method.Invoke(null, null) is Task task)
+                    {
+                        await task.ConfigureAwait(false);
+
+                        if (method.ReturnType == typeof(Task<GameObject>))
+                        {
+                            prefab = ((Task<GameObject>) task).Result;
+                        }
+                        else if (method.ReturnType == typeof(Task<InnerNetObject>))
+                        {
+                            prefab = ((Task<InnerNetObject>) task).Result;
+                        }
+                    }
+                }
+                else
+                {
+                    prefab = method.Invoke(null, null);
+                }
+            }
+            else if (prefabMember is FieldInfo field)
+            {
+                prefab = field.GetValue(null);
+            }
+            else if (prefabMember is PropertyInfo property)
+            {
+                prefab = property.GetValue(null);
+            }
 
             if (prefab == null)
             {

Reactor/Networking/Attributes/InnerNetObjectPrefabAttribute.cs

@@ -8,7 +8,7 @@ namespace Reactor.Networking.Attributes;
 /// Attribute for Load prefab method for custom <see cref="InnerNetObject"/>.
 /// </summary>
 /// <remarks>Must be static and return either <see cref="GameObject"/> with a <see cref="InnerNetObject"/> component, or a <see cref="InnerNetObject"/> prefab.</remarks>
-[AttributeUsage(AttributeTargets.Method)]
+[AttributeUsage(AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
 public sealed class InnerNetObjectPrefabAttribute : Attribute
 {
 }

Reactor/ReactorPlugin.cs

@@ -51,7 +51,7 @@ public ReactorPlugin()
         RegisterCustomRpcAttribute.Initialize();
         MessageConverterAttribute.Initialize();
         MethodRpcAttribute.Initialize();
-        InnerNetObjectAttribute.Initialize();
+        IgnoreInnerNetObjectAttribute.Initialize();
 
         LocalizationManager.Register(new HardCodedLocalizationProvider());
     }
@@ -83,7 +83,7 @@ public override void Load()
     /// <inheritdoc />
     public void LateLoad()
     {
-        InnerNetObjectAttribute.LoadRegistered();
+        _ = IgnoreInnerNetObjectAttribute.LoadRegisteredAsync();
     }
 
     /// <inheritdoc />