目前来说比较.net下最好的bdb操作封装（附单元测试）

  1using System;
  2using System.Collections.Generic;
  3using System.IO;
  4using System.Linq;
  5using System.Runtime.Serialization.Formatters.Binary;
  6using System.Text;
  7using BerkeleyDb;
  8using Component;
  9
 10namespace ToolManager
 11{
 12    public class BDBRecord
 13    {
 14        public object Key { get; set; }
 15        public string Value { get; set; }
 16    }    /**//// <summary>
 17    /// BDB数据库操作类库
 18    /// </summary>
 19    public class BDBHelper
 20    {
 21
 22        private string DBFilePath { get; set; }
 23        private DBStoreType DBType { get; set; }
 24        public enum DBStoreType : byte
 25        {
 26            Auto=1,
 27            Queue,
 28            Hash
 29        }
 30        [Obsolete("该构造函数已废弃 ，请使用BDBHelper(string dbfilePath)")]
 31        public BDBHelper()
 32        {
 33        }
 34
 35        public BDBHelper(string dbfilePath)
 36        {
 37            this.DBFilePath = dbfilePath;
 38        }
 39        [Obsolete("该构造函数已废弃 ，请使用BDBHelper(string dbfilePath)")]
 40        public BDBHelper(string dbfilePath, DBStoreType type)
 41        {
 42            this.DBFilePath = dbfilePath;
 43            this.DBType = type;
 44        }
 45        public BDBRecord FindOne()
 46        {
 47            return this.FindOne(null);
 48        }
 49        public BDBRecord FindOne(Func<object, string, bool> predicate)
 50        {
 51            //Dictionary<string, object> dict = new Dictionary<string, object>();
 52            try
 53            {
 54                Queue格式#region Queue格式
 55                //if (this.DBType == DBStoreType.Queue)
 56                //{
 57                using (Db db = new Db(DbCreateFlags.None))
 58                {
 59                    db.RecLen = 5000;
 60                    db.RecPad = '.';
 61                    DbQueue file = (DbQueue)db.Open(null, this.DBFilePath, null, DbType.Queue, Db.OpenFlags.Create, 0);
 62                    using (DbQueueCursor cursor = file.OpenCursor(null, DbFileCursor.CreateFlags.None))
 63                    {
 64                        foreach (KeyDataPair kvp in cursor)
 65                        {
 66                            BinaryFormatter bf = new BinaryFormatter();
 67                            MemoryStream stream = new MemoryStream();
 68                            stream.Write(kvp.Data.Buffer, 0, kvp.Data.Size);
 69                            stream.Seek(0, SeekOrigin.Begin);
 70                            string k = BitConverter.ToInt32(kvp.Key.Buffer, 0).ToString();
 71                            object v = bf.Deserialize(stream);
 72                            if (predicate == null)
 73                            {
 74                                return new BDBRecord() { Key = v, Value = k };
 75                            }
 76                            else if (predicate(v, k))
 77                            {
 78                                return new BDBRecord() { Key = v, Value = k };
 79                            }
 80                        }
 81                    }
 82                }
 83                //}
 84                #endregion
 85            }
 86            catch (Exception ex)
 87            {
 88                Hash格式#region Hash格式
 89                //else if(this.DBType==DBStoreType.Hash)
 90                //{
 91                //遍历数据
 92                using (Db db = new Db(DbCreateFlags.None))
 93                {
 94                    //这里如果应用Db.OpenFlags.Create则在启动后会覆盖同名文件，并新建同名文件
 95                    //Db.OpenFlags.Truncate会清空数据库
 96                    DbHash dbf = (DbHash)db.Open(null, this.DBFilePath, null, DbType.Hash,
 97        Db.OpenFlags.ThreadSafe, 0);
 98
 99                    using (DbHashCursor cursor = dbf.OpenCursor(null, DbFileCursor.CreateFlags.None))
                    {
                        foreach (KeyDataPair kvp in cursor)
                        {
                            BinaryFormatter bf = new BinaryFormatter();
                            MemoryStream stream = new MemoryStream();
                            stream.Write(kvp.Data.Buffer, 0, kvp.Data.Size);
                            stream.Seek(0, SeekOrigin.Begin);
                            string k = Encoding.UTF8.GetString(kvp.Key.Buffer, 0, kvp.Key.Size);
                            object v = bf.Deserialize(stream);
                            if (predicate == null)
                            {
                                return new BDBRecord() { Key = v, Value = k };
                            }
                            else if (predicate(v, k))
                            {
                                return new BDBRecord() { Key = v, Value = k };
                            }
                        }
                    }
                }
                #endregion
                //}
            }
            //return dict;
            return null;
        }
        public Dictionary<object, string> FindAll(Func<object, string, bool> predicate)
        {

            Dictionary<object, string> dict = new Dictionary<object, string>();
            try
            {
                Queue格式#region Queue格式
                //if (this.DBType == DBStoreType.Queue)
                //{
                using (Db db = new Db(DbCreateFlags.None))
                {
                    db.RecLen = 5000;
                    db.RecPad = '.';
                    DbQueue file = (DbQueue)db.Open(null, this.DBFilePath, null, DbType.Queue, Db.OpenFlags.Create, 0);
                    using (DbQueueCursor cursor = file.OpenCursor(null, DbFileCursor.CreateFlags.None))
                    {
                        foreach (KeyDataPair kvp in cursor)
                        {
                            _Do2(kvp, predicate, dict);
                        }
                    }
                }
                //}
                #endregion
            }
            catch (Exception ex)
            {
                Hash格式#region Hash格式
                //else if(this.DBType==DBStoreType.Hash)
                //{
                //遍历数据
                using (Db db = new Db(DbCreateFlags.None))
                {
                    //这里如果应用Db.OpenFlags.Create则在启动后会覆盖同名文件，并新建同名文件
                    //Db.OpenFlags.Truncate会清空数据库
                    DbHash dbf = (DbHash)db.Open(null, this.DBFilePath, null, DbType.Hash,
        Db.OpenFlags.ThreadSafe, 0);

                    using (DbHashCursor cursor = dbf.OpenCursor(null, DbFileCursor.CreateFlags.None))
                    {
                        foreach (KeyDataPair kdp in cursor)
                        {
                            _Do(kdp, predicate, dict);
                        }
                    }
                }
                #endregion
                //}
            }
            return dict;
        }
        public Dictionary<object, string> FindAll()
        {
            //either below works fine
            //return this.FindAll((s, o) => true);
            return this.FindAll(null);
        }
        private static void _Do(KeyDataPair kvp, Func<object, string, bool> predicate, Dictionary<object, string> result)
        {
            BinaryFormatter bf = new BinaryFormatter();
            MemoryStream stream = new MemoryStream();
            stream.Write(kvp.Data.Buffer, 0, kvp.Data.Size);
            stream.Seek(0, SeekOrigin.Begin);
            string k = Encoding.UTF8.GetString(kvp.Key.Buffer, 0, kvp.Key.Size);
            object v = bf.Deserialize(stream);
            if (predicate == null)
            {
                result.Add(v, k);
            }
            else if (predicate(v, k))
            {
                result.Add(v, k);
            }
        }
        private static void _Do2(KeyDataPair kvp, Func<object, string, bool> predicate, Dictionary<object, string> result)
        {
            BinaryFormatter bf = new BinaryFormatter();
            MemoryStream stream = new MemoryStream();
            stream.Write(kvp.Data.Buffer, 0, kvp.Data.Size);
            stream.Seek(0, SeekOrigin.Begin);
            string k = BitConverter.ToInt32(kvp.Key.Buffer, 0).ToString();
            object v = bf.Deserialize(stream);
            if (predicate == null)
            {
                result.Add(v, k);
            }
            else if (predicate(v, k))
            {
                result.Add(v, k);
            }
        }
        /**//// <summary>
        /// 更新数据库中的数据
        /// </summary>
        /// <param name="predicate">execute condition</param>
        /// <param name="isMatchOnlyOnce">is match only once</param>
        /// <returns>effect records</returns>
        public int UpdateInQueueMode(Func<int, object, bool> predicate, object value,bool isMatchOnlyOnce)
        {
                 int count = 0;
                 if (predicate == null)
                     return 0;
               //遍历数据
                using (Db db = new Db(DbCreateFlags.None))
                {
                    db.RecLen = 5000;
                    db.RecPad = '.';
                    //这里如果应用Db.OpenFlags.Create则在启动后会覆盖同名文件，并新建同名文件
                    //Db.OpenFlags.Truncate会清空数据库
                    DbQueue dbf = (DbQueue)db.Open(null, this.DBFilePath, null, DbType.Queue,
        Db.OpenFlags.ThreadSafe|Db.OpenFlags.Create, 0);

                    using (DbQueueCursor cursor = dbf.OpenCursor(null, DbFileCursor.CreateFlags.None))
                    {
                        BinaryFormatter bf = new BinaryFormatter();
                        MemoryStream stream = new MemoryStream();
                        foreach (KeyDataPair kdp in cursor)
                        {
                            int k = BitConverter.ToInt32(kdp.Key.Buffer, 0);
                            Console.WriteLine("k={0}", k.ToString());
                            stream.SetLength(0);
                            stream.Position = 0;
                            stream.Write(kdp.Data.Buffer, 0, kdp.Data.Size);
                            stream.Seek(0, SeekOrigin.Begin);
                            object v = bf.Deserialize(stream);
                            if(predicate(k,v))
                            {
                                count++;
                                //string d = Encoding.UTF8.GetString(kdp.Data.Buffer, 0, kdp.Data.Size);
                                //如何读取Queue类型的主键值


                                //Console.WriteLine("{0},{1}", p2.State, p2.Os);
                                //p2.Os = "changed";
                                //stream = new MemoryStream();
                                stream.Position = 0;
                                stream.SetLength(0);
                                bf.Serialize(stream, value);
                                DbEntry data = DbEntry.InOut(stream.ToArray());
                                cursor.Put(ref data);
                                if (isMatchOnlyOnce)
                                {
                                    stream.Close();
                                    return count;
                                }
                            }
                        }
                            stream.Close();
                    }
            }
            return count;
        }

        public void CreateInQueueMode(object value)
        {
            Db PC = new Db(DbCreateFlags.None);
            PC.RecLen = 5000;
            PC.RecPad = '.';
            DbQueue file = (DbQueue)PC.Open(null, this.DBFilePath, null, DbType.Queue, Db.OpenFlags.Create|Db.OpenFlags.ThreadSafe, 0);
            //CreateSecondaryDB(file,"Id.PCs.s",new DbFile.KeyGeneratorFcn(Common.Id));
            //CreateSecondaryDB(file, "Id.PCs.s", new DbFile.KeyGeneratorFcn(Common.Id));
            //由于数据量不是很大，不考虑使用二级数据库，直接使用游标操作，降低复杂度
            //首先遍历数据库看有没有已经存在，如果没有，则添加一个，如果有，改变其状态
            BinaryFormatter bf = new BinaryFormatter();
            MemoryStream stream= new MemoryStream();
            bf.Serialize(stream, value);
            DbEntry k = DbEntry.Out(new byte[1024]);
            DbEntry data = DbEntry.InOut(stream.ToArray());
            file.Append(null, ref k, ref data);
            stream.Close();
            file.Sync();
            PC.Close();
        }
        public int DeleteInQueueMode(Func<int, object, bool> predicate,bool isMatchOnlyOnce)
        {
            int count = 0;
            if (predicate == null)
                return 0;
            //遍历数据
            using (Db db = new Db(DbCreateFlags.None))
            {
                db.RecLen = 5000;
                db.RecPad = '.';
                //这里如果应用Db.OpenFlags.Create则在启动后会覆盖同名文件，并新建同名文件
                //Db.OpenFlags.Truncate会清空数据库
                DbQueue dbf = (DbQueue)db.Open(null, this.DBFilePath, null, DbType.Queue,
    Db.OpenFlags.ThreadSafe|Db.OpenFlags.Create, 0);

                using (DbQueueCursor cursor = dbf.OpenCursor(null, DbFileCursor.CreateFlags.None))
                {
                    BinaryFormatter bf = new BinaryFormatter();
                    MemoryStream stream = new MemoryStream();
                    foreach (KeyDataPair kdp in cursor)
                    {
                        int k = BitConverter.ToInt32(kdp.Key.Buffer, 0);
                        Console.WriteLine("k={0}", k.ToString());
                        stream.SetLength(0);
                        stream.Position = 0;
                        stream.Write(kdp.Data.Buffer, 0, kdp.Data.Size);
                        stream.Seek(0, SeekOrigin.Begin);
                        object v = bf.Deserialize(stream);
                        if (predicate(k, v))
                        {
                            count++;
                            //string d = Encoding.UTF8.GetString(kdp.Data.Buffer, 0, kdp.Data.Size);
                            //如何读取Queue类型的主键值


                            //Console.WriteLine("{0},{1}", p2.State, p2.Os);
                            //p2.Os = "changed";
                            //stream = new MemoryStream();
                            //stream.Position = 0;
                            //stream.SetLength(0);
                            //bf.Serialize(stream, v);
                            //DbEntry data = DbEntry.InOut(stream.ToArray());
                            //cursor.Put(ref data);
                            cursor.Delete();
                            if (isMatchOnlyOnce)
                            {
                                stream.Close();
                                return count;
                            }
                        }
                    }stream.Close();
                }
            }
            return count;
        }

        /**//// <summary>
        /// 用于向支持重复键值的数据库文件添加数据
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void CreateInHashModeWithDup(string key,object value)
        {
            //这里只是更新了一条记录，更新多条同key的情况没有考虑
            Db db = new Db(DbCreateFlags.None);
            db.SetFlags(DbFlags.Dup);
            DbFile dbf = db.Open(null, this.DBFilePath, null, DbType.Hash, Db.OpenFlags.Create|Db.OpenFlags.ThreadSafe, 0);
            MemoryStream stream = new MemoryStream();
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.Serialize(stream, value);
            DbEntry _key = DbEntry.InOut(Encoding.UTF8.GetBytes(key));
            DbEntry _data = DbEntry.InOut(stream.ToArray());
            if (dbf.Put(null, ref _key, ref _data) != 0)
                Console.Write("{0}:输入错误", key);
            stream.Close();
            dbf.Sync();//数据更新 
            db.Close();
        }
        /**//// <summary>
        /// 默认方式，如果已有键则进行更新操作
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void CreateOrUpdateInHashModeWithoutDup(string key,object value)
        {
            //这里只是更新了一条记录，更新多条同key的情况没有考虑
            Db db = new Db(DbCreateFlags.None);
            //db.SetFlags(DbFlags.Dup);
            DbFile dbf = db.Open(null, this.DBFilePath, null, DbType.Hash, Db.OpenFlags.Create|Db.OpenFlags.ThreadSafe, 0);
            MemoryStream stream = new MemoryStream();
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.Serialize(stream, value);
            DbEntry _key = DbEntry.InOut(Encoding.UTF8.GetBytes(key));
            DbEntry _data = DbEntry.InOut(stream.ToArray());
            if (dbf.Put(null, ref _key, ref _data) != 0)
                Console.Write("{0}:输入错误", key);
            stream.Close();
            dbf.Sync();//数据更新 
            db.Close();
        }
        public int UpdateInHashMode(Func<string,object,bool> predicate,object value,bool isMatchOnlyOnce)
        {
            int count = 0;
            if (predicate == null)
                return count;
           //遍历数据
            using (Db db = new Db(DbCreateFlags.None))
            {
                //这里如果应用Db.OpenFlags.Create则在启动后会覆盖同名文件，并新建同名文件
                //Db.OpenFlags.Truncate会清空数据库
                DbHash dbf = (DbHash)db.Open(null, this.DBFilePath, null, DbType.Hash,
    Db.OpenFlags.ThreadSafe|Db.OpenFlags.Create, 0);

                using (DbHashCursor cursor = dbf.OpenCursor(null, DbFileCursor.CreateFlags.None))
                {
                    BinaryFormatter bf = new BinaryFormatter();
                    MemoryStream stream = new MemoryStream();
                   foreach (KeyDataPair kvp in cursor)
                    {
                        stream.SetLength(0);
                        stream.Position = 0; 
                        stream.Write(kvp.Data.Buffer, 0, kvp.Data.Size);
                        stream.Seek(0, SeekOrigin.Begin);
                        string k = Encoding.UTF8.GetString(kvp.Key.Buffer, 0, kvp.Key.Size);
                        object v = bf.Deserialize(stream);
                        if (predicate(k, v))
                        {
                            count++;
                            stream.SetLength(0);
                            stream.Position = 0;
                            bf.Serialize(stream, value);
                            DbEntry data = DbEntry.InOut(stream.ToArray());
                            cursor.Put(ref data, DbKeyCursor<DbHashCursor, DbHash>.PutMode.Current);
                            if (isMatchOnlyOnce)
                            {
                                stream.Close();
                                return count;
                            }
                        }
                    }
                    stream.Close();
                }
            }
            return count;
        }
        public int DeleteInHashMode(Func<string,object,bool> predicate,bool isMatchOnlyOnce)
        {
            int count = 0;
            if (predicate == null)
                return count;
            //遍历数据
            using (Db db = new Db(DbCreateFlags.None))
            {
                //这里如果应用Db.OpenFlags.Create则在启动后会覆盖同名文件，并新建同名文件
                //Db.OpenFlags.Truncate会清空数据库
                DbHash dbf = (DbHash)db.Open(null, this.DBFilePath, null, DbType.Hash,
    Db.OpenFlags.ThreadSafe|Db.OpenFlags.Create, 0);

                using (DbHashCursor cursor = dbf.OpenCursor(null, DbFileCursor.CreateFlags.None))
                {
                    BinaryFormatter bf = new BinaryFormatter();
                    MemoryStream stream = new MemoryStream();
                    foreach (KeyDataPair kvp in cursor)
                    {
                        stream.SetLength(0);
                        stream.Position = 0;
                        stream.Write(kvp.Data.Buffer, 0, kvp.Data.Size);
                        stream.Seek(0, SeekOrigin.Begin);
                        string k = Encoding.UTF8.GetString(kvp.Key.Buffer, 0, kvp.Key.Size);
                        object v = bf.Deserialize(stream);
                        if (predicate(k, v))
                        {
                            count++;
                            cursor.Delete();
                            if (isMatchOnlyOnce)
                            {
                                stream.Close();
                                return count;
                            }
                        }
                    }
                    stream.Close();
                }
            }
            return count;
        }
    }
}

