C# MongoDb使用新的异步方法创建存储库模式 public类MongoDbRepository:IRepository其中T:IEntityBase { 专用数据库； 私人收藏； 公共MongoDbRepository（） { GetDatabase（）； GetCollection（）； } 私有数据库（） { var client=newmongoclient（GetConnectionString（））； database=client.GetDatabase（GetDatabaseName（））； } 私有void GetCollection（） { collection=database.GetCollection（typeof（T）.Name）； } 私有字符串GetDatabaseName（） { 返回ConfigurationManager.AppSettings.Get（“MongoDbDatabaseName”）； } 私有字符串GetConnectionString（） { 返回ConfigurationManager.AppSettings.Get（“MongoDbConnectionString”）.Replace（“{DB_NAME}”，GetDatabaseName（））； } 公共异步任务SelectAllSync（） { //添加每个文档唯一的\u id var filter=newbsondocument（'u id'，newbsondocument（$exists'，true））； var people=wait collection.Find（filter.toListSync（）； //搜索方法 var result1=await database.GetCollection（typeof（T）.Name） .Aggregate（） .Match（x=>x.last_name.Equals（“霍尔”））.ToListSync（）； var result2=collection.FindAsync（生成器） .Filter.Eq（x=>x.last_name，“Grammer”） ，新的FindOptions{Comment=“TEST”} ，CancellationToken.None）； var result3=await collection.FindAsync( Builders.Filter.Eq（“经销商名称”、“D-PATRICK NISSAN”）， 新的FindOptions{Comment=“TEST”}， 取消令牌（无）； 返回（IList）人员； } 公共任务插入（T实体） { var result=collection.InsertOneAsync（实体）； 返回结果； } 公共异步任务删除（T实体） { var deleteResult=await collection.DeleteOneAsync（Builders.Filter.Eq（s=>s._id，entity._id））； 返回结果； } 公共异步任务SearchFor（System.Linq.Expressions.Expression谓词） { var result=await database.GetCollection（typeof（T）.Name） .Aggregate（） .Match（谓词）.toListSync（）； 返回结果； } 公共异步任务GetById（ObjectId） { var result=await database.GetCollection（typeof（T）.Name） .Aggregate（） .Match（x=>x._id.Equals（id））.toListSync（）； 返回结果； } 公共异步任务更新（T实体） { if（实体.\u id==null） 等待插入（实体）；

//添加了经销商代码的字符串值列表

var list=newlist（）；
列表。添加（“经销商代码”）；
var result=await collection.UpdateOneAsync(
Builders.Filter.Eq（s=>s.dealer\u代码，entity.dealer\u代码），
Builders.Update.AddToSet（列表[0]，实体.dealer\u代码）
);
返回结果；
}
}

我对更新方法有问题。它给了我：

“字段

'dealer\u code'

的序列化程序必须实现

IBMSerializer

，并提供项目序列化信息。”

---

这是什么意思？我怎样才能解决这个问题

我的假设是，您试图对非集合的对象调用

$addToSet

：

        var list = new List<string>();
        list.Add("dealer_code");
        var result = await collection.UpdateOneAsync(
             Builders<T>.Filter.Eq(s => s.dealer_code, entity.dealer_code),
             Builders<T>.Update.AddToSet(list[0], entity.dealer_code)
                                      );

        return result;
    }
}

/。。。
Builders.Update.AddToSet（“经销商代码”，实体。经销商代码）
// ...

但正如您在评论中所解释的，

dealer\u code

的类型为

string

。如果元素是集合，则只能向集合中添加某些内容，例如

字符串[]

或

列表

。现在还不清楚您想要实现什么，但您可以尝试将

字符串经销商代码

更改为

列出经销商代码

公共类MongodBrespository:iRespository where T:IEntityBase
// ... 
Builders<T>.Update.AddToSet("dealer_code", entity.dealer_code)
// ...

