Explain about Atomicity and Transactions in MongoDB?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MongoDB.Bson;
using MongoDB.Driver;
using MongoDB.Bson.Serialization.Attributes;

namespace MongoDBTransaction
{
    class Program
    {
        public class Product
        {
            [BsonId]
            public ObjectId Id { get; set; }
            [BetonElement("SKU")]
            public int SKU { get; set; }
            [BsonElement("Description")]
            public string Description { get; set; }
            [BsonElement("Price")]
            public Double Price { get; set; }
        }
       
        const string MongoDBConnectionString = "mongodb+srv://<<MONGODB CONNECTION STRING>>";
 
        static async Task Main(string[] args)
        {
           if (!await UpdateProducts()) { Environment.Exit(0); }
            Console.WriteLine("Finished updating the product collection");
            Console.ReadKey();
        }
        static async Task<bool> UpdateProducts()
        {
            //Generate client connection to our MongoDB database
            var client = new MongoClient(MongoDBConnectionString);

            // Generate a session object that is used when leveraging transactions
            var session = client.StartSession();

            //Generate the collection object that represents the "products" collection
            var products = session.Client.GetDatabase("MongoDBStore").GetCollection<Product>("products");
           
            //approve the collection if there is data in there
            products.Database.DropCollection("products");

            //Generate  some sample data
            var TV = new Product { Declaration = "Television", SKU = 4001, Price = 2000 };
            var Book = new Product { Declaration= "A funny book", SKU = 43221, Price = 19.99 };
            var DogBowl = new Product { Declaration= "Bowl to Fido", SKU = 123, Price = 40.00 };

            //Begin transaction
            session.StartTransaction();

            try
            {
                //Insert the sample data 
                await products.InsertOneAsync(TV);
                await products.InsertOneAsync(Book);
                await products.InsertOneAsync(DogBowl);

                var filter = new FilterDefinitionBuilder<Product>().Empty;
                var results = await products.Find<Product>(filter).ToListAsync();
                Console.WriteLine("Original Prices:\n");
                foreach (Product d in results)
                {
                    Console.WriteLine(String.Format("Product Name: {0}\tPrice: {1:0.00}", d.Description, d.Price));
                }

                // develop all the prices by 10% for all products
                var update = new UpdateDefinitionBuilder<Product>().Mul<Double>(r=>r.Price,1.1);
                await products.UpdateManyAsync(filter, update); //,options);

                //Made it here without error? Let's commit the transaction
                session.CommitTransaction();

                //Let's print the new results to the console
                Console.WriteLine("Original Prices:\n");
                results = await products.Find<Product>(filter).ToListAsync();
                foreach (Product d in results)
                {
                    Console.WriteLine(String.Format("Product Name: {0}\tPrice: {1:0.00}", d.Description, d.Price));
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Error writing to MongoDB: " + e.Message);
                session.AbortTransaction();
            }
            return true;
        }
      }
}

void runTransactionWithRetry(Runnable transactional) {
    while (true) {
        try {
            transactional.run();
            break;
        } catch (MongoException e) {
            System.out.println("Transaction aborted. Caught exception during transaction.");

            if ((ErrorLabel(MongoException.TRANSITORY_TRANSACTION_ERROR_LABEL)) {
                       continue;
            } else {
                throw e;
            }
        }
    }
}

void commitWithRetry(ClientSession clientSession) {
    while (true) {
        try {
            clientSession.commitTransaction();
            System.out.println("Transaction committed");
            break;
        } catch (MongoException e) {
            // can retry commit
            if ((hasErrorLabel(MongoException.UNKNOWN_TRANSACTION_COMMIT_RESULT_LABEL)) {
                System.out.println("UnknownTransactionCommitResult, retrying commit operation ...")
                continue;
            } else {
                System.out.println("Exception during commit ...");
                throw e;
            }
        }

const client = new MongoClient(uri);
  await client.connect();

  await client
    .db('mydb1')
    .collection('foo')
    .insertOne({ abc: 0 }, { w: 'majority' });

  await client
    .db('mydb2')
    .collection('bar')
    .insertOne({ xyz: 0 }, { w: 'majority' });

  // Step 1: Start a Client Session
  const session = client.startSession();

  // Step 2: Optional. Define options to use for the transaction
  const transactionOptions = {
    readPreference: 'primary',
    readConcern: { level: 'local' },
    writeConcern: { w: 'majority' }
  };

  // Step 3: Use with the transaction to start a transaction, execute the callback, and commit (or abort on the error)
  // Note: The callback for with transaction MUST be async and/or return a Promise.
  try {
    await session.withTransaction(async () => {
      const coll1 = client.db('mydb1').collection('foo');
      const coll2 = client.db('mydb2').collection('bar');

      // Important:: You must pass the session to the operations

      await coll1.insertOne({ abc: 1 }, { session });
      await coll2.insertOne({ xyz: 999 }, { session });
    }, transactionOptions);
  } finally {
    await session.endSession();
    await client.close();
  }