SHJX_GM/SHJX.Service.Control/Repository/Repositorys.cs

using Autofac;
using System.Reflection;
using SHJX.Service.Control.Proxy;
using Autofac.Extras.DynamicProxy;
using SHJX.Service.Control.Extends;
using SHJX.Service.Control.Common.Assets;
using SHJX.Service.Control.Pipeline.Contents;
using shjxCamera;
namespace SHJX.Service.Control.Repository
{
    public class Repositorys
    {
        #region Private Fields
        private static IEventAggregator _ea;
        private static IDataManager _dataManager;
        private static ReadConfigUtil _readConfig;
        private static EaseScheduler.IScheduler _scheduler;
        #endregion

        #region Public Properties
        public static IContainer Container { get; set; }
        #endregion

        public Repositorys(IEventAggregator ea, IDataManager dataManager, ReadConfigUtil readConfig, EaseScheduler.IScheduler scheduler)
        {
            _ea = ea;
            _readConfig = readConfig;
            _dataManager = dataManager;
            _scheduler = scheduler;
        }

        #region 任务继续
        public void ExecuteTaskByVirtualPipe(string type, EquipmentTask task)
        {
            using ILifetimeScope scope = Container.BeginLifetimeScope();
            PipelineConfig config = scope.Resolve<PipelineConfig>();
            List<string> CurrentNodes = new();
            foreach (PipelineContent item in from PipelineContent item in config.PipelineContents where item.Alias.Equals(type) select item)
            {
                CurrentNodes = item.Nodes;
            }
            IPipeline pipeline = scope.ResolveNamed<IPipeline>("VirtualPipeline");
            int index = string.IsNullOrWhiteSpace(task.Record) ? 0 : CurrentNodes.FindLastIndex(it => it.Equals(task.Record));
            CurrentNodes.Skip(index + 1).ToList().ForEach(node =>
            {
                pipeline.AddNode(scope.ResolveNamed<INode>(node));
            });
            pipeline.Invoke(task);
        }

        public void ExecuteTaskByVirtualPipe(EquipmentTask task)
        {
            using ILifetimeScope scope = Container.BeginLifetimeScope();
            PipelineConfig config = scope.Resolve<PipelineConfig>();
            List<string> CurrentNodes = new();
            foreach (PipelineContent item in from PipelineContent item in config.PipelineContents where item.Alias.Equals(task.RouteStep) select item)
            {
                CurrentNodes = item.Nodes;
            }
            IPipeline pipeline = scope.ResolveNamed<IPipeline>("VirtualPipeline");
            int index = task.Target.Equals(nameof(task.From)) ? CurrentNodes.FindIndex(it => it.Equals(task.Record)) : CurrentNodes.FindLastIndex(it => it.Equals(task.Record));
            CurrentNodes.Skip(index + 1).ToList().ForEach(node =>
            {
                pipeline.AddNode(scope.ResolveNamed<INode>(node));
            });
            pipeline.Invoke(task);
        }

        public void ExecuteTaskByVirtualPipe(EquipmentTask task, List<string> steps)
        {
            using ILifetimeScope scope = Container.BeginLifetimeScope();
            IPipeline pipeline = scope.ResolveNamed<IPipeline>("VirtualPipeline");
            steps.ForEach(step =>
            {
                pipeline.AddNode(scope.ResolveNamed<INode>(step));
            });
            pipeline.Invoke(task);
        }
        #endregion

        public void InitializationBean()
        {
            using ILifetimeScope scope = Container.BeginLifetimeScope();
            scope.Resolve<shjxCamera.Globals>();
            scope.Resolve<CalculationResult>();
            scope.Resolve<TaskRuntime>();
            scope.Resolve<PipeContent>();
            scope.Resolve<PortProducerFactory>();
            scope.Resolve<ConfigInstance>();
            scope.Resolve<DataManagerInstance>();
            scope.Resolve<ExecuteCommand>();
            foreach (Type scheduler in Assembly.GetAssembly(GetType()).GetExportedTypes().Where(type => typeof(IScheduler).IsAssignableFrom(type) && !type.GetTypeInfo().IsAbstract))
            {
                scope.ResolveNamed<IScheduler>(scheduler.Name);
            };
        }

        public void StartTaskProcesser()
        {
            _scheduler.Start();
        }

        #region Register
        public void RegisterContainer()
        {
            ContainerBuilder builder = new();
            RegistSingletonType(ref builder);
            RegistPipeNodes(ref builder);
            RegistFromAppType(ref builder);
            RegistConfig(ref builder);
            RegistInterface<IPipeline>(ref builder);
            RegistInterface<IScheduler>(ref builder);
            Container = builder.Build();
        }

        private void RegistSingletonType(ref ContainerBuilder builder)
        {
            builder.RegisterType<Globals>();
            builder.RegisterType<OptCommand>();
            builder.RegisterType<TaskExtend>();
            builder.RegisterType<PipeContent>();
            builder.RegisterType<TaskRuntime>();
            builder.RegisterType<CalculationResult>();
            builder.RegisterType<ConfigInstance>();
            builder.RegisterType<ExecuteCommand>();
            builder.RegisterType<PortProducerFactory>();
            builder.RegisterType<AopInterceptor>();
            builder.RegisterType<DataManagerInstance>();
        }

        private void RegistFromAppType(ref ContainerBuilder builder)
        {
            builder.Register(it => _ea).As<IEventAggregator>();
            builder.Register(it => _dataManager).As<IDataManager>();
        }

        private void RegistConfig(ref ContainerBuilder builder)
        {
            PipelineConfig config = PipelineConfig.Instance;
            builder.Register(it => config).As<PipelineConfig>();
            builder.Register(it => _readConfig).As<ReadConfigUtil>();
        }

        private void RegistPipeNodes(ref ContainerBuilder builder)
        {
            Assembly assem = GetType().GetTypeInfo().Assembly;
            builder.RegisterAssemblyTypes(assem)
                .Where(type => typeof(INode).IsAssignableFrom(type) && !type.GetTypeInfo().IsAbstract)
                .AsImplementedInterfaces()
                .InstancePerDependency()
                .Named<INode>(it => it.Name)
                .EnableClassInterceptors()
                .InterceptedBy(typeof(AopInterceptor));
        }

        private void RegistInterface<T>(ref ContainerBuilder builder)
        {
            builder.RegisterAssemblyTypes(AppDomain.CurrentDomain.GetAssemblies())
                .Where(type => typeof(T).IsAssignableFrom(type) && !type.GetTypeInfo().IsAbstract)
                .AsImplementedInterfaces()
                .Named<T>(it => it.Name)
                .InstancePerDependency();
        }
        #endregion
    }
}