Añade soporte para detectar atributos MethodFlux en interfaces y actualiza la documentación correspondiente en README.md

Author: xavierarpa

Editor/Editors/MonoFluxEditor.cs

@@ -35,6 +35,9 @@ public partial class MonoFluxEditor : UnityEditor.Editor
         private MethodInfo[] methods_subscribeAttrb;
         private Dictionary<MethodInfo, object> dic_method_parameters;
         private Dictionary<MethodInfo, object> dic_method_outputs;
+        #pragma warning disable CS0618
+        private Dictionary<MethodInfo, FluxAttribute> dic_method_attributes;
+        #pragma warning restore CS0618
         private static bool ShowMethods
         { 
             get => PlayerPrefs.GetInt("__UniFlux.MonoFluxEditor.ShowBox", default) == default;
@@ -45,7 +48,43 @@ private void OnEnable()
             Type type = target.GetType();
             var methods = type.GetMethods((BindingFlags)(-1));
             #pragma warning disable CS0618
-            methods_subscribeAttrb = methods.Where(m => m.GetCustomAttributes(typeof(FluxAttribute), true).Length > 0).ToArray();
+            var discoveredMethods = new List<MethodInfo>();
+            dic_method_attributes = new Dictionary<MethodInfo, FluxAttribute>();
+
+            // Phase 1: methods with FluxAttribute on the concrete class
+            foreach (var m in methods)
+            {
+                if (Attribute.GetCustomAttributes(m).FirstOrDefault(a => a is FluxAttribute) is FluxAttribute attr)
+                {
+                    discoveredMethods.Add(m);
+                    dic_method_attributes[m] = attr;
+                }
+            }
+
+            // Phase 2: FluxAttributes declared on interface method definitions
+            var interfaces = type.GetInterfaces();
+            for (int i = 0; i < interfaces.Length; i++)
+            {
+                var map = type.GetInterfaceMap(interfaces[i]);
+                for (int j = 0; j < map.InterfaceMethods.Length; j++)
+                {
+                    var ifaceMethod = map.InterfaceMethods[j];
+                    if (Attribute.GetCustomAttributes(ifaceMethod).FirstOrDefault(a => a is FluxAttribute) is FluxAttribute attr)
+                    {
+                        var implMethod = map.TargetMethods[j];
+                        if (!dic_method_attributes.ContainsKey(implMethod))
+                        {
+                            dic_method_attributes[implMethod] = attr;
+                        }
+                        if (!discoveredMethods.Contains(implMethod))
+                        {
+                            discoveredMethods.Add(implMethod);
+                        }
+                    }
+                }
+            }
+
+            methods_subscribeAttrb = discoveredMethods.ToArray();
             #pragma warning restore CS0618
             dic_method_parameters = methods_subscribeAttrb.Select(m => new { Method = m, Parameters = null as object  }).ToDictionary(mp => mp.Method, mp => mp.Parameters);
             dic_method_outputs = methods_subscribeAttrb.Select(m => new { Method = m, Return = null as object }).ToDictionary(mp => mp.Method, mp => mp.Return);
@@ -88,17 +127,15 @@ private void _Draw()
             foreach (var item in methods_subscribeAttrb)
             {
                 #pragma warning disable CS0618
-                var atribute = item.GetCustomAttribute<FluxAttribute>();
+                var atribute = dic_method_attributes[item];
                 #pragma warning restore CS0618
                 var parameters = item.GetParameters();
                 var isParameters = parameters.Length > 0;
                 var isReturn = item.ReturnType != typeof(void);
                 var isErr_static = item.IsStatic;
                 var isError = isErr_static;
                 string key_color =  isError ? "yellow" : "white";
-                #pragma warning disable CS0618
-                var atrbtype = item.GetCustomAttributes(typeof(FluxAttribute), true)[0];
-                #pragma warning restore CS0618
+                var atrbtype = atribute;
 
 
                 int opt_status = (param: isParameters, rtrn: isReturn) switch

README.md

@@ -55,6 +55,28 @@ npm i com.xavierarpa.uniflux
 
 Note: Storing (ADD and REMOVE) by design is planned to do it once so there's no problem in performance.
 
+# Tip: MethodFlux in Interfaces
+
+You can use `[MethodFlux]` directly in an interface so that implementations are automatically detected. Example:
+
+```csharp
+public interface IService<T>
+{
+    T Service 
+    { 
+        [MethodFlux(0)] get; // attribute lives on the interface
+    }
+}
+
+internal class AudioModule : MonoFlux, IService<IAudioService>
+{
+    IAudioService IService<IAudioService>.Service => this;
+    // ↑ Automatically subscribed — UniFlux reads the attribute from the interface
+}
+```
+
+_Personal recommendation from Xavier!_
+
 ## Star History
 
 [![Star History Chart](https://api.star-history.com/svg?repos=xavierarpa/uniflux&type=Date)](https://star-history.com/#xavierarpa/uniflux&Date)