有没有办法在ASP.NET Web API应用程序中全局限制并行任务的数量？

public class TaskLimiter
{
    private readonly SemaphoreSlim _semaphore;

    public TaskLimiter(int maxConcurrency)
    {
        _semaphore = new SemaphoreSlim(maxConcurrency);
    }

    public async Task<T> ExecuteAsync<T>(Func<Task<T>> taskFunc)
    {
        await _semaphore.WaitAsync();
        try
        {
            return await taskFunc();
        }
        finally
        {
            _semaphore.Release();
        }
    }
}

public static class WebApiApplication
{
    private static TaskLimiter _taskLimiter;

    static WebApiApplication()
    {
        _taskLimiter = new TaskLimiter(maxConcurrency: 10); // 设置最大并发任务数
    }

    public static async Task<T> ExecuteWithLimiter<T>(Func<Task<T>> taskFunc)
    {
        return await _taskLimiter.ExecuteAsync(taskFunc);
    }
}

public class MyController : ApiController
{
    [HttpGet]
    public async Task<IHttpActionResult> GetData()
    {
        var result = await WebApiApplication.ExecuteWithLimiter(async () =>
        {
            // 你的异步任务代码
            return await SomeAsyncOperation();
        });

        return Ok(result);
    }

    private async Task<string> SomeAsyncOperation()
    {
        // 模拟异步操作
        await Task.Delay(1000);
        return "Data";
    }
}

public class TaskScheduler
{
    private readonly ConcurrentQueue<Func<Task>> _taskQueue = new ConcurrentQueue<Func<Task>>();
    private readonly SemaphoreSlim _semaphore;
    private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();

    public TaskScheduler(int maxConcurrency)
    {
        _semaphore = new SemaphoreSlim(maxConcurrency);
    }

    public void EnqueueTask(Func<Task> taskFunc)
    {
        _taskQueue.Enqueue(taskFunc);
        ProcessQueueAsync().ConfigureAwait(false);
    }

    private async Task ProcessQueueAsync()
    {
        await _semaphore.WaitAsync();
        if (_taskQueue.TryDequeue(out var taskFunc))
        {
            try
            {
                await taskFunc();
            }
            finally
            {
                _semaphore.Release();
                ProcessQueueAsync().ConfigureAwait(false);
            }
        }
    }

    public void Stop()
    {
        _cancellationTokenSource.Cancel();
    }
}

public static class WebApiApplication
{
    private static TaskScheduler _taskScheduler;

    static WebApiApplication()
    {
        _taskScheduler = new TaskScheduler(maxConcurrency: 10); // 设置最大并发任务数
    }

    public static void EnqueueTask(Func<Task> taskFunc)
    {
        _taskScheduler.EnqueueTask(taskFunc);
    }
}

public class MyController : ApiController
{
    [HttpGet]
    public void GetData()
    {
        WebApiApplication.EnqueueTask(async () =>
        {
            // 你的异步任务代码
            await SomeAsyncOperation();
        });
    }

    private async Task SomeAsyncOperation()
    {
        // 模拟异步操作
        await Task.Delay(1000);
    }
}

public class TaskLimiter
{
    private readonly AsyncLock _asyncLock = new AsyncLock();

    public async Task<T> ExecuteAsync<T>(Func<Task<T>> taskFunc)
    {
        using (await _asyncLock.LockAsync())
        {
            return await taskFunc();
        }
    }
}