Потоки, эвенты, делегаты. Преобразовать код так, чтобы функция вызывалась в отдельном потоке

public MyModel[] ReturnList( int id )
{
        MyModel [] ReturnModel = new MyModel[0];
        
        try
        {
               ReturnModel = GetList(id);
        }
        catch
        {
               ReturnModel = null;
        }
  
         return ReturnModel;
}

public int _id = new int();
 
public void ReturnList( int id )
{
    _id = id;
     Thread TR = new Thread(Tr_ReturnList);
    TR.Start();
}
 
public delegate void MyDelegate ( MyModel []data );
public event MyDelegate MyEvent;
 
public void Tr_ReturnList()
{
     MyModel [] ReturnModel = new MyModel[0];
        
        try
        {
               ReturnModel = GetList(id);
        }
        catch
        {
               ReturnModel = null;
        }
}

        static public Int32[] ReturnList(Int32 id)
        {
            return new Int32[id];
        }
 
 
        static void Main(string[] args)
        {
 
            var list = new Int32[0];
            var thread = new Thread(() =>list = ReturnList(10));//создаем поток с анонимным делегатом
            thread.Start();//вызываем поток
            thread.Join();// ждем завершения
            Console.WriteLine(list.Length.ToString());//проверяем что изменился размер
            }

using System;
using System.Threading;
 
namespace ConsoleApplication1
{
    public delegate T GetDataHandler<T>(int id);
 
    class Program
    {
        static void Main(string[] args)
        {
            for (int i = 0; i < 4; i++)
            {
                LoadData(i);
            }
 
            Console.ReadKey();
        }
 
        public static void LoadData(int id)
        {
            GetDataHandler<Something[]> handler = Database.GetData;
            handler.BeginInvoke(id,
                 asyncResult =>
                 {
                     Something[] data = handler.EndInvoke(asyncResult);
                     Display(data);
                 }, null);
        }
 
        public static void Display(Something[] data)
        {
            foreach (Something something in data)
            {
                Console.WriteLine(something.Name);
            }
        }
    }
 
    public class Something
    {
        public Something(string name)
        {
            Name = name;
        }
        public string Name { get; set; }
    }
 
    public class Database
    {
        private static readonly Random _random = new Random();
        private static readonly object _randomSync = new object();
 
 
        public static Something[] GetData(int id)
        {
            Thread.Sleep(GetRandomValue());
            switch (id)
            {
                case 0:
                    return new Something[]
                               {
                                   new Something("1"), 
                                   new Something("2"), 
                                   new Something("3")
                               };
                case 1:
                    return new Something[]
                               {
                                   new Something("4"), 
                                   new Something("5"), 
                                   new Something("6")
                               };
                case 2:
                    return new Something[]
                               {
                                   new Something("7"), 
                                   new Something("8"), 
                                   new Something("9")
                               };
                case 3:
                    return new Something[]
                               {
                                   new Something("10"), 
                                   new Something("11"), 
                                   new Something("12")
                               };
                default:
                    return null;
            }
        }
 
        private static int GetRandomValue()
        {
            lock (_randomSync)
                return _random.Next(100, 400);
        }
    }
}

            // Ждем окончания работы всех потоков
            Task.WaitAll(threads);

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;
 
namespace ConsApp_Multithreading_UsingTasks
{
    class Program
    {
        // Блокирующая очередь. Сюда будут добавляться "логины" из ричбокса и отсюда их будут доставать обрабатывающие потоки
        static BlockingCollection<int> queue = new BlockingCollection<int>();
 
        static void Main(string[] args)
        {
            // Создаем шесть потоков, которые будут заниматься логином
            Task[] threads = new Task[6];
            for (int i = 0; i < threads.Length; i++)
            {
                int num = i + 1;
                threads[i] = Task.Factory.StartNew(() => ProcessQueue("Thread " + num));
            }
 
            // Создаем очередь "логинов"
            for (int i = 0; i < 100; i++)
            {
                queue.Add(i);
            }
 
            // Эта строчка заставит все слушающие потоки разблокироваться, когда в очереди не останется элементов.
            // На деле ее надо добавлять при завершении работы приложения - чтобы слушающие потоки не висели бесконечно.
            queue.CompleteAdding();
 
            // Ждем окончания работы всех потоков
            Task.WaitAll(threads);
 
            Console.WriteLine("All threads finished execution");
            Console.ReadLine();
        }
 
        // Добавляет элемент в очередь
        static void Enqueue(int value)
        {
            queue.Add(value);
        }
 
        // Удаляет и возвращает первый элемент в очереди
        static int Dequeue()
        {
            return queue.Take();
        }
 
        // Достает элементы из очереди и обрабатывает их
        static void ProcessQueue(object taskName)
        {
 
            while (true)
            {
                try
                {
                    // Достаем следующий элемент из очереди. Если элементов ноль и свойство очереди IsCompleted = false, поток будет заблокирован пока элементы не появятся.
                    int item = Dequeue();
 
                    // Делаем что нам нужно. В данном случае просто выводим полученный из очереди элемент в консоль. На деле здесь будут обрабатываться логины.
                    Console.WriteLine("{0}: processing {1}.", taskName, item);
 
                    // Допустим, один логин занимает 1 секунду.
                    Thread.Sleep(1000);
                }
                catch (InvalidOperationException)
                {
                    // Обеспечиваем выход из бесконечного цикла при завершении работы приложения
                    Console.WriteLine("{0} has finished working", taskName);
                    return;
                }
            }
        }
    }
}