.net2.0是否支持 mongodb

发布网友发布时间：2022-05-02 01:15

共2个回答

懂视网时间：2022-05-02 05:36

class MongoDbManager { private static IMongoDatabase db = null; private static readonly object locker = new object(); /// <summary> /// 使用单列模式创建连接 /// </summary> /// <returns></returns> public static IMongoDatabase CreateDb() { if (db == null) { lock (locker) { if (db == null) { MongoClient Client = new MongoClient(MongoDbConfig.Host); db = Client.GetDatabase(MongoDbConfig.DataBase); } } } return db; } }

第二步创建DB：

public class MongoDbBase
 {
 private IMongoDatabase db = null;
 public IMongoDatabase Db { get => db; }
 public MongoDbBase()
 {
  db = MongoDbManager.CreateDb();
 }
 }

最后献上自己mongodbhelper:

using KuRuMi.Mio.DoMain.MongoDbCache.MongoDbCommon;
using MongoDB.Bson;
using MongoDB.Driver;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace KuRuMi.Mio.DoMain.MongoDbCache.MongoDbCache
{
 /// <summary>
 /// MongoDb缓存
 /// </summary>
 public sealed class MongoDbCacheService : MongoDbBase
 {
 #region 同步
 #region 增加
 /// <summary>
 /// 保存单个对象
 /// </summary>
 /// <param name="Root"></param>
 /// <returns></returns>
 public bool AddSignleObject<TAggregateRoot>(TAggregateRoot Root)
 {
  try
  {
  var collection = Db.GetCollection<TAggregateRoot>(typeof(TAggregateRoot).Name);
  collection.InsertOne(Root);
  return true;
  }
  catch (Exception)
  {
  return false;
  }

 }
 /// <summary>
 /// 批量保存多个对象
 /// </summary>
 /// <param name="Root"></param>
 /// <returns></returns>
 public bool AddManyObject<TAggregateRoot>(List<TAggregateRoot> Root)
 {
  try
  {
  var collection = Db.GetCollection<TAggregateRoot>(typeof(TAggregateRoot).Name);
  collection.InsertMany(Root);
  return true;
  }
  catch (Exception)
  {
  return false;
  }

 }
 #endregion

 #region 删除
 /// <summary>
 /// 删除单个记录
 /// </summary>
 /// <typeparam name="TAggregateRoot"></typeparam>
 /// <param name="parameter"></param>
 /// <returns></returns>
 public int DeleteSingleIndex<TAggregateRoot>(Expression<Func<TAggregateRoot, bool>> filter)
 {
  try
  {
  var collection = Db.GetCollection<TAggregateRoot>(typeof(TAggregateRoot).Name);
  return (int)collection.DeleteOne(filter).DeletedCount;
  }
  catch (Exception e)
  {
  throw e;
  }
 }
 #endregion

 #region 查询
 /// <summary>
 /// 查询单条记录
 /// </summary>
 /// <typeparam name="TAggregateRoot"></typeparam>
 /// <param name="parameter"></param>
 /// <returns></returns>
 public TAggregateRoot FindSingleIndex<TAggregateRoot>(Expression<Func<TAggregateRoot, bool>> filter)
 {
  try
  {
  var collection = Db.GetCollection<TAggregateRoot>(typeof(TAggregateRoot).Name);
  return collection.Find(filter).FirstOrDefault();
  }
  catch (Exception e)
  {
  throw e;
  }
 }
 /// <summary>
 /// 查询整个集合
 /// </summary>
 /// <typeparam name="TAggregateRoot"></typeparam>
 /// <param name="filter"></param>
 /// <returns></returns>
 public List<TAggregateRoot> FindMany<TAggregateRoot>(Expression<Func<TAggregateRoot, bool>> filter)
 {
  try
  {
  var collection = Db.GetCollection<TAggregateRoot>(typeof(TAggregateRoot).Name);
  return collection.Find(filter).ToList();
  }
  catch (Exception e)
  {
  throw e;
  }
 }
 #endregion

 #region 更新
 /// <summary>
 /// 更新单个值
 /// </summary>
 /// <typeparam name="TAggregateRoot"></typeparam>
 /// <param name="filter"></param>
 /// <param name="field"></param>
 /// <param name="parameter"></param>
 /// <returns></returns>
 public int UpdateSingle<TAggregateRoot>(Expression<Func<TAggregateRoot, bool>> filter, string name, string parameter)
 {
  try
  {
  var collection = Db.GetCollection<TAggregateRoot>(typeof(TAggregateRoot).Name);
  var set = Builders<TAggregateRoot>.Update.Set(name, parameter);
  return (int)collection.UpdateOne(filter, set).ModifiedCount;
  }
  catch (Exception e)
  {
  throw e;
  }
 }
 /// <summary>
 /// 更新多个值
 /// </summary>
 /// <typeparam name="TAggregateRoot"></typeparam>
 /// <param name="filter"></param>
 /// <param name="Root"></param>
 /// <param name="property"></param>
 /// <param name="replace"></param>
 public int UpdateMany<TAggregateRoot>(Expression<Func<TAggregateRoot, bool>> filter, TAggregateRoot Root, List<string> property = null, bool replace = false)
 {
  try
  {
  var collection = Db.GetCollection<TAggregateRoot>(typeof(TAggregateRoot).Name);
  var type = Root.GetType();
  //修改集合
  var list = new List<UpdateDefinition<TAggregateRoot>>();
  foreach (var propert in type.GetProperties())
  {
   if (propert.Name.ToLower() != "id")
   {
   try
   {
    if (property == null && property.Count < 1 || property.Any(o => o.ToLower() == propert.Name.ToLower()))
    {
    var replaceValue = propert.GetValue(Root);
    if (replaceValue != null)
     list.Add(Builders<TAggregateRoot>.Update.Set(propert.Name, replaceValue));
    else if (replace)
     list.Add(Builders<TAggregateRoot>.Update.Set(propert.Name, replaceValue));
    }
   }
   catch (Exception)
   {
    if (property == null)
    {
    var replaceValue = propert.GetValue(Root);
    if (replaceValue != null)
     list.Add(Builders<TAggregateRoot>.Update.Set(propert.Name, replaceValue));
    else if (replace)
     list.Add(Builders<TAggregateRoot>.Update.Set(propert.Name, replaceValue));
    }
   }
   
   }
  }
  if (list.Count > 0)
  {
   var builders = Builders<TAggregateRoot>.Update.Combine(list);
   return (int)collection.UpdateOne(filter, builders).ModifiedCount;
  }
  return 0;
  }
  catch (Exception e)
  {
  throw e;
  }
 }
 #endregion
 #endregion

 #region 异步
 #region 增加
 /// <summary>
 /// 异步保存单个对象
 /// </summary>
 /// <param name="Root"></param>
 /// <returns></returns>
 public bool AddSignleObjectAsync<TAggregateRoot>(TAggregateRoot Root)
 {
  try
  {
  var collection = Db.GetCollection<TAggregateRoot>(typeof(TAggregateRoot).Name);
  collection.InsertOneAsync(Root);
  return true;
  }
  catch (Exception)
  {
  return false;
  }

 }
 /// <summary>
 /// 批量保存多个对象
 /// </summary>
 /// <param name="Root"></param>
 /// <returns></returns>
 public bool AddManyObjectAsync<TAggregateRoot>(List<TAggregateRoot> Root)
 {
  try
  {
  var collection = Db.GetCollection<TAggregateRoot>(typeof(TAggregateRoot).Name);
  collection.InsertManyAsync(Root);
  return true;
  }
  catch (Exception)
  {
  return false;
  }

 }
 #endregion

 #region 删除
 /// <summary>
 /// 异步删除单个记录
 /// </summary>
 /// <typeparam name="TAggregateRoot"></typeparam>
 /// <param name="parameter"></param>
 /// <returns></returns>
 public int DeleteSingleIndexAsync<TAggregateRoot>(Expression<Func<TAggregateRoot, bool>> filter)
 {
  try
  {
  var collection = Db.GetCollection<TAggregateRoot>(typeof(TAggregateRoot).Name);
  return (int)collection.DeleteOneAsync(filter).Result.DeletedCount;
  }
  catch (Exception e)
  {
  throw e;
  }
 }
 #endregion

 #region 查询
 /// <summary>
 /// 异步查询单条记录
 /// </summary>
 /// <typeparam name="TAggregateRoot"></typeparam>
 /// <param name="parameter"></param>
 /// <returns></returns>
 public TAggregateRoot FindSingleIndexAsync<TAggregateRoot>(Expression<Func<TAggregateRoot, bool>> filter)
 {
  try
  {
  var collection = Db.GetCollection<TAggregateRoot>(typeof(TAggregateRoot).Name);
  return collection.FindAsync(filter).Result.FirstOrDefault();
  }
  catch (Exception e)
  {
  throw e;
  }
 }
 /// <summary>
 /// 异步查询整个集合
 /// </summary>
 /// <typeparam name="TAggregateRoot"></typeparam>
 /// <param name="filter"></param>
 /// <returns></returns>
 public List<TAggregateRoot> FindManyAsync<TAggregateRoot>(Expression<Func<TAggregateRoot, bool>> filter)
 {
  try
  {
  var collection = Db.GetCollection<TAggregateRoot>(typeof(TAggregateRoot).Name);
  return collection.FindAsync(filter).Result.ToList();
  }
  catch (Exception e)
  {
  throw e;
  }
 }
 #endregion

 #region 更新
 /// <summary>
 /// 异步更新单个值
 /// </summary>
 /// <typeparam name="TAggregateRoot"></typeparam>
 /// <param name="filter"></param>
 /// <param name="field"></param>
 /// <param name="parameter"></param>
 /// <returns></returns>
 public int UpdateSingleAsync<TAggregateRoot>(Expression<Func<TAggregateRoot, bool>> filter, string name, string parameter)
 {
  try
  {
  var collection = Db.GetCollection<TAggregateRoot>(typeof(TAggregateRoot).Name);
  var set = Builders<TAggregateRoot>.Update.Set(name, parameter);
  return (int)collection.UpdateOneAsync(filter, set).Result.ModifiedCount;
  }
  catch (Exception e)
  {
  throw e;
  }
 }
 /// <summary>
 ///异步更新多个值
 /// </summary>
 /// <typeparam name="TAggregateRoot"></typeparam>
 /// <param name="filter"></param>
 /// <param name="Root"></param>
 /// <param name="property"></param>
 /// <param name="replace"></param>
 public int UpdateManyAsync<TAggregateRoot>(Expression<Func<TAggregateRoot, bool>> filter, TAggregateRoot Root, List<string> property = null, bool replace = false)
 {
  try
  {
  var collection = Db.GetCollection<TAggregateRoot>(typeof(TAggregateRoot).Name);
  var type = Root.GetType();
  //修改集合
  var list = new List<UpdateDefinition<TAggregateRoot>>();
  foreach (var propert in type.GetProperties())
  {
   if (propert.Name.ToLower() != "id")
   {
   try
   {
    if (property == null && property.Count < 1 || property.Any(o => o.ToLower() == propert.Name.ToLower()))
    {
    var replaceValue = propert.GetValue(Root);
    if (replaceValue != null)
     list.Add(Builders<TAggregateRoot>.Update.Set(propert.Name, replaceValue));
    else if (replace)
     list.Add(Builders<TAggregateRoot>.Update.Set(propert.Name, replaceValue));
    }
   }
   catch (Exception)
   {
    if (property == null)
    {
    var replaceValue = propert.GetValue(Root);
    if (replaceValue != null)
     list.Add(Builders<TAggregateRoot>.Update.Set(propert.Name, replaceValue));
    else if (replace)
     list.Add(Builders<TAggregateRoot>.Update.Set(propert.Name, replaceValue));
    }
   }

   }
  }
  if (list.Count > 0)
  {
   var builders = Builders<TAggregateRoot>.Update.Combine(list);
   return (int)collection.UpdateOneAsync(filter, builders).Result.ModifiedCount;
  }
  return 0;
  }
  catch (Exception e)
  {
  throw e;
  }
 }
 #endregion
 #endregion
 }
}

最后在我的仓库中取调用

技术分享

最后把mongodb的脚本文件贴上，欢迎大家给出好的建议，当然有更好的基于.net的mongoDB学习资源推荐给博主。

function HexToBase64(hex) {
 var base64Digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var base64 = "";
 var group;
 for (var i = 0; i < 30; i += 6) {
 group = parseInt(hex.substr(i, 6), 16);
 base64 += base64Digits[(group >> 18) & 0x3f];
 base64 += base64Digits[(group >> 12) & 0x3f];
 base64 += base64Digits[(group >> 6) & 0x3f];
 base64 += base64Digits[group & 0x3f];
 }
 group = parseInt(hex.substr(30, 2), 16);
 base64 += base64Digits[(group >> 2) & 0x3f];
 base64 += base64Digits[(group << 4) & 0x3f];
 base64 += "==";
 return base64;
}

function Base64ToHex(base64) {
 var base64Digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
 var hexDigits = "0123456789abcdef";
 var hex = "";
 for (var i = 0; i < 24;) {
 var e1 = base64Digits.indexOf(base64[i++]);
 var e2 = base64Digits.indexOf(base64[i++]);
 var e3 = base64Digits.indexOf(base64[i++]);
 var e4 = base64Digits.indexOf(base64[i++]);
 var c1 = (e1 << 2) | (e2 >> 4);
 var c2 = ((e2 & 15) << 4) | (e3 >> 2);
 var c3 = ((e3 & 3) << 6) | e4;
 hex += hexDigits[c1 >> 4];
 hex += hexDigits[c1 & 15];
 if (e3 != 64) {
  hex += hexDigits[c2 >> 4];
  hex += hexDigits[c2 & 15];
 }
 if (e4 != 64) {
  hex += hexDigits[c3 >> 4];
  hex += hexDigits[c3 & 15];
 }
 }
 return hex;
}

function UUID(uuid) {
 var hex = uuid.replace(/[{}-]/g, ""); // remove extra characters
 var base64 = HexToBase64(hex);
 return new BinData(4, base64); // new subtype 4
}

function JUUID(uuid) {
 var hex = uuid.replace(/[{}-]/g, ""); // remove extra characters
 var msb = hex.substr(0, 16);
 var lsb = hex.substr(16, 16);
 msb = msb.substr(14, 2) + msb.substr(12, 2) + msb.substr(10, 2) + msb.substr(8, 2) + msb.substr(6, 2) + msb.substr(4, 2) + msb.substr(2, 2) + msb.substr(0, 2);
 lsb = lsb.substr(14, 2) + lsb.substr(12, 2) + lsb.substr(10, 2) + lsb.substr(8, 2) + lsb.substr(6, 2) + lsb.substr(4, 2) + lsb.substr(2, 2) + lsb.substr(0, 2);
 hex = msb + lsb;
 var base64 = HexToBase64(hex);
 return new BinData(3, base64);
}

function CSUUID(uuid) {
 var hex = uuid.replace(/[{}-]/g, ""); // remove extra characters
 var a = hex.substr(6, 2) + hex.substr(4, 2) + hex.substr(2, 2) + hex.substr(0, 2);
 var b = hex.substr(10, 2) + hex.substr(8, 2);
 var c = hex.substr(14, 2) + hex.substr(12, 2);
 var d = hex.substr(16, 16);
 hex = a + b + c + d;
 var base64 = HexToBase64(hex);
 return new BinData(3, base64);
}

function PYUUID(uuid) {
 var hex = uuid.replace(/[{}-]/g, ""); // remove extra characters
 var base64 = HexToBase64(hex);
 return new BinData(3, base64);
}

BinData.prototype.toUUID = function () {
 var hex = Base64ToHex(this.base64()); // don‘t use BinData‘s hex function because it has bugs in older versions of the shell
 var uuid = hex.substr(0, 8) + ‘-‘ + hex.substr(8, 4) + ‘-‘ + hex.substr(12, 4) + ‘-‘ + hex.substr(16, 4) + ‘-‘ + hex.substr(20, 12);
 return ‘UUID("‘ + uuid + ‘")‘;
}

BinData.prototype.toJUUID = function () {
 var hex = Base64ToHex(this.base64()); // don‘t use BinData‘s hex function because it has bugs in older versions of the shell
 var msb = hex.substr(0, 16);
 var lsb = hex.substr(16, 16);
 msb = msb.substr(14, 2) + msb.substr(12, 2) + msb.substr(10, 2) + msb.substr(8, 2) + msb.substr(6, 2) + msb.substr(4, 2) + msb.substr(2, 2) + msb.substr(0, 2);
 lsb = lsb.substr(14, 2) + lsb.substr(12, 2) + lsb.substr(10, 2) + lsb.substr(8, 2) + lsb.substr(6, 2) + lsb.substr(4, 2) + lsb.substr(2, 2) + lsb.substr(0, 2);
 hex = msb + lsb;
 var uuid = hex.substr(0, 8) + ‘-‘ + hex.substr(8, 4) + ‘-‘ + hex.substr(12, 4) + ‘-‘ + hex.substr(16, 4) + ‘-‘ + hex.substr(20, 12);
 return ‘JUUID("‘ + uuid + ‘")‘;
}

BinData.prototype.toCSUUID = function () {
 var hex = Base64ToHex(this.base64()); // don‘t use BinData‘s hex function because it has bugs in older versions of the shell
 var a = hex.substr(6, 2) + hex.substr(4, 2) + hex.substr(2, 2) + hex.substr(0, 2);
 var b = hex.substr(10, 2) + hex.substr(8, 2);
 var c = hex.substr(14, 2) + hex.substr(12, 2);
 var d = hex.substr(16, 16);
 hex = a + b + c + d;
 var uuid = hex.substr(0, 8) + ‘-‘ + hex.substr(8, 4) + ‘-‘ + hex.substr(12, 4) + ‘-‘ + hex.substr(16, 4) + ‘-‘ + hex.substr(20, 12);
 return ‘CSUUID("‘ + uuid + ‘")‘;
}

BinData.prototype.toPYUUID = function () {
 var hex = Base64ToHex(this.base64()); // don‘t use BinData‘s hex function because it has bugs
 var uuid = hex.substr(0, 8) + ‘-‘ + hex.substr(8, 4) + ‘-‘ + hex.substr(12, 4) + ‘-‘ + hex.substr(16, 4) + ‘-‘ + hex.substr(20, 12);
 return ‘PYUUID("‘ + uuid + ‘")‘;
}


BinData.prototype.toHexUUID = function () {
 var hex = Base64ToHex(this.base64()); // don‘t use BinData‘s hex function because it has bugs
 var uuid = hex.substr(0, 8) + ‘-‘ + hex.substr(8, 4) + ‘-‘ + hex.substr(12, 4) + ‘-‘ + hex.substr(16, 4) + ‘-‘ + hex.substr(20, 12);
 return ‘HexData(‘ + this.subtype() + ‘, "‘ + uuid + ‘")‘;
}

在.net下打造mongoDb基于官方驱动最新版本

标签：names bool private 技术 .net top namespace efault sea

热心网友时间：2022-05-02 02:44

可以支持

有很多的mongdb 的驱动程序

网页链接这是nuget 的链接，引用一个就可以用了