增加同步物流模块

修改现有架构，改为分模块( 简易版)

Store.Framework/DependencyInjection/ContainerConfig.cs

@@ -0,0 +1,99 @@
+using Autofac;
+using Autofac.Core;
+using Autofac.Integration.WebApi;
+using FreeSql;
+using MAX.Core.DependencyInjection;
+using MAX.Core.Helpers;
+using MAX.Core.Interfaces;
+using MAX.Core.Logger;
+using MAX.Framework.Logger;
+using Store.Framework.Commons;
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Store.Framework.DependencyInjection;
+
+public class ContainerConfig
+{
+
+	public static IContainer BuildContainer()
+	{
+		var builder = new ContainerBuilder();
+		var appAssembly = StoreAppTypeFinder.Current.GetAssemblies().ToArray();
+
+		var connection = ConfigurationManager.ConnectionStrings["ConnKJD"];
+		if (connection == null || string.IsNullOrWhiteSpace(connection.ConnectionString))
+		{
+			throw new ConfigurationErrorsException("未配置连接字符串：ConnKJD");
+		}
+		// ImageCacheService 使用独立的 imagecache 数据库。
+		builder.Register(_ =>
+		{
+			return new FreeSqlBuilder()
+				.UseConnectionString(
+					DataType.MySql,
+					connection.ConnectionString)
+				.Build();
+		})
+		.As<IFreeSql>()
+		.SingleInstance();
+
+
+		// 注册 Web API 所有 Controller
+		builder.RegisterApiControllers(appAssembly);
+		builder.RegisterInstance(NLogger.Instance).As<ILoggerFacade>().SingleInstance();
+
+
+
+
+		#region 注册所有IOC接口
+
+		Type typeSingleton = typeof(ISingletonDependency);
+		builder.RegisterAssemblyTypes(appAssembly)
+			.Where(a =>
+				typeSingleton.IsAssignableFrom(a)
+				&& a.IsClass
+				&& !a.IsAbstract
+			)
+			.AsImplementedInterfaces()
+			.AsSelf()
+			.SingleInstance();
+
+		Type typeTransient = typeof(ITransientDependency);
+		builder.RegisterAssemblyTypes(appAssembly)
+			.Where(a =>
+				typeTransient.IsAssignableFrom(a)
+				&& a.IsClass
+				&& !a.IsAbstract
+			)
+			.AsImplementedInterfaces()
+			.AsSelf()
+			.InstancePerDependency();
+
+		Type typeScoped = typeof(IScopedDependency);
+		builder.RegisterAssemblyTypes(appAssembly)
+			.Where(a => typeScoped.IsAssignableFrom(a) && a.IsClass && !a.IsAbstract)
+			.AsImplementedInterfaces()
+			.AsSelf()
+			.InstancePerRequest();
+
+		#endregion
+		IServiceRegistrar registrar = new ServiceRegistrarProxy(builder);
+		IEnumerable<IStartup> startupList = ReflectionHelper.GetInstancesByInterface<IStartup>(appAssembly);
+		foreach (IStartup item in startupList.OrderByDescending(a => a.Priority))
+		{
+			Debug.WriteLine($"Startup : {item.GetType()}");
+			item.Initialize();
+			item.Register(registrar);
+		}
+
+		var app = builder.Build();
+		return app;
+	}
+
+}

Store.Framework/DependencyInjection/ServiceRegistrarProxy.cs

