Dynamically add controller. #4883

2 Answer(s)

• 

  0

  liangshiwei created one year ago

  Support Team Fullstack Developer

  Hi,

  Because ABP uses controller as a service: https://andrewlock.net/controller-activation-and-dependency-injection-in-asp-net-core-mvc/

  But you can't add service after the application start.

  You can try this.

  The MyControllerActivator will try to create from DI and manually create an instance if it does not exist.

  public sealed class MyTypeActivatorCache : ISingletonDependency
  {
  
  #nullable disable
      private readonly Func<Type, ObjectFactory> _createFactory = (Func<Type, ObjectFactory>) (type => ActivatorUtilities.CreateFactory(type, Type.EmptyTypes));
      private readonly ConcurrentDictionary<Type, ObjectFactory> _typeActivatorCache = new ConcurrentDictionary<Type, ObjectFactory>();
      
      public TInstance CreateInstance<TInstance>(
          IServiceProvider serviceProvider,
          Type implementationType)
      {
          if (serviceProvider == null)
              throw new ArgumentNullException(nameof (serviceProvider));
          if (implementationType == (Type) null)
              throw new ArgumentNullException(nameof (implementationType));
          return (TInstance) this._typeActivatorCache.GetOrAdd(implementationType, this._createFactory)(serviceProvider, (object[]) null);
      }
      
      public bool IsCreated(Type implementationType)
      {
          return this._typeActivatorCache.ContainsKey(implementationType);
      }
  }
  
  public class MyControllerActivator : IControllerActivator
  {
      private readonly ServiceBasedControllerActivator _serviceBasedControllerActivator;
      private readonly MyTypeActivatorCache _typeActivatorCache;
      public MyControllerActivator(ServiceBasedControllerActivator serviceBasedControllerActivator,
          MyTypeActivatorCache typeActivatorCache)
      {
          _serviceBasedControllerActivator = serviceBasedControllerActivator;
          _typeActivatorCache = typeActivatorCache;
      }
  
      public object Create(ControllerContext context)
      {
          try
          {
              return _serviceBasedControllerActivator.Create(context);
          }
          catch (Exception e)
          {
              if (context == null)
              {
                  throw new ArgumentNullException(nameof(context));
              }
          
              var controllerTypeInfo = context.ActionDescriptor.ControllerTypeInfo;
  
              if (controllerTypeInfo == null)
              {
                  throw new ArgumentException(nameof(context.ActionDescriptor.ControllerTypeInfo));
              }
  
              var serviceProvider = context.HttpContext.RequestServices;
              return _typeActivatorCache.CreateInstance<object>(serviceProvider, controllerTypeInfo.AsType());
          }
      }
  
      public void Release(ControllerContext context, object controller)
      {
          if (context == null)
          {
              throw new ArgumentNullException(nameof(context));
          }
  
          if (controller == null)
          {
              throw new ArgumentNullException(nameof(controller));
          }
  
          if (_typeActivatorCache.IsCreated(controller.GetType()))
          {
              if (controller is IDisposable disposable)
              {
                  disposable.Dispose();
              }
          }
      }
  }
  
  
  context.Services.AddTransient<ServiceBasedControllerActivator>();
  context.Services.Replace(ServiceDescriptor.Transient<IControllerActivator, MyControllerActivator>());
  

  Save Cancel
• 

  0

  alirizaadiyahsi created one year ago

  Hi @liangshiwei, this is the good point. This fixes my issue.

  Thanks a lot.

  Save Cancel