internal void DeleteAVolunteersContracts(string id)
{
IMongoCollection <Volcontract> contractcollection = dBContext.Database.GetCollection <Volcontract>("Contracts");
var contractlist = contractcollection.Find(zz => zz.OwnerID == id).ToList();
for (int i = 0; i < contractlist.Count(); i++)
{
modifiedDocumentManager.AddIDtoDeletionString(contractlist[i]._id);
}
contractcollection.DeleteMany(Builders <Volcontract> .Filter.Eq("OwnerID", id));
}
static void Main(string[] args)
{
MongoClient client = new MongoClient("mongodb://localhost");
//相当于数据库
IMongoDatabase database = client.GetDatabase("TestDb1");
//相当于表
IMongoCollection <Person> teachers = database.GetCollection <Person>("Persons");
var filter = Builders <Person> .Filter.Where(p => p.Age <= 28);
teachers.DeleteMany(filter);
}
protected override DeleteResult ExecuteAndGetResult(IMongoDatabase database, IMongoCollection <BsonDocument> collection, bool async)
{
if (async)
{
return(collection.DeleteManyAsync(_filter, _options).GetAwaiter().GetResult());
}
else
{
return(collection.DeleteMany(_filter, _options));
}
}
public virtual bool DeleteBatch(List <ObjectId> idList)
{
IMongoCollection <T> collection = GetCollection();
var filterBuilder = Builders <T> .Filter;
var filter = filterBuilder.In("Id", idList);
var result = collection.DeleteMany(filter);
return(result != null && result.DeletedCount > 0);
}
public TimeSpan deleteQueries(int count)
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
collection.DeleteMany(Builders <MongoDB.User> .Filter.Empty);
stopWatch.Stop();
return(stopWatch.Elapsed);
}
// Admin/DeleteCustomer
public ActionResult DeleteCustomer()
{
var id = Request.QueryString["id"];
// delete customer orders
collection_order.DeleteMany(d => d.CustomerID.Equals(ObjectId.Parse(id)));
// delete customer
collection.DeleteOne(b => b._id.Equals(ObjectId.Parse(id)));
TempData["message"] = "The customer and customer's orders deleted from the system.";
return(RedirectToAction("Customers", "Admin"));
}
/// <summary>
/// 删除一条数据
/// </summary>
/// <param name="filter">删除的条件</param>
/// <returns></returns>
public DeleteResult DeleteMany(FilterDefinition <T> filter)
{
try
{
return(mongoDb.DeleteMany(filter));
}
catch (Exception ex)
{
throw ex;
}
}
public void DeleteFeature(string featureId)
{
var storyList = storyCollection.Find(it => it.Feature_id == featureId).ToList();
foreach (var item in storyList)
{
taskCollection.DeleteMany(Builders <TaskModel> .Filter.Eq(it => it.Story_id, item._id));
}
storyCollection.DeleteMany(Builders <StoryModel> .Filter.Eq(it => it.Feature_id, featureId));
featureCollection.DeleteOne(Builders <FeatureModel> .Filter.Eq(it => it._id, featureId));
}
public bool Eliminar(string SharedKey)
{
try
{
return(Coleccion.DeleteMany(Builders <Modelos.M_Clients> .Filter.Eq("_id", new MongoDB.Bson.ObjectId(SharedKey))).DeletedCount > 0);
}
catch (Exception ex)
{
Registros(ex);
return(false);
}
}
/// <summary>
/// 根据指定的一段时间获取对应的日志记录
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="guidArray"></param>
public void Delete <T>(params Guid[] guidArray) where T : Model.BaseInfo
{
if (guidArray == null || guidArray.Length == 0)
{
return;
}
IMongoCollection <T> mongoCollection = this.GetCollection <T>();
mongoCollection.DeleteMany(new FilterDefinitionBuilder <T>().In(item => item.InfoGuid, guidArray));
}
public bool Xoa(Expression <Func <T, bool> > @where)
{
try
{
_collection.DeleteMany(@where);
return(true);
}
catch
{
return(false);
}
}
private bool DelArchived(IMongoCollection <GovDoc> col)
{
if (_isArchived != 1)
{
return(false);
}
var filter = new BsonDocument("BidNumberG", _bidNumber);
var delRes = col.DeleteMany(filter);
DeleteCount += (int)delRes.DeletedCount;
return(true);
}
//删除多条数据
static void DeleteManyInMongoDB(IMongoDatabase db)
{
IMongoCollection <Person> persons = db.GetCollection <Person>("Persons");
FilterDefinition <Person> filter = Builders <Person> .Filter.Where(p => p.Age > 99);
//与上面删除一条数据不同，就是我们的筛选结果Age大于29，可能是多条数据
persons.DeleteMany(filter);
Console.WriteLine("删除所有Age>99的用户成功");
}
//删除一条数据
static void DeleteInMongoDB(IMongoDatabase db)
{
IMongoCollection <Person> persons = db.GetCollection <Person>("Persons");
FilterDefinition <Person> filter = Builders <Person> .Filter.Where(p => p.Name == "Tom");
//persons.DeleteOne(filter);//只删除一个（即使有多条数据满足你定义的filter，也只删除其中的一条数据）
//但是即使只是删除一条Name="Tom"的数据，我们也应该使用DeleteMany（），
//因为MongoDB数据中可能有多条Name ="Tom"的重复数据,而我们想要的效果是删除所有的Name="Tom"（我们默认的假设就时没有重复数据）
persons.DeleteMany(filter);
Console.WriteLine("删除Tom用户成功");
}
/// <summary>
/// 根据指导对象的ID,从数据库中删除指定的对象
/// </summary>
/// <param name="idList">对象的ID集合</param>
/// <returns></returns>
public virtual bool DeleteBetch(List <string> idList)
{
if (idList.Count == 0 || idList == null)
{
return(false);
}
IMongoCollection <T> collection = GetCollection();
var result = collection.DeleteMany(m => idList.Contains(m.Id));
return(result != null && result.DeletedCount > 0);
}
public void DeleteListEntity(List <T> Entity)
{
ConfigDbSet();
if (Entity != null)
{
for (int i = 0; i < Entity.Count; i++)
{
object _id = Entity[i].GetType().GetProperty("_id").GetValue(Entity[i]);
DbSet.DeleteMany(Builders <T> .Filter.Eq("_id", _id));
}
}
}
public async Task SavePasswordResetCodeAsync(IAccountInfoData account, string code)
{
await Task.Run(() =>
{
_resetCodesCollection.DeleteMany(i => i.Email == account.Email.ToLower());
_resetCodesCollection.InsertOne(new PasswordResetDataMongoDB()
{
Email = account.Email,
Code = code
});
});
}
private IMongoCollection <Dog> SetupDb()
{
var mongoClient = new MongoClient(CONNECTION_STRNG);
IMongoDatabase db = mongoClient.GetDatabase("dogs-db");
IMongoCollection <Dog> collection = db.GetCollection <Dog>("dogs-collection");
collection.Indexes.CreateOne(new CreateIndexModel <Dog>(Builders <Dog> .IndexKeys.Geo2DSphere(d => d.Coordinates)));
collection.DeleteMany(d => true);
return(collection);
}
/// <summary>
/// Xóa một tập hợp dữ liệu, đảm bảo không còn giàn buộc dữ liệu khi gọi hàm này
/// </summary>
/// <param name="entities">Tập hợp dữ liệu</param>
/// <returns>bool</returns>
public virtual bool Delete(IEnumerable <Entity> entities)
{
if (entities == null)
{
throw new ArgumentNullException(nameof(entities));
}
var _ids = entities.Select(q => q._id).ToList();
var deleteResult = Entitys.DeleteMany(q => _ids.Contains(q._id));
return(deleteResult.DeletedCount > 0);
}
public async Task SaveEmailConfirmationCodeAsync(string email, string code)
{
await Task.Run(() =>
{
_emailConfirmations.DeleteMany(i => i.Email == email.ToLower());
_emailConfirmations.InsertOne(new EmailConfirmationDataMongoDB()
{
Code = code,
Email = email
});
});
}
public IDataAdapter DeleteMany(string filter, out long totalDeleted)
{
totalDeleted = 0;
var bsonFilter = BsonDocument.Parse(filter);
DeleteResult result = _collection.DeleteMany(bsonFilter);
if (result.IsAcknowledged)
{
totalDeleted = result.DeletedCount;
}
return(this);
}
public OperationResult Execute(CancellationToken cancellationToken)
{
try
{
var result = _collection.DeleteMany(_filter, _options, cancellationToken);
return(new UnifiedDeleteManyOperationResultConverter().Convert(result));
}
catch (Exception exception)
{
return(OperationResult.FromException(exception));
}
}
public bool DeleteFaceHitStaticLibById(string compareId)
{
bool ret = false;
var builder = Builders <FaceHitStaticLib> .Filter;
var filter = builder.Eq("LibCompareId", compareId);
var result = mFaceHitStaticLibCollection.DeleteMany(filter);
if (result.DeletedCount >= 1)
{
ret = true;
}
return(ret);
}
public bool DeleteFaceObjByLibResId(string faceLibResId)
{
bool ret = false;
var builder = Builders <FaceObject> .Filter;
var filter = builder.Eq("LibResId", faceLibResId);
var result = mFaceObjectCollection.DeleteMany(filter);
if (result.DeletedCount >= 1)
{
ret = true;
}
return(ret);
}
public virtual ResultBase DeleteMany(IEnumerable <TKey> ids)
{
var result = new ResultBase();
try
{
var filter = new FilterDefinitionBuilder <T>().In("_id", ids.Select(id => new ObjectId(id as string)).ToList());
var deleteRes = collection.DeleteMany(filter);
if (deleteRes.DeletedCount < 1)
{
result.Message = "Failed to delete document";
return(result);
}
result.Success = true;
return(result);
}
catch (Exception ex)
{
result.Message = ex.Message;
return(result);
}
}
//[Transacao]
public void Delete(IList <TEntity> instances)
{
if (instances == null || instances.Count == 0)
{
return;
}
var ids = instances.Select(x => idMember.Getter.Invoke(x)).ToArray();
var filter = Builders <TEntity> .Filter.In(idMember.MemberName, ids);
collection.DeleteMany(filter);
}
public void DeleteMany(IEnumerable <string> ids)
{
try
{
var filter = Builders <Timesheet> .Filter.In("Id", ids);
_collection.DeleteMany(filter);
}
catch (Exception)
{
throw;
}
}
public void Trim(int amount)
{
var items = Get()
.OrderByDescending(x => x)
.Take(amount)
.Select(x => x.ToBinary())
.ToList();
var builder = Builders <Call> .Filter;
var filter = builder.Nin(x => x.Value, items);
_store.DeleteMany(filter);
}
public void MongoDeleteTest(int rows)
{
db.DropCollection("acount");
this.MongoInsertTest(rows);
Stopwatch stopwatch = Stopwatch.StartNew();
FilterDefinition <acount> filter = Builders <acount> .Filter.Empty;
collection.DeleteMany(filter);
stopwatch.Stop();
Console.WriteLine("Mongodb delete " + rows + " Time Elapsed={0}", stopwatch.Elapsed);
}
/// <inheritdoc />
public void RemoveRange(IEnumerable <TEntity> entities)
{
var entitiesList = entities.ToList();
if (!entitiesList.Any())
{
return;
}
var ids = entitiesList.Select(d => d.Id);
_dbCollection.DeleteMany(Builders <TEntity> .Filter.In("_id", ids));
}
private void InitializeCollection(IMongoCollection<BsonDocument> collection, List<BsonDocument> documents)
{
collection.DeleteMany(new BsonDocument());
if (documents.Count > 0)
{
collection.InsertMany(documents);
}
}
