How to reduce parallel inserted time in MongoDB?

I have a VM that host in Azure which Standard D2ds v5 (2 CPU core, 8 Gb of RAM)
I create the console application that read data from CSV file and insert into Collection.
The CSV file is around 100k rows with 30 columns (14MB).
The code that use to insert data shown below

public static void ConnectAndInsert(string path, string myQueueItem)
    {
        string connectionString = "mongodb://localhost:27017/";
        MongoClient client = new MongoClient(connectionString);

        IMongoDatabase database = client.GetDatabase($"csa");
        // connect to collection
        if (!CollectionExists(database, myQueueItem))
        {
            var options = new CreateCollectionOptions()
            {

            };
            database.CreateCollection(myQueueItem, options);
        }
        IMongoCollection<BsonDocument> collection = database.GetCollection<BsonDocument>(myQueueItem);

        // stopwatch to measure time
        Stopwatch stopwatch = new Stopwatch();


        Console.WriteLine("Inserting data...");
        stopwatch.Start();

        using (var reader = new StreamReader(path))
        using (var csvReader = new CsvReader(reader, new CsvConfiguration(CultureInfo.InvariantCulture) { Delimiter = ";" }))
        {
            csvReader.Read();
            csvReader.ReadHeader();

            int offset = 0;
            var data = new List<BsonDocument>();
            var option = new InsertManyOptions() { IsOrdered = false };
            while (csvReader.Read())
            {
                var document = new BsonDocument();
                foreach (var header in csvReader.HeaderRecord)
                {
                    document.Add(header, csvReader.GetField(header));
                }

                if (offset > 20000)
                {
                    Stopwatch insertStopwatch = new Stopwatch();
                    insertStopwatch.Start();
                    collection.InsertMany(data, option);
                    insertStopwatch.Stop();
                    Console.WriteLine("inserted time : " + insertStopwatch.ElapsedMilliseconds + " ms");
                    offset = 0;
                    data = new List<BsonDocument>();
                }
                else
                {
                    data.Add(document);
                    offset++;
                }
            }

            if (offset > 0)
            {
                collection.InsertMany(data, option);
            }
        }

        stopwatch.Stop();
        Console.WriteLine(stopwatch.ElapsedMilliseconds + " ms");
    }

The method will be triggered by queue message.
I drop 100 messages at a time and run the application(1) to import data
It takes 3000 ms. to insert data to MongoDB one by one
Then I run the application(2) to import data
After run 2 applications to import data. It takes 5000 ms. to insert data to MongoDB each time.

the collection is around 1000 collections with same data
the information about mongoDB is

MongoDB 6.0.6 community. Deploy in single machine without shard
{
 name: 'wiredTiger',
 supportsCommittedReads: true,
 oldestRequiredTimestampForCrashRecovery: Timestamp({ t: 0, i: 0 }),
 supportsPendingDrops: true,
 dropPendingIdents: Long("0"),
 supportsSnapshotReadConcern: true,
 readOnly: false,
 persistent: true,
 backupCursorOpen: false
 }

My question is How to reduce insert time if the import run parallel? It looks like the Application(1) and Application(2) wait each other to finish before insert, only one insert command can run at a time, and time double in my case.

From comment I have edited the code to measure the time only insert code I found that if I run 1 process it use 60ms to insert but if I run 2 processes it use 100ms to insert

MongoDB only has 1 writer per collection, this restraint is what gives you atomicity in your actions. But it also limits how much you can "parallel" your inserts.

No matter what you do in your application this constraint remains true, a single writer cursor needs to write the data into the collection. This is also why parallelising your code does not necessarily help it go faster.

>My question is How to reduce insert time if the import run parallel? It looks like the Application(1) and Application(2) wait each other to finish before insert

Now that we understand this constraints let's understand what can we do to reduce this processing time.

1. Even with the single writer constraint Parallelising the processes might still be faster, if there are a lot of in memory actions happening for example. Yes each single insert will get slower but overall the 2 processes might finish faster. Optimising this is purely trial and error to find the sweet spot of the # of concurrent processes to run.
2. Dropping redundant indexes - Indexes are created on insertion, so they slow down the operation quite a bit, especially when scale increases and/or if the indexes are very complex (multikey / geo / etc). If you have any redundant indexes you don't really use I recommend dropping them as this will speed up the inserts.
3. I believe you mentioned you're running this DB as a standalone, but if this DB is replicated then write concern may also be an issue, especially with high volume inserts replication lag can occur. depending on your requirements you can turn off the "majority" requirement, however this should not be done recklessly as it can come with a data integrity cost.
4. Sharing the collection - if you shard the collection (either application level shard - which is multiple smaller collections, or actual mongo sharding) inserts will also be much more efficient, this is mainly relevant for high scale for similar reasons as #2 as the index sizes are going to be much smaller.
5. Finally hardware improvements, many people forget about this aspect at this day and age but hardware limitations are real, adding some disk IOPS could also help speed things along. I would say this should be used as a "last resort" kind of action as generally speaking disk IOPS are quite expensive.