Fixed #3: Allow additional ActorService constructor parameters to be passed through from RegisterActor registration method.

Author: alexmg

src/Autofac.Integration.ServiceFabric/ActorFactoryRegistration.cs

@@ -23,14 +23,19 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 
+using System;
 using Microsoft.ServiceFabric.Actors.Runtime;
 
 namespace Autofac.Integration.ServiceFabric
 {
     // ReSharper disable once ClassNeverInstantiated.Global
     internal sealed class ActorFactoryRegistration : IActorFactoryRegistration
     {
-        public void RegisterActorFactory<TActor>(ILifetimeScope container) where TActor : ActorBase
+        public void RegisterActorFactory<TActor>(
+            ILifetimeScope container,
+            Func<ActorBase, IActorStateProvider, IActorStateManager> stateManagerFactory = null,
+            IActorStateProvider stateProvider = null,
+            ActorServiceSettings settings = null) where TActor : ActorBase
         {
             ActorRuntime.RegisterActorAsync<TActor>((context, actorTypeInfo) =>
             {
@@ -41,7 +46,7 @@ public void RegisterActorFactory<TActor>(ILifetimeScope container) where TActor
                         TypedParameter.From(actorService),
                         TypedParameter.From(actorId));
                     return actor;
-                });
+                }, stateManagerFactory, stateProvider, settings);
             }).GetAwaiter().GetResult();
         }
     }

src/Autofac.Integration.ServiceFabric/AutofacActorExtensions.cs

@@ -37,10 +37,17 @@ public static class AutofacActorExtensions
         /// Registers an actor service with the container.
         /// </summary>
         /// <param name="builder">The container builder.</param>
+        /// <param name="stateManagerFactory">A factory method to create <see cref="T:Microsoft.ServiceFabric.Actors.Runtime.IActorStateManager" /></param>
+        /// <param name="stateProvider">State provider to store the state for actor objects.</param>
+        /// <param name="settings">/// Settings to configures behavior of Actor Service.</param>
         /// <typeparam name="TActor">The type of the actor to register.</typeparam>
         /// <exception cref="ArgumentException">Thrown when <typeparamref name="TActor"/> is not a valid actor type.</exception>
         /// <remarks>The actor will be wrapped in a dynamic proxy and must be public and not sealed.</remarks>
-        public static void RegisterActor<TActor>(this ContainerBuilder builder) where TActor : ActorBase
+        public static void RegisterActor<TActor>(
+            this ContainerBuilder builder,
+            Func<ActorBase, IActorStateProvider, IActorStateManager> stateManagerFactory = null,
+            IActorStateProvider stateProvider = null,
+            ActorServiceSettings settings = null) where TActor : ActorBase
         {
             if (builder == null)
                 throw new ArgumentNullException(nameof(builder));
@@ -52,7 +59,9 @@ public static void RegisterActor<TActor>(this ContainerBuilder builder) where TA
 
             builder.RegisterServiceWithInterception<TActor, ActorInterceptor>();
 
-            builder.RegisterBuildCallback(c => c.Resolve<IActorFactoryRegistration>().RegisterActorFactory<TActor>(c));
+            builder.RegisterBuildCallback(
+                c => c.Resolve<IActorFactoryRegistration>().RegisterActorFactory<TActor>(
+                    c, stateManagerFactory, stateProvider, settings));
         }
     }
 }

src/Autofac.Integration.ServiceFabric/IActorFactoryRegistration.cs

@@ -23,12 +23,17 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 
+using System;
 using Microsoft.ServiceFabric.Actors.Runtime;
 
 namespace Autofac.Integration.ServiceFabric
 {
     internal interface IActorFactoryRegistration
     {
-        void RegisterActorFactory<TActor>(ILifetimeScope lifetimeScope) where TActor : ActorBase;
+        void RegisterActorFactory<TActor>(
+            ILifetimeScope lifetimeScope,
+            Func<ActorBase, IActorStateProvider, IActorStateManager> stateManagerFactory = null,
+            IActorStateProvider stateProvider = null,
+            ActorServiceSettings settings = null) where TActor : ActorBase;
     }
 }

test/Autofac.Integration.ServiceFabric.Test/AutofacActorExtensionsTests.cs

@@ -64,7 +64,7 @@ public void RegisterActorAddsFactoryCallback()
 
             var container = builder.Build();
 
-            factoryMock.Verify(x => x.RegisterActorFactory<Actor1>(container), Times.Once);
+            factoryMock.Verify(x => x.RegisterActorFactory<Actor1>(container, null, null, null), Times.Once);
         }
 
         [Fact]
@@ -90,7 +90,53 @@ public void RegisterActorCanBeCalledFromModuleLoad()
             var container = builder.Build();
 
             container.AssertRegistered<Actor1>();
-            factoryMock.Verify(x => x.RegisterActorFactory<Actor1>(container), Times.Once);
+            factoryMock.Verify(x => x.RegisterActorFactory<Actor1>(container, null, null, null), Times.Once);
+        }
+
+        [Fact]
+        public void RegisterActorCanBeCalledWithStateManagerFactory()
+        {
+            var builder = new ContainerBuilder();
+            // ReSharper disable once ConvertToLocalFunction
+            Func<ActorBase, IActorStateProvider, IActorStateManager> stateManagerFactory = (actor, provider) => null;
+            builder.RegisterActor<Actor1>(stateManagerFactory: stateManagerFactory);
+            var factoryMock = new Mock<IActorFactoryRegistration>();
+            builder.RegisterInstance(factoryMock.Object);
+
+            var container = builder.Build();
+
+            container.AssertRegistered<Actor1>();
+            factoryMock.Verify(x => x.RegisterActorFactory<Actor1>(container, stateManagerFactory, null, null), Times.Once);
+        }
+
+        [Fact]
+        public void RegisterActorCanBeCalledWithStateProvider()
+        {
+            var builder = new ContainerBuilder();
+            var stateProvider = new Mock<IActorStateProvider>().Object;
+            builder.RegisterActor<Actor1>(stateProvider: stateProvider);
+            var factoryMock = new Mock<IActorFactoryRegistration>();
+            builder.RegisterInstance(factoryMock.Object);
+
+            var container = builder.Build();
+
+            container.AssertRegistered<Actor1>();
+            factoryMock.Verify(x => x.RegisterActorFactory<Actor1>(container, null, stateProvider, null), Times.Once);
+        }
+
+        [Fact]
+        public void RegisterActorCanBeCalledWithSettings()
+        {
+            var builder = new ContainerBuilder();
+            var settings = new ActorServiceSettings();
+            builder.RegisterActor<Actor1>(settings: settings);
+            var factoryMock = new Mock<IActorFactoryRegistration>();
+            builder.RegisterInstance(factoryMock.Object);
+
+            var container = builder.Build();
+
+            container.AssertRegistered<Actor1>();
+            factoryMock.Verify(x => x.RegisterActorFactory<Actor1>(container, null, null, settings), Times.Once);
         }
 
         [Fact]