Mongo DB Helper类

/// <summary>
/// MongoDB的配置
/// </summary>
public class MongoDBConn
{
    /// <summary>
    /// 数据库所在主机
    /// </summary>
    private readonly string MONGO_CONN_HOST = ConfigConstant.MIP;// "192.168.1.169";

    /// <summary>
    /// 数据库所在主机的端口
    /// </summary>
    private readonly int MONGO_CONN_PORT = Convert.ToInt32(ConfigConstant.MPORT);//27017;

    /// <summary>
    /// 连接超时设置 秒
    /// </summary>
    private readonly int CONNECT_TIME_OUT = 30;

    private readonly int CONNECT_LIFE_TIME = 300;

    /// <summary>
    /// 数据库的名称
    /// </summary>
    private readonly string DB_NAME = ConfigConstant.MDBNAME;

    /// <summary>
    /// 得到数据库实例
    /// </summary>
    /// <returns></returns>
    public MongoDatabase GetDataBase()
    {

        MongoClientSettings mongoSetting = new MongoClientSettings();
        //设置连接超时时间
        mongoSetting.ConnectTimeout = new TimeSpan(CONNECT_TIME_OUT * TimeSpan.TicksPerSecond);
        mongoSetting.MaxConnectionLifeTime = new TimeSpan(CONNECT_LIFE_TIME * TimeSpan.TicksPerSecond);
        //设定最大连接池
        mongoSetting.MinConnectionPoolSize = 20;
        //等待列队数量
        mongoSetting.WaitQueueSize = 50;

        //设置数据库服务器
        mongoSetting.Server = new MongoServerAddress(MONGO_CONN_HOST, MONGO_CONN_PORT);

        //设置用户名和密码
        MongoCredential mc = MongoCredential.CreateCredential(DB_NAME, ConfigConstant.MUSER, ConfigConstant.MPWD);
        mongoSetting.Credential = mc;

        //创建Mongo的客户端
        MongoClient client = new MongoClient(mongoSetting);

        
        MongoServer ms = client.GetServer();
        ms.Connect();
        //得到服务器端并且生成数据库实例
        return ms.GetDatabase(DB_NAME);
    }
}



public class ConfigConstant
{
    /// <summary>
    /// mogodb IP
    /// </summary>
    public static string MIP = ConfigurationManager.ConnectionStrings["MIP"].ToString(); // "127.0.0.1";

    /// <summary>
    /// mogodb 端口号
    /// </summary>
    public static string MPORT = ConfigurationManager.ConnectionStrings["MPORT"].ToString(); //"27017";

    /// <summary>
    /// mogodb 数据库名称
    /// </summary>
    public static string MDBNAME = ConfigurationManager.ConnectionStrings["MDB"].ToString();// "Items"; 

    /// <summary>
    /// mogodb 用户名
    /// </summary>
    public static string MUSER = ConfigurationManager.ConnectionStrings["MUSER"].ToString();//"sa";

    /// <summary>
    /// mogodb 密码
    /// </summary>
    public static string MPWD = ConfigurationManager.ConnectionStrings["MPWD"].ToString();//"111";


    //public static string MIP = "127.0.0.1";
    //public static string MPORT = "27017";
    //public static string MDBNAME = "Items";
    //public static string MUSER = "sa";
    //public static string MPWD = "111"; 
}



public sealed class MongodbHelper
{
    static public readonly MongodbHelper Instance = new MongodbHelper();
    private MongoDatabase db;

    /// <summary>
    /// ObjectId的键
    /// </summary>
    static private readonly string OBJECTID_KEY = "_id";

    #region 初始化数据
    private MongodbHelper()
    {
        ////http://www.studyofnet.com/news/337.html
        ////mongodb://[username:password@]host1[:port1][,host2[:port2],…[,hostN[:portN]]][/[database][?options]]
        ////string strconn = "mongodb://sa:123456@127.0.0.1:27017";
        //string strconn = "mongodb://47.74.175.189:27017";
        //string dbName = "mongodb_name";
        //MongoDB.Driver.MongoClient mongoClient = new MongoClient(strconn);
        //MongoServer server = mongoClient.GetServer();
        //db = server.GetDatabase(dbName);
        try
        {
            db = new MongoDBConn().GetDataBase();
        }
        catch { }
    }

