C#操作MongoDB数据库方法

    本文利用MongoDB官方发布的C#驱动，封闭了对MongoDB数据库的增删改查访问方法。

    1、引用MongoDB for C# Driver

    从网上下载C#访问MongoDB的驱动，得到两个DLL：

• MongoDB.Driver.dll
• MongoDB.Bson.dll

    将它们引用到项目中。

    2、编写数据库访问帮助类

    编写MongoDB访问帮助类MongoDbHelper：

using System;
using System.Collections.Generic;
using System.Linq;
using MongoDB.Bson;
using MongoDB.Driver;
using MongoDB.Driver.Builders;
using MongoDbTest.Models;

namespace MongoDbTest
{
    /// <summary>
    /// MongoDB帮助类
    /// </summary>
    internal static class MongoDbHepler
    {
        /// <summary>
        /// 获取数据库实例对象
        /// </summary>
        /// <param name="connectionString">数据库连接串</param>
        /// <param name="dbName">数据库名称</param>
        /// <returns>数据库实例对象</returns>
        private static MongoDatabase GetDatabase(string connectionString, string dbName)
        {
            var server = MongoServer.Create(connectionString);
            return server.GetDatabase(dbName);
        }

        #region 新增

        /// <summary>
        /// 插入一条记录
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="connectionString">数据库连接串</param>
        /// <param name="dbName">数据名称</param>
        /// <param name="collectionName">集合名称</param>
        /// <param name="model">数据对象</param>
        public static void Insert<T>(string connectionString, string dbName, string collectionName, T model) where T : EntityBase
        {
            if (model == null)
            {
                throw new ArgumentNullException("model", "待插入数据不能为空");
            }
            var db = GetDatabase(connectionString, dbName);
            var collection = db.GetCollection<T>(collectionName);
            collection.Insert(model);
        }

        #endregion

        #region 更新

        /// <summary>
        /// 更新数据
        /// </summary>
        /// <param name="connectionString">数据库连接串</param>
        /// <param name="dbName">数据库名称</param>
        /// <param name="collectionName">集合名称</param>
        /// <param name="query">查询条件</param>
        /// <param name="dictUpdate">更新字段</param>
        public static void Update(string connectionString, string dbName, string collectionName, IMongoQuery query, Dictionary<string, BsonValue> dictUpdate)
        {
            var db = GetDatabase(connectionString, dbName);
            var collection = db.GetCollection(collectionName);
            var update = new UpdateBuilder();
            if (dictUpdate != null && dictUpdate.Count > 0)
            {
                foreach (var item in dictUpdate)
                {
                    update.Set(item.Key, item.Value);
                }
            }
            var d = collection.Update(query, update, UpdateFlags.Multi);
        }

        #endregion

        #region 查询

        /// <summary>
        /// 根据ID获取数据对象
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="connectionString">数据库连接串</param>
        /// <param name="dbName">数据库名称</param>
        /// <param name="collectionName">集合名称</param>
        /// <param name="id">ID</param>
        /// <returns>数据对象</returns>
        public static T GetById<T>(string connectionString, string dbName, string collectionName, ObjectId id)
            where T : EntityBase
        {
            var db = GetDatabase(connectionString, dbName);
            var collection = db.GetCollection<T>(collectionName);
            return collection.FindOneById(id);
        }

        /// <summary>
        /// 根据查询条件获取一条数据
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="connectionString">数据库连接串</param>
        /// <param name="dbName">数据库名称</param>
        /// <param name="collectionName">集合名称</param>
        /// <param name="query">查询条件</param>
        /// <returns>数据对象</returns>
        public static T GetOneByCondition<T>(string connectionString, string dbName, string collectionName, IMongoQuery query)
            where T : EntityBase
        {
            var db = GetDatabase(connectionString, dbName);
            var collection = db.GetCollection<T>(collectionName);
            return collection.FindOne(query);
        }

        /// <summary>
        /// 根据查询条件获取多条数据
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="connectionString">数据库连接串</param>
        /// <param name="dbName">数据库名称</param>
        /// <param name="collectionName">集合名称</param>
        /// <param name="query">查询条件</param>
        /// <returns>数据对象集合</returns>
        public static List<T> GetManyByCondition<T>(string connectionString, string dbName, string collectionName, IMongoQuery query)
            where T : EntityBase
        {
            var db = GetDatabase(connectionString, dbName);
            var collection = db.GetCollection<T>(collectionName);
            return collection.Find(query).ToList();
        }

        /// <summary>
        /// 根据集合中的所有数据
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="connectionString">数据库连接串</param>
        /// <param name="dbName">数据库名称</param>
        /// <param name="collectionName">集合名称</param>
        /// <returns>数据对象集合</returns>
        public static List<T> GetAll<T>(string connectionString, string dbName, string collectionName)
            where T : EntityBase
        {
            var db = GetDatabase(connectionString, dbName);
            var collection = db.GetCollection<T>(collectionName);
            return collection.FindAll().ToList();
        }

        #endregion

        #region 删除

        /// <summary>
        /// 删除集合中符合条件的数据
        /// </summary>
        /// <param name="connectionString">数据库连接串</param>
        /// <param name="dbName">数据库名称</param>
        /// <param name="collectionName">集合名称</param>
        /// <param name="query">查询条件</param>
        public static void DeleteByCondition(string connectionString, string dbName, string collectionName, IMongoQuery query)
        {
            var db = GetDatabase(connectionString, dbName);
            var collection = db.GetCollection(collectionName);
            collection.Remove(query);
        }

        /// <summary>
        /// 删除集合中的所有数据
        /// </summary>
        /// <param name="connectionString">数据库连接串</param>
        /// <param name="dbName">数据库名称</param>
        /// <param name="collectionName">集合名称</param>
        public static void DeleteAll(string connectionString, string dbName, string collectionName)
        {
            var db = GetDatabase(connectionString, dbName);
            var collection = db.GetCollection(collectionName);
            collection.RemoveAll();
        }

        #endregion

    }
}

    3、编写测试类

    （1）配置数据库参数

    在配置文件中编写数据库连接串和数据库名称。

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <!--MongoDB数据库连接串-->
    <add key="MongoDBConn" value="mongodb://127.0.0.1:27017"/>
    <!--MongoDB数据库名称-->
    <add key="MongoDBName" value="mydb"/>
  </appSettings> 
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
    </startup>
</configuration>

    将其写入C#代码中：

using System.Configuration;

namespace MongoDbTest
{
    /// <summary>
    /// 数据库配置参数
    /// </summary>
    internal static class DbConfigParams
    {
        private static string _conntionString = ConfigurationManager.AppSettings["MongoDBConn"];

        /// <summary>
        /// 获取 数据库连接串
        /// </summary>
        public static string ConntionString
        {
            get { return _conntionString; }
        }

        private static string _dbName = ConfigurationManager.AppSettings["MongoDBName"];

        /// <summary>
        /// 获取 数据库名称
        /// </summary>
        public static string DbName
        {
            get { return _dbName; }
        }
    }
}

    另外，将集合名称写到C#代码中作为字符串常量：

namespace MongoDbTest
{
    public class CollectionNames
    {
        public const string User = "User";

        public const string Student = "Student";
    }
}

    （2）编写实体类

    首先，编写实体基类，其中含有默认的Id：

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

namespace MongoDbTest.Models
{
    /// <summary>
    /// 实体基类
    /// </summary>
    public class EntityBase
    {
        /// <summary>
        /// 主键
        /// </summary>
        [BsonId]
        public ObjectId Id { get; set; }
    }
}

    然后，编写实体类：

namespace MongoDbTest.Models
{
    /// <summary>
    /// 学生类
    /// </summary>
    public class Student : EntityBase
    {
        /// <summary>
        /// 获取 姓名
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// 获取 年龄
        /// </summary>
        public int Age { get; set; }

        /// <summary>
        /// 获取 状态
        /// </summary>
        public State State { get; set; }
    }
}

    其中，State枚举类定义如下：

namespace MongoDbTest.Models
{
    /// <summary>
    /// 状态
    /// </summary>
    public enum State
    {
        /// <summary>
        /// 全部
        /// </summary>
        All = 0,

        /// <summary>
        /// 正常
        /// </summary>
        Normal = 1,

        /// <summary>
        /// 未使用
        /// </summary>
        Unused = 2,
    }
}

    （3）编写测试代码

    在主程序中编写测试代码：

using System;
using System.Collections.Generic;
using MongoDB.Bson;
using MongoDB.Driver.Builders;
using MongoDbTest.Models;

namespace MongoDbTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Title = "Mongo DB Test";
            InsertTest();
            //QueryTest();
            //UpdateTest();
            DeleteTest();

            Console.WriteLine("Finish!");

            Console.ReadLine();
        }

        /// <summary>
        /// 插入数据测试
        /// </summary>
        static void InsertTest()
        {
            var random = new Random();
            for (var i = 1; i <= 10; i++)
            {
                var item = new Student()
                {
                    Name = "我的名字" + i,
                    Age = random.Next(25, 30),
                    State = i%2 == 0 ? State.Normal : State.Unused
                };
                MongoDbHepler.Insert(DbConfigParams.ConntionString, DbConfigParams.DbName, CollectionNames.Student, item);
            }
        }

        /// <summary>
        /// 查询测试
        /// </summary>
        static void QueryTest()
        {
            var queryBuilder = new QueryBuilder<Student>();
            var query = queryBuilder.GTE(x => x.Age, 27);
            var ltModel = MongoDbHepler.GetManyByCondition<Student>(DbConfigParams.ConntionString, DbConfigParams.DbName,
                CollectionNames.Student, query);
            if (ltModel != null && ltModel.Count > 0)
            {
                foreach (var item in ltModel)
                {
                    Console.WriteLine("姓名：{0}，年龄：{1}，状态：{2}",
                        item.Name, item.Age, GetStateDesc(item.State));
                }
            }
        }

        /// <summary>
        /// 更新测试
        /// </summary>
        static void UpdateTest()
        {
            var queryBuilder = new QueryBuilder<Student>();
            var query = queryBuilder.GTE(x => x.Age, 27);
            var dictUpdate = new Dictionary<string, BsonValue>();
            dictUpdate["State"] = State.Unused;
            MongoDbHepler.Update(DbConfigParams.ConntionString, DbConfigParams.DbName, CollectionNames.Student, query,
                dictUpdate);
        }

        /// <summary>
        /// 删除测试
        /// </summary>
        static void DeleteTest()
        {
            var queryBuilder = new QueryBuilder<Student>();
            var query = queryBuilder.GTE(x => x.Age, 28);
            MongoDbHepler.DeleteByCondition(DbConfigParams.ConntionString, DbConfigParams.DbName, CollectionNames.Student, query);
        }

        /// <summary>
        /// 获取状态描述
        /// </summary>
        /// <param name="state">状态</param>
        /// <returns>状态描述</returns>
        static string GetStateDesc(State state)
        {
            string result = string.Empty;
            switch (state)
            {
                case State.All:
                    result = "全部";
                    break;
                case State.Normal:
                    result = "正常";
                    break;
                case State.Unused:
                    result = "未使用";
                    break;
                default:
                    throw new ArgumentOutOfRangeException("state");
            }
            return result;
        }
    }
}