internal static IMiCakeModuleCollection CombineNormalAndFeatureModules(
IMiCakeModuleCollection normalModules,
IMiCakeModuleCollection featureModules)
{
IMiCakeModuleCollection miCakeModules = new MiCakeModuleCollection();
var assignFeatureModules = AssignFeatureModules(featureModules);
Queue <IMiCakeModuleCollection> moduleQueue = new Queue <IMiCakeModuleCollection>();
moduleQueue.Enqueue(assignFeatureModules.before);
moduleQueue.Enqueue(normalModules);
moduleQueue.Enqueue(assignFeatureModules.after);
var count = moduleQueue.Count;
for (int i = 0; i < count; i++)
{
var modules = moduleQueue.Dequeue();
foreach (var module in modules)
{
miCakeModules.AddIfNotContains(module);
}
}
return(miCakeModules);
}
public DefaultDomainObjectModelProvider(
IMiCakeModuleContext moduleContext)
{
CheckValue.NotNull(moduleContext, nameof(moduleContext));
_exceptedModules = moduleContext.MiCakeModules.Where(s => !s.Instance.IsFrameworkLevel)
.ToMiCakeModuleCollection();
}
public MiCakeModuleBoot(
ILoggerFactory loggerFactory,
IMiCakeModuleCollection modules)
{
_logger = loggerFactory.CreateLogger("MiCake.Core.Modularity.MiCakeModuleBoot");
_moduleLogger = new MiCakeModuleLogger(_logger);
_modules = modules;
}
public MiCakeModuleContext(
IMiCakeModuleCollection allModules,
IMiCakeModuleCollection normalModules,
IMiCakeModuleCollection featureModules)
{
AllModules = allModules;
MiCakeModules = normalModules;
FeatureModules = featureModules;
}
public ModuleConfigServiceContext(
IServiceCollection services,
IMiCakeModuleCollection miCakeModules,
MiCakeApplicationOptions miCakeApplication)
{
Services = services;
MiCakeModules = miCakeModules;
MiCakeApplicationOptions = miCakeApplication;
}
public ModuleBearingContext(
IServiceProvider serviceProvider,
IMiCakeModuleCollection miCakeModules,
MiCakeApplicationOptions applicationOptions
)
{
ServiceProvider = serviceProvider;
MiCakeModules = miCakeModules;
MiCakeApplicationOptions = applicationOptions;
}
public void PopulateModules(Type entryType)
{
if (_isPopulate)
{
throw new InvalidOperationException("PopulateDefaultModule can only be called once.");
}
_isPopulate = true;
MiCakeModuleHelper.FindAllModulesFromEntry(_normalModulesTypes, entryType);
IMiCakeModuleCollection normalModules = ResolvingMiCakeModules(_normalModulesTypes)
.ToMiCakeModuleCollection();
//Ensure that the position of the entry module is the last
if (normalModules[^ 1].ModuleType != entryType)
private void StartModuleLifetime(
IMiCakeModuleCollection modules,
IEnumerable <ModuleBootInfo> lifetimes,
object contextInfo)
{
foreach (var lifetimeInfo in lifetimes)
{
foreach (var module in modules)
{
//logging current module info.
_moduleLogger.LogModuleInfo(module, $"MiCake {lifetimeInfo.Description}: ");
//execute current module lifetime.
lifetimeInfo.StartAction(module.Instance, contextInfo);
}
}
}
public virtual void Register(IMiCakeModuleCollection miCakeModules)
{
var injectServices = new List <InjectServiceInfo>();
//filter need register modules
var needRegitsterModules = miCakeModules.Where(s => s.Instance.IsAutoRegisterServices)
.ToMiCakeModuleCollection();
var assemblies = needRegitsterModules.GetAssemblies();
foreach (var assembly in assemblies)
{
var types = assembly.GetTypes().Where(type => type.IsClass & !type.IsAbstract & !type.IsSealed).ToList();
foreach (var type in types)
{
var currentTypeServices = AddInjectServices(type);
if (currentTypeServices.Count != 0)
{
injectServices.AddRange(currentTypeServices);
}
}
}
foreach (var serviceInfo in injectServices)
{
var serviceLifetime = serviceInfo.Lifetime.HasValue ?
serviceInfo.Lifetime.Value.ConvertToMSLifetime() :
ServiceLifetime.Transient;
var serviceDescriptor = new ServiceDescriptor(serviceInfo.Type, serviceInfo.ImplementationType, serviceLifetime);
if (serviceInfo.ReplaceServices)
{
_services.Replace(serviceDescriptor);
}
else if (serviceInfo.TryRegister)
{
_services.TryAdd(serviceDescriptor);
}
else
{
_services.Add(serviceDescriptor);
}
}
}
//Base on MediatR.Registration
//see https://github.com/jbogard/MediatR.Extensions.Microsoft.DependencyInjection
public static void ResigterDomainEventHandler(this IServiceCollection services, IMiCakeModuleCollection miCakeModules)
{
var assemblies = miCakeModules.GetAssemblies(false).ToList();
ConnectImplementationsToTypesClosing(typeof(IDomainEventHandler <>), services, assemblies, true);
}
private Assembly[] GetDomianLayer(IMiCakeModuleCollection miCakeModules)
{
return(miCakeModules.GetAssemblies(false).Where(asm =>
asm.GetTypes().AsEnumerable().Any(inModuleType =>
DomainTypeHelper.IsDomainObject(inModuleType))).ToArray());
}
public MiCakeModuleContext()
{
AllModules = new MiCakeModuleCollection();
MiCakeModules = new MiCakeModuleCollection();
FeatureModules = new MiCakeModuleCollection();
}
private static (IMiCakeModuleCollection before, IMiCakeModuleCollection after) AssignFeatureModules(IMiCakeModuleCollection featureModules)
{
var beforeFeatureModules = new MiCakeModuleCollection();
var afterFeatureModules = new MiCakeModuleCollection();
foreach (var featureModule in featureModules)
{
bool depencyIsAfter = featureModule.RelyOnModules.Any(module =>
((IFeatureModule)module.Instance).Order == FeatureModuleLoadOrder.AfterCommonModule);
var currentOrder = ((IFeatureModule)featureModule.Instance).Order;
if (!depencyIsAfter && currentOrder == FeatureModuleLoadOrder.BeforeCommonModule)
{
beforeFeatureModules.Add(featureModule);
}
else
{
afterFeatureModules.Add(featureModule);
}
}
return(beforeFeatureModules, afterFeatureModules);
}
public ModuleInspectionContext(IServiceProvider serviceProvider, IMiCakeModuleCollection miCakeModules)
{
AppServiceProvider = serviceProvider;
MiCakeModules = miCakeModules;
}
