在创建任务时，确保传递TaskScheduler参数，以指定任务应该在哪个任务调度器上运行。如果不传递TaskScheduler参数，任务将在当前线程上运行，这可能会导致性能问题。

以下是一个示例代码，演示了如何传递TaskScheduler参数来创建一个任务：

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static void Main(string[] args)
    {
        // 创建一个新的任务调度器
        var taskScheduler = new LimitedConcurrencyLevelTaskScheduler(2);

        // 在创建任务时，传递TaskScheduler参数
        Task.Factory.StartNew(() =>
        {
            Console.WriteLine("Task is running on thread {0}", Thread.CurrentThread.ManagedThreadId);
            // 执行任务的代码
        }, CancellationToken.None, TaskCreationOptions.None, taskScheduler);

        Console.ReadLine();
    }
}

// 自定义的任务调度器，限制并发任务数
class LimitedConcurrencyLevelTaskScheduler : TaskScheduler
{
    private readonly object _lock = new object();
    private readonly int _maxDegreeOfParallelism;
    private int _currentDegreeOfParallelism;
    private readonly ConcurrentQueue _tasks = new ConcurrentQueue();
    private readonly HashSet _processingTasks = new HashSet();

    public LimitedConcurrencyLevelTaskScheduler(int maxDegreeOfParallelism)
    {
        _maxDegreeOfParallelism = maxDegreeOfParallelism;
    }

    protected override IEnumerable GetScheduledTasks()
    {
        return _tasks.ToArray();
    }

    protected override void QueueTask(Task task)
    {
        lock (_lock)
        {
            _tasks.Enqueue(task);
            if (_currentDegreeOfParallelism < _maxDegreeOfParallelism)
            {
                _currentDegreeOfParallelism++;
                NotifyThreadPoolOfPendingWork();
            }
        }
    }

    private void NotifyThreadPoolOfPendingWork()
    {
        ThreadPool.QueueUserWorkItem(_ =>
        {
            while (true)
            {
                Task task;
                lock (_lock)
                {
                    if (_tasks.Count == 0)
                    {
                        _currentDegreeOfParallelism--;
                        return;
                    }

                    if (_currentDegreeOfParallelism >= _maxDegreeOfParallelism || !_tasks.TryDequeue(out task))
                    {
                        continue;
                    }

                    _processingTasks.Add(task);
                }

                TryExecuteTask(task);
                lock (_lock)
                {
                    _processingTasks.Remove(task);
                }
            }
        });
    }

    protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
    {
        if (!taskWasPreviouslyQueued)
        {
            return TryExecuteTask(task);
        }

        if (_processingTasks.Contains(task))
        {
            return false;
        }

        return TryExecuteTask(task);
    }
}

在上面的示例中，我们创建了一个自定义的LimitedConcurrencyLevelTaskScheduler，它限制了并发任务的数量。在Main方法中，我们创建了一个任务调度器taskScheduler，并在创建任务时将其传递给了Task.Factory.StartNew方法。这样，任务将在指定的任务调度器上运行，而不是在当前线程上运行。