@@ -0,0 +1,135 @@
+using Autofac;
+using Autofac.Core;
+using MAX.Core.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Store.Framework.DependencyInjection;
+
+internal class ServiceRegistrarProxy : IServiceRegistrar
+{
+	private readonly ContainerBuilder _services;
+
+	public object Services => _services;
+
+	public ServiceRegistrarProxy(ContainerBuilder builder)
+	{
+		_services = builder ?? throw new ArgumentNullException(nameof(builder));
+	}
+
+	// ---------------- Scoped ----------------
+
+	public void RegisterScoped<TService>(Func<IServiceProvider, TService> factory)
+		where TService : class
+	{
+		_services.Register(c => factory(c.Resolve<IServiceProvider>()))
+				 .As<TService>()
+				 .InstancePerLifetimeScope();
+	}
+
+	public void RegisterScoped<TService>(object? serviceKey,
+		Func<IServiceProvider, object?, TService> factory)
+		where TService : class
+	{
+		_services.Register(c => factory(c.Resolve<IServiceProvider>(), serviceKey))
+				 .Keyed<TService>(serviceKey ?? throw new ArgumentNullException(nameof(serviceKey)))
+				 .InstancePerLifetimeScope();
+	}
+
+	void IServiceRegistrar.RegisterScoped<TService, TImplementation>()
+	{
+		_services.RegisterType<TImplementation>()
+				 .As<TService>()
+				 .InstancePerLifetimeScope();
+	}
+
+	void IServiceRegistrar.RegisterScoped<TService, TImplementation>(object? serviceKey)
+	{
+		_services.RegisterType<TImplementation>()
+				 .Keyed<TService>(serviceKey ?? throw new ArgumentNullException(nameof(serviceKey)))
+				 .InstancePerLifetimeScope();
+	}
+
+	// ---------------- Singleton ----------------
+
+	public void RegisterSingleton<TService>(TService instance)
+		where TService : class
+	{
+		_services.RegisterInstance(instance)
+				 .As<TService>()
+				 .SingleInstance();
+	}
+
+	public void RegisterSingleton<TService>(Func<IServiceProvider, TService> factory)
+		where TService : class
+	{
+		_services.Register(c => factory(c.Resolve<IServiceProvider>()))
+				 .As<TService>()
+				 .SingleInstance();
+	}
+
+	public void RegisterSingleton<TService>(object? serviceKey, TService instance)
+		where TService : class
+	{
+		_services.RegisterInstance(instance)
+				 .Keyed<TService>(serviceKey ?? throw new ArgumentNullException(nameof(serviceKey)))
+				 .SingleInstance();
+	}
+
+	public void RegisterSingleton<TService>(object? serviceKey,
+		Func<IServiceProvider, object?, TService> factory)
+		where TService : class
+	{
+		_services.Register(c => factory(c.Resolve<IServiceProvider>(), serviceKey))
+				 .Keyed<TService>(serviceKey ?? throw new ArgumentNullException(nameof(serviceKey)))
+				 .SingleInstance();
+	}
+
+	void IServiceRegistrar.RegisterSingleton<TService, TImplementation>()
+	{
+		_services.RegisterType<TImplementation>()
+				 .As<TService>()
+				 .SingleInstance();
+	}
+
+	void IServiceRegistrar.RegisterSingleton<TService, TImplementation>(object? serviceKey)
+	{
+		_services.RegisterType<TImplementation>()
+				 .Keyed<TService>(serviceKey ?? throw new ArgumentNullException(nameof(serviceKey)))
+				 .SingleInstance();
+	}
+
+	// ---------------- Transient ----------------
+
+	public void RegisterTransient<TService>(Func<IServiceProvider, TService> factory)
+		where TService : class
+	{
+		_services.Register(c => factory(c.Resolve<IServiceProvider>()))
+				 .As<TService>()
+				 .InstancePerDependency();
+	}
+
+	public void RegisterTransient<TService>(object? serviceKey,
+		Func<IServiceProvider, object?, TService> factory)
+		where TService : class
+	{
+		_services.Register(c => factory(c.Resolve<IServiceProvider>(), serviceKey))
+				 .Keyed<TService>(serviceKey ?? throw new ArgumentNullException(nameof(serviceKey)))
+				 .InstancePerDependency();
+	}
+
+	void IServiceRegistrar.RegisterTransient<TService, TImplementation>()
+	{
+		_services.RegisterType<TImplementation>()
+				 .As<TService>()
+				 .InstancePerDependency();
+	}
+
+	void IServiceRegistrar.RegisterTransient<TService, TImplementation>(object? serviceKey)
+	{
+		_services.RegisterType<TImplementation>()
+				 .Keyed<TService>(serviceKey ?? throw new ArgumentNullException(nameof(serviceKey)))
+				 .InstancePerDependency();
+	}
+}