diff --git a/Pilz.Plugins.Advanced/PluginFeatureController.cs b/Pilz.Plugins.Advanced/PluginFeatureController.cs
index db3240e..686e960 100644
--- a/Pilz.Plugins.Advanced/PluginFeatureController.cs
+++ b/Pilz.Plugins.Advanced/PluginFeatureController.cs
@@ -28,7 +28,7 @@ namespace Pilz.Plugins.Advanced
         /// </summary>
         public static PluginFeatureController Instance { get; private set; } = new();
 
-        private readonly HashSet<PluginFeature> features = new();
+        private readonly HashSet<PluginFeature> features = [];
 
         /// <summary>
         /// A wrapper of all registred <see cref="PluginFeature"/> instances.
@@ -52,6 +52,48 @@ namespace Pilz.Plugins.Advanced
             Modules = new(this);
         }
 
+        //public void RegisterAll()
+        //{
+        //    var assembly = Assembly.GetCallingAssembly();
+
+        //    foreach (var type in assembly.GetTypes())
+        //    {
+        //        if (type.IsAssignableFrom(typeof(IPluginFeaturesProvider)))
+        //        {
+        //            var methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
+        //            var method = methods.FirstOrDefault(n => n.Name == nameof(IPluginFeaturesProvider.GetFeatures) || n.Name.EndsWith(nameof(IPluginFeaturesProvider.GetFeatures)));
+
+        //            if (method != null && method.Invoke(null, null) is PluginFeature[] features)
+        //            {
+        //                foreach (var feature in features)
+        //                    Register(feature);
+        //            }
+        //        }
+        //        else if (type.IsAssignableFrom(typeof(IPluginFeatureProvider<>)))
+        //        {
+        //            var methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
+        //            var method = methods.FirstOrDefault(n => n.Name == nameof(IPluginFeatureProvider<PluginFeature>.Instance) || n.Name.EndsWith(nameof(IPluginFeatureProvider.Instance)));
+
+        //            if (method != null && method.Invoke(null, null) is PluginFeature[] features)
+        //            {
+        //                foreach (var feature in features)
+        //                    Register(feature);
+        //            }
+        //        }
+        //    }
+        //}
+
+        public void Register<T>() where T : IPluginFeatureProvider<PluginFeature>
+        {
+            Register(T.Instance);
+        }
+
+        public void RegisterAll<T>() where T : IPluginFeaturesProvider
+        {
+            foreach (var feature in T.GetFeatures())
+                Register(feature);
+        }
+
         public void Register(PluginFeature module)
         {
             if (!features.Contains(module))
@@ -67,14 +109,9 @@ namespace Pilz.Plugins.Advanced
             OnPluginFeatureUnregistred?.Invoke(this, module);
         }
 
-        public class FeatureController
+        public class FeatureController(PluginFeatureController controller)
         {
-            protected readonly PluginFeatureController controller;
-
-            public FeatureController(PluginFeatureController controller)
-            {
-                this.controller = controller;
-            }
+            protected readonly PluginFeatureController controller = controller;
 
             public virtual IEnumerable<PluginFeature> GetAll()
             {
@@ -102,12 +139,8 @@ namespace Pilz.Plugins.Advanced
             }
         }
 
-        public class FeatureController<T> : FeatureController where T : PluginFeature
+        public class FeatureController<T>(PluginFeatureController controller) : FeatureController(controller) where T : PluginFeature
         {
-            public FeatureController(PluginFeatureController controller) : base(controller)
-            {
-            }
-
             public override IEnumerable<T> GetAll()
             {
                 return controller.features.OfType<T>();
@@ -134,19 +167,12 @@ namespace Pilz.Plugins.Advanced
             }
         }
 
-        public class ModuleController : FeatureController<PluginModule>
+        public class ModuleController(PluginFeatureController controller) : FeatureController<PluginModule>(controller)
         {
-            public ModuleController(PluginFeatureController controller) : base(controller)
-            {
-            }
         }
 
-        public class FunctionController : FeatureController<PluginFunction>
+        public class FunctionController(PluginFeatureController controller) : FeatureController<PluginFunction>(controller)
         {
-            public FunctionController(PluginFeatureController controller) : base(controller)
-            {
-            }
-
             public void ExecuteAll(string functionType)
             {
                 foreach (var function in Get(functionType))