Не выполнять метод и не создавать объект, пока предыдущий вызов не закончит работу

Order order = new Order();
CreateOrder(client);

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;
 
namespace ConsoleApp1
{
    class Program
    {
        #region Entry point
 
        static Program _program;
 
        static void Main(string[] args)
        {
            _program = new Program();
            _program.Run(args);
        }
 
        #endregion
 
        private Random _random1;
        private Random _random2;
 
        private ConcurrentQueue<string> _orderQueue;
        private AutoResetEvent _orderAddedEvent;
        private CancellationTokenSource _cancellationTokenSource;
 
        private void Run(string[] args)
        {
            _random1 = new Random();
            _random2 = new Random();
 
            _orderQueue = new ConcurrentQueue<string>();
            _orderAddedEvent = new AutoResetEvent(false);
            _cancellationTokenSource = new CancellationTokenSource();
 
            FillQueueAsync().LogErrors();    // Ожидать завершения не нужно. Идём дальше.
            ProcessQueueAsync().LogErrors(); // Ожидать завершения не нужно. Идём дальше.
 
            Console.ReadKey();
 
            _cancellationTokenSource.Cancel();
 
            _cancellationTokenSource.Dispose();
            _orderAddedEvent.Set();
            _orderAddedEvent.Dispose();
        }
 
        private async Task ProcessQueueAsync()
        {
            await Task.Factory.StartNew(async () =>
            {
                while (!_cancellationTokenSource.IsCancellationRequested)
                {
                    string order = null;
 
                    while (!_cancellationTokenSource.IsCancellationRequested && _orderQueue.Count > 0 && !_orderQueue.TryDequeue(out order)) { }
 
                    if (order != null)
                    {
                        await CreateOrderAsync(order);
                    }
 
                    _orderAddedEvent.WaitOne();
                }
            });
        }
 
        private async Task CreateOrderAsync(string order)
        {
            await Task.Delay(_random1.Next(125, 750), _cancellationTokenSource.Token);
            Console.WriteLine($"Заказ \"{order}\" обработан.");
        }
 
        private async Task FillQueueAsync()
        {
            await Task.Factory.StartNew(async () =>
            {
                for (int i = 0; i < 20; i++)
                {
                    await Task.Delay(_random2.Next(250, 850), _cancellationTokenSource.Token);
                    _orderQueue.Enqueue($"#{(i + 1).ToString()}");
 
                    _orderAddedEvent.Set();
                }
            });
        }
    }
 
    public static class TaskExtensions
    {
        public static async void LogErrors(this Task task)
        {
            try
            {
                await task;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Exception {ex.ToString()}");
            }
        }
    }
}

CRMWorker cRMWorker = new CRMWorker();
cRMWorker.InsertOperation(order, Client, addNewContact); //В CRM

public async void InsertOperation(Order order, Client client, bool result)
{
        //Авторизация администратора
        await Challenge();
 
        //Дальше тут куча проверок на наличие заказчика
        //И потом уже оформляется заказ
            var CRMorder = new CRMOrder()
            {
                subject = $"Заказ из чатбота | {client.Name} {client.LastName}",
                account_id = $"{account_id}", 
                contact_id = $"{contact_id}",
                sostatus = "Создано",
                assigned_user_id = "0x0",
                ship_street = $"{ order.Address }",
                invoicestatus = "Автосоздан",
                productid = "0x0",
                LineItems = new List<Item>
                          {
                             new Item
                             {
                                productid = "0x0",
                                listprice = "150", //Цена за единицу
                                quantity = $"{ order.CountBottle }"
                             }
 
                          }
            };
 
            string jsonData1 = JsonConvert.SerializeObject(CRMorder);
 
            var responseString = await "https://site.net/webservice.php"
            .PostUrlEncodedAsync(new { operation = "create", sessionName = sessionID, elementType = "Table", element = jsonData1})
            .ReceiveString();
 
            //Выход администратора из системы
            await LogOut();

        private async Task<bool> CreateOrderAsync(string order)
        {
            await Task.Delay(_random1.Next(125, 750), _cancellationTokenSource.Token);
            return true;
        }

        public static async void LogErrors()
        {
            try
            {
                bool result = await CreateOrderAsync("");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Exception {ex.ToString()}");
            }
        }