846 lines
25 KiB
C#
846 lines
25 KiB
C#
using Lattice.Core.DragDrop.Abstractions;
|
||
using Lattice.Core.DragDrop.Constants;
|
||
using Lattice.Core.DragDrop.Enums;
|
||
using Lattice.Core.DragDrop.Models;
|
||
using Lattice.Core.Geometry;
|
||
|
||
namespace Lattice.Core.DragDrop.Services;
|
||
|
||
/// <summary>
|
||
/// Центральный сервис управления операциями перетаскивания.
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// <see cref="DragDropService"/> является основным компонентом системы drag-and-drop,
|
||
/// который координирует взаимодействие между источниками данных (<see cref="Abstractions.IDragSource"/>)
|
||
/// и целями сброса (<see cref="Abstractions.IDropTarget"/>).
|
||
/// </para>
|
||
/// <para>
|
||
/// Основные функции сервиса:
|
||
/// </para>
|
||
/// <list type="bullet">
|
||
/// <item>Регистрация и управление целями сброса</item>
|
||
/// <item>Оркестрация жизненного цикла операций перетаскивания</item>
|
||
/// <item>Обработка событий мыши и клавиатуры</item>
|
||
/// <item>Распространение информации между компонентами</item>
|
||
/// <item>Обеспечение потокобезопасности операций</item>
|
||
/// </list>
|
||
/// <para>
|
||
/// Сервис поддерживает полностью асинхронную модель работы, уведомления через события
|
||
/// и статистику использования. Все операции защищены от параллельного доступа
|
||
/// и обеспечивают корректную очистку ресурсов.
|
||
/// </para>
|
||
/// <para>
|
||
/// Для использования сервиса необходимо:
|
||
/// <list type="number">
|
||
/// <item>Зарегистрировать цели сброса с помощью <see cref="RegisterDropTarget"/></item>
|
||
/// <item>Вызывать методы <see cref="StartDragAsync"/>, <see cref="UpdateDragAsync"/>,
|
||
/// <see cref="EndDragAsync"/> в ответ на действия пользователя</item>
|
||
/// <item>Подписаться на события для отслеживания состояния операций</item>
|
||
/// </list>
|
||
/// </para>
|
||
/// </remarks>
|
||
public sealed class DragDropService : IDragDropService
|
||
{
|
||
#region Nested Types
|
||
|
||
/// <summary>
|
||
/// Информация о зарегистрированной цели сброса.
|
||
/// </summary>
|
||
private sealed class DropTargetInfo : IDisposable
|
||
{
|
||
public required Abstractions.IDropTarget Target { get; init; }
|
||
public required Geometry.Rect Bounds { get; set; }
|
||
public required int Priority { get; init; }
|
||
public required string? Group { get; init; }
|
||
public required string Id { get; init; }
|
||
public DateTime LastAccessTime { get; set; } = DateTime.UtcNow;
|
||
public int UsageCount { get; set; }
|
||
|
||
public void Dispose()
|
||
{
|
||
if (Target is IDisposable disposable)
|
||
disposable.Dispose();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Контекст текущей операции перетаскивания.
|
||
/// </summary>
|
||
private sealed class DragOperationContext : IDisposable
|
||
{
|
||
public Abstractions.IDragSource? Source { get; set; }
|
||
public Models.DragInfo? DragInfo { get; set; }
|
||
public Abstractions.IDropTarget? CurrentDropTarget { get; set; }
|
||
public CancellationTokenSource? CancellationTokenSource { get; set; }
|
||
public DateTime StartTime { get; set; } = DateTime.UtcNow;
|
||
public bool ThresholdExceeded { get; set; }
|
||
public Point LastPosition { get; set; }
|
||
|
||
public void Dispose()
|
||
{
|
||
DragInfo?.Dispose();
|
||
CancellationTokenSource?.Dispose();
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Fields
|
||
|
||
private readonly Dictionary<string, DropTargetInfo> _dropTargets = new();
|
||
private readonly ReaderWriterLockSlim _dropTargetsLock = new(LockRecursionPolicy.NoRecursion);
|
||
private readonly object _dragOperationLock = new();
|
||
|
||
private DragOperationContext? _currentDragOperation;
|
||
private Timer? _cleanupTimer;
|
||
private bool _disposed;
|
||
|
||
private int _totalDragOperations;
|
||
private int _successfulDrops;
|
||
private int _cancelledOperations;
|
||
private int _errorCount;
|
||
private long _totalOperationTicks;
|
||
|
||
#endregion
|
||
|
||
#region Events
|
||
|
||
private event EventHandler<DragStartedEventArgs>? _dragStarted;
|
||
private event EventHandler<DragUpdatedEventArgs>? _dragUpdated;
|
||
private event EventHandler<DropTargetChangedEventArgs>? _dropTargetChanged;
|
||
private event EventHandler<DragCompletedEventArgs>? _dragCompleted;
|
||
private event EventHandler<DragCancelledEventArgs>? _dragCancelled;
|
||
private event EventHandler<DragDropErrorEventArgs>? _errorOccurred;
|
||
|
||
#endregion
|
||
|
||
#region Properties
|
||
|
||
/// <inheritdoc/>
|
||
public bool IsDragActive => Volatile.Read(ref _currentDragOperation) != null;
|
||
|
||
/// <inheritdoc/>
|
||
public Models.DragInfo? CurrentDragInfo => _currentDragOperation?.DragInfo;
|
||
|
||
/// <inheritdoc/>
|
||
public Abstractions.IDropTarget? CurrentDropTarget => _currentDragOperation?.CurrentDropTarget;
|
||
|
||
/// <inheritdoc/>
|
||
public double DragStartThreshold { get; set; } = DragDropConstants.DefaultDragThreshold;
|
||
|
||
/// <inheritdoc/>
|
||
public bool EnableAsyncOperations { get; set; } = true;
|
||
|
||
/// <inheritdoc/>
|
||
public int AsyncOperationTimeout { get; set; } = DragDropConstants.DefaultAsyncTimeout;
|
||
|
||
/// <inheritdoc/>
|
||
public event EventHandler<DragStartedEventArgs> DragStarted
|
||
{
|
||
add => _dragStarted += value;
|
||
remove => _dragStarted -= value;
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
public event EventHandler<DragUpdatedEventArgs> DragUpdated
|
||
{
|
||
add => _dragUpdated += value;
|
||
remove => _dragUpdated -= value;
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
public event EventHandler<DropTargetChangedEventArgs> DropTargetChanged
|
||
{
|
||
add => _dropTargetChanged += value;
|
||
remove => _dropTargetChanged -= value;
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
public event EventHandler<DragCompletedEventArgs> DragCompleted
|
||
{
|
||
add => _dragCompleted += value;
|
||
remove => _dragCompleted -= value;
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
public event EventHandler<DragCancelledEventArgs> DragCancelled
|
||
{
|
||
add => _dragCancelled += value;
|
||
remove => _dragCancelled -= value;
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
public event EventHandler<DragDropErrorEventArgs> ErrorOccurred
|
||
{
|
||
add => _errorOccurred += value;
|
||
remove => _errorOccurred -= value;
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Constructor
|
||
|
||
/// <summary>
|
||
/// Инициализирует новый экземпляр класса <see cref="DragDropService"/>.
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// Создает сервис с настройками по умолчанию:
|
||
/// <list type="bullet">
|
||
/// <item>Порог начала перетаскивания: <see cref="Constants.DragDropConstants.DefaultDragThreshold"/> пикселей</item>
|
||
/// <item>Таймаут асинхронных операций: <see cref="Constants.DragDropConstants.DefaultAsyncTimeout"/> миллисекунд</item>
|
||
/// <item>Включены асинхронные операции: true</item>
|
||
/// </list>
|
||
/// </remarks>
|
||
public DragDropService()
|
||
{
|
||
// Инициализация таймера очистки (каждые 5 минут)
|
||
_cleanupTimer = new Timer(CleanupExpiredTargets, null,
|
||
TimeSpan.FromMinutes(Constants.DragDropConstants.TargetLifetimeMinutes / 2),
|
||
TimeSpan.FromMinutes(Constants.DragDropConstants.TargetLifetimeMinutes / 2));
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Registration Methods
|
||
|
||
/// <inheritdoc/>
|
||
public string RegisterDropTarget(Abstractions.IDropTarget target, Geometry.Rect bounds, int priority = 0, string? group = null)
|
||
{
|
||
ThrowIfDisposed();
|
||
if (target == null) throw new ArgumentNullException(nameof(target));
|
||
|
||
var id = Guid.NewGuid().ToString("N");
|
||
var info = new DropTargetInfo
|
||
{
|
||
Target = target,
|
||
Bounds = bounds,
|
||
Priority = priority,
|
||
Group = group,
|
||
Id = id
|
||
};
|
||
|
||
_dropTargetsLock.EnterWriteLock();
|
||
try
|
||
{
|
||
_dropTargets[id] = info;
|
||
return id;
|
||
}
|
||
finally
|
||
{
|
||
_dropTargetsLock.ExitWriteLock();
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
public bool UpdateDropTargetBounds(string id, Geometry.Rect bounds)
|
||
{
|
||
ThrowIfDisposed();
|
||
|
||
_dropTargetsLock.EnterUpgradeableReadLock();
|
||
try
|
||
{
|
||
if (!_dropTargets.TryGetValue(id, out var info))
|
||
return false;
|
||
|
||
_dropTargetsLock.EnterWriteLock();
|
||
try
|
||
{
|
||
info.Bounds = bounds;
|
||
info.LastAccessTime = DateTime.UtcNow;
|
||
return true;
|
||
}
|
||
finally
|
||
{
|
||
_dropTargetsLock.ExitWriteLock();
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
_dropTargetsLock.ExitUpgradeableReadLock();
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
public bool UnregisterDropTarget(string id)
|
||
{
|
||
ThrowIfDisposed();
|
||
|
||
_dropTargetsLock.EnterWriteLock();
|
||
try
|
||
{
|
||
if (_dropTargets.Remove(id, out var info))
|
||
{
|
||
info.Dispose();
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
finally
|
||
{
|
||
_dropTargetsLock.ExitWriteLock();
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
public void UnregisterDropTargetsInGroup(string group)
|
||
{
|
||
ThrowIfDisposed();
|
||
if (string.IsNullOrEmpty(group)) return;
|
||
|
||
_dropTargetsLock.EnterWriteLock();
|
||
try
|
||
{
|
||
var idsToRemove = new List<string>();
|
||
|
||
foreach (var kvp in _dropTargets)
|
||
{
|
||
if (kvp.Value.Group == group)
|
||
{
|
||
idsToRemove.Add(kvp.Key);
|
||
}
|
||
}
|
||
|
||
foreach (var id in idsToRemove)
|
||
{
|
||
if (_dropTargets.Remove(id, out var info))
|
||
{
|
||
info.Dispose();
|
||
}
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
_dropTargetsLock.ExitWriteLock();
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Async Operations
|
||
|
||
/// <inheritdoc/>
|
||
public async Task<bool> StartDragAsync(IDragSource source, Point startPosition)
|
||
{
|
||
ThrowIfDisposed();
|
||
if (source == null) throw new ArgumentNullException(nameof(source));
|
||
|
||
lock (_dragOperationLock)
|
||
{
|
||
if (_currentDragOperation != null)
|
||
return false;
|
||
}
|
||
|
||
try
|
||
{
|
||
Interlocked.Increment(ref _totalDragOperations);
|
||
|
||
DragInfo? dragInfo;
|
||
|
||
// Пытаемся начать перетаскивание
|
||
if (EnableAsyncOperations)
|
||
{
|
||
dragInfo = await ExecuteWithTimeoutAsync(
|
||
source.TryStartDragAsync(startPosition),
|
||
"TryStartDragAsync",
|
||
source);
|
||
}
|
||
else
|
||
{
|
||
dragInfo = await source.TryStartDragAsync(startPosition);
|
||
}
|
||
|
||
if (dragInfo == null)
|
||
return false;
|
||
|
||
var updatedDragInfo = dragInfo.CloneWithPosition(startPosition);
|
||
|
||
lock (_dragOperationLock)
|
||
{
|
||
_currentDragOperation = new DragOperationContext
|
||
{
|
||
Source = source,
|
||
DragInfo = updatedDragInfo,
|
||
CancellationTokenSource = new CancellationTokenSource(),
|
||
LastPosition = startPosition
|
||
};
|
||
}
|
||
|
||
// Вызов события
|
||
_dragStarted?.Invoke(this, new DragStartedEventArgs(updatedDragInfo, startPosition));
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Interlocked.Increment(ref _errorCount);
|
||
HandleError(ex, "StartDragAsync", source);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
public async Task UpdateDragAsync(Point position)
|
||
{
|
||
ThrowIfDisposed();
|
||
|
||
DragOperationContext? context;
|
||
lock (_dragOperationLock)
|
||
{
|
||
context = _currentDragOperation;
|
||
}
|
||
|
||
if (context?.DragInfo == null || context.Source == null)
|
||
return;
|
||
|
||
try
|
||
{
|
||
// Проверка порога начала
|
||
if (!context.ThresholdExceeded && DragStartThreshold > 0)
|
||
{
|
||
var distance = CalculateDistance(context.DragInfo.StartPosition, position);
|
||
if (distance < DragStartThreshold)
|
||
return;
|
||
|
||
context.ThresholdExceeded = true;
|
||
}
|
||
|
||
var updatedDragInfo = context.DragInfo.CloneWithPosition(position);
|
||
context.DragInfo.Dispose();
|
||
context.DragInfo = updatedDragInfo;
|
||
context.LastPosition = position;
|
||
|
||
// Поиск новой цели сброса
|
||
var newDropTarget = await FindDropTargetAsync(position, updatedDragInfo);
|
||
|
||
// Обработка смены цели
|
||
if (context.CurrentDropTarget != newDropTarget?.Target)
|
||
{
|
||
if (context.CurrentDropTarget != null)
|
||
{
|
||
await ExecuteTargetOperationAsync(
|
||
context.CurrentDropTarget,
|
||
t => t.OnDragLeaveAsync(),
|
||
"OnDragLeave");
|
||
}
|
||
|
||
context.CurrentDropTarget = newDropTarget?.Target;
|
||
|
||
if (newDropTarget != null)
|
||
{
|
||
newDropTarget.UsageCount++;
|
||
_dropTargetChanged?.Invoke(this, new DropTargetChangedEventArgs(
|
||
updatedDragInfo, position, newDropTarget.Target, newDropTarget.Bounds));
|
||
}
|
||
}
|
||
|
||
// Уведомление текущей цели
|
||
if (context.CurrentDropTarget != null)
|
||
{
|
||
var dropInfo = new DropInfo(
|
||
updatedDragInfo.Data,
|
||
position,
|
||
updatedDragInfo.AllowedEffects,
|
||
context.CurrentDropTarget);
|
||
|
||
await ExecuteTargetOperationAsync(
|
||
context.CurrentDropTarget,
|
||
t => t.OnDragOverAsync(dropInfo),
|
||
"OnDragOver");
|
||
}
|
||
|
||
_dragUpdated?.Invoke(this, new DragUpdatedEventArgs(updatedDragInfo, position));
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Interlocked.Increment(ref _errorCount);
|
||
HandleError(ex, "UpdateDragAsync", context);
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
public async Task<DragDropEffects> EndDragAsync(Point position)
|
||
{
|
||
ThrowIfDisposed();
|
||
|
||
DragOperationContext? context;
|
||
lock (_dragOperationLock)
|
||
{
|
||
context = _currentDragOperation;
|
||
_currentDragOperation = null;
|
||
}
|
||
|
||
if (context == null || context.DragInfo == null || context.Source == null)
|
||
{
|
||
Reset();
|
||
return DragDropEffects.None;
|
||
}
|
||
|
||
try
|
||
{
|
||
var effects = DragDropEffects.None;
|
||
var operationTime = DateTime.UtcNow - context.StartTime;
|
||
Interlocked.Add(ref _totalOperationTicks, operationTime.Ticks);
|
||
|
||
// Выполнение сброса
|
||
if (context.CurrentDropTarget != null)
|
||
{
|
||
var dropInfo = new DropInfo(
|
||
context.DragInfo.Data,
|
||
position,
|
||
context.DragInfo.AllowedEffects,
|
||
context.CurrentDropTarget);
|
||
|
||
await ExecuteTargetOperationAsync(
|
||
context.CurrentDropTarget,
|
||
t => t.OnDropAsync(dropInfo),
|
||
"OnDrop");
|
||
|
||
if (dropInfo.Handled)
|
||
{
|
||
effects = dropInfo.SuggestedEffects;
|
||
Interlocked.Increment(ref _successfulDrops);
|
||
}
|
||
}
|
||
|
||
// Уведомление источника
|
||
await ExecuteSourceOperationAsync(
|
||
context.Source,
|
||
s => s.OnDragCompletedAsync(context.DragInfo, effects),
|
||
"OnDragCompleted");
|
||
|
||
// Событие завершения
|
||
_dragCompleted?.Invoke(this, new DragCompletedEventArgs(
|
||
context.DragInfo, position, effects));
|
||
|
||
return effects;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Interlocked.Increment(ref _errorCount);
|
||
HandleError(ex, "EndDragAsync", context);
|
||
return DragDropEffects.None;
|
||
}
|
||
finally
|
||
{
|
||
context.Dispose();
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
public async Task CancelDragAsync()
|
||
{
|
||
ThrowIfDisposed();
|
||
|
||
DragOperationContext? context;
|
||
lock (_dragOperationLock)
|
||
{
|
||
context = _currentDragOperation;
|
||
_currentDragOperation = null;
|
||
}
|
||
|
||
if (context == null || context.DragInfo == null || context.Source == null)
|
||
{
|
||
Reset();
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
context.CancellationTokenSource?.Cancel();
|
||
Interlocked.Increment(ref _cancelledOperations);
|
||
|
||
await ExecuteSourceOperationAsync(
|
||
context.Source,
|
||
s => s.OnDragCancelledAsync(context.DragInfo),
|
||
"OnDragCancelled");
|
||
|
||
_dragCancelled?.Invoke(this, new DragCancelledEventArgs(context.DragInfo, context.LastPosition));
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Interlocked.Increment(ref _errorCount);
|
||
HandleError(ex, "CancelDragAsync", context);
|
||
}
|
||
finally
|
||
{
|
||
context.Dispose();
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Utility Methods
|
||
|
||
/// <inheritdoc/>
|
||
public void ClearAllDropTargets()
|
||
{
|
||
ThrowIfDisposed();
|
||
|
||
_dropTargetsLock.EnterWriteLock();
|
||
try
|
||
{
|
||
foreach (var info in _dropTargets.Values)
|
||
{
|
||
info.Dispose();
|
||
}
|
||
_dropTargets.Clear();
|
||
}
|
||
finally
|
||
{
|
||
_dropTargetsLock.ExitWriteLock();
|
||
}
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
public DragDropStats GetStats()
|
||
{
|
||
return new DragDropStats
|
||
{
|
||
TotalDragOperations = _totalDragOperations,
|
||
SuccessfulDrops = _successfulDrops,
|
||
CancelledOperations = _cancelledOperations,
|
||
ErrorCount = _errorCount,
|
||
RegisteredTargets = _dropTargets.Count,
|
||
AverageOperationTime = _totalDragOperations > 0
|
||
? TimeSpan.FromTicks(_totalOperationTicks / _totalDragOperations)
|
||
: TimeSpan.Zero
|
||
};
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Private Helper Methods
|
||
|
||
private async Task<DropTargetInfo?> FindDropTargetAsync(Geometry.Point position, Models.DragInfo dragInfo)
|
||
{
|
||
DropTargetInfo? bestTarget = null;
|
||
|
||
_dropTargetsLock.EnterReadLock();
|
||
try
|
||
{
|
||
// Фильтруем цели по границам и сортируем по приоритету
|
||
var candidates = _dropTargets.Values
|
||
.Where(info => info.Bounds.Contains(position))
|
||
.OrderByDescending(info => info.Priority)
|
||
.ToList();
|
||
|
||
foreach (var info in candidates)
|
||
{
|
||
var dropInfo = new Models.DropInfo(
|
||
dragInfo.Data,
|
||
position,
|
||
dragInfo.AllowedEffects,
|
||
info.Target);
|
||
|
||
bool canAccept = await ExecuteWithTimeoutAsync(
|
||
info.Target.CanAcceptDropAsync(dropInfo),
|
||
"CanAcceptDropAsync",
|
||
info.Target);
|
||
|
||
if (canAccept)
|
||
{
|
||
info.LastAccessTime = DateTime.UtcNow;
|
||
bestTarget = info;
|
||
break; // Берем первую подходящую с наивысшим приоритетом
|
||
}
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
_dropTargetsLock.ExitReadLock();
|
||
}
|
||
|
||
return bestTarget;
|
||
}
|
||
|
||
private async Task ExecuteTargetOperationAsync(
|
||
IDropTarget target,
|
||
Func<IDropTarget, Task> operation,
|
||
string operationName)
|
||
{
|
||
try
|
||
{
|
||
if (EnableAsyncOperations)
|
||
{
|
||
await ExecuteWithTimeoutAsync(
|
||
operation(target),
|
||
$"{operationName}Async",
|
||
target);
|
||
}
|
||
else
|
||
{
|
||
await operation(target);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Interlocked.Increment(ref _errorCount);
|
||
HandleError(ex, operationName, target);
|
||
}
|
||
}
|
||
|
||
private async Task ExecuteSourceOperationAsync(
|
||
IDragSource source,
|
||
Func<IDragSource, Task> operation,
|
||
string operationName)
|
||
{
|
||
try
|
||
{
|
||
if (EnableAsyncOperations)
|
||
{
|
||
await ExecuteWithTimeoutAsync(
|
||
operation(source),
|
||
$"{operationName}Async",
|
||
source);
|
||
}
|
||
else
|
||
{
|
||
await operation(source);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Interlocked.Increment(ref _errorCount);
|
||
HandleError(ex, operationName, source);
|
||
}
|
||
}
|
||
|
||
private async Task<T> ExecuteWithTimeoutAsync<T>(Task<T> task, string operationName, object? context = null)
|
||
{
|
||
if (AsyncOperationTimeout <= 0)
|
||
return await task;
|
||
|
||
var timeoutTask = Task.Delay(AsyncOperationTimeout);
|
||
var completedTask = await Task.WhenAny(task, timeoutTask);
|
||
|
||
if (completedTask == timeoutTask)
|
||
{
|
||
throw new TimeoutException($"{operationName} timed out after {AsyncOperationTimeout}ms");
|
||
}
|
||
|
||
return await task;
|
||
}
|
||
|
||
private async Task ExecuteWithTimeoutAsync(Task task, string operationName, object? context = null)
|
||
{
|
||
if (AsyncOperationTimeout <= 0)
|
||
{
|
||
await task;
|
||
return;
|
||
}
|
||
|
||
var timeoutTask = Task.Delay(AsyncOperationTimeout);
|
||
var completedTask = await Task.WhenAny(task, timeoutTask);
|
||
|
||
if (completedTask == timeoutTask)
|
||
{
|
||
throw new TimeoutException($"{operationName} timed out after {AsyncOperationTimeout}ms");
|
||
}
|
||
|
||
await task;
|
||
}
|
||
|
||
private double CalculateDistance(Geometry.Point p1, Geometry.Point p2)
|
||
{
|
||
var dx = p2.X - p1.X;
|
||
var dy = p2.Y - p1.Y;
|
||
return Math.Sqrt(dx * dx + dy * dy);
|
||
}
|
||
|
||
private void Reset()
|
||
{
|
||
lock (_dragOperationLock)
|
||
{
|
||
_currentDragOperation?.Dispose();
|
||
_currentDragOperation = null;
|
||
}
|
||
}
|
||
|
||
private void CleanupExpiredTargets(object? state)
|
||
{
|
||
var expirationTime = DateTime.UtcNow.AddMinutes(-Constants.DragDropConstants.TargetLifetimeMinutes);
|
||
|
||
_dropTargetsLock.EnterWriteLock();
|
||
try
|
||
{
|
||
var idsToRemove = new List<string>();
|
||
var currentTarget = _currentDragOperation?.CurrentDropTarget;
|
||
|
||
foreach (var kvp in _dropTargets)
|
||
{
|
||
if (kvp.Value.LastAccessTime < expirationTime && !ReferenceEquals(kvp.Value.Target, currentTarget))
|
||
{
|
||
idsToRemove.Add(kvp.Key);
|
||
}
|
||
}
|
||
|
||
foreach (var id in idsToRemove)
|
||
{
|
||
if (_dropTargets.Remove(id, out var info))
|
||
{
|
||
info.Dispose();
|
||
}
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
_dropTargetsLock.ExitWriteLock();
|
||
}
|
||
}
|
||
|
||
private void HandleError(Exception exception, string operation, object? context = null)
|
||
{
|
||
_errorOccurred?.Invoke(this, new DragDropErrorEventArgs(exception, operation, context));
|
||
}
|
||
|
||
private void ThrowIfDisposed()
|
||
{
|
||
if (_disposed)
|
||
throw new ObjectDisposedException(GetType().Name);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region IDisposable Implementation
|
||
|
||
public void Dispose()
|
||
{
|
||
if (_disposed) return;
|
||
|
||
lock (_dragOperationLock)
|
||
{
|
||
if (_disposed) return;
|
||
|
||
var timer = Interlocked.Exchange(ref _cleanupTimer, null);
|
||
timer?.Dispose();
|
||
|
||
_cleanupTimer?.Dispose();
|
||
_cleanupTimer = null;
|
||
|
||
if (_currentDragOperation != null)
|
||
{
|
||
_currentDragOperation.CancellationTokenSource?.Cancel();
|
||
_currentDragOperation.Dispose();
|
||
_currentDragOperation = null;
|
||
}
|
||
|
||
ClearAllDropTargets();
|
||
|
||
_dropTargetsLock.Dispose();
|
||
|
||
// Очистка событий
|
||
_dragStarted = null;
|
||
_dragUpdated = null;
|
||
_dropTargetChanged = null;
|
||
_dragCompleted = null;
|
||
_dragCancelled = null;
|
||
_errorOccurred = null;
|
||
|
||
_disposed = true;
|
||
}
|
||
|
||
GC.SuppressFinalize(this);
|
||
}
|
||
|
||
#endregion
|
||
} |