First pass at getting rid of expressions

I have a feeling that CreateProducer might still be needed but testing this out for now.

Author: mhbuck

src/core/Akka.TestKit/TestKitBase_ActorOf.cs

@@ -6,7 +6,6 @@
 //-----------------------------------------------------------------------
 
 using System;
-using System.Linq.Expressions;
 using Akka.Actor;
 using Akka.Actor.Dsl;
 
@@ -71,7 +70,7 @@ public IActorRef ActorOf(Props props, string name)
         /// <typeparam name="TActor">The type of the actor.</typeparam>
         /// <param name="factory">An expression that calls the constructor of <typeparamref name="TActor"/></param>
         /// <returns>TBD</returns>
-        public IActorRef ActorOf<TActor>(Expression<Func<TActor>> factory) where TActor : ActorBase
+        public IActorRef ActorOf<TActor>(Func<TActor> factory) where TActor : ActorBase
         {
             return Sys.ActorOf(Props.Create(factory), null);
         }
@@ -87,7 +86,7 @@ public IActorRef ActorOf<TActor>(Expression<Func<TActor>> factory) where TActor
         /// <param name="factory">An expression that calls the constructor of <typeparamref name="TActor"/></param>
         /// <param name="name">The name of the actor.</param>
         /// <returns>TBD</returns>
-        public IActorRef ActorOf<TActor>(Expression<Func<TActor>> factory, string name) where TActor : ActorBase
+        public IActorRef ActorOf<TActor>(Func<TActor> factory, string name) where TActor : ActorBase
         {
             return Sys.ActorOf(Props.Create(factory), name);
         }
@@ -201,7 +200,7 @@ public TestActorRef<TActor> ActorOfAsTestActorRef<TActor>(Props props, string na
         /// <param name="supervisor">The supervisor</param>
         /// <param name="name">Optional: The name.</param>
         /// <returns>TBD</returns>
-        public TestActorRef<TActor> ActorOfAsTestActorRef<TActor>(Expression<Func<TActor>> factory, IActorRef supervisor, string name = null) where TActor : ActorBase
+        public TestActorRef<TActor> ActorOfAsTestActorRef<TActor>(Func<TActor> factory, IActorRef supervisor, string name = null) where TActor : ActorBase
         {
             return new TestActorRef<TActor>(Sys, Props.Create(factory), supervisor, name);
         }
@@ -218,7 +217,7 @@ public TestActorRef<TActor> ActorOfAsTestActorRef<TActor>(Expression<Func<TActor
         /// <param name="factory">An expression that calls the constructor of <typeparamref name="TActor"/></param>
         /// <param name="name">Optional: The name.</param>
         /// <returns>TBD</returns>
-        public TestActorRef<TActor> ActorOfAsTestActorRef<TActor>(Expression<Func<TActor>> factory, string name = null) where TActor : ActorBase
+        public TestActorRef<TActor> ActorOfAsTestActorRef<TActor>(Func<TActor> factory, string name = null) where TActor : ActorBase
         {
             return new TestActorRef<TActor>(Sys, Props.Create(factory), NoSupervisor, name);
         }
@@ -333,7 +332,7 @@ public TestFSMRef<TFsmActor, TState, TData> ActorOfAsTestFSMRef<TFsmActor, TStat
         /// <param name="name">Optional: The name.</param>
         /// <param name="withLogging">Optional: If set to <c>true</c> logs state changes of the FSM as Debug messages. Default is <c>false</c>.</param>
         /// <returns>TBD</returns>
-        public TestFSMRef<TFsmActor, TState, TData> ActorOfAsTestFSMRef<TFsmActor, TState, TData>(Expression<Func<TFsmActor>> factory, IActorRef supervisor, string name = null, bool withLogging = false)
+        public TestFSMRef<TFsmActor, TState, TData> ActorOfAsTestFSMRef<TFsmActor, TState, TData>(Func<TFsmActor> factory, IActorRef supervisor, string name = null, bool withLogging = false)
             where TFsmActor : FSM<TState, TData>
         {
             return new TestFSMRef<TFsmActor, TState, TData>(Sys, Props.Create(factory), supervisor, name, withLogging);
@@ -351,7 +350,7 @@ public TestFSMRef<TFsmActor, TState, TData> ActorOfAsTestFSMRef<TFsmActor, TStat
         /// <param name="name">Optional: The name.</param>
         /// <param name="withLogging">Optional: If set to <c>true</c> logs state changes of the FSM as Debug messages. Default is <c>false</c>.</param>
         /// <returns>TBD</returns>
-        public TestFSMRef<TFsmActor, TState, TData> ActorOfAsTestFSMRef<TFsmActor, TState, TData>(Expression<Func<TFsmActor>> factory, string name = null, bool withLogging = false)
+        public TestFSMRef<TFsmActor, TState, TData> ActorOfAsTestFSMRef<TFsmActor, TState, TData>(Func<TFsmActor> factory, string name = null, bool withLogging = false)
             where TFsmActor : FSM<TState, TData>
         {
             return new TestFSMRef<TFsmActor, TState, TData>(Sys, Props.Create(factory), NoSupervisor, name, withLogging);

src/core/Akka/Actor/Props.cs

@@ -1,4 +1,4 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // <copyright file="Props.cs" company="Akka.NET Project">
 //     Copyright (C) 2009-2022 Lightbend Inc. <http://www.lightbend.com>
 //     Copyright (C) 2013-2025 .NET Foundation <https://github.com/akkadotnet/akka.net>
@@ -8,13 +8,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Linq.Expressions;
-using Akka.Configuration;
 using Akka.Dispatch;
 using Akka.Routing;
 using Akka.Util;
-using Akka.Util.Internal;
-using Akka.Util.Reflection;
 using Newtonsoft.Json;
 
 namespace Akka.Actor
@@ -46,8 +42,6 @@ public class Props : IEquatable<Props>, ISurrogated
         ///     </note>
         /// </summary>
         public static readonly Props None = null;
-        private Type _inputType;
-        private Type _outputType;
         private readonly IIndirectActorProducer _producer;
 
         /// <summary>
@@ -163,13 +157,12 @@ public Props(Deploy deploy, Type type, IEnumerable<object> args)
         /// <param name="args">The arguments needed to create the actor.</param>
         /// <exception cref="ArgumentException">This exception is thrown if <paramref name="type" /> is an unknown actor producer.</exception>
         public Props(Deploy deploy, Type type, params object[] args)
-#pragma warning disable CS0618 // Type or member is obsolete
-            : this(CreateProducer(type, args), deploy, args) // have to preserve the "CreateProducer" call here to preserve backwards compat with Akka.DI.Core
-#pragma warning restore CS0618 // Type or member is obsolete
+            : this(new ActivatorProducer(type, args), deploy, args)
         {
 
         }
 
+
         /// <summary>
         ///     Initializes a new instance of the <see cref="Props" /> class using a specified <see cref="IIndirectActorProducer"/>.
         /// </summary>
@@ -182,7 +175,6 @@ public Props(Deploy deploy, Type type, params object[] args)
         internal Props(IIndirectActorProducer producer, Deploy deploy, params object[] args)
         {
             Deploy = deploy;
-            _inputType = producer.ActorType;
             Arguments = args ?? NoArgs;
             _producer = producer;
         }
@@ -195,9 +187,7 @@ public Type Type
         {
             get
             {
-                if (_outputType == null) _outputType = _producer.ActorType;
-
-                return _outputType;
+                return _producer.ActorType;
             }
         }
 
@@ -225,9 +215,8 @@ public string Dispatcher
         /// </summary>
         public string TypeName
         {
-            get => _inputType.AssemblyQualifiedName;
-            //for serialization
-            private set => _inputType = Type.GetType(value);
+            get => _producer.ActorType.AssemblyQualifiedName;
+            //private set => _producer.ActorType = Type.GetType(value);
         }
 
         /// <summary>
@@ -283,7 +272,7 @@ public ISurrogate ToSurrogate(ActorSystem system)
 
         private bool CompareInputType(Props other)
         {
-            return _inputType == other._inputType;
+            return _producer.ActorType == other._producer.ActorType;
         }
 
         private bool CompareDeploy(Props other)
@@ -328,15 +317,14 @@ public override bool Equals(object obj)
             return Equals((Props)obj);
         }
 
-       
         public override int GetHashCode()
         {
             unchecked
             {
                 var hashCode = Deploy != null ? Deploy.GetHashCode() : 0;
                 //  hashCode = (hashCode*397) ^ (SupervisorStrategy != null ? SupervisorStrategy.GetHashCode() : 0);
                 //  hashCode = (hashCode*397) ^ (Arguments != null ? Arguments.GetHashCode() : 0);
-                hashCode = (hashCode * 397) ^ (_inputType != null ? _inputType.GetHashCode() : 0);
+                hashCode = (hashCode * 397) ^ (_producer.ActorType != null ? _producer.ActorType.GetHashCode() : 0);
                 return hashCode;
             }
         }
@@ -349,19 +337,9 @@ public override int GetHashCode()
         /// <param name="supervisorStrategy">Optional: The supervisor strategy used to manage the actor.</param>
         /// <returns>The newly created <see cref="Akka.Actor.Props" />.</returns>
         /// <exception cref="ArgumentException">The create function must be a 'new T (args)' expression</exception>
-        public static Props Create<TActor>(Expression<Func<TActor>> factory,
-            SupervisorStrategy supervisorStrategy = null) where TActor : ActorBase
+        public static Props Create<TActor>(Func<TActor> factory, SupervisorStrategy supervisorStrategy = null) where TActor : ActorBase
         {
-            if (factory.Body is UnaryExpression)
-                return new DynamicProps<TActor>(factory.Compile());
-
-            var newExpression = factory.Body.AsInstanceOf<NewExpression>();
-            if (newExpression == null)
-                throw new ArgumentException("The create function must be a 'new T (args)' expression");
-
-            var args = newExpression.Arguments.Count > 0 ? newExpression.GetArguments() : NoArgs;
-
-            return new Props(new ActivatorProducer(typeof(TActor), args), DefaultDeploy, args){ SupervisorStrategy = supervisorStrategy };
+            return new Props(new FactoryProducer<TActor>(factory), DefaultDeploy, NoArgs) { SupervisorStrategy = supervisorStrategy };
         }
 
         /// <summary>
@@ -406,7 +384,7 @@ public static Props CreateBy(IIndirectActorProducer producer, params object[] ar
         /// <returns>The newly created <see cref="Akka.Actor.Props" />.</returns>
         public static Props Create<TActor>(SupervisorStrategy supervisorStrategy) where TActor : ActorBase, new()
         {
-            return new Props(new ActivatorProducer(typeof(TActor), NoArgs), DefaultDeploy, NoArgs){ SupervisorStrategy = supervisorStrategy };
+            return new Props(new FactoryProducer<TActor>(() => new TActor()), DefaultDeploy, NoArgs) { SupervisorStrategy = supervisorStrategy };
         }
 
         /// <summary>
@@ -468,7 +446,7 @@ public Props WithRouter(RouterConfig routerConfig)
             copy.Deploy = Deploy.WithRouterConfig(routerConfig);
             return copy;
         }
-        
+
         /// <summary>
         ///     Creates a new <see cref="Akka.Actor.Props" /> with a given stash size.
         ///     <note>
@@ -499,12 +477,13 @@ public Props WithStashCapacity(int stashCapacity)
         public Props WithDeploy(Deploy deploy)
         {
             var copy = Copy();
-            var original = copy.Deploy;
+            //var original = copy.Deploy;
 
             // TODO: this is a hack designed to preserve explicit router deployments https://github.com/akkadotnet/akka.net/issues/546
             // in reality, we should be able to do copy.Deploy = deploy.WithFallback(copy.Deploy); but that blows up at the moment
             // - Aaron Stannard
             copy.Deploy = deploy.WithFallback(copy.Deploy);
+            
             //if (!(original.RouterConfig is NoRouter || original.RouterConfig is FromConfig) && deploy.RouterConfig is NoRouter)
             //{
             //    copy.Deploy = deploy.WithFallback(copy.Deploy);
@@ -555,17 +534,13 @@ public Props WithSupervisorStrategy(SupervisorStrategy supervisorStrategy)
         /// <returns>The newly created actor</returns>
         public virtual ActorBase NewActor()
         {
-            var type = Type;
-            var arguments = Arguments;
             try
             {
                 return _producer.Produce();
             }
             catch (Exception e)
             {
-                throw new TypeLoadException(
-                    $"Error while creating actor instance of type {type} with {arguments.Length} args: ({StringFormat.SafeJoin(",", arguments)})",
-                    e);
+                throw new TypeLoadException($"Error while creating actor instance of type {Type} with {Arguments.Length} args: ({StringFormat.SafeJoin(",", Arguments)})", e);
             }
         }
 
@@ -578,23 +553,6 @@ protected virtual Props Copy()
             return new Props(_producer, Deploy, Arguments) { SupervisorStrategy = SupervisorStrategy };
         }
 
-        [Obsolete("we should not be calling this method. Pass in an explicit IIndirectActorProducer reference instead.")]
-        private static IIndirectActorProducer CreateProducer(Type type, object[] args)
-        {
-            if (type == null) return DefaultProducer.Instance;
-
-            if (typeof(IIndirectActorProducer).IsAssignableFrom(type))
-                return Activator.CreateInstance(type, args).AsInstanceOf<IIndirectActorProducer>();
-
-            if (typeof(ActorBase).IsAssignableFrom(type)) return new ActivatorProducer(type, args);
-
-            throw new ArgumentException($"Unknown actor producer [{type.FullName}]", nameof(type));
-        }
-
-        /// <summary>
-        ///     Signals the producer that it can release its reference to the actor.
-        /// </summary>
-        /// <param name="actor">The actor to release</param>
         internal void Release(ActorBase actor)
         {
             try
@@ -687,23 +645,22 @@ public ActivatorProducer(Type actorType, object[] args)
 
             public ActorBase Produce()
             {
-                return Activator.CreateInstance(ActorType, _args).AsInstanceOf<ActorBase>();
+                return (ActorBase)Activator.CreateInstance(ActorType, _args);
             }
 
             public Type ActorType { get; }
 
-
             public void Release(ActorBase actor)
             {
                 actor = null;
             }
         }
 
-        private class FactoryConsumer<TActor> : IIndirectActorProducer where TActor : ActorBase
+        private class FactoryProducer<TActor> : IIndirectActorProducer where TActor : ActorBase
         {
             private readonly Func<TActor> _factory;
 
-            public FactoryConsumer(Func<TActor> factory)
+            public FactoryProducer(Func<TActor> factory)
             {
                 _factory = factory;
             }
@@ -715,7 +672,6 @@ public ActorBase Produce()
 
             public Type ActorType => typeof(TActor);
 
-
             public void Release(ActorBase actor)
             {
                 actor = null;
@@ -828,4 +784,4 @@ public interface IIndirectActorProducer
         /// <param name="actor">The actor to release</param>
         void Release(ActorBase actor);
     }
-}
+}