Renamed methods; readme update; minor changes

README.md

@@ -207,22 +207,22 @@ public static IServiceCollection AddPowerPipe(
 By default all found implementations will be registered as Transient.
 
 ```csharp
-services.AddPowerPipe(c =>
+services.AddPowerPipe(cfg =>
 {
-    c.RegisterServicesFromAssemblies(Assembly.GetExecutingAssembly());
+    cfg.RegisterServicesFromAssemblies(Assembly.GetExecutingAssembly());
 });
 ```
 
 But you can configure service lifetime per step implementation.
 
 ```csharp
-services.AddPowerPipe(c =>
+services.AddPowerPipe(cfg =>
 {
-    c.RegisterServicesFromAssemblies(typeof(Program).Assembly)
-        .AddBehavior<Step1>(ServiceLifetime.Singleton)
-        .AddBehavior<Step2>(ServiceLifetime.Scoped)
-        // default Transient
-        .AddBehavior<TestStep3>();
+    cfg.RegisterServicesFromAssemblies(typeof(Program).Assembly)
+        .ChangeDefaultLifetime(ServiceLifetime.Scoped) // to override default lifetime
+        .AddSingleton<Step1>()
+        .AddTransient<Step2>()
+        .AddTransient(typeof(Step2));
 });
 ```
 

samples/PowerPipe.Sample/Program.cs

@@ -26,7 +26,7 @@ private static IServiceProvider ConfigureServices()
             config
                 .RegisterServicesFromAssemblies(Assembly.GetExecutingAssembly())
                 .ChangeDefaultLifetime(ServiceLifetime.Scoped)
-                .AddBehavior(typeof(SampleGenericStep<>), ServiceLifetime.Singleton);
+                .AddScoped(typeof(SampleGenericStep<>));
         });
 
         services.AddSingleton<SamplePipeline>();

src/PowerPipe.Extensions.MicrosoftDependencyInjection/PowerPipeConfiguration.cs

@@ -28,7 +28,9 @@ public class PowerPipeConfiguration
     public PowerPipeConfiguration ChangeDefaultLifetime(ServiceLifetime lifetime)
     {
         if (DefaultLifetime == lifetime)
+        {
             return this;
+        }
 
         DefaultLifetime = lifetime;
 
@@ -63,31 +65,57 @@ public PowerPipeConfiguration RegisterServicesFromAssemblies(params Assembly[] a
     }
 
     /// <summary>
-    /// Register implementation with specific lifetime. By default - Transient.
+    /// Register implementation with specific lifetime
     /// </summary>
-    /// <param name="serviceLifetime">ServiceLifetime.Transient by default</param>
     /// <typeparam name="TServiceType">Type of step implementation</typeparam>
-    /// <returns>instance of PowerPipeConfiguration</returns>
-    public PowerPipeConfiguration AddBehavior<TServiceType>(ServiceLifetime serviceLifetime = ServiceLifetime.Transient)
-        => AddBehavior(typeof(TServiceType), serviceLifetime);
+    /// <returns>Instance of PowerPipeConfiguration</returns>
+    public PowerPipeConfiguration AddTransient<TServiceType>() =>
+        AddTransient(typeof(TServiceType));
 
     /// <summary>
-    /// Register implementation with specific lifetime. By default - Transient.
+    /// Register implementation with specific lifetime
     /// </summary>
     /// <param name="type">Type of step implementation</param>
-    /// <param name="serviceLifetime">ServiceLifetime.Transient by default</param>
-    /// <returns>instance of PowerPipeConfiguration</returns>
-    public PowerPipeConfiguration AddBehavior(Type type, ServiceLifetime serviceLifetime = ServiceLifetime.Transient)
-        => AddBehavior(type, type, serviceLifetime);
+    /// <returns>Instance of PowerPipeConfiguration</returns>
+    public PowerPipeConfiguration AddTransient(Type type) =>
+        Add(type, ServiceLifetime.Transient);
+
+    /// <summary>
+    /// Register implementation with specific lifetime
+    /// </summary>
+    /// <typeparam name="TServiceType">Type of step implementation</typeparam>
+    /// <returns>Instance of PowerPipeConfiguration</returns>
+    public PowerPipeConfiguration AddScoped<TServiceType>() =>
+        AddScoped(typeof(TServiceType));
+
+    /// <summary>
+    /// Register implementation with specific lifetime
+    /// </summary>
+    /// <param name="type">Type of step implementation</param>
+    /// <returns>Instance of PowerPipeConfiguration</returns>
+    public PowerPipeConfiguration AddScoped(Type type) =>
+        Add(type, ServiceLifetime.Scoped);
+
+    /// <summary>
+    /// Register implementation with specific lifetime
+    /// </summary>
+    /// <typeparam name="TServiceType">Type of step implementation</typeparam>
+    /// <returns>Instance of PowerPipeConfiguration</returns>
+    public PowerPipeConfiguration AddSingleton<TServiceType>() =>
+        AddSingleton(typeof(TServiceType));
 
-    #region PrivateMethods
+    /// <summary>
+    /// Register implementation with specific lifetime
+    /// </summary>
+    /// <param name="type">Type of step implementation</param>
+    /// <returns>Instance of PowerPipeConfiguration</returns>
+    public PowerPipeConfiguration AddSingleton(Type type) =>
+        Add(type, ServiceLifetime.Singleton);
 
-    private PowerPipeConfiguration AddBehavior(Type serviceType, Type implementationType, ServiceLifetime serviceLifetime)
+    private PowerPipeConfiguration Add(Type serviceType, ServiceLifetime serviceLifetime)
     {
-        BehaviorsToRegister.Add(new ServiceDescriptor(serviceType, implementationType, serviceLifetime));
+        BehaviorsToRegister.Add(new ServiceDescriptor(serviceType, serviceType, serviceLifetime));
 
         return this;
     }
-
-    #endregion
 }

tests/PowerPipe.UnitTests/PipelineAutoDITests.cs

@@ -53,10 +53,8 @@ public void TestAutoDIRegistration()
         services.AddPowerPipe(c =>
         {
             c.RegisterServicesFromAssemblies(typeof(AutoDIFixture).Assembly)
-                .AddBehavior<TestStep1>(ServiceLifetime.Singleton)
-                .AddBehavior<TestStep2>(ServiceLifetime.Scoped)
-                // default Transient
-                .AddBehavior<TestStep3>();
+                .AddSingleton<TestStep1>()
+                .AddScoped<TestStep2>();
         });
 
         var serviceProvider = services.BuildServiceProvider();