Add support for "Scoped" lifetime (#31)

Author: jazzman55

.editorconfig

@@ -0,0 +1,4 @@
+[*.cs]
+
+# Default severity for all analyzer diagnostics
+dotnet_analyzer_diagnostic.severity = silent

README.md

@@ -27,6 +27,8 @@ A Dependency Injection (DI) Container provides functionality and automates many
 This API mirrors as close as possible the official .NET 
 [DependencyInjection](https://docs.microsoft.com/en-us/dotnet/core/extensions/dependency-injection). Exceptions are mainly derived from the lack of generics support in .NET nanoFramework.
 
+The .NET nanoFramework [Generic Host](https://github.com/nanoframework/nanoFramework.Hosting) provides convenience methods for creating dependency injection (DI) application containers with preconfigured defaults.
+
 ## Usage
 
 ### Service Collection
@@ -91,6 +93,20 @@ var service = (RootObject)serviceProvider.GetService(typeof(RootObject));
 service.ServiceObject.Three = "3";
 ```
 
+Create a scoped Service Provider providing convient access to crate and distroy scoped object.
+
+```csharp
+var serviceProvider = new ServiceCollection()
+    .AddScoped(typeof(typeof(ServiceObject))
+    .BuildServiceProvider();
+
+using (var scope = serviceProvider.CreateScope())
+{
+    var service = scope.ServiceProvider.GetServices(typeof(ServiceObject));
+    service.ServiceObject.Three = "3";
+}
+```
+
 ## Activator Utilities
 
 An instance of an object can be created by calling its constructor with any dependencies resolved through the service provider. Automatically instantiate a type with constructor arguments provided from an IServiceProvider without having to register the type with the DI Container.
@@ -116,6 +132,18 @@ var serviceProvider = new ServiceCollection()
     .BuildServiceProvider(new ServiceProviderOptions() { ValidateOnBuild = true });
 ```
 
+
+###  Validate Scopes
+
+A check verifying that scoped services never gets resolved from root provider. Validate on build is configured false by default.
+
+```csharp
+var serviceProvider = new ServiceCollection()
+    .AddSingleton(typeof(IServiceObject), typeof(ServiceObject))
+    .BuildServiceProvider(new ServiceProviderOptions() { ValidateScopes = true });
+```
+
+
 ## Example Application Container
 
 ```csharp

nanoFramework.DependencyInjection/DependencyInjection/IServiceScope.cs

@@ -0,0 +1,20 @@
+//
+// Copyright (c) .NET Foundation and Contributors
+// See LICENSE file in the project root for full license information.
+//
+
+using System;
+
+namespace nanoFramework.DependencyInjection
+{
+    /// <summary>
+    /// Defines scope for <see cref="IServiceProvider"/>.
+    /// </summary>
+    public interface IServiceScope : IDisposable
+    {
+        /// <summary>
+        /// The <see cref="IServiceProvider"/> used to resolve dependencies from the scope.
+        /// </summary>
+        IServiceProvider ServiceProvider { get; }
+    }
+}

nanoFramework.DependencyInjection/DependencyInjection/ServiceCollectionServiceExtensions.cs

@@ -9,7 +9,7 @@
 namespace nanoFramework.DependencyInjection
 {
     /// <summary>
-    /// Extensions for <see cref="ServiceCollection"/>.
+    /// Extensions for <see cref="IServiceCollection"/>.
     /// </summary>
     public static class ServiceCollectionServiceExtensions
     {
@@ -123,6 +123,49 @@ public static IServiceCollection AddTransient(this IServiceCollection services,
             return services.AddTransient(serviceType, serviceType);
         }
 
+        /// <summary>
+        /// Adds a scoped service of the type specified in <paramref name="serviceType"/> with an
+        /// implementation of the type specified in <paramref name="implementationType"/> to the
+        /// specified <see cref="IServiceCollection"/>.
+        /// </summary>
+        /// <param name="services">The <see cref="IServiceCollection"/> to add the service to.</param>
+        /// <param name="serviceType">The type of the service to register.</param>
+        /// <param name="implementationType">The implementation type of the service.</param>
+        /// <returns>A reference to this instance after the operation has completed.</returns>
+        /// <seealso cref="ServiceLifetime.Scoped"/>
+        /// <exception cref="ArgumentNullException"><paramref name="services"/> can't be <see langword="null"/>.</exception>
+        public static IServiceCollection AddScoped(this IServiceCollection services, Type serviceType, Type implementationType)
+        {
+            if (services == null)
+            {
+                throw new ArgumentNullException();
+            }
+
+            var descriptor = new ServiceDescriptor(serviceType, implementationType, ServiceLifetime.Scoped);
+            services.Add(descriptor);
+
+            return services;
+        }
+
+        /// <summary>
+        /// Adds a scoped service of the type specified in <paramref name="serviceType"/> to the
+        /// specified <see cref="IServiceCollection"/>.
+        /// </summary>
+        /// <param name="services">The <see cref="IServiceCollection"/> to add the service to.</param>
+        /// <param name="serviceType">The type of the service to register and the implementation to use.</param>
+        /// <returns>A reference to this instance after the operation has completed.</returns>
+        /// <seealso cref="ServiceLifetime.Scoped"/>
+        /// <exception cref="ArgumentNullException"><paramref name="services"/> can't be <see langword="null"/>.</exception>
+        public static IServiceCollection AddScoped(this IServiceCollection services, Type serviceType)
+        {
+            if (services == null)
+            {
+                throw new ArgumentNullException();
+            }
+
+            return services.AddScoped(serviceType, serviceType);
+        }
+
         /// <summary>
         /// Adds the specified <paramref name="descriptor"/> to the <paramref name="collection"/> if the
         /// service type hasn't already been registered.

nanoFramework.DependencyInjection/DependencyInjection/ServiceLifetime.cs

@@ -18,6 +18,11 @@ public enum ServiceLifetime
         /// <summary>
         /// Specifies that a new instance of the service will be created every time it is requested.
         /// </summary>
-        Transient
+        Transient,
+
+        /// <summary>
+        /// Specifies that a single instance of the service will be created within a scope.
+        /// </summary>
+        Scoped
     }
 }

nanoFramework.DependencyInjection/DependencyInjection/ServiceProvider.cs

@@ -15,7 +15,8 @@ namespace nanoFramework.DependencyInjection
     public sealed class ServiceProvider : IServiceProvider, IDisposable
     {
         private bool _disposed;
-        internal ServiceProviderEngine _engine;
+
+        internal ServiceProviderEngine Engine { get; }
 
         internal ServiceProvider(IServiceCollection services, ServiceProviderOptions options)
         {
@@ -29,9 +30,10 @@ internal ServiceProvider(IServiceCollection services, ServiceProviderOptions opt
                 throw new ArgumentNullException();
             }
 
-            _engine = GetEngine();
-            _engine.Services = services;
-            _engine.Services.Add(new ServiceDescriptor(typeof(IServiceProvider), this));
+            Engine = GetEngine();
+            Engine.Services = services;
+            Engine.Services.Add(new ServiceDescriptor(typeof(IServiceProvider), this));
+            Engine.Options = options;
 
             if (options.ValidateOnBuild)
             {
@@ -41,7 +43,7 @@ internal ServiceProvider(IServiceCollection services, ServiceProviderOptions opt
                 {
                     try
                     {
-                        _engine.ValidateService(descriptor);
+                        Engine.ValidateService(descriptor);
                     }
                     catch (Exception ex)
                     {
@@ -65,7 +67,7 @@ public object GetService(Type serviceType)
                 throw new ObjectDisposedException();
             }
 
-            return _engine.GetService(serviceType);
+            return Engine.GetService(serviceType);
         }
 
         /// <inheritdoc/>
@@ -76,7 +78,13 @@ public object[] GetService(Type[] serviceType)
                 throw new ObjectDisposedException();
             }
 
-            return _engine.GetService(serviceType);
+            return Engine.GetService(serviceType);
+        }
+
+        /// <inheritdoc />
+        public IServiceScope CreateScope()
+        {
+            return new ServiceProviderEngineScope(this);
         }
 
         /// <inheritdoc/>
@@ -88,7 +96,7 @@ public void Dispose()
             }
 
             _disposed = true;
-            _engine.DisposeServices();
+            Engine.DisposeServices();
         }
 
         private ServiceProviderEngine GetEngine()

nanoFramework.DependencyInjection/DependencyInjection/ServiceProviderEngine.cs

@@ -23,6 +23,11 @@ private ServiceProviderEngine() { }
         /// </summary>
         internal IServiceCollection Services { get; set; }
 
+        /// <summary>
+        /// ServiceProvider Options instance
+        /// </summary>
+        internal ServiceProviderOptions Options { get; set; }
+
         /// <summary>
         /// Validate service by attempting to activate all dependent services.
         /// </summary>
@@ -49,9 +54,10 @@ internal void DisposeServices()
         /// Gets the last added service object of the specified type.
         /// </summary>
         /// <param name="serviceType">An object that specifies the type of service object to get.</param>
-        internal object GetService(Type serviceType)
+        /// <param name="scopeServices">Services collection from current scope.</param>
+        internal object GetService(Type serviceType, IServiceCollection scopeServices = null)
         {
-            var services = GetServiceObjects(serviceType);
+            var services = GetServiceObjects(serviceType, scopeServices);
 
             if (services.Length == 0)
             {
@@ -66,9 +72,10 @@ internal object GetService(Type serviceType)
         /// Gets the service objects of the specified type.
         /// </summary>
         /// <param name="serviceType">An object that specifies the type of service object to get.</param>
+        /// <param name="scopeServices">Services collection from current scope.</param>
         /// <exception cref="ArgumentNullException"><paramref name="serviceType"/> can't be <see langword="null"/>.</exception>
         /// <exception cref="ArgumentException"><paramref name="serviceType"/> can't be empty.</exception>
-        internal object[] GetService(Type[] serviceType)
+        internal object[] GetService(Type[] serviceType, IServiceCollection scopeServices = null)
         {
             if (serviceType == null)
             {
@@ -83,7 +90,7 @@ internal object[] GetService(Type[] serviceType)
             // optimized for single item service type
             if (serviceType.Length == 1)
             {
-                var services = GetServiceObjects(serviceType[0]);
+                var services = GetServiceObjects(serviceType[0], scopeServices);
 
                 if (services.Length > 0)
                 {
@@ -98,7 +105,7 @@ internal object[] GetService(Type[] serviceType)
 
             foreach (Type type in serviceType)
             {
-                var services = GetServiceObjects(type);
+                var services = GetServiceObjects(type, scopeServices);
 
                 if (services.Length > 0)
                 {
@@ -118,29 +125,41 @@ internal object[] GetService(Type[] serviceType)
         /// Gets the service objects of the specified type.
         /// </summary>
         /// <param name="serviceType">An object that specifies the type of service object to get.</param>
-        private object[] GetServiceObjects(Type serviceType)
+        /// <param name="scopeServices">Services collection from current scope.</param>
+        private object[] GetServiceObjects(Type serviceType, IServiceCollection scopeServices)
         {
             ArrayList services = new ArrayList();
 
+            if (scopeServices != null)
+            {
+                foreach (ServiceDescriptor descriptor in scopeServices)
+                {
+                    if (descriptor.ServiceType != serviceType) continue;
+
+                    descriptor.ImplementationInstance ??= Resolve(descriptor.ImplementationType);
+                    services.Add(descriptor.ImplementationInstance);
+                }
+            }
+
             foreach (ServiceDescriptor descriptor in Services)
             {
-                if (descriptor.ServiceType == serviceType)
+                if (descriptor.ServiceType != serviceType) continue;
+                
+                switch (descriptor.Lifetime)
                 {
-                    if (descriptor.Lifetime == ServiceLifetime.Singleton
-                        && descriptor.ImplementationInstance != null)
-                    {
+                    case ServiceLifetime.Singleton:
+                        descriptor.ImplementationInstance ??= Resolve(descriptor.ImplementationType);
                         services.Add(descriptor.ImplementationInstance);
-                    }
-                    else
-                    {
-                        var instance = Resolve(descriptor.ImplementationType);
-                        if (descriptor.Lifetime != ServiceLifetime.Transient)
-                        {
-                            descriptor.ImplementationInstance = instance;
-                        }
+                        break;
 
-                        services.Add(instance);
-                    }
+                    case ServiceLifetime.Transient:
+                        services.Add(Resolve(descriptor.ImplementationType));
+                        break;
+
+                    case ServiceLifetime.Scoped:
+                        if (scopeServices == null && Options.ValidateScopes)
+                            throw new InvalidOperationException();
+                        break;
                 }
             }