unit test code

  1using System;
  2using System.Collections.Generic;
  3using System.Linq;
  4using System.Text;
  5using Component;
  6using MbUnit.Framework;
  7
  8namespace ToolManager.Test
  9{
 10    [TestFixture]
 11    class BDBHelperTest2
 12    {
 13        hash mode unit test#region hash mode unit test
 14        [Row("1")]
 15        [Row("2")]
 16        [Row("1")]
 17        [RowTest]
 18        public void CreateInHashModeWithDupTest(string key)
 19        {
 20            BDBHelper bdb = new BDBHelper("zzzzzzzzzzzzzzzzzzz.p",BDBHelper.DBStoreType.Auto);
 21            UrlConfig config=new UrlConfig()
 22                                 {
 23                                     Url="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz",
 24                                     CreatedOn=DateTime.Now
 25                                 };
 26            bdb.CreateInHashModeWithDup(key,config);
 27        }
 28        //[Row("2")]
 29        //[Row("1")]
 30        [Row("2")]
 31        [Row("3")]
 32        [RowTest]
 33        public void CreateOrUpdateInHashModeWithoutDup(string key)
 34        {
 35            BDBHelper bdb = new BDBHelper("222222222.p", BDBHelper.DBStoreType.Auto);
 36            UrlConfig config = new UrlConfig()
 37            {
 38                Url = "ccccccccccc",
 39                CreatedOn = DateTime.Now
 40            };
 41            bdb.CreateOrUpdateInHashModeWithoutDup(key, config);
 42        }
 43        [Test]
 44        public void UpdateInHashModeTest()
 45        {
 46            UrlConfig config = new UrlConfig()
 47            {
 48                Url = "dddddddeeeeee",
 49                CreatedOn = DateTime.Now
 50            };
 51            BDBHelper bdb = new BDBHelper("222222222.p", BDBHelper.DBStoreType.Auto);
 52            int actual=bdb.UpdateInHashMode((a, b) => (b as UrlConfig).Url.Equals("ccccccccccc"), config, false);
 53            Assert.AreEqual(2,actual);
 54        }
 55        [Test]
 56        public void DeleteInHashModeTest()
 57        {
 58            UrlConfig config = new UrlConfig()
 59            {
 60                Url = "dddddddeeeeee",
 61                CreatedOn = DateTime.Now
 62            };
 63            BDBHelper bdb = new BDBHelper("222222222.p", BDBHelper.DBStoreType.Auto);
 64            int actual = bdb.DeleteInHashMode((a, b) => (b as UrlConfig).Url.Equals("ccccccccccc"), false);
 65            Assert.AreEqual(2,actual);
 66        }
 67        
 68        #endregion
 69
 70        queue mode unit test#region queue mode unit test
 71        [RepeatTest(5)]
 72        public void CreateInQueueModeTest()
 73        {
 74            UrlConfig config = new UrlConfig()
 75                                   {
 76                                       Url="www.bjut.edu.cn",
 77                                       ModifiedOn=DateTime.Now
 78                                   };
 79            BDBHelper bdb = new BDBHelper("CreateInQueueModeTest.p", BDBHelper.DBStoreType.Auto);
 80            bdb.CreateInQueueMode(config);
 81        }
 82        [Test]
 83        public void UpdateInQueueModeTest()
 84        {
 85            UrlConfig config = new UrlConfig()
 86            {
 87                Url = "www.maolz.com",
 88                ModifiedOn = DateTime.Now
 89            };
 90            BDBHelper bdb = new BDBHelper("CreateInQueueModeTest.p", BDBHelper.DBStoreType.Auto);
 91            int actual=bdb.UpdateInQueueMode((a, b) => a >10, config, false);
 92            Assert.AreEqual(1,actual);
 93        }
 94        [Test]
 95        public void DeleteInQueueModeTest()
 96        {
 97            BDBHelper bdb = new BDBHelper("CreateInQueueModeTest.pddd", BDBHelper.DBStoreType.Auto);
 98            int actual=bdb.DeleteInQueueMode((a, b) => a > 8, false);
 99            Assert.AreEqual(0,actual);
        }

        #endregion

    }
}