    public MongoDatabase DB
    {
        get { return db; }
    }

    public MongoCollection this[string value]
    {
        get
        {
            return db.GetCollection(value);
        }
    }
    #endregion
    
    #region 插入数据
    /// <summary>
    /// 增加操作
    /// </summary>
    /// <param name="colName">集合名称</param>
    /// <param name="bson">单条数据</param>
    /// <returns></returns>
    public static bool insert<T>(string tbName, T bson)
    { 
        try
        { 
            bool isPass = true;
            MongoCollection<BsonDocument> mc = Instance.DB.GetCollection<BsonDocument>(tbName);

            //将实体转换为json文档
            BsonDocument bd = bson.ToBsonDocument();
            //进行插入操作
            WriteConcernResult result = mc.Insert(bd);
            if (!string.IsNullOrEmpty(result.LastErrorMessage))
            {
                isPass = false;
                //throw new Exception(result.LastErrorMessage);
            }
            mc = null;
            Instance.DB.Server.Disconnect();
            return isPass;

        }
        catch
        {
            return false;
        } 
    }

    public static bool insert<T>(T bson)
    {
        try
        {
            string tbName = typeof(T).Name;

            bool isPass = true;
            MongoCollection<BsonDocument> mc = Instance.DB.GetCollection<BsonDocument>(tbName);

            //将实体转换为json文档
            BsonDocument bd = bson.ToBsonDocument();
            //进行插入操作
            WriteConcernResult result = mc.Insert(bd);
            if (!string.IsNullOrEmpty(result.LastErrorMessage))
            {
                isPass = false;
                //throw new Exception(result.LastErrorMessage);
            }
            mc = null;
            Instance.DB.Server.Disconnect();
            return isPass;

            //MongoCollection mcoll = Instance.DB.GetCollection(tbName);
            //mcoll.Insert(bson);
            //mcoll = null;
            //Instance.DB.Server.Disconnect();
            //return true;
        }
        catch
        {
            return false;
        }
    }

    /// <summary>
    /// 增加多条
    /// </summary>
    /// <param name="tbName">集合名称</param>
    /// <param name="bsonlist">数据集合</param>
    /// <returns></returns>
    public static bool Add_List<T>(string tbName, List<T> list)
    { 
        try
        {
            MongoCollection mcoll = Instance.DB.GetCollection(tbName);
            //创建一个空间json集合
            List<BsonDocument> bsonList = new List<BsonDocument>();
            //批量将数据转为json格式 并且放进json文档
            list.ForEach(t => bsonList.Add(t.ToBsonDocument()));
            //批量插入数据
            mcoll.InsertBatch(list);
            mcoll = null;
            Instance.DB.Server.Disconnect();
            return true;
        }
        catch
        {
            return false;
        } 
    }
    public static bool Add_List<T>(List<T> list)
    {
        try
        {
            string tbName = typeof(T).Name;
            MongoCollection mcoll = Instance.DB.GetCollection(tbName);
            //创建一个空间json集合
            List<BsonDocument> bsonList = new List<BsonDocument>();
            //批量将数据转为json格式 并且放进json文档
            list.ForEach(t => bsonList.Add(t.ToBsonDocument()));
            //批量插入数据
            mcoll.InsertBatch(bsonList);
            mcoll = null;
            Instance.DB.Server.Disconnect();
            return true;
        }
        catch
        {
            return false;
        }
    }

    #endregion

    #region 查询数据

    #region 查询说明
    //Query.All("name", "a", "b");//通过多个元素来匹配数组
    //Query.And(Query.EQ("name", "a"), Query.EQ("title", "t"));//同时满足多个条件
    //Query.EQ("name", "a");//等于
    //Query.Exists("type", true);//判断键值是否存在
    //Query.GT("value", 2);//大于>
    //Query.GTE("value", 3);//大于等于>=
    //Query.In("name", "a", "b");//包括指定的所有值,可以指定不同类型的条件和值
    //Query.LT("value", 9);//小于<
    //Query.LTE("value", 8);//小于等于<=
    //Query.Mod("value", 3, 1);//将查询值除以第一个给定值,若余数等于第二个给定值则返回该结果
    //Query.NE("name", "c");//不等于
    //Query.Nor(Array);//不包括数组中的值
    //Query.Not("name");//元素条件语句
    //Query.NotIn("name", "a", 2);//返回与数组中所有条件都不匹配的文档
    //Query.Or(Query.EQ("name", "a"), Query.EQ("title", "t"));//满足其中一个条件
    //Query.Size("name", 2);//给定键的长度
    //Query.Type("_id", BsonType.ObjectId );//给定键的类型
    //Query.Where(BsonJavaScript);//执行JavaScript
    //Query.Matches("Title",str);//模糊查询 相当于sql中like  -- str可包含正则表达式
    #endregion

    #region 查询所有记录
    /// <summary>
    /// 查询一个集合中的所有数据
    /// </summary>
    /// <typeparam name="T">该集合数据的所属类型</typeparam>
    /// <param name="collectionName">指定集合的名称</param>
    /// <returns>返回一个List列表</returns>
    public static List<T> FindAll<T>(string collectionName)
    {
        try
        {
            MongoCollection<T> mc = Instance.DB.GetCollection<T>(collectionName);
            //以实体方式取出其数据集合
            MongoCursor<T> mongoCursor = mc.FindAll();
            //直接转化为List返回
            return mongoCursor.ToList<T>();
        }
        catch { return new List<T>(); }
    }

    /// <summary>
    /// 查询一个集合中的所有数据 其集合的名称为T的名称
    /// </summary>
    /// <typeparam name="T">该集合数据的所属类型</typeparam>
    /// <returns>返回一个List列表</returns>
    public static List<T> FindAll<T>()
    {
        string collectionName = typeof(T).Name;
        return FindAll<T>(collectionName);
    }
    #endregion

    #region 查询一条记录
    /// <summary>
    /// 查询一条记录
    /// </summary>
    /// <typeparam name="T">该数据所属的类型</typeparam>
    /// <param name="query">查询的条件 可以为空</param>
    /// <param name="collectionName">去指定查询的集合</param>
    /// <returns>返回一个实体类型</returns>
    public static T FindOne<T>(IMongoQuery query, string collectionName)
    {
        try
        {
            MongoCollection<T> mc = Instance.DB.GetCollection<T>(collectionName);
            query = InitQuery(query);
            T t = mc.FindOne(query);
            return t;
        }
        catch
        {
            return default(T);
        }
    } 

    /// <summary>
    /// 查询一条记录
    /// </summary>
    /// <typeparam name="T">该数据所属的类型</typeparam>
    /// <param name="query">查询的条件 可以为空</param>
    /// <returns>返回一个实体类型</returns>
    public static T FindOne<T>(IMongoQuery query)
    {
        string collectionName = typeof(T).Name;
        return FindOne<T>(query, collectionName);
    }
    #endregion

    #region 普通的条件查询
    /// <summary>
    /// 根据指定条件查询集合中的数据
    /// </summary>
    /// <typeparam name="T">该集合数据的所属类型</typeparam>
    /// <param name="query">指定的查询条件 比如Query.And(Query.EQ("username","admin"),Query.EQ("password":"admin"))</param>
    /// <param name="collectionName">指定的集合的名称</param>
    /// <returns>返回一个List列表</returns>
    public static List<T> FindList<T>(IMongoQuery query, string collectionName, int limit = 10)
    {
        MongoCollection<T> mc = Instance.DB.GetCollection<T>(collectionName);
        IMongoQuery querys = InitQuery(query);

        MongoCursor<T> mongoCursor = mc.Find(querys).SetLimit(limit);
        mongoCursor = mc.Find(querys).SetLimit(limit);
        //IQueryable<T> queryable = mc.Find(query).AsQueryable();
        //queryable.ToList<T>();
        return mongoCursor.ToList<T>();
    }

    /// <summary>
    /// 根据指定条件查询集合中的数据
    /// </summary>
    /// <typeparam name="T">该集合数据的所属类型</typeparam>
    /// <param name="query">指定的查询条件 比如Query.And(Query.EQ("username","admin"),Query.EQ("password":"admin"))</param>
    /// <param name="collectionName">指定的集合的名称</param>
    /// <returns>返回一个List列表</returns>
    public static List<T> FindListBy<T>(IMongoQuery query, SortByDocument sortBy, string collectionName)
    {
        try
        {
            MongoCollection<T> mc = Instance.DB.GetCollection<T>(collectionName);
            query = InitQuery(query);

            MongoCursor<T> mongoCursor = mc.Find(query).SetSortOrder(sortBy);

            return mongoCursor.ToList<T>();
        }
        catch
        {
            return new List<T>();
        }
    }


    /// <summary>
    /// 根据指定条件查询集合中的数据记录数
    /// </summary>
    /// <typeparam name="T">该集合数据的所属类型</typeparam>
    /// <param name="query">指定的查询条件 比如Query.And(Query.EQ("username","admin"),Query.EQ("password":"admin"))</param>
    /// <param name="collectionName">指定的集合的名称</param>
    /// <returns>返回一个List列表</returns>
    public static long FindCount<T>(IMongoQuery query, string collectionName)
    {
        try
        {
            MongoCollection<T> mc = Instance.DB.GetCollection<T>(collectionName);
            query = InitQuery(query);

            MongoCursor<T> mongoCursor = mc.Find(query);

            return mongoCursor.Count();
        }
        catch { return 0; }
    }
     
    #endregion

    #region 分页查询 PageIndex和PageSize模式  在页数PageIndex大的情况下 效率明显变低

    /// <summary>
    /// 分页查询 PageIndex和PageSize模式  在页数PageIndex大的情况下 效率明显变低
    /// </summary>
    /// <typeparam name="T">所需查询的数据的实体类型</typeparam>
    /// <param name="query">查询的条件</param>
    /// <param name="pageIndex">当前的页数</param>
    /// <param name="pageSize">当前的尺寸</param>
    /// <param name="sortBy">排序方式</param>
    /// <param name="collectionName">集合名称</param>
    /// <returns>返回List列表</returns> 
    public static List<T> FindPage<T>(IMongoQuery query, int pageIndex, int pageSize, SortByDocument sortBy, string collectionName, out int totalPage, out int totalRows)
    {
        try
        {
            MongoCollection<T> mc = Instance.DB.GetCollection<T>(collectionName);
            MongoCursor<T> mongoCursor = null;
            query = InitQuery(query);
            sortBy = InitSortBy(sortBy);

            //如页序号为0时初始化为1
            pageIndex = pageIndex == 0 ? 1 : pageIndex;
            //按条件查询 排序 跳数 取数
            mongoCursor = mc.Find(query);
            totalRows = (mongoCursor.Count()).ToInt();
            totalPage = (totalRows - 1) / pageSize + 1;
            if (totalRows > 0)
            {
                mongoCursor = mc.Find(query).SetSortOrder(sortBy).SetSkip((pageIndex - 1) * pageSize).SetLimit(pageSize);
                return mongoCursor.ToList<T>();
            }
            return new List<T>();
        }
        catch (Exception ex)
        {
            totalRows = 1;
            totalPage = 1;
            return new List<T>();
        }
    }

    public static void GetDataCount<T>(IMongoQuery query, int pageSize, string collectionName, out int totalPage, out int totalRows, int maxDataCount)
    {
        try
        {
            MongoCollection<T> mc = Instance.DB.GetCollection<T>(collectionName);
            MongoCursor<T> mongoCursor = null;
            IMongoQuery querys = InitQuery(query);
            //先查询第一条是否有数据，若没有说明数据为空
            mongoCursor = mc.Find(querys).SetSkip(1).SetLimit(1);
            if (mongoCursor.GetEnumerator().MoveNext())
            {
                mongoCursor = mc.Find(querys).SetSkip(maxDataCount).SetLimit(1);
                //判断是否存在最大数据量，若存在总行数=最大数据量
                if (mongoCursor.GetEnumerator().MoveNext())
                {
                    totalRows = maxDataCount;
                }
                else
                {
                    totalRows = Convert.ToInt32(mongoCursor.Count());
                }
                totalPage = (totalRows - 1) / pageSize + 1;
            }
            else
            {
                totalPage = 1;
                totalRows = 1;
            }
        }
        catch
        {
            totalPage = 1;
            totalRows = 1;
        }
    }

    /// <summary>
    /// 得到字段数据
    /// </summary>
    /// <returns></returns>
    private FieldsDocument GetFieldsDocument()
    {
        FieldsDocument f = new FieldsDocument();
        f.Add("G_00_C1", 1);
        f.Add("S_60_C1", 1);
        f.Add("S_60_C12", 1);
        f.Add("S_60_C16", 1);
        f.Add("S_60_C17", 1);
        f.Add("S_60_C18", 1);
        f.Add("S_60_C19", 1);
        f.Add("S_60_C2", 1);
        f.Add("S_60_C3", 1);
        f.Add("S_60_C5", 1);
        f.Add("S_60_C6", 1);
        f.Add("S_60_C7", 1);
        f.Add("S_60_c26", 1);
        f.Add("S_60_C30", 1);
        f.Add("N_60_C32", 1);
        f.Add("S_60_C39", 1);
        f.Add("S_60_C41", 1);
        f.Add("S_60_C43", 1);
        f.Add("S_60_C46", 1);
        f.Add("S_60_C51", 1);
        f.Add("F_60_C55", 1);
        f.Add("SortType", 1);
        f.Add("IsSpecialPrice", 1);
        f.Add("ItemType", 1);
        f.Add("ItemFork", 1);
        f.Add("CN_S_ITEM_NAME", 1);
        f.Add("D_60_C36", 1);
        f.Add("D_60_C37", 1);
        f.Add("CN_F_PRICE", 1);
        f.Add("ItemPriceList", 1);
        return f;
    }

    /// <summary>
    /// 分页查询 PageIndex和PageSize模式  查询固定字段的方法
    /// </summary>
    /// <typeparam name="T">所需查询的数据的实体类型</typeparam>
    /// <param name="query">查询的条件</param>
    /// <param name="fd">指定查询的字段</param>
    /// <param name="pageIndex">当前的页数</param>
    /// <param name="pageSize">当前的尺寸</param>
    /// <param name="sortBy">排序方式</param>
    /// <param name="collectionName">集合名称</param>
    /// <returns>返回List列表</returns>
    public static List<T> FindFields<T>(IMongoQuery query, FieldsDocument fd, int pageIndex, int pageSize, SortByDocument sortBy, string collectionName, out int totalPage, out int totalRows)
    {
        try
        {
            MongoCollection<T> mc = Instance.DB.GetCollection<T>(collectionName);
            MongoCursor<T> mongoCursor = null;
            query = InitQuery(query);
            sortBy = InitSortBy(sortBy);

            //如页序号为0时初始化为1
            pageIndex = pageIndex == 0 ? 1 : pageIndex;
            //按条件查询 排序 跳数 取数
            mongoCursor = mc.Find(query);
            totalRows = (mongoCursor.Count()).ToInt();
            totalPage = (totalRows - 1) / pageSize + 1;

            if (totalRows > 0)
            {
                //按条件查询 排序 跳数 取数
                mongoCursor = mongoCursor.SetFields(fd).SetSortOrder(sortBy).SetSkip((pageIndex - 1) * pageSize).SetLimit(pageSize);
                return mongoCursor.ToList<T>();
            }
            return new List<T>();
        }
        catch (Exception ex)
        {
            totalRows = 1;
            totalPage = 1;
            return new List<T>();
        }
    }
     

    #endregion

    #endregion

    #region 更新数据
    /// <summary>
    /// 更新数据
    /// </summary>
    /// <typeparam name="T">更新的数据 所属的类型</typeparam>
    /// <param name="query">更新数据的查询</param>
    /// <param name="update">需要更新的文档</param>
    public static bool Update<T>(IMongoQuery query, IMongoUpdate update)
    {
        string collectionName = typeof(T).Name;
        return Update<T>(query, update, collectionName);
    }

    /// <summary>
    /// 更新数据
    /// </summary>
    /// <typeparam name="T">更新的数据 所属的类型</typeparam>
    /// <param name="query">更新数据的查询</param>
    /// <param name="update">需要更新的文档</param>
    /// <param name="collectionName">指定更新集合的名称</param>
    public static bool Update<T>(IMongoQuery query, IMongoUpdate update, string collectionName)
    {
        try
        {
            MongoCollection<T> mc = Instance.DB.GetCollection<T>(collectionName);

            query = InitQuery(query);
            //更新数据
            WriteConcernResult result = mc.Update(query, update);
            return true;
        }
        catch (Exception ex)
        {
            return false;
        }
    }

    public static bool Update<T>(IMongoQuery query, IMongoUpdate update, string collectionName,UpdateFlags upflg)
    {
        try
        {
            MongoCollection<T> mc = Instance.DB.GetCollection<T>(collectionName);

            query = InitQuery(query);
            //更新数据
            WriteConcernResult result = mc.Update(query, update, upflg);
            return true;
        }
        catch (Exception ex)
        {
            return false;
        }
    }
    #endregion

    #region 移除/删除数据
    /// <summary>
    /// 移除指定的数据
    /// </summary>
    /// <typeparam name="T">移除的数据类型</typeparam>
    /// <param name="query">移除的数据条件</param>
    /// <param name="collectionName">指定的集合名词</param>
    public static bool Remove<T>(IMongoQuery query, string collectionName)
    {
        try
        {
            MongoCollection<T> mc = MongodbHelper.Instance.db.GetCollection<T>(collectionName);
            query = InitQuery(query);
            //根据指定查询移除数据
            mc.Remove(query);
            return true;
        }
        catch (Exception ex)
        {
            return false;
        }
    }

    /// <summary>
    /// 移除指定的数据
    /// </summary>
    /// <typeparam name="T">移除的数据类型</typeparam>
    /// <param name="query">移除的数据条件</param>
    public static bool Remove<T>(IMongoQuery query)
    {
        string collectionName = typeof(T).Name;
        return Remove<T>(query, collectionName);
    }

    /// <summary>
    /// 移除实体里面所有的数据
    /// </summary>
    /// <typeparam name="T">移除的数据类型</typeparam>
    public static bool ReomveAll<T>()
    {
        string collectionName = typeof(T).Name;
        return RemoveAll(collectionName);
    }


    /// <summary>
    /// 删除所有
    /// </summary>
    /// <param name="tbName">集合名称</param> 
    /// <returns></returns>
    public static bool RemoveAll(string tbName)
    {
        try
        {
            MongoCollection mcoll = Instance.DB.GetCollection(tbName);
            mcoll.RemoveAll();
            mcoll = null;
            return true;
        }
        catch
        {
            return false;
        }
    }
    #endregion

    #region 私有的一些辅助方法
    /// <summary>
    /// 初始化查询记录 主要当该查询条件为空时 会附加一个恒真的查询条件，防止空查询报错
    /// </summary>
    /// <param name="query">查询的条件</param>
    /// <returns></returns>
    private static IMongoQuery InitQuery(IMongoQuery query)
    {
        if (query == null)
        {
            //当查询为空时 附加恒真的条件 类似SQL：1=1的语法
            query = Query.Exists(OBJECTID_KEY);
        }
        return query;
    }

    /// <summary>
    /// 初始化排序条件  主要当条件为空时 会默认以ObjectId递增的一个排序
    /// </summary>
    /// <param name="sortBy"></param>
    /// <returns></returns>
    private static SortByDocument InitSortBy(SortByDocument sortBy)
    {
        if (sortBy == null)
        {
            //默认ObjectId 递增
            sortBy = new SortByDocument(OBJECTID_KEY, -1);
        }
        return sortBy;
    }
    #endregion
 }

public class BaseEntity
{
    /// <summary>
    /// 字段映射，告诉mongodb这个字段在数据库中对应_id
    /// </summary>
    [BsonId]
    //告诉mongodb这个字段在数据库中的类型是ObjectId
    [BsonRepresentation(BsonType.ObjectId)]
    public string _id { get; set; }
}


public class InsertBaseEntity
{
    /// <summary>
    /// 字段映射，告诉mongodb这个字段在数据库中对应_id
    /// </summary>
    [BsonId]
    //告诉mongodb这个字段在数据库中的类型是ObjectId
    [BsonRepresentation(BsonType.ObjectId)]
    //private string id;
    public string _id
    {
        get
        {
            return new ObjectId().ToString();
        }
        set
        {

        }
    }
}

需要引用的DLL
https://download.youkuaiyun.com/download/xiongliuyun/20320080

web config 中需要配置
<add name="MIP" connectionString="192.168.10.18" />
<add name="MPORT" connectionString="27017" />
<add name="MDB" connectionString="mongodb_name" />
<add name="MUSER" connectionString="stander" />
<add name="MPWD" connectionString="stander7955178" />