zoukankan      html  css  js  c++  java
  • Mongodb使用基础-Mongodb.Driver操作MongoDB

    上一篇博客主要介绍了MongoDB和它的的使用场景,这篇文章主要介绍一下如何用C#如何借助官方的Mongodb.Driver操作MongoDB

    1.NuGet引入Mongodb.Dirver

    安装后项目中会新增如下dll

    MongoDB.Driver.dll:顾名思义,驱动程序

    MongoDB.Bson.dll:序列化、Json相关

    2.初始化集合,子类需重写集合名

            #region 构造函数
            /// <summary>
            /// 集合
            /// </summary>
            public string _collName { get; set; }
            public MongoBaseRepository(string collName)
            {
                this._collName = collName;
            }
            #endregion
    View Code

    3..初始化链接和数据库

    #region 连接配置
            /// <summary>
            /// 链接
            /// </summary>
            private static readonly string conneStr = "mongodb://127.0.0.1:27017";
            /// <summary>
            /// 数据库
            /// </summary>
            private static readonly string dbName = "TestDb";
            #endregion
    
            #region 单例创建链接
            private static IMongoClient _mongoclient { get; set; }
            private static IMongoClient CreateClient()
            {
                if (_mongoclient == null)
                {
                    _mongoclient = new MongoClient(conneStr);
                }
                return _mongoclient;
            }
            #endregion
    
            #region 获取链接和数据库
    
            private IMongoClient client = CreateClient();
            public IMongoDatabase _database { get { return _mongoclient.GetDatabase(dbName); } }
    
            public IMongoDatabase GetDatabase()
            {
                return _database;
            }
            public IMongoCollection<T> GetClient<T>() where T : class, new()
            {
                return _database.GetCollection<T>(_collName);
            }
            #endregion
    View Code

    4.操作

    Add:

     #region +Add 添加一条数据
            /// <summary>
            /// 添加一条数据
            /// </summary>
            /// <param name="t">添加的实体</param>
            /// <param name="host">mongodb连接信息</param>
            /// <returns></returns>
            public int Add<T>(T t) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    client.InsertOne(t);
                    return 1;
                }
                catch (Exception ex)
                {
                    return 0;
                }
            }
            #endregion
    
            #region +AddAsync 异步添加一条数据
            /// <summary>
            /// 异步添加一条数据
            /// </summary>
            /// <param name="t">添加的实体</param>
            /// <param name="host">mongodb连接信息</param>
            /// <returns></returns>
            public async Task<int> AddAsync<T>(T t) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    await client.InsertOneAsync(t);
                    return 1;
                }
                catch
                {
                    return 0;
                }
            }
            #endregion
    
            #region +InsertMany 批量插入
            /// <summary>
            /// 批量插入
            /// </summary>
            /// <param name="host">mongodb连接信息</param>
            /// <param name="t">实体集合</param>
            /// <returns></returns>
            public int InsertMany<T>(List<T> t) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    client.InsertMany(t);
                    return 1;
                }
                catch (Exception ex)
                {
                    return 0;
                }
            }
            #endregion
    
            #region +InsertManyAsync 异步批量插入
            /// <summary>
            /// 异步批量插入
            /// </summary>
            /// <param name="host">mongodb连接信息</param>
            /// <param name="t">实体集合</param>
            /// <returns></returns>
            public async Task<int> InsertManyAsync<T>(List<T> t) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    await client.InsertManyAsync(t);
                    return 1;
                }
                catch
                {
                    return 0;
                }
            }
            #endregion
    View Code

    Modify:

      #region +Update 修改一条数据
            /// <summary>
            /// 修改一条数据
            /// </summary>
            /// <param name="t">添加的实体</param>
            /// <param name="host">mongodb连接信息</param>
            /// <returns></returns>
            public UpdateResult Update<T>(T t, string id, bool isObjectId = true) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    //修改条件
                    FilterDefinition<T> filter;
                    if (isObjectId)
                    {
                        filter = Builders<T>.Filter.Eq("_id", new ObjectId(id));
                    }
                    else
                    {
                        filter = Builders<T>.Filter.Eq("_id", id);
                    }
                    //要修改的字段
                    var list = new List<UpdateDefinition<T>>();
                    foreach (var item in t.GetType().GetProperties())
                    {
                        if (item.Name.ToLower() == "id") continue;
                        list.Add(Builders<T>.Update.Set(item.Name, item.GetValue(t)));
                    }
                    var updatefilter = Builders<T>.Update.Combine(list);
                    return client.UpdateOne(filter, updatefilter);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region +UpdateAsync 异步修改一条数据
            /// <summary>
            /// 异步修改一条数据
            /// </summary>
            /// <param name="t">添加的实体</param>
            /// <param name="host">mongodb连接信息</param>
            /// <returns></returns>
            public async Task<UpdateResult> UpdateAsync<T>(T t, string id, bool isObjectId) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    //修改条件
                    FilterDefinition<T> filter;
                    if (isObjectId)
                    {
                        filter = Builders<T>.Filter.Eq("_id", new ObjectId(id));
                    }
                    else
                    {
                        filter = Builders<T>.Filter.Eq("_id", id);
                    }
                    //要修改的字段
                    var list = new List<UpdateDefinition<T>>();
                    foreach (var item in t.GetType().GetProperties())
                    {
                        if (item.Name.ToLower() == "id") continue;
                        list.Add(Builders<T>.Update.Set(item.Name, item.GetValue(t)));
                    }
                    var updatefilter = Builders<T>.Update.Combine(list);
                    return await client.UpdateOneAsync(filter, updatefilter);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region +UpdateManay 批量修改数据
            /// <summary>
            /// 批量修改数据
            /// </summary>
            /// <param name="dic">要修改的字段</param>
            /// <param name="host">mongodb连接信息</param>
            /// <param name="filter">修改条件</param>
            /// <returns></returns>
            public UpdateResult UpdateManay<T>(Dictionary<string, string> dic, FilterDefinition<T> filter) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    T t = new T();
                    //要修改的字段
                    var list = new List<UpdateDefinition<T>>();
                    foreach (var item in t.GetType().GetProperties())
                    {
                        if (!dic.ContainsKey(item.Name)) continue;
                        var value = dic[item.Name];
                        list.Add(Builders<T>.Update.Set(item.Name, value));
                    }
                    var updatefilter = Builders<T>.Update.Combine(list);
                    return client.UpdateMany(filter, updatefilter);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region +UpdateManayAsync 异步批量修改数据
            /// <summary>
            /// 异步批量修改数据
            /// </summary>
            /// <param name="dic">要修改的字段</param>
            /// <param name="host">mongodb连接信息</param>
            /// <param name="filter">修改条件</param>
            /// <returns></returns>
            public async Task<UpdateResult> UpdateManayAsync<T>(Dictionary<string, string> dic, FilterDefinition<T> filter) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    T t = new T();
                    //要修改的字段
                    var list = new List<UpdateDefinition<T>>();
                    foreach (var item in t.GetType().GetProperties())
                    {
                        if (!dic.ContainsKey(item.Name)) continue;
                        var value = dic[item.Name];
                        list.Add(Builders<T>.Update.Set(item.Name, value));
                    }
                    var updatefilter = Builders<T>.Update.Combine(list);
                    return await client.UpdateManyAsync(filter, updatefilter);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    View Code

    Remove:

     #region Delete 删除一条数据
            /// <summary>
            /// 删除一条数据
            /// </summary>
            /// <param name="host">mongodb连接信息</param>
            /// <param name="id">objectId</param>
            /// <returns></returns>
            public DeleteResult Delete<T>(string id, bool isObjectId = true) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    FilterDefinition<T> filter;
                    if (isObjectId)
                    {
                        filter = Builders<T>.Filter.Eq("_id", new ObjectId(id));
                    }
                    else
                    {
                        filter = Builders<T>.Filter.Eq("_id", id);
                    }
                    return client.DeleteOne(filter);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
    
            }
            #endregion
    
            #region DeleteAsync 异步删除一条数据
            /// <summary>
            /// 异步删除一条数据
            /// </summary>
            /// <param name="host">mongodb连接信息</param>
            /// <param name="id">objectId</param>
            /// <returns></returns>
            public async Task<DeleteResult> DeleteAsync<T>(string id, bool isObjectId = true) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    //修改条件
                    FilterDefinition<T> filter;
                    if (isObjectId)
                    {
                        filter = Builders<T>.Filter.Eq("_id", new ObjectId(id));
                    }
                    else
                    {
                        filter = Builders<T>.Filter.Eq("_id", id);
                    }
                    return await client.DeleteOneAsync(filter);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
    
            }
            #endregion
    
            #region DeleteMany 删除多条数据
            /// <summary>
            /// 删除一条数据
            /// </summary>
            /// <param name="host">mongodb连接信息</param>
            /// <param name="filter">删除的条件</param>
            /// <returns></returns>
            public DeleteResult DeleteMany<T>(FilterDefinition<T> filter) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    return client.DeleteMany(filter);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
    
            }
            #endregion
    
            #region DeleteManyAsync 异步删除多条数据
            /// <summary>
            /// 异步删除多条数据
            /// </summary>
            /// <param name="host">mongodb连接信息</param>
            /// <param name="filter">删除的条件</param>
            /// <returns></returns>
            public async Task<DeleteResult> DeleteManyAsync<T>(FilterDefinition<T> filter) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    return await client.DeleteManyAsync(filter);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
    
            }
            #endregion
    View Code

    Find:

     #region FindOne 根据id查询一条数据
            /// <summary>
            /// 根据id查询一条数据
            /// </summary>
            /// <param name="host">mongodb连接信息</param>
            /// <param name="id">objectid</param>
            /// <param name="field">要查询的字段,不写时查询全部</param>
            /// <returns></returns>
            public T FindOne<T>(string id, bool isObjectId = true, string[] field = null) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    FilterDefinition<T> filter;
                    if (isObjectId)
                    {
                        filter = Builders<T>.Filter.Eq("_id", new ObjectId(id));
                    }
                    else
                    {
                        filter = Builders<T>.Filter.Eq("_id", id);
                    }
                    //不指定查询字段
                    if (field == null || field.Length == 0)
                    {
                        return client.Find(filter).FirstOrDefault<T>();
                    }
    
                    //制定查询字段
                    var fieldList = new List<ProjectionDefinition<T>>();
                    for (int i = 0; i < field.Length; i++)
                    {
                        fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));
                    }
                    var projection = Builders<T>.Projection.Combine(fieldList);
                    fieldList?.Clear();
                    return client.Find(filter).Project<T>(projection).FirstOrDefault<T>();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region FindOneAsync 异步根据id查询一条数据
            /// <summary>
            /// 异步根据id查询一条数据
            /// </summary>
            /// <param name="host">mongodb连接信息</param>
            /// <param name="id">objectid</param>
            /// <returns></returns>
            public async Task<T> FindOneAsync<T>(string id, bool isObjectId = true, string[] field = null) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    FilterDefinition<T> filter;
                    if (isObjectId)
                    {
                        filter = Builders<T>.Filter.Eq("_id", new ObjectId(id));
                    }
                    else
                    {
                        filter = Builders<T>.Filter.Eq("_id", id);
                    }
    
                    //不指定查询字段
                    if (field == null || field.Length == 0)
                    {
                        return await client.Find(filter).FirstOrDefaultAsync();
                    }
    
                    //制定查询字段
                    var fieldList = new List<ProjectionDefinition<T>>();
                    for (int i = 0; i < field.Length; i++)
                    {
                        fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));
                    }
                    var projection = Builders<T>.Projection.Combine(fieldList);
                    fieldList?.Clear();
                    return await client.Find(filter).Project<T>(projection).FirstOrDefaultAsync();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region FindList 查询集合
            /// <summary>
            /// 查询集合
            /// </summary>
            /// <param name="host">mongodb连接信息</param>
            /// <param name="filter">查询条件</param>
            /// <param name="field">要查询的字段,不写时查询全部</param>
            /// <param name="sort">要排序的字段</param>
            /// <returns></returns>
            public List<T> FindList<T>(FilterDefinition<T> filter, string[] field = null, SortDefinition<T> sort = null) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    //不指定查询字段
                    if (field == null || field.Length == 0)
                    {
                        if (sort == null) return client.Find(filter).ToList();
                        //进行排序
                        return client.Find(filter).Sort(sort).ToList();
                    }
    
                    //制定查询字段
                    var fieldList = new List<ProjectionDefinition<T>>();
                    for (int i = 0; i < field.Length; i++)
                    {
                        fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));
                    }
                    var projection = Builders<T>.Projection.Combine(fieldList);
                    fieldList?.Clear();
                    if (sort == null) return client.Find(filter).Project<T>(projection).ToList();
                    //排序查询
                    return client.Find(filter).Sort(sort).Project<T>(projection).ToList();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region FindListAsync 异步查询集合
            /// <summary>
            /// 异步查询集合
            /// </summary>
            /// <param name="host">mongodb连接信息</param>
            /// <param name="filter">查询条件</param>
            /// <param name="field">要查询的字段,不写时查询全部</param>
            /// <param name="sort">要排序的字段</param>
            /// <returns></returns>
            public async Task<List<T>> FindListAsync<T>(FilterDefinition<T> filter, string[] field = null, SortDefinition<T> sort = null) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    //不指定查询字段
                    if (field == null || field.Length == 0)
                    {
                        if (sort == null) return await client.Find(filter).ToListAsync();
                        return await client.Find(filter).Sort(sort).ToListAsync();
                    }
    
                    //制定查询字段
                    var fieldList = new List<ProjectionDefinition<T>>();
                    for (int i = 0; i < field.Length; i++)
                    {
                        fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));
                    }
                    var projection = Builders<T>.Projection.Combine(fieldList);
                    fieldList?.Clear();
                    if (sort == null) return await client.Find(filter).Project<T>(projection).ToListAsync();
                    //排序查询
                    return await client.Find(filter).Sort(sort).Project<T>(projection).ToListAsync();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region FindListByPage 分页查询集合
            /// <summary>
            /// 分页查询集合
            /// </summary>
            /// <param name="host">mongodb连接信息</param>
            /// <param name="filter">查询条件</param>
            /// <param name="pageIndex">当前页</param>
            /// <param name="pageSize">页容量</param>
            /// <param name="count">总条数</param>
            /// <param name="field">要查询的字段,不写时查询全部</param>
            /// <param name="sort">要排序的字段</param>
            /// <returns></returns>
            public List<T> FindListByPage<T>(FilterDefinition<T> filter, int pageIndex, int pageSize, out long count, string[] field = null, SortDefinition<T> sort = null) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    count = client.CountDocuments(filter);
                    //不指定查询字段
                    if (field == null || field.Length == 0)
                    {
                        if (sort == null) return client.Find(filter).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
                        //进行排序
                        return client.Find(filter).Sort(sort).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
                    }
    
                    //制定查询字段
                    var fieldList = new List<ProjectionDefinition<T>>();
                    for (int i = 0; i < field.Length; i++)
                    {
                        fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));
                    }
                    var projection = Builders<T>.Projection.Combine(fieldList);
                    fieldList?.Clear();
    
                    //不排序
                    if (sort == null) return client.Find(filter).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
    
                    //排序查询
                    return client.Find(filter).Sort(sort).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
    
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region FindListByPageAsync 异步分页查询集合
            /// <summary>
            /// 异步分页查询集合
            /// </summary>
            /// <param name="host">mongodb连接信息</param>
            /// <param name="filter">查询条件</param>
            /// <param name="pageIndex">当前页</param>
            /// <param name="pageSize">页容量</param>
            /// <param name="field">要查询的字段,不写时查询全部</param>
            /// <param name="sort">要排序的字段</param>
            /// <returns></returns>
            public async Task<List<T>> FindListByPageAsync<T>(FilterDefinition<T> filter, int pageIndex, int pageSize, string[] field = null, SortDefinition<T> sort = null) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    //不指定查询字段
                    if (field == null || field.Length == 0)
                    {
                        if (sort == null) return await client.Find(filter).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();
                        //进行排序
                        return await client.Find(filter).Sort(sort).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();
                    }
    
                    //制定查询字段
                    var fieldList = new List<ProjectionDefinition<T>>();
                    for (int i = 0; i < field.Length; i++)
                    {
                        fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));
                    }
                    var projection = Builders<T>.Projection.Combine(fieldList);
                    fieldList?.Clear();
    
                    //不排序
                    if (sort == null) return await client.Find(filter).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();
    
                    //排序查询
                    return await client.Find(filter).Sort(sort).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();
    
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    View Code

    Count:

            #region Count 根据条件获取总数
            /// <summary>
            /// 根据条件获取总数
            /// </summary>
            /// <param name="host">mongodb连接信息</param>
            /// <param name="filter">条件</param>
            /// <returns></returns>
            public long Count<T>(FilterDefinition<T> filter) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    return client.CountDocuments(filter);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region CountAsync 异步根据条件获取总数
            /// <summary>
            /// 异步根据条件获取总数
            /// </summary>
            /// <param name="host">mongodb连接信息</param>
            /// <param name="filter">条件</param>
            /// <returns></returns>
            public async Task<long> CountAsync<T>( FilterDefinition<T> filter) where T : class, new()
            {
                try
                {
                    var client = _database.GetCollection<T>(_collName);
                    return await client.CountDocumentsAsync(filter);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    View Code

    查询实例:

            public async Task<IList<Messages>> MyMessage(BaseCondition condition)
            {
                //根据时间排序
                var sort = Builders<Messages>.Sort.Ascending("State");
                var list = new List<FilterDefinition<Messages>>();
                list.Add(Builders<Messages>.Filter.Eq("ReciveCode","admin"));
                //>开始时间 <结束时间
                if (!string.IsNullOrEmpty(condition.startTime) && !string.IsNullOrEmpty(condition.endTime))
                {
                    list.Add(Builders<Messages>.Filter.Gte("CreateDate", condition.startTime));
                    list.Add(Builders<Messages>.Filter.Lte("CreateDate", condition.endTime));
                }
                //Or条件
                if (!string.IsNullOrEmpty(condition.SerachCondition))
                {
                    var list_or = new List<FilterDefinition<Messages>>();
                    list_or.Add(Builders<Messages>.Filter.Regex("Title", condition.SerachCondition));
                    list_or.Add(Builders<Messages>.Filter.Regex("MContent", condition.SerachCondition));
                    list_or.Add(Builders<Messages>.Filter.Regex("SendCode", condition.SerachCondition));
                    list.Add(Builders<Messages>.Filter.Or(list_or));
                }
                var filter = Builders<Messages>.Filter.And(list);
                var result = await base.FindListAsync<Messages>(filter, null, sort);
                return result;
            }
    View Code

    时间格式需要序列化,如下

    5.ObjectId详解

    MongoDB中我们经常会接触到一个自动生成的字段:”_id”,类型为ObjectId。

    ObjectId构成
    之前我们使用MySQL等关系型数据库时,主键都是设置成自增的。但在分布式环境下,这种方法就不可行了,会产生冲突。为此,MongoDB采用了一个称之为ObjectId的类型来做主键。ObjectId是一个12字节的 BSON 类型字符串。按照字节顺序,一次代表:

    4字节:UNIX时间戳
    3字节:表示运行MongoDB的机器
    2字节:表示生成此_id的进程
    3字节:由一个随机数开始的计数器生成的值

     从ObjectId的构造上来看,内部就嵌入了时间类型。我们肯定可以从中获取时间信息:即插入此文档时的时间。MongoDB对ObjectId对象提供了getTimestamp()方法来获取ObjectId的时间。

    6.注意事项:

    平均插入速率:MongoDB不指定_id插入 > MongoDB指定_id插入

    分析:

    在MongoDB中,指定索引插入比不指定慢很多,这是因为,MongoDB里每一条数据的_id值都是唯一的。当在不指定_id插入数据的时候,其_id是系统自动计算生成的。MongoDB通过计算机特征值、时间、进程ID与随机数来确保生成的_id是唯一的。而在指定_id插入时,MongoDB每插一条数据,都需要检查此_id可不可用,当数据库中数据条数太多的时候,这一步的查询开销会拖慢整个数据库的插入速度。如果想充分利用MongoDB性能的话,推荐采取不带”_id”的插入方式

  • 相关阅读:
    C++ VC实现对话框窗口任意分割
    C++ 关于滚动条的滚动问题
    C++ 自定义控件的移植(将在其它程序中设计的自定义控件,移植到现在的系统中)
    C++ 动态创建按钮及 按钮的消息响应
    C++ Custom Control控件 向父窗体发送对应的消息
    C++ MFC 改变控件大小和位置
    C++ 使用VS2010创建MFC ActiveX工程项目
    VC++ 自定义控件的建立及使用方法
    C++ CTreeview的checkbox使用方法
    C++ vc中怎么使用SendMessage自定义消息函数
  • 原文地址:https://www.cnblogs.com/quebra/p/10202449.html
Copyright © 2011-2022 走看看