C# Better operation MongoDB database

I wrote an article before C# operation MongoDB Database articles , Operate the database directly , Not very optimized , The code is scattered in the actual project , There is no unified plan , So with this article , If you want to get started, you can also develop the project by looking at the previous articles C# operation Mongodb database

• Because we're going to mongodb Operation of database , But our business level doesn't want to deal directly with the database , So we made an intermediate layer ORM（ Proxy mapping ） Now let's start to realize this ORM Steps are as follows
• Still use the previous Library MongoDB.Driver

Directory structure

Explain separately ：

• The real middle tier is ORM Under folder 3 File , and DB Under folder Person This is a test file ！
• DBEntity.cs This is a MongoDB The base class of all entities in the table ~ Our customized entity classes should be integrated into DBEntity, for example Person class
• Proxy.cs This is a proxy class , Any specific Table Classes have a corresponding Proxy proxy class
• Table.cs This is a watch , To put it bluntly , Our business level only contacts this Table The class can , adopt Table Class to add, delete, and modify ！

DBEntity.cs Complete code

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using System;

namespace Common.ORM
{
    
    [Serializable]
    [BsonIgnoreExtraElements(Inherited = true)]
    public abstract class DBEntity
    {
    
        public DBEntity()
        {
    
            ID = ObjectId.GenerateNewId().ToString();  
        }

        [BsonElement("_id")]
        [BsonRepresentation(BsonType.ObjectId)]  
        public virtual string ID {
     get; set; }
    }
}

Proxy.cs Complete code

using MongoDB.Bson.Serialization;
using MongoDB.Driver;
using System;

namespace Common.ORM
{
    
    public static class Proxy<T>
    {
    
        /// <summary>
        ///  Name of the database table 
        /// </summary>
        private static string tableName;

        /// <summary>
        ///  Database name 
        /// </summary>
        private static string dataBaseName;

        /// <summary>
        ///  Database connection configuration Url
        /// </summary>
        private static string mongoUrl;

        /// <summary>
        ///  Reference to a single table in the database ( namely mongo A single set of )
        /// </summary>
        private static IMongoCollection<T> collection;

        /// <summary>
        ///  Reference to a single table in the database ( namely mongo A single set of )
        /// </summary>
        public static IMongoCollection<T> Collection
        {
    
            get => collection;
        }

        /// <summary>
        ///  Static constructor  ( Be careful ： Access control characters are not allowed )
        /// </summary>
        static Proxy()
        {
    
            Init();
        }

        /// <summary>
        ///  Initialization function of a single table 
        /// </summary>
        private static void Init()
        {
    
            dataBaseName = "TestMongoDB";

            mongoUrl = "mongodb://localhost:27017";

            tableName = typeof(T).Name;

            BsonClassMap.RegisterClassMap<T>(cm => cm.AutoMap());

            collection = new MongoClient(mongoUrl).GetDatabase(dataBaseName).GetCollection<T>(tableName);
        }
    }
}

Table.cs Complete code

using MongoDB.Bson;
using MongoDB.Driver;
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;

namespace Common.ORM
{
    
    public class Table<T> where T : DBEntity
    {
    
        /// <summary>
        ///  The reference of the corresponding set 
        /// </summary>
        private IMongoCollection<T> collection = Proxy<T>.Collection;

        /// <summary>
        ///  Add a record 
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public bool Add(T entity)
        {
    
            try
            {
    
                collection.InsertOne(entity);

                return true;
            }
            catch (Exception ex)
            {
    
                throw ex;
            }
        }

        /// <summary>
        ///  Delete a record 
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="conditions"></param>
        /// <returns></returns>
        public bool Delete(T entity, Expression<Func<T, bool>> conditions = null)
        {
    
            try
            {
    
                string _id = string.Empty;

                if (conditions == null)
                {
    
                    foreach (PropertyInfo item in entity.GetType().GetProperties())
                    {
    
                        if (item.Name == "ID" && item.GetValue(entity) != null)
                        {
    
                            _id = item.GetValue(entity).ToString();

                            DeleteResult result = collection.DeleteOne(new BsonDocument("_id", BsonValue.Create(new ObjectId(_id))));
                            
                            return result.IsAcknowledged;
                        }
                    }
                }

                DeleteResult res = collection.DeleteOne(conditions);

                return res.IsAcknowledged;
            }
            catch (Exception ex)
            {
    
                throw ex;
            }
        }

        /// <summary>
        ///  Update a record 
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="conditions"></param>
        /// <returns></returns>
        public bool Update(T entity, Expression<Func<T, bool>> conditions = null)
        {
    
            try
            {
    
                ObjectId _id;

                var options = new ReplaceOptions() {
     IsUpsert = true };

                if (conditions == null)
                {
    
                    foreach (var item in entity.GetType().GetProperties())
                    {
    
                        if (item.Name == "ID" && item.GetValue(entity) != null)
                        {
    
                            _id = new ObjectId(item.GetValue(entity).ToString());

                            ReplaceOneResult result = collection.ReplaceOne(new BsonDocument("_id", BsonValue.Create(_id)), entity, options);
                            
                            return result.IsAcknowledged;
                        }
                    }
                }

                ReplaceOneResult res = collection.ReplaceOne(conditions, entity, options);

                return res.IsAcknowledged;
            }
            catch (Exception ex)
            {
    
                throw ex;
            }
        }

        /// <summary>
        ///  Find a record 
        /// </summary>
        /// <param name="conditions"></param>
        /// <returns></returns>
        public List<T> Find(Expression<Func<T, bool>> conditions = null)
        {
    
            try
            {
    
                if (conditions == null)
                {
    
                    conditions = t => true;
                }

                return collection.Find(conditions).ToList() ?? new List<T>();
            }
            catch (Exception ex)
            {
    
                throw ex;
            }
        }
    }
}

Person.cs Complete code

using Common.ORM;
using MongoDB.Bson.Serialization.Attributes;
using System;
using System.Collections.Generic;

namespace Common.DB
{
    
    [Serializable]
    public class Person : DBEntity
    {
    
        [BsonConstructor]
        public Person(string name, int age, string guid, GenderEnum gender)
        {
    
            Name = name;

            Age = age;

            Guid = guid;

            Gender = gender;
        }

        public override string ToString()
        {
    
            return "ID:" + ID + " " + "user:" + Name + " " + "age:" + Age + " " + "guid:" + Guid + " " + "Gender:" + Gender.ToString() + " " + " Pet call " + Pet.Name + "," + Pet.Age + " Year old ";
        }

        public string Name {
     get; set; }

        public int Age {
     get; set; }

        public string Guid {
     get; set; }

        public GenderEnum Gender {
     get; set; }

        public List<Person> Students {
     get => students; set => students = value; }

        public Pet Pet {
     get => pet; set => pet = value; }

        private Pet pet;

        private List<Person> students;
    }

    public enum GenderEnum
    {
    
         male ,

         Woman 
    }

    public class Pet
    {
    
        public string Name {
     get => name; set => name = value; }

        public int Age {
     get => age; set => age = value; }

        private string name;

        private int age;
    }
}

test

ORM The above part of the framework is finished , Now let's use it ！

        private static void TestDB()
        {
    
            Person person = new Person(" Zhang San ", 8, Guid.NewGuid().ToString(), GenderEnum. male );
            
            person.Students = new List<Person>() 
            {
     
                new Person(" Zhang Xiaosan 1", 8, Guid.NewGuid().ToString(), GenderEnum. male ),

                new Person(" Zhang Xiaosan 2", 8, Guid.NewGuid().ToString(), GenderEnum. male ),

                new Person(" Zhang Xiaosan 3", 8, Guid.NewGuid().ToString(), GenderEnum. male ),

                new Person(" Zhang Xiaosan 4", 8, Guid.NewGuid().ToString(), GenderEnum. male )
            };

            person.Pet = new Pet() {
     Name = " Wangcai ", Age = 3 };

            personDB.Add(person);
        }