725 lines
22 KiB
C#
725 lines
22 KiB
C#
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Channels;
|
|
using System.Threading.Tasks;
|
|
|
|
// 1. 任务接口定义
|
|
public interface ITaskItem
|
|
{
|
|
string TaskId { get; }
|
|
TaskPriority Priority { get; }
|
|
DateTime CreatedAt { get; }
|
|
int SequenceNumber { get; set; } // 用于严格排序
|
|
string GroupId { get; } // 用于分组排序
|
|
Task ExecuteAsync(CancellationToken cancellationToken = default);
|
|
}
|
|
|
|
public enum TaskPriority
|
|
{
|
|
Low = 0,
|
|
Normal = 1,
|
|
High = 2,
|
|
Critical = 3,
|
|
Urgent = 4 // 最高优先级，用于插队
|
|
}
|
|
|
|
// 2. 基础任务实现
|
|
public abstract class BaseTask : ITaskItem
|
|
{
|
|
public string TaskId { get; } = Guid.NewGuid().ToString();
|
|
public TaskPriority Priority { get; set; } = TaskPriority.Normal;
|
|
public DateTime CreatedAt { get; } = DateTime.UtcNow;
|
|
public int SequenceNumber { get; set; } = 0;
|
|
public string GroupId { get; set; } = null;
|
|
|
|
public abstract Task ExecuteAsync(CancellationToken cancellationToken = default);
|
|
}
|
|
|
|
// 3. 支持分组的任务基类
|
|
public abstract class GroupedTask : BaseTask
|
|
{
|
|
protected GroupedTask(string? groupId)
|
|
{
|
|
GroupId = groupId ?? throw new ArgumentNullException(nameof(groupId));
|
|
}
|
|
}
|
|
|
|
// 4. 网络连接任务（支持分组）
|
|
public class NetworkConnectionTask : GroupedTask
|
|
{
|
|
private readonly NetworkConnectionData _data;
|
|
private readonly INetworkDataStore _dataStore;
|
|
|
|
public NetworkConnectionTask(NetworkConnectionData data, INetworkDataStore dataStore, string? groupId = null)
|
|
: base(groupId ?? $"network_{data.ProcessName}")
|
|
{
|
|
_data = data;
|
|
_dataStore = dataStore;
|
|
Priority = TaskPriority.High;
|
|
}
|
|
|
|
public override async Task ExecuteAsync(CancellationToken cancellationToken = default)
|
|
{
|
|
await _dataStore.UpdateNetworkConnectionAsync(_data);
|
|
}
|
|
}
|
|
|
|
// 5. 数据库写入任务
|
|
public class DatabaseWriteTask : BaseTask
|
|
{
|
|
private readonly object _data;
|
|
private readonly Func<object, CancellationToken, Task> _writeAction;
|
|
|
|
public DatabaseWriteTask(object data, Func<object, CancellationToken, Task> writeAction,
|
|
TaskPriority priority = TaskPriority.Normal)
|
|
{
|
|
_data = data;
|
|
_writeAction = writeAction;
|
|
Priority = priority;
|
|
}
|
|
|
|
public override async Task ExecuteAsync(CancellationToken cancellationToken = default)
|
|
{
|
|
await _writeAction(_data, cancellationToken);
|
|
}
|
|
}
|
|
|
|
// 6. 任务队列配置
|
|
public class TaskQueueOptions
|
|
{
|
|
public int MaxConcurrency { get; set; } = Environment.ProcessorCount;
|
|
public int MaxQueueSize { get; set; } = 10000;
|
|
public TimeSpan TaskTimeout { get; set; } = TimeSpan.FromMinutes(5);
|
|
public bool EnablePriorityProcessing { get; set; } = true;
|
|
public bool EnableGroupedExecution { get; set; } = true; // 是否启用分组执行
|
|
public TimeSpan StatisticsUpdateInterval { get; set; } = TimeSpan.FromSeconds(1);
|
|
}
|
|
|
|
// 7. 任务统计信息
|
|
public class TaskStatistics
|
|
{
|
|
public int QueuedTasks { get; set; }
|
|
public int RunningTasks { get; set; }
|
|
public int AvailableWorkers { get; set; }
|
|
public long TotalEnqueued { get; set; } // 总入队任务数
|
|
public long TotalCompleted { get; set; } // 总完成任务数
|
|
public long TotalFailed { get; set; } // 总失败任务数
|
|
public double AverageExecutionTime { get; set; } // 平均执行时间（毫秒）
|
|
public Dictionary<TaskPriority, int> QueuedByPriority { get; set; } = new();
|
|
public Dictionary<string, int> QueuedByGroup { get; set; } = new();
|
|
public DateTime LastUpdated { get; set; } = DateTime.UtcNow;
|
|
}
|
|
|
|
// 8. 任务信息
|
|
public class TaskInfo
|
|
{
|
|
public ITaskItem Task { get; set; }
|
|
public DateTime StartTime { get; set; }
|
|
public DateTime? EndTime { get; set; }
|
|
public bool IsCompleted { get; set; }
|
|
public bool IsFailed { get; set; }
|
|
public Exception Exception { get; set; }
|
|
|
|
public TimeSpan ExecutionTime => EndTime.HasValue ? EndTime.Value - StartTime : DateTime.UtcNow - StartTime;
|
|
}
|
|
|
|
// 9. 优先级任务比较器
|
|
public class TaskPriorityComparer : IComparer<ITaskItem>
|
|
{
|
|
public int Compare(ITaskItem x, ITaskItem y)
|
|
{
|
|
if (x == null && y == null) return 0;
|
|
if (x == null) return 1;
|
|
if (y == null) return -1;
|
|
|
|
// 1. 先按优先级排序（优先级高的在前）
|
|
var priorityComparison = y.Priority.CompareTo(x.Priority);
|
|
if (priorityComparison != 0) return priorityComparison;
|
|
|
|
// 2. 同优先级按序列号排序
|
|
if (x.SequenceNumber != 0 || y.SequenceNumber != 0)
|
|
{
|
|
return x.SequenceNumber.CompareTo(y.SequenceNumber);
|
|
}
|
|
|
|
// 3. 最后按创建时间排序（FIFO）
|
|
return x.CreatedAt.CompareTo(y.CreatedAt);
|
|
}
|
|
}
|
|
|
|
// 10. 增强的任务队列实现
|
|
public class EnhancedTaskQueue : ITaskQueue, IDisposable
|
|
{
|
|
private readonly PriorityQueue<ITaskItem, ITaskItem> _priorityQueue;
|
|
private readonly TaskQueueOptions _options;
|
|
private readonly SemaphoreSlim _concurrencySemaphore;
|
|
private readonly ConcurrentDictionary<string, TaskInfo> _runningTasks;
|
|
private readonly ConcurrentDictionary<string, SemaphoreSlim> _groupSemaphores;
|
|
private readonly CancellationTokenSource _cancellationTokenSource;
|
|
private readonly Task[] _workerTasks;
|
|
private readonly ReaderWriterLockSlim _queueLock;
|
|
private readonly Timer _statisticsTimer;
|
|
|
|
// 统计数据
|
|
private long _totalEnqueued = 0;
|
|
private long _totalCompleted = 0;
|
|
private long _totalFailed = 0;
|
|
private readonly ConcurrentQueue<double> _executionTimes = new();
|
|
|
|
/// <summary>
|
|
/// 当前序列号
|
|
/// </summary>
|
|
private int _currentSequenceNumber = 0;
|
|
|
|
private bool _disposed = false;
|
|
private readonly ManualResetEventSlim _newTaskEvent;
|
|
|
|
public EnhancedTaskQueue(TaskQueueOptions? options = null)
|
|
{
|
|
_options = options ?? new TaskQueueOptions();
|
|
|
|
_priorityQueue = new PriorityQueue<ITaskItem, ITaskItem>(new TaskPriorityComparer());
|
|
_concurrencySemaphore = new SemaphoreSlim(_options.MaxConcurrency, _options.MaxConcurrency);
|
|
_runningTasks = new ConcurrentDictionary<string, TaskInfo>();
|
|
_groupSemaphores = new ConcurrentDictionary<string, SemaphoreSlim>();
|
|
_cancellationTokenSource = new CancellationTokenSource();
|
|
_queueLock = new ReaderWriterLockSlim();
|
|
_newTaskEvent = new ManualResetEventSlim(false);
|
|
|
|
// 启动统计更新定时器
|
|
_statisticsTimer = new Timer(UpdateStatistics, null,
|
|
_options.StatisticsUpdateInterval, _options.StatisticsUpdateInterval);
|
|
|
|
// 启动工作线程
|
|
_workerTasks = new Task[_options.MaxConcurrency];
|
|
for (int i = 0; i < _options.MaxConcurrency; i++)
|
|
{
|
|
_workerTasks[i] = Task.Run(() => ProcessTasksAsync(_cancellationTokenSource.Token));
|
|
}
|
|
}
|
|
|
|
public async Task<bool> EnqueueAsync(ITaskItem task, CancellationToken cancellationToken = default)
|
|
{
|
|
if (_disposed) return false;
|
|
|
|
try
|
|
{
|
|
_queueLock.EnterWriteLock();
|
|
|
|
// 检查队列大小
|
|
if (_priorityQueue.Count >= _options.MaxQueueSize)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// 如果没有设置序列号，自动分配
|
|
if (task.SequenceNumber == 0)
|
|
{
|
|
task.SequenceNumber = Interlocked.Increment(ref _currentSequenceNumber);
|
|
}
|
|
|
|
_priorityQueue.Enqueue(task, task);
|
|
Interlocked.Increment(ref _totalEnqueued);
|
|
|
|
_newTaskEvent.Set(); // 通知工作线程有新任务
|
|
return true;
|
|
}
|
|
finally
|
|
{
|
|
_queueLock.ExitWriteLock();
|
|
}
|
|
}
|
|
|
|
public async Task<bool> EnqueueUrgentAsync(ITaskItem task, CancellationToken cancellationToken = default)
|
|
{
|
|
// 设置为最高优先级并立即处理
|
|
if (task is BaseTask baseTask)
|
|
{
|
|
baseTask.Priority = TaskPriority.Urgent;
|
|
}
|
|
|
|
return await EnqueueAsync(task, cancellationToken);
|
|
}
|
|
|
|
public async Task<bool> EnqueueSequentialAsync(IEnumerable<ITaskItem> tasks, string? groupId = null)
|
|
{
|
|
if (_disposed) return false;
|
|
|
|
var taskList = tasks.ToList();
|
|
if (!taskList.Any()) return true;
|
|
|
|
var actualGroupId = groupId ?? Guid.NewGuid().ToString();
|
|
|
|
try
|
|
{
|
|
_queueLock.EnterWriteLock();
|
|
|
|
// 检查队列容量
|
|
if (_priorityQueue.Count + taskList.Count > _options.MaxQueueSize)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var sequenceStart = Interlocked.Add(ref _currentSequenceNumber, taskList.Count) - taskList.Count + 1;
|
|
|
|
for (int i = 0; i < taskList.Count; i++)
|
|
{
|
|
var task = taskList[i];
|
|
task.SequenceNumber = sequenceStart + i;
|
|
|
|
// 设置分组ID
|
|
if (task is BaseTask baseTask && string.IsNullOrEmpty(baseTask.GroupId))
|
|
{
|
|
baseTask.GroupId = actualGroupId;
|
|
}
|
|
|
|
_priorityQueue.Enqueue(task, task);
|
|
Interlocked.Increment(ref _totalEnqueued);
|
|
}
|
|
|
|
_newTaskEvent.Set();
|
|
return true;
|
|
}
|
|
finally
|
|
{
|
|
_queueLock.ExitWriteLock();
|
|
}
|
|
}
|
|
|
|
public TaskStatistics GetStatistics()
|
|
{
|
|
var stats = new TaskStatistics
|
|
{
|
|
RunningTasks = _runningTasks.Count,
|
|
AvailableWorkers = _concurrencySemaphore.CurrentCount,
|
|
TotalEnqueued = Interlocked.Read(ref _totalEnqueued),
|
|
TotalCompleted = Interlocked.Read(ref _totalCompleted),
|
|
TotalFailed = Interlocked.Read(ref _totalFailed),
|
|
LastUpdated = DateTime.UtcNow
|
|
};
|
|
|
|
// 计算平均执行时间
|
|
if (_executionTimes.Count > 0)
|
|
{
|
|
stats.AverageExecutionTime = _executionTimes.Average();
|
|
}
|
|
|
|
// 获取队列统计
|
|
_queueLock.EnterReadLock();
|
|
try
|
|
{
|
|
stats.QueuedTasks = _priorityQueue.Count;
|
|
|
|
// 按优先级和分组统计（这里简化处理，实际中可能需要遍历队列）
|
|
var tempQueue = new List<ITaskItem>();
|
|
while (_priorityQueue.Count > 0)
|
|
{
|
|
var task = _priorityQueue.Dequeue();
|
|
tempQueue.Add(task);
|
|
|
|
// 统计优先级
|
|
if (!stats.QueuedByPriority.ContainsKey(task.Priority))
|
|
stats.QueuedByPriority[task.Priority] = 0;
|
|
stats.QueuedByPriority[task.Priority]++;
|
|
|
|
// 统计分组
|
|
if (!string.IsNullOrEmpty(task.GroupId))
|
|
{
|
|
stats.QueuedByGroup.TryAdd(task.GroupId, 0);
|
|
stats.QueuedByGroup[task.GroupId]++;
|
|
}
|
|
}
|
|
|
|
// 重新入队
|
|
foreach (var task in tempQueue)
|
|
{
|
|
_priorityQueue.Enqueue(task, task);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
_queueLock.ExitReadLock();
|
|
}
|
|
|
|
return stats;
|
|
}
|
|
|
|
public List<ITaskItem> GetQueuedTasks()
|
|
{
|
|
_queueLock.EnterReadLock();
|
|
try
|
|
{
|
|
var result = new List<ITaskItem>();
|
|
var tempQueue = new List<ITaskItem>();
|
|
|
|
while (_priorityQueue.Count > 0)
|
|
{
|
|
var task = _priorityQueue.Dequeue();
|
|
tempQueue.Add(task);
|
|
result.Add(task);
|
|
}
|
|
|
|
// 重新入队
|
|
foreach (var task in tempQueue)
|
|
{
|
|
_priorityQueue.Enqueue(task, task);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
finally
|
|
{
|
|
_queueLock.ExitReadLock();
|
|
}
|
|
}
|
|
|
|
public List<TaskInfo> GetRunningTasks()
|
|
{
|
|
return _runningTasks.Values.ToList();
|
|
}
|
|
|
|
private async Task ProcessTasksAsync(CancellationToken cancellationToken)
|
|
{
|
|
while (!cancellationToken.IsCancellationRequested)
|
|
{
|
|
ITaskItem? task = null;
|
|
|
|
// 从优先级队列获取任务
|
|
_queueLock.EnterWriteLock();
|
|
try
|
|
{
|
|
if (_priorityQueue.Count > 0)
|
|
{
|
|
task = _priorityQueue.Dequeue();
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
_queueLock.ExitWriteLock();
|
|
}
|
|
|
|
if (task == null)
|
|
{
|
|
// 没有任务，等待新任务信号
|
|
try
|
|
{
|
|
_newTaskEvent.Wait(1000, cancellationToken); // 最多等待1秒
|
|
_newTaskEvent.Reset();
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
break;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// 控制并发数
|
|
await _concurrencySemaphore.WaitAsync(cancellationToken);
|
|
|
|
// 处理分组任务的串行执行
|
|
SemaphoreSlim? groupSemaphore = null;
|
|
if (_options.EnableGroupedExecution && !string.IsNullOrEmpty(task.GroupId))
|
|
{
|
|
groupSemaphore = _groupSemaphores.GetOrAdd(task.GroupId, _ => new SemaphoreSlim(1, 1));
|
|
await groupSemaphore.WaitAsync(cancellationToken);
|
|
}
|
|
|
|
var taskInfo = new TaskInfo
|
|
{
|
|
Task = task,
|
|
StartTime = DateTime.UtcNow
|
|
};
|
|
|
|
_runningTasks.TryAdd(task.TaskId, taskInfo);
|
|
|
|
// 异步执行任务
|
|
_ = Task.Run(async () =>
|
|
{
|
|
try
|
|
{
|
|
using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
|
|
cts.CancelAfter(_options.TaskTimeout);
|
|
|
|
await task.ExecuteAsync(cts.Token);
|
|
|
|
taskInfo.IsCompleted = true;
|
|
taskInfo.EndTime = DateTime.UtcNow;
|
|
Interlocked.Increment(ref _totalCompleted);
|
|
|
|
// 记录执行时间
|
|
var executionTime = taskInfo.ExecutionTime.TotalMilliseconds;
|
|
_executionTimes.Enqueue(executionTime);
|
|
|
|
// 限制执行时间队列大小
|
|
while (_executionTimes.Count > 1000)
|
|
{
|
|
_executionTimes.TryDequeue(out _);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
taskInfo.IsFailed = true;
|
|
taskInfo.Exception = ex;
|
|
taskInfo.EndTime = DateTime.UtcNow;
|
|
Interlocked.Increment(ref _totalFailed);
|
|
}
|
|
finally
|
|
{
|
|
_runningTasks.TryRemove(task.TaskId, out _);
|
|
_concurrencySemaphore.Release();
|
|
groupSemaphore?.Release();
|
|
}
|
|
}, cancellationToken);
|
|
}
|
|
}
|
|
|
|
private void UpdateStatistics(object state)
|
|
{
|
|
// 定期更新统计信息的逻辑
|
|
// 这里可以添加更复杂的统计计算
|
|
}
|
|
|
|
public async Task StopAsync()
|
|
{
|
|
if (_disposed) return;
|
|
|
|
_cancellationTokenSource.Cancel();
|
|
_newTaskEvent.Set(); // 唤醒等待的工作线程
|
|
|
|
try
|
|
{
|
|
await Task.WhenAll(_workerTasks);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
// 预期的取消异常
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (_disposed) return;
|
|
|
|
_disposed = true;
|
|
_cancellationTokenSource.Cancel();
|
|
_newTaskEvent.Set();
|
|
|
|
try
|
|
{
|
|
Task.WaitAll(_workerTasks, TimeSpan.FromSeconds(5));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// 忽略关闭时的异常
|
|
}
|
|
|
|
_concurrencySemaphore?.Dispose();
|
|
_cancellationTokenSource?.Dispose();
|
|
_queueLock?.Dispose();
|
|
_newTaskEvent?.Dispose();
|
|
_statisticsTimer?.Dispose();
|
|
|
|
// 清理分组信号量
|
|
foreach (var semaphore in _groupSemaphores.Values)
|
|
{
|
|
semaphore.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
// 11. 增强的接口定义
|
|
public interface ITaskQueue
|
|
{
|
|
Task<bool> EnqueueAsync(ITaskItem task, CancellationToken cancellationToken = default);
|
|
Task<bool> EnqueueUrgentAsync(ITaskItem task, CancellationToken cancellationToken = default);
|
|
Task<bool> EnqueueSequentialAsync(IEnumerable<ITaskItem> tasks, string groupId = null);
|
|
TaskStatistics GetStatistics();
|
|
List<ITaskItem> GetQueuedTasks();
|
|
List<TaskInfo> GetRunningTasks();
|
|
Task StopAsync();
|
|
}
|
|
|
|
// 12. 网络数据存储接口和实现（保持原有实现）
|
|
public interface INetworkDataStore
|
|
{
|
|
Task UpdateNetworkConnectionAsync(NetworkConnectionData data);
|
|
Task<IEnumerable<NetworkConnectionData>> GetRecentConnectionsAsync(TimeSpan timeSpan);
|
|
Task<NetworkStatistics> GetStatisticsAsync();
|
|
}
|
|
|
|
public class NetworkDataStore : INetworkDataStore
|
|
{
|
|
private readonly ConcurrentQueue<NetworkConnectionData> _recentConnections;
|
|
private readonly ConcurrentDictionary<string, ConnectionStatistics> _connectionStats;
|
|
private readonly Timer _cleanupTimer;
|
|
|
|
public NetworkDataStore()
|
|
{
|
|
_recentConnections = new ConcurrentQueue<NetworkConnectionData>();
|
|
_connectionStats = new ConcurrentDictionary<string, ConnectionStatistics>();
|
|
|
|
_cleanupTimer = new Timer(CleanupExpiredData, null,
|
|
TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1));
|
|
}
|
|
|
|
public async Task UpdateNetworkConnectionAsync(NetworkConnectionData data)
|
|
{
|
|
await Task.Run(() =>
|
|
{
|
|
_recentConnections.Enqueue(data);
|
|
|
|
var key = $"{data.ProcessName}:{data.LocalPort}";
|
|
_connectionStats.AddOrUpdate(key,
|
|
new ConnectionStatistics { Count = 1, LastSeen = DateTime.UtcNow },
|
|
(k, v) => new ConnectionStatistics { Count = v.Count + 1, LastSeen = DateTime.UtcNow });
|
|
});
|
|
}
|
|
|
|
public async Task<IEnumerable<NetworkConnectionData>> GetRecentConnectionsAsync(TimeSpan timeSpan)
|
|
{
|
|
return await Task.FromResult(
|
|
_recentConnections
|
|
.Where(c => DateTime.UtcNow - c.Timestamp <= timeSpan)
|
|
.ToList());
|
|
}
|
|
|
|
public async Task<NetworkStatistics> GetStatisticsAsync()
|
|
{
|
|
return await Task.FromResult(new NetworkStatistics
|
|
{
|
|
TotalConnections = _recentConnections.Count,
|
|
ActiveProcesses = _connectionStats.Count,
|
|
LastUpdate = DateTime.UtcNow
|
|
});
|
|
}
|
|
|
|
private void CleanupExpiredData(object state)
|
|
{
|
|
var cutoff = DateTime.UtcNow.AddHours(-1);
|
|
|
|
while (_recentConnections.TryPeek(out var connection) &&
|
|
connection.Timestamp < cutoff)
|
|
{
|
|
_recentConnections.TryDequeue(out _);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 13. 数据模型
|
|
public class NetworkConnectionData
|
|
{
|
|
public string ProcessName { get; set; }
|
|
public int ProcessId { get; set; }
|
|
public string LocalAddress { get; set; }
|
|
public int LocalPort { get; set; }
|
|
public string RemoteAddress { get; set; }
|
|
public int RemotePort { get; set; }
|
|
public DateTime Timestamp { get; set; } = DateTime.UtcNow;
|
|
public string Protocol { get; set; }
|
|
}
|
|
|
|
public class ConnectionStatistics
|
|
{
|
|
public int Count { get; set; }
|
|
public DateTime LastSeen { get; set; }
|
|
}
|
|
|
|
public class NetworkStatistics
|
|
{
|
|
public int TotalConnections { get; set; }
|
|
public int ActiveProcesses { get; set; }
|
|
public DateTime LastUpdate { get; set; }
|
|
}
|
|
|
|
// 14. 增强的任务队列管理器
|
|
public class EnhancedTaskQueueManager
|
|
{
|
|
private readonly EnhancedTaskQueue _taskQueue;
|
|
private readonly NetworkDataStore _dataStore;
|
|
|
|
public EnhancedTaskQueueManager(TaskQueueOptions options = null)
|
|
{
|
|
var defaultOptions = new TaskQueueOptions
|
|
{
|
|
MaxConcurrency = Environment.ProcessorCount,
|
|
MaxQueueSize = 5000,
|
|
EnableGroupedExecution = true,
|
|
EnablePriorityProcessing = true
|
|
};
|
|
|
|
_taskQueue = new EnhancedTaskQueue(options ?? defaultOptions);
|
|
_dataStore = new NetworkDataStore();
|
|
}
|
|
|
|
// 普通任务入队
|
|
public async Task<bool> EnqueueNetworkTask(NetworkConnectionData data)
|
|
{
|
|
var task = new NetworkConnectionTask(data, _dataStore);
|
|
return await _taskQueue.EnqueueAsync(task);
|
|
}
|
|
|
|
// 紧急任务插队
|
|
public async Task<bool> EnqueueUrgentNetworkTask(NetworkConnectionData data)
|
|
{
|
|
var task = new NetworkConnectionTask(data, _dataStore);
|
|
return await _taskQueue.EnqueueUrgentAsync(task);
|
|
}
|
|
|
|
// 批量有序任务
|
|
public async Task<bool> EnqueueSequentialDatabaseWrites(IEnumerable<object> dataList)
|
|
{
|
|
var tasks = dataList.Select(data => new DatabaseWriteTask(data,
|
|
async (d, ct) => await WriteToDatabase(d),
|
|
TaskPriority.Normal)).Cast<ITaskItem>();
|
|
|
|
return await _taskQueue.EnqueueSequentialAsync(tasks, "database_batch");
|
|
}
|
|
|
|
// 获取详细统计信息
|
|
public TaskStatistics GetDetailedStatistics()
|
|
{
|
|
return _taskQueue.GetStatistics();
|
|
}
|
|
|
|
// 获取队列中的任务列表
|
|
public List<ITaskItem> GetPendingTasks()
|
|
{
|
|
return _taskQueue.GetQueuedTasks();
|
|
}
|
|
|
|
// 获取正在执行的任务
|
|
public List<TaskInfo> GetActiveTasks()
|
|
{
|
|
return _taskQueue.GetRunningTasks();
|
|
}
|
|
|
|
// 获取网络数据
|
|
public async Task<IEnumerable<NetworkConnectionData>> GetRecentConnections(TimeSpan timeSpan)
|
|
{
|
|
return await _dataStore.GetRecentConnectionsAsync(timeSpan);
|
|
}
|
|
|
|
private async Task WriteToDatabase(object data)
|
|
{
|
|
// 模拟数据库写入
|
|
await Task.Delay(100);
|
|
}
|
|
|
|
public async Task StopAsync()
|
|
{
|
|
await _taskQueue.StopAsync();
|
|
_taskQueue.Dispose();
|
|
}
|
|
}
|
|
// 保留一个任务队列工具函数；
|
|
// 提供公共阿德网络处理模板；
|
|
// 尝试获取所有的网络连接信息；
|
|
// 如何模拟低性能设设备的软件运行情况？
|
|
// 提供公共的网络处理任务类，并将其投入使用；
|
|
// 提供全局的公共的，唯一的信息类（提供软件开启状态；网络连接；等其他信息） 将网络信息及其他信息进程整合
|
|
// 页面展示提供多种状态：（仅联网软件；已打开软件）
|