{
专用数据库；
私人收藏；
公共MongoDbRepository（）
{
GetDatabase（）；
GetCollection（）；
}
私有数据库（）
{
var client=newmongoclient（GetConnectionString（））；
database=client.GetDatabase（GetDatabaseName（））；
}
私有void GetCollection（）
{
collection=database.GetCollection（typeof（T）.Name）；
}
私有字符串GetDatabaseName（）
{
返回ConfigurationManager.AppSettings.Get（“MongoDbDatabaseName”）；
}
私有字符串GetConnectionString（）
{
返回ConfigurationManager.AppSettings.Get（“MongoDbConnectionString”）.Replace（“{DB_NAME}”，GetDatabaseName（））；
}
公共异步任务SelectAllSync（）
{
//var filter=新的BsonDocument（“经销商代码”，新的BsonDocument（$exists），true））；
//var people=wait collection.Find（filter.toListSync（）；
//搜索方法
var result1=await database.GetCollection（typeof（T）.Name）
.Aggregate（）
.Match（x=>x.last_name.Equals（“霍尔”））.ToListSync（）；
var result2=collection.FindAsync（生成器）
.Filter.Eq（x=>x.last_name，“Grammer”）
，新的FindOptions{Comment=“TEST”}
，CancellationToken.None）；
返回（IList）结果1；
}
公共任务插入（T实体）
{
var result=collection.InsertOneAsync（实体）；
返回结果；
}
公共异步任务删除（T实体）
{
var deleteResult=await collection.DeleteOneAsync（Builders.Filter.Eq（s=>s._id，entity._id））；
返回结果；
}
公共异步任务SearchFor（System.Linq.Expressions.Expression谓词）
{
var result=await database.GetCo
// ... 
Builders<T>.Update.AddToSet("dealer_code", entity.dealer_code)
// ...

 public class MongoDbRepository<T> : IRepository<T> where T : IEntityBase
{
    private IMongoDatabase database;
    private IMongoCollection<T> collection;

    public MongoDbRepository()
    {
        GetDatabase();
        GetCollection();
    }

    private void GetDatabase()
    {
        var client = new MongoClient(GetConnectionString());
        database = client.GetDatabase(GetDatabaseName());
    }

    private void GetCollection()
    {
        collection = database.GetCollection<T>(typeof(T).Name);
    }

    private string GetDatabaseName()
    {
        return ConfigurationManager.AppSettings.Get("MongoDbDatabaseName");
    }

    private string GetConnectionString()
    {
        return ConfigurationManager.AppSettings.Get("MongoDbConnectionString").Replace("{DB_NAME}", GetDatabaseName());
    }


    public async Task<IList<T>> SelectAllSync() 
    {

        //var filter = new BsonDocument("dealer_code", new BsonDocument("$exists", true));
        //var people = await collection.Find<T>(filter).ToListAsync<T>();

        //Search methods
        var result1 = await database.GetCollection<T>(typeof(T).Name)
                                .Aggregate()
                                .Match(x => x.last_name.Equals("Hall")).ToListAsync();


        var result2 = collection.FindAsync<T>(Builders<T>
                            .Filter.Eq(x => x.last_name, "Grammer")
                            , new FindOptions<T> { Comment = "TEST" }
                            , CancellationToken.None);





        return (IList<T>)result1;
    }

    public Task Insert(T entity)
    {
        var result = collection.InsertOneAsync(entity);
        return  result;
    }

    public async Task<DeleteResult> Delete(T entity)
    {
        var deleteResult = await collection.DeleteOneAsync(Builders<T>.Filter.Eq(s => s._id, entity._id));
        return deleteResult;
    }

    public async Task<IList<T>> SearchFor(System.Linq.Expressions.Expression<Func<T, bool>> predicate)
    {
        var result = await database.GetCollection<T>(typeof(T).Name)
                                .Aggregate()
                                .Match(predicate).ToListAsync();
        return result;
    }

    public async Task<IList<T>> GetById(ObjectId id)
    {
        var result = await database.GetCollection<T>(typeof(T).Name)
                                .Aggregate()
                                .Match(x => x._id.Equals(id)).ToListAsync();
        return result;
    }

    public async Task<UpdateResult> Update(Expression<Func<T, bool>> filter,T entity) 
    {
        if (entity._id == null)
            await Insert(entity);

        var list = new List<string>();
        list.Add("dealer_code");

        var result = await collection.UpdateOneAsync(
                                Builders<T>.Filter.Where(filter),
                                Builders<T>.Update.Set(x=>x.dealer_code, entity.dealer_code));

        if (result.IsAcknowledged)
        {
            Console.WriteLine("Success");
        }
        return result;
    }
}