dotnet-campus/dotnetCampus.ApplicationStartupManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #3 from dotnet-campus/app

Browse Source 
支持更多业务接入
This commit is contained in:
LanXiaofang
2022-03-16 20:18:43 +08:00
committed by GitHub
parent 1d736929c3 65f134d1f3
commit 469b76c814
13 changed files with 150 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/dotnetCampus.ApplicationStartupManager/IStartupContext.cs
View File

@@ -1,12 +1,12 @@
using System.Threading.Tasks;
using dotnetCampus.Configurations;
//using dotnetCampus.Configurations;
namespace dotnetCampus.ApplicationStartupManager
{
public interface IStartupContext
{
IAppConfigurator Configs { get; }
Task<string> ReadCacheAsync(string key, string @default = "");
//IAppConfigurator Configs { get; }
//Task<string> ReadCacheAsync(string key, string @default = "");
Task WaitStartupTaskAsync(string startupKey);
}
}

2
src/dotnetCampus.ApplicationStartupManager/IStartupManager.cs
View File

@@ -6,6 +6,6 @@ namespace dotnetCampus.ApplicationStartupManager
{
Task WaitStartupTaskAsync(string startupTaskKey);
StartupTask GetStartupTask<T>() where T : StartupTask;
StartupTaskBase GetStartupTask<T>() where T : StartupTaskBase;
}
}

2
src/dotnetCampus.ApplicationStartupManager/NullObjectStartup.cs
View File

@@ -1,6 +1,6 @@
namespace dotnetCampus.ApplicationStartupManager
{
internal sealed class NullObjectStartup : StartupTask
internal sealed class NullObjectStartup : StartupTaskBase
{
}

24
src/dotnetCampus.ApplicationStartupManager/StartupContext.cs
View File

@@ -1,7 +1,7 @@
using System;
using System.Threading.Tasks;
using dotnetCampus.Configurations;
using dotnetCampus.Configurations.Core;
//using dotnetCampus.Configurations;
//using dotnetCampus.Configurations.Core;
namespace dotnetCampus.ApplicationStartupManager
{
@@ -9,29 +9,29 @@ namespace dotnetCampus.ApplicationStartupManager
{
public IStartupLogger Logger { get; }
public FileConfigurationRepo Configuration { get; }
//public FileConfigurationRepo Configuration { get; }
public IAppConfigurator Configs { get; }
//public IAppConfigurator Configs { get; }
public Func<Exception, Task> FastFail { get; }
private readonly Func<string, Task> _waitStartupTaskAsync;
public Task<string> ReadCacheAsync(string key, string @default = "")
{
return Configuration.TryReadAsync(key, @default);
}
//public Task<string> ReadCacheAsync(string key, string @default = "")
//{
// return Configuration.TryReadAsync(key, @default);
//}
Task IStartupContext.WaitStartupTaskAsync(string startupKey) => _waitStartupTaskAsync(startupKey);
public StartupContext(IStartupLogger logger, FileConfigurationRepo configuration,
public StartupContext(IStartupLogger logger, /*FileConfigurationRepo configuration,*/
Func<Exception, Task> fastFailAction, Func<string, Task> waitStartupAsync)
{
Logger = logger;
Configuration = configuration;
//Configuration = configuration;
_waitStartupTaskAsync = waitStartupAsync;
Configs = configuration.CreateAppConfigurator();
FastFail = fastFailAction ?? (exception => StartupTask.CompletedTask);
//Configs = configuration.CreateAppConfigurator();
FastFail = fastFailAction ?? (exception => StartupTaskBase.CompletedTask);
}
}
}

19
src/dotnetCampus.ApplicationStartupManager/StartupLogger.cs
View File

@@ -9,14 +9,14 @@ using System.Threading.Tasks;
namespace dotnetCampus.ApplicationStartupManager
{
public class StartupLogger : IStartupLogger
public class StartupLoggerBase : IStartupLogger
{
private readonly Stopwatch _mainWatch;
private readonly ConcurrentDictionary<string, (string name, long start, long elapsed)>
_milestoneDictionary = new ConcurrentDictionary<string, (string, long, long)>();
protected ConcurrentDictionary<string, (string threadName, long start, long elapsed)>
MilestoneDictionary { get; } = new ConcurrentDictionary<string, (string, long, long)>();
public StartupLogger()
public StartupLoggerBase()
{
_mainWatch = new Stopwatch();
_mainWatch.Start();
@@ -24,11 +24,11 @@ namespace dotnetCampus.ApplicationStartupManager
public void RecordTime(string milestoneName)
{
var start = _milestoneDictionary.Count > 0
? _milestoneDictionary.Max(x => x.Value.start + x.Value.elapsed)
var start = MilestoneDictionary.Count > 0
? MilestoneDictionary.Max(x => x.Value.start + x.Value.elapsed)
: 0;
var end = _mainWatch.ElapsedTicks;
_milestoneDictionary[milestoneName] =
MilestoneDictionary[milestoneName] =
(Thread.CurrentThread.Name ?? Thread.CurrentThread.ManagedThreadId.ToString(CultureInfo.InvariantCulture),
start, end - start);
}
@@ -46,13 +46,12 @@ namespace dotnetCampus.ApplicationStartupManager
{
var end = _mainWatch.ElapsedTicks;
var elapse = end - begin;
_milestoneDictionary[taskName] = (threadName, begin, elapse);
MilestoneDictionary[taskName] = (threadName, begin, elapse);
}
}
public void ReportResult(IReadOnlyList<IStartupTaskWrapper> wrappers)
public virtual void ReportResult(IReadOnlyList<IStartupTaskWrapper> wrappers)
{
// todo 还没有具体实现
}
}
}

151
src/dotnetCampus.ApplicationStartupManager/StartupManager.cs → src/dotnetCampus.ApplicationStartupManager/StartupManagerBase.cs
View File

@@ -2,24 +2,21 @@
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Net.Mime;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using dotnetCampus.Configurations.Core;
//using dotnetCampus.Configurations.Core;
namespace dotnetCampus.ApplicationStartupManager
{
public class StartupManager : IStartupManager
public class StartupManagerBase : IStartupManager
{
private readonly IMainThreadDispatcher _dispatcher;
/// <summary>
/// Builder 模式所需状态：包含当前剩余需要管理的启动任务程序集。
/// </summary>
private readonly List<Assembly> _assembliesToBeManaged = new List<Assembly>();
///// <summary>
///// Builder 模式所需状态：包含当前剩余需要管理的启动任务程序集。
///// </summary>
//private readonly List<Assembly> _assembliesToBeManaged = new List<Assembly>();
/// <summary>
/// Builder 模式所需状态：包含当前所有的关键启动任务。
@@ -42,13 +39,14 @@ namespace dotnetCampus.ApplicationStartupManager
internal ConcurrentDictionary<string, StartupTaskWrapper> StartupTaskWrappers { get; } =
new ConcurrentDictionary<string, StartupTaskWrapper>();
private List<StartupTaskWrapper> Graph { get; set; }
private List<StartupTaskWrapper>? Graph { get; set; }
private StartupContext Context { get; }
protected IStartupContext StartupContext => Context;
private IStartupLogger Logger => Context.Logger;
protected IStartupLogger Logger => Context.Logger;
public StartupManager(IStartupLogger logger, FileConfigurationRepo configurationRepo,
public StartupManagerBase(IStartupLogger logger, /*FileConfigurationRepo configurationRepo,*/
Func<Exception, Task> fastFailAction, IMainThreadDispatcher dispatcher, bool shouldSetThreadPool = true)
{
if (logger == null)
@@ -56,10 +54,10 @@ namespace dotnetCampus.ApplicationStartupManager
throw new ArgumentNullException(nameof(logger));
}
if (configurationRepo is null)
{
throw new ArgumentNullException(nameof(configurationRepo));
}
//if (configurationRepo is null)
//{
// throw new ArgumentNullException(nameof(configurationRepo));
//}
_dispatcher = dispatcher;
@@ -71,40 +69,56 @@ namespace dotnetCampus.ApplicationStartupManager
ThreadPool.SetMinThreads(Math.Max(_workerThreads, 16), Math.Max(_completionPortThreads, 16));
}
Context = new StartupContext(logger, configurationRepo,
Context = new StartupContext(logger, /*configurationRepo,*/
fastFailAction, WaitStartupTaskAsync);
Logger.RecordTime("ManagerInitialized");
}
///// <summary>
///// 配置被 <see cref="StartupManager"/> 管理的程序集。
///// 只有被管理的程序集中的启动信息、依赖注入信息才会被执行。
///// </summary>
///// <param name="assemblies"></param>
///// <returns></returns>
//public StartupManagerBase ConfigAssemblies(IEnumerable<Assembly> assemblies)
//{
// // 可能的限制尚未完成：
// // 1. Run 之后不能再调用此方法（适用于固定的程序集应用）；
// // 2. 可以多次 Config 然后多次 Run（适用于动态加载的插件程序集）。
// _assembliesToBeManaged.AddRange(assemblies);
// return this;
//}
/// <summary>
/// 配置被 <see cref="StartupManager"/> 管理的程序集。
/// 配置被 <see cref="StartupManagerBase"/> 管理的程序集。
/// 只有被管理的程序集中的启动信息、依赖注入信息才会被执行。
/// </summary>
/// <param name="assemblies"></param>
/// <param name="collector"></param>
/// <returns></returns>
public StartupManager ConfigAssemblies(IEnumerable<Assembly> assemblies)
public virtual StartupManagerBase AddStartupTaskMetadataCollector(Func<IEnumerable<StartupTaskMetadata>> collector)
{
// 可能的限制尚未完成：
// 1. Run 之后不能再调用此方法（适用于固定的程序集应用）；
// 2. 可以多次 Config 然后多次 Run（适用于动态加载的插件程序集）。
_assembliesToBeManaged.AddRange(assemblies);
_startupTaskMetadataCollectorList.Add(collector);
return this;
}
private readonly ConcurrentBag<Func<IEnumerable<StartupTaskMetadata>>> _startupTaskMetadataCollectorList = new ConcurrentBag<Func<IEnumerable<StartupTaskMetadata>>>();
/// <summary>
/// 在启动流程中定义一组关键的启动节点。使用此方法定义的关键启动节点将按顺序前后依次依赖。
/// 例如传入 A、B、C、D 四个关键启动节点，那么 A - B - C - D 将依次执行，其他任务将插入其中。
/// </summary>
/// <param name="criticalNodeKeys">关键启动节点的名称。</param>
/// <returns><see cref="StartupManager"/> 实例自身，用于使用重建者模式创建启动流程管理器。</returns>
/// <returns><see cref="StartupManagerBase"/> 实例自身，用于使用重建者模式创建启动流程管理器。</returns>
/// <remarks>
/// <para>
/// 通常情况下你可以编写常规的 StartupTask 来添加一个关键节点，只要这个节点被众多节点声明了依赖，那么它就能视为一个关键节点。
/// 使用此方法可以添加一些虚拟的，实际上不会执行任何启动任务的关键启动节点，用于汇总其他模块的依赖关系。
/// </para>
/// </remarks>
public StartupManager UseCriticalNodes(params string[] criticalNodeKeys)
public StartupManagerBase UseCriticalNodes(params string[] criticalNodeKeys)
{
if (criticalNodeKeys == null)
{
@@ -129,7 +143,7 @@ namespace dotnetCampus.ApplicationStartupManager
{
var key = criticalNodeKeys[i];
var current = GetStartupTaskWrapper(key);
current.StartupTask = new NullObjectStartup();
current.TaskBase = new NullObjectStartup();
current.Categories = StartupCategory.All;
if (i - 1 >= 0)
@@ -153,7 +167,7 @@ namespace dotnetCampus.ApplicationStartupManager
/// <param name="nodeName">关键节点的名称。</param>
/// <param name="beforeTasks">关键节点的前置节点。</param>
/// <param name="afterTasks">关键节点的后置节点。</param>
/// <returns><see cref="StartupManager"/> 实例自身，用于使用重建者模式创建启动流程管理器。</returns>
/// <returns><see cref="StartupManagerBase"/> 实例自身，用于使用重建者模式创建启动流程管理器。</returns>
/// <remarks>
/// <para>
/// 通常情况下你可以编写常规的 StartupTask 来添加一个关键节点，只要这个节点被众多节点声明了依赖，那么它就能视为一个关键节点。
@@ -164,13 +178,13 @@ namespace dotnetCampus.ApplicationStartupManager
/// 例如，你需要根据不同的启动条件决定不同的启动顺序，那么你可能需要使用此方法动态生成关键节点。
/// </para>
/// </remarks>
public StartupManager AddCriticalNodes(string nodeName, string beforeTasks = null, string afterTasks = null)
public StartupManagerBase AddCriticalNodes(string nodeName, string? beforeTasks = null, string? afterTasks = null)
{
var wrapper = GetStartupTaskWrapper(nodeName);
wrapper.StartupTask = new NullObjectStartup();
wrapper.TaskBase = new NullObjectStartup();
wrapper.Categories = StartupCategory.All;
if (beforeTasks?.Split(new[] {";"}, StringSplitOptions.RemoveEmptyEntries) is string[] before)
if (beforeTasks?.Split(new[] { ";" }, StringSplitOptions.RemoveEmptyEntries) is { } before)
{
foreach (var b in before)
{
@@ -179,7 +193,7 @@ namespace dotnetCampus.ApplicationStartupManager
}
}
if (afterTasks?.Split(new[] {";"}, StringSplitOptions.RemoveEmptyEntries) is string[] after)
if (afterTasks?.Split(new[] { ";" }, StringSplitOptions.RemoveEmptyEntries) is { } after)
{
foreach (var a in after)
{
@@ -192,22 +206,16 @@ namespace dotnetCampus.ApplicationStartupManager
return this;
}
public StartupManager SelectNodes(StartupCategory categories)
{
_selectingCategories = categories;
return this;
}
// 不支持被使用
//public StartupManagerBase SelectNodes(StartupCategory categories)
//{
// _selectingCategories = categories;
// return this;
//}
public StartupManager ForStartupTasksOfCategory(StartupCategory category,
Action<StartupTaskBuilder> taskBuilder)
public StartupManagerBase ForStartupTasksOfCategory(Action<StartupTaskBuilder> taskBuilder)
{
_additionalBuilders.Add(builder =>
{
if (builder.Categories == category)
{
taskBuilder(builder);
}
});
_additionalBuilders.Add(taskBuilder);
return this;
}
@@ -222,7 +230,7 @@ namespace dotnetCampus.ApplicationStartupManager
var dispatcher = _dispatcher;
foreach (var wrapper in Graph)
{
var startupTasks = wrapper.Dependencies.Select(s => GetStartupTaskWrapper(s).StartupTask);
var startupTasks = wrapper.Dependencies.Select(s => GetStartupTaskWrapper(s).TaskBase);
if (wrapper.UIOnly)
{
await dispatcher.InvokeAsync(() => wrapper.ExecuteTask(startupTasks, Context));
@@ -233,7 +241,7 @@ namespace dotnetCampus.ApplicationStartupManager
}
}
await Graph.Last().StartupTask.TaskResult;
await Graph.Last().TaskBase.TaskResult;
Logger.RecordTime("AllStartupTasksCompleted");
@@ -254,7 +262,7 @@ namespace dotnetCampus.ApplicationStartupManager
wrapper.Categories &= _selectingCategories;
}
var taskMetadataList = ExportStartupTasks(_assembliesToBeManaged, _selectingCategories).ToList();
var taskMetadataList = ExportStartupTasks().ToList();
foreach (var meta in taskMetadataList)
{
@@ -262,8 +270,8 @@ namespace dotnetCampus.ApplicationStartupManager
wrapper.UIOnly = meta.Scheduler == StartupScheduler.UIOnly;
wrapper.Categories = meta.Categories;
wrapper.CriticalLevel = meta.CriticalLevel;
wrapper.StartupTask = meta.Instance;
wrapper.StartupTask.Manager = this;
wrapper.TaskBase = meta.Instance;
wrapper.TaskBase.Manager = this;
wrappers.Add(wrapper);
}
@@ -294,25 +302,9 @@ namespace dotnetCampus.ApplicationStartupManager
return DFSGraph(wrappers);
IEnumerable<StartupTaskMetadata> ExportStartupTasks(
IEnumerable<Assembly> assemblies, StartupCategory categories)
{
// todo 高性能的预编译框架接入
//foreach (var meta in AssemblyMetadataExporter.ExportStartupTasks(assemblies))
//{
// meta.Categories &= categories;
// if (meta.Categories != StartupCategory.None)
// {
// yield return meta;
// }
//}
yield break;
}
void AddDependencies(StartupTaskWrapper wrapper, string afterTasks)
{
foreach (var task in afterTasks.Split(new[] {';'}, StringSplitOptions.RemoveEmptyEntries)
foreach (var task in afterTasks.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
.Select(CompatibleTaskName))
{
if (!taskMetadataList.Exists(metadata => metadata.Key == task)
@@ -332,7 +324,7 @@ namespace dotnetCampus.ApplicationStartupManager
void AddFollowTasks(StartupTaskWrapper wrapper, string beforeTasks)
{
foreach (var task in beforeTasks.Split(new[] {';'}, StringSplitOptions.RemoveEmptyEntries)
foreach (var task in beforeTasks.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
.Select(CompatibleTaskName))
{
if (!taskMetadataList.Exists(metadata => metadata.Key == task)
@@ -351,6 +343,18 @@ namespace dotnetCampus.ApplicationStartupManager
}
}
protected virtual IEnumerable<StartupTaskMetadata> ExportStartupTasks()
{
foreach (var func in _startupTaskMetadataCollectorList)
{
var taskMetadataList = func();
foreach (var taskMetadata in taskMetadataList)
{
yield return taskMetadata;
}
}
}
private static string CompatibleTaskName(string task)
{
const string startupName = "Startup";
@@ -417,7 +421,7 @@ namespace dotnetCampus.ApplicationStartupManager
return wrapper;
}
wrapper = new StartupTaskWrapper(startupTaskKey);
wrapper = new StartupTaskWrapper(startupTaskKey, this);
if (StartupTaskWrappers.TryAdd(startupTaskKey, wrapper))
{
return wrapper;
@@ -432,12 +436,17 @@ namespace dotnetCampus.ApplicationStartupManager
}
public Task WaitStartupTaskAsync(string startupTaskKey)
=> GetStartupTaskWrapper(startupTaskKey).StartupTask.TaskResult;
=> GetStartupTaskWrapper(startupTaskKey).TaskBase.TaskResult;
StartupTask IStartupManager.GetStartupTask<T>()
=> GetStartupTaskWrapper(StartupTypeToKey(typeof(T))).StartupTask;
StartupTaskBase IStartupManager.GetStartupTask<T>()
=> GetStartupTaskWrapper(StartupTypeToKey(typeof(T))).TaskBase;
private static string StartupTypeToKey(Type type)
=> type.Name.Remove(type.Name.Length - "startup".Length);
internal virtual Task<string> ExecuteStartupTaskAsync(StartupTaskBase startupTask, IStartupContext context, bool uiOnly)
{
return startupTask.JoinAsync(context, uiOnly);
}
}
}

12
src/dotnetCampus.ApplicationStartupManager/StartupTaskAttribute.cs
View File

@@ -9,12 +9,12 @@ namespace dotnetCampus.ApplicationStartupManager
/// <summary>
/// 此启动任务的任务必须在指定的其他启动任务之前完成。可以使用 “;” 分隔符指定多个启动任务。
/// </summary>
public string BeforeTasks { get; set; }
public string? BeforeTasks { get; set; }
/// <summary>
/// 效果上等同于 <see cref="BeforeTasks"/> 属性，此属性只是为了开发方便而已
/// </summary>
public string[] BeforeTaskList
public string[]? BeforeTaskList
{
set
{
@@ -22,19 +22,19 @@ namespace dotnetCampus.ApplicationStartupManager
}
get
{
return BeforeTasks.Split(';');
return BeforeTasks?.Split(';');
}
}
/// <summary>
/// 此启动任务的任务将在指定的其他启动任务之后开始执行。可以使用 “;” 分隔符指定多个启动任务。
/// </summary>
public string AfterTasks { get; set; }
public string? AfterTasks { get; set; }
/// <summary>
/// 效果上等同于 <see cref="AfterTasks"/> 属性，此属性只是为了开发方便而已
/// </summary>
public string[] AfterTaskList
public string[]? AfterTaskList
{
set
{
@@ -42,7 +42,7 @@ namespace dotnetCampus.ApplicationStartupManager
}
get
{
return AfterTasks.Split(';');
return AfterTasks?.Split(';');
}
}

10
src/dotnetCampus.ApplicationStartupManager/StartupTask.cs → src/dotnetCampus.ApplicationStartupManager/StartupTaskBase.cs
View File

@@ -4,7 +4,7 @@ using System.Threading.Tasks;
namespace dotnetCampus.ApplicationStartupManager
{
public abstract class StartupTask
public abstract class StartupTaskBase
{
// 由于我们都在编译期间收集 Attribute 了，当然也能收集使用方到底重写了哪个 Run。
// 这里传入的 isUIOnly 就是编译期间收集的那个属性。
@@ -38,18 +38,22 @@ namespace dotnetCampus.ApplicationStartupManager
protected internal static Task CompletedTask =>
#if NETFRAMEWORK
CompletedCommonTask;
#pragma warning disable IDE0032 // Use auto property
private static readonly Task CompletedCommonTask = Task.FromResult(true);
#pragma warning restore IDE0032 // Use auto property
#else
Task.CompletedTask;
#endif
public Task TaskResult => CompletedSource.Task;
private TaskCompletionSource<object> CompletedSource { get; } = new TaskCompletionSource<object>();
private TaskCompletionSource<object?> CompletedSource { get; } = new TaskCompletionSource<object?>();
internal IStartupManager Manager { get; set; }
// 框架注入，一定不为空
= null!;
protected TValue FetchValue<TStartup, TValue>() where TStartup : StartupTask, IStartupValueProvider<TValue>
protected TValue FetchValue<TStartup, TValue>() where TStartup : StartupTaskBase, IStartupValueProvider<TValue>
{
var task = Manager.GetStartupTask<TStartup>();
var v = (IStartupValueProvider<TValue>)task;

7
src/dotnetCampus.ApplicationStartupManager/StartupTaskHelper.cs
View File

@@ -2,8 +2,13 @@
{
static class StartupTaskHelper
{
public static string BuildTasks(params string[] taskList)
public static string? BuildTasks(params string[]? taskList)
{
if (taskList is null)
{
return null;
}
if (taskList.Length > 1)
{
return string.Join(";", taskList);

2
src/dotnetCampus.ApplicationStartupManager/StartupTaskMetadata.T.cs
View File

@@ -8,7 +8,7 @@ namespace dotnetCampus.ApplicationStartupManager
/// 记录 <typeparamref name="TStartupTask"/> 类型中标记的从 <see cref="StartupTaskAttribute"/> 中统一收集元数据。
/// </summary>
/// <typeparam name="TStartupTask"></typeparam>
public class StartupTaskMetadata<TStartupTask> : StartupTaskMetadata where TStartupTask : StartupTask, new()
public class StartupTaskMetadata<TStartupTask> : StartupTaskMetadata where TStartupTask : StartupTaskBase, new()
{
/// <summary>
/// 创建包含 <typeparamref name="TStartupTask"/> 元数据的 <see cref="StartupTaskMetadata{TStartupTask}"/> 的新实例。

34
src/dotnetCampus.ApplicationStartupManager/StartupTaskMetadata.cs
View File

@@ -4,54 +4,44 @@ using System.Threading;
namespace dotnetCampus.ApplicationStartupManager
{
/// <summary>
/// 记录 <see cref="StartupTask"/> 类型中标记的从 <see cref="StartupTaskAttribute"/> 中统一收集元数据。
/// 记录 <see cref="StartupTaskBase"/> 类型中标记的从 <see cref="StartupTaskAttribute"/> 中统一收集元数据。
/// </summary>
public class StartupTaskMetadata
{
private readonly Lazy<StartupTask> _taskLazy;
private string _afterTasks;
private string _beforeTasks;
private readonly Lazy<StartupTaskBase> _taskLazy;
/// <summary>
/// 创建 <see cref="StartupTaskMetadata"/> 的新实例。
/// </summary>
/// <param name="key">表示此 <see cref="StartupTask"/> 的唯一标识符。</param>
/// <param name="creator">此 <see cref="StartupTask"/> 实例的创建方法。</param>
public StartupTaskMetadata( string key, Func<StartupTask> creator)
/// <param name="key">表示此 <see cref="StartupTaskBase"/> 的唯一标识符。</param>
/// <param name="creator">此 <see cref="StartupTaskBase"/> 实例的创建方法。</param>
public StartupTaskMetadata( string key, Func<StartupTaskBase> creator)
{
Key = key ?? throw new ArgumentNullException(nameof(key));
_taskLazy = new Lazy<StartupTask>(
_taskLazy = new Lazy<StartupTaskBase>(
creator ?? throw new ArgumentNullException(nameof(creator)),
LazyThreadSafetyMode.None);
}
/// <summary>
/// 获取 <see cref="StartupTask"/> 的唯一标识符。
/// 获取 <see cref="StartupTaskBase"/> 的唯一标识符。
/// </summary>
public string Key { get; }
/// <summary>
/// 获取<see cref="StartupTaskAttribute.Categories"/> 的值，
/// 获取 Categories 的值
/// </summary>
public StartupCategory Categories { get; set; } = StartupCategory.All;
/// <summary>
/// 获取 <see cref="StartupTaskAttribute.BeforeTasks"/> 的值，如果没有标记，则为 null。
/// </summary>
public string BeforeTasks
{
get => _beforeTasks;
set => _beforeTasks = value;
}
public string? BeforeTasks { get; set; }
/// <summary>
/// 获取 <see cref="StartupTaskAttribute.AfterTasks"/> 的值，如果没有标记，则为 null。
/// </summary>
public string AfterTasks
{
get => _afterTasks;
set => _afterTasks = value;
}
public string? AfterTasks { get; set; }
/// <summary>
/// 获取 <see cref="StartupTaskAttribute.Scheduler"/> 的值，如果没有标记，则为 <see cref="StartupScheduler.Default"/>。
@@ -59,9 +49,9 @@ namespace dotnetCampus.ApplicationStartupManager
public StartupScheduler Scheduler { get; set; }
/// <summary>
/// 根据从元数据中收集到的创建 <see cref="StartupTask"/> 的方法获取或创建 <see cref="StartupTask"/> 的实例。
/// 根据从元数据中收集到的创建 <see cref="StartupTaskBase"/> 的方法获取或创建 <see cref="StartupTaskBase"/> 的实例。
/// </summary>
public StartupTask Instance => _taskLazy.Value;
public StartupTaskBase Instance => _taskLazy.Value;
/// <summary>
/// 获取 <see cref="StartupTaskAttribute.CriticalLevel"/> 的值，如果没有获取或设置此启动任务的关键级别，则为 <see cref="StartupCriticalLevel.Unset"/>。

12
src/dotnetCampus.ApplicationStartupManager/StartupTaskWrapper.cs
View File

@@ -9,6 +9,7 @@ namespace dotnetCampus.ApplicationStartupManager
[DebuggerDisplay("{StartupTaskKey}:{IsVisited},{VisitedFinishTime}")]
internal class StartupTaskWrapper : IStartupTaskWrapper
{
private readonly StartupManagerBase _manager;
public HashSet<string> FollowTasks { get; private set; } = new HashSet<string>();
public HashSet<string> Dependencies { get; private set; } = new HashSet<string>();
@@ -20,16 +21,19 @@ namespace dotnetCampus.ApplicationStartupManager
public StartupCategory Categories { get; internal set; } = StartupCategory.All;
public StartupTask StartupTask { get; internal set; }
public StartupTaskBase TaskBase { get; internal set; }
// 框架注入，一定不为空
= null!;
public bool UIOnly { get; internal set; }
public StartupCriticalLevel CriticalLevel { get; set; }
public StartupTaskWrapper(string startupTaskKey)
public StartupTaskWrapper(string startupTaskKey, StartupManagerBase manager)
{
_manager = manager;
StartupTaskKey = startupTaskKey;
}
public async void ExecuteTask(IEnumerable<StartupTask> dependencies, StartupContext context)
public async void ExecuteTask(IEnumerable<StartupTaskBase> dependencies, StartupContext context)
{
await Task.WhenAll(dependencies.Select(task => task.TaskResult));
#pragma warning disable CS4014 // 由于此调用不会等待，因此在调用完成前将继续执行当前方法
@@ -43,7 +47,7 @@ namespace dotnetCampus.ApplicationStartupManager
//todo Tracer.Info($"[Startup]关键节点：{StartupTaskKey}开始执行");
}
var result = await StartupTask.JoinAsync(context, UIOnly);
var result = await _manager.ExecuteStartupTaskAsync(TaskBase, context, UIOnly);
if (CriticalLevel == StartupCriticalLevel.Critical)
{

7
src/dotnetCampus.ApplicationStartupManager/dotnetCampus.ApplicationStartupManager.csproj
View File

@@ -4,7 +4,8 @@
<TargetFrameworks>netcoreapp3.1;netstandard2.0;net45;net5.0</TargetFrameworks>
<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
<GenerateDocumentationFile>true</GenerateDocumentationFile>
<!-- <GenerateDocumentationFile>true</GenerateDocumentationFile> -->
<Nullable>enable</Nullable>
</PropertyGroup>
<PropertyGroup>
@@ -41,8 +42,8 @@
</ItemGroup>
<ItemGroup>
<PackageReference Include="dotnetCampus.Configurations" Version="1.6.9" />
<PackageReference Include="dotnetCampus.SourceYard" Version="0.1.19369-alpha">
<!--<PackageReference Include="dotnetCampus.Configurations" Version="1.6.9" />-->
<PackageReference Include="dotnetCampus.SourceYard" Version="1.0.0-alpha01">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>