public void Count_should_include_the_filter(
[Values(false, true)] bool async)
{
var subject = CreateSubject();
var options = new CountOptions();
if (async)
{
#pragma warning disable 618
subject.CountAsync(_providedFilter, options, CancellationToken.None);
_mockDerivedCollection.Verify(
c => c.CountAsync(
It.Is <FilterDefinition <B> >(f => RenderFilter(f).Equals(_expectedFilter)),
options,
CancellationToken.None),
Times.Once);
#pragma warning restore
}
else
{
#pragma warning disable 618
subject.Count(_providedFilter, options, CancellationToken.None);
_mockDerivedCollection.Verify(
c => c.Count(
It.Is <FilterDefinition <B> >(f => RenderFilter(f).Equals(_expectedFilter)),
options,
CancellationToken.None),
Times.Once);
#pragma warning restore
}
}
public UnifiedCountDocumentsOperation Build(string targetCollectionId, BsonDocument arguments)
{
var collection = _entityMap.GetCollection(targetCollectionId);
FilterDefinition <BsonDocument> filter = null;
CountOptions options = null;
IClientSessionHandle session = null;
foreach (var argument in arguments)
{
switch (argument.Name)
{
case "comment":
options ??= new CountOptions();
options.Comment = argument.Value;
break;
case "filter":
filter = new BsonDocumentFilterDefinition <BsonDocument>(argument.Value.AsBsonDocument);
break;
case "session":
session = _entityMap.GetSession(argument.Value.AsString);
break;
default:
throw new FormatException($"Invalid CountDocumentsOperation argument name: '{argument.Name}'.");
}
}
return(new UnifiedCountDocumentsOperation(collection, filter, options, session));
}
/// <summary>
/// 获取总数
/// </summary>
/// <param name="collectionName"></param>
/// <param name="filter"></param>
/// <param name="options"></param>
/// <returns></returns>
public long Count(string collectionName, FilterDefinition <T> filter, CountOptions options = null)
{
return(infrastructure.Exec(database =>
{
return database.GetCollection <T>(collectionName).CountDocuments(filter, options);
}));
}
public void Count_should_include_the_filter(
[Values(false, true)] bool async)
{
var subject = CreateSubject();
var options = new CountOptions();
if (async)
{
subject.CountAsync(_providedFilter, options, CancellationToken.None);
_derivedCollection.Received().CountAsync(
Arg.Is <FilterDefinition <B> >(f => RenderFilter(f).Equals(_expectedFilter)),
options,
CancellationToken.None);
}
else
{
subject.Count(_providedFilter, options, CancellationToken.None);
_derivedCollection.Received().Count(
Arg.Is <FilterDefinition <B> >(f => RenderFilter(f).Equals(_expectedFilter)),
options,
CancellationToken.None);
}
}
public async Task<bool> Exists(Expression<Func<T, bool>> expression)
{
var options = new CountOptions { Limit = 1 };
long count = await _context.Collection.CountDocumentsAsync(_session?.Handle, expression, options);
return count != 0;
}
public async Task<bool> Exists(params Guid[] ids)
{
var filter = StorageUtils.BuildIdsFilter<T>(ids);
var options = new CountOptions { Limit = 1 };
long count = await _context.Collection.CountDocumentsAsync(_session?.Handle, filter, options);
return count != 0;
}
public UnifiedCountDocumentsOperation(
IMongoCollection <BsonDocument> collection,
FilterDefinition <BsonDocument> filter,
CountOptions options)
{
_collection = collection;
_filter = filter;
_options = options;
}
/// <summary>
/// 数量
/// </summary>
/// <param name="filter"></param>
/// <param name="limit"></param>
/// <param name="skip"></param>
/// <param name="hint">hint索引</param>
/// <param name="readPreference">访问设置</param>
/// <returns></returns>
public Task <long> CountAsync(FilterDefinition <TEntity> filter, int limit = 0, int skip = 0, BsonValue hint = null, ReadPreference readPreference = null)
{
if (filter == null)
{
filter = Builders <TEntity> .Filter.Empty;
}
CountOptions options = base.CreateCountOptions(limit, skip, hint);
return(base.GetCollection(readPreference).CountAsync(filter, options, default(CancellationToken)));
}
/// <summary>
///
/// </summary>
/// <typeparam name="TForeign">文档类型</typeparam>
/// <typeparam name="T">文档类型</typeparam>
/// <param name="foreignDocument">文档对象</param>
/// <param name="filter">过滤器</param>
/// <param name="options">设置</param>
/// <param name="cancellationToken">标记</param>
/// <returns></returns>
public long DynamicCollectionCountDocuments <TForeign, T>(
TForeign foreignDocument,
Expression <Func <T, bool> > filter,
CountOptions options = null,
CancellationToken cancellationToken = default)
where TForeign : BaseMongoEntity
where T : BaseMongoEntity
{
return(Database.GetCollection <T>($"{typeof(T).Name}_{foreignDocument.Id}").CountDocuments(filter, options, cancellationToken));
}
public Task <long> CountAsync(FilterDefinition <TEntity> filter, int limit = 0, int skip = 0, BsonValue hint = null, ReadPreference readPreference = null)
{
if (filter == null)
{
filter = Filter.Empty;
}
CountOptions options = CreateCountOptions(limit, skip, hint);
return(GetCollection(readPreference).CountAsync(filter, options));
}
/// <summary>
///
/// </summary>
/// <typeparam name="TForeign">文档类型</typeparam>
/// <typeparam name="T">文档类型</typeparam>
/// <param name="foreignDocument">文档对象</param>
/// <param name="filter">Lambda过滤器</param>
/// <param name="options">设置</param>
/// <param name="cancellationToken">标记</param>
/// <returns></returns>
public Task <long> DynamicCollectionCountDocumentsAsync <TForeign, T>(
TForeign foreignDocument,
Expression <Func <T, bool> > filter,
CountOptions options = null,
CancellationToken cancellationToken = default)
where TForeign : BaseMongoEntity
where T : BaseMongoEntity
{
return(Task.Run(() => DynamicCollectionCountDocuments(foreignDocument, filter, options, cancellationToken)));
}
/// <summary>
///
/// </summary>
/// <typeparam name="TForeign">文档类型</typeparam>
/// <typeparam name="T">文档类型</typeparam>
/// <param name="session">会话句柄(作用于事务)</param>
/// <param name="foreignDocument">文档对象</param>
/// <param name="filter">过滤器</param>
/// <param name="options">设置</param>
/// <param name="cancellationToken">标记</param>
/// <returns></returns>
public long DynamicCollectionCountDocuments <TForeign, T>(
IClientSessionHandle session,
TForeign foreignDocument,
FilterDefinition <T> filter,
CountOptions options = null,
CancellationToken cancellationToken = default)
where TForeign : BaseMongoEntity
where T : BaseMongoEntity
{
return(Database.GetCollection <T>($"{typeof(T).Name}_{foreignDocument.Id}").CountDocuments(session, filter, options, cancellationToken));
}
public UnifiedCountDocumentsOperation(
IMongoCollection <BsonDocument> collection,
FilterDefinition <BsonDocument> filter,
CountOptions options,
IClientSessionHandle session)
{
_collection = collection;
_filter = filter;
_options = options;
_session = session;
}
/// <summary>
///
/// </summary>
/// <typeparam name="TForeign">文档类型</typeparam>
/// <typeparam name="T">文档类型</typeparam>
/// <param name="foreignDocument">文档对象</param>
/// <param name="session">客户端会话句柄</param>
/// <param name="filter">过滤器</param>
/// <param name="options">设置</param>
/// <param name="cancellationToken">标记</param>
/// <returns></returns>
public Task <long> DynamicCollectionCountDocumentsAsync <TForeign, T>(
IClientSessionHandle session,
TForeign foreignDocument,
FilterDefinition <T> filter,
CountOptions options = null,
CancellationToken cancellationToken = default)
where TForeign : BaseMongoEntity
where T : BaseMongoEntity
{
return(Task.Run(() => DynamicCollectionCountDocuments(session, foreignDocument, filter, options, cancellationToken)));
}
static void Main()
{
bool repeat = true;
do
{
MainMenu();
CountOptions OptionNumber = TryReadOption();
Console.Clear();
Console.WriteLine(" === Расчёт площади фигуры === \n");
switch (OptionNumber)
{
case CountOptions.Circle:
Console.Write(" Введите радиус круга: ");
var radius = TryReadDouble();
var circle = new Circle(radius);
PrintAnswer(circle.CountArea());
ReturnToMainMenu();
break;
case CountOptions.Rectangle:
Console.Write(" Введите длину прямоугольника: ");
var width = TryReadDouble();
Console.Write(" Введите ширину прямоугольника: ");
var height = TryReadDouble();
var rectangle = new Rectangle(width, height);
PrintAnswer(rectangle.CountArea());
ReturnToMainMenu();
break;
case CountOptions.Triangle:
Console.Write(" Введите основание треугольника: ");
var triangleBase = TryReadDouble();
Console.Write(" Введите высоту треугольника: ");
var triangleHeight = TryReadDouble();
var triangle = new Triangle(triangleBase, triangleHeight);
PrintAnswer(triangle.CountArea());
ReturnToMainMenu();
break;
case CountOptions.Quit:
repeat = false;
break;
}
} while (repeat);
}
public int GetCount(DataBaseContext context, BsonDocument filter, CountOptions options = null)
{
if (!MongoClients.ContainsKey(context.ClientKey))
{
throw new NullReferenceException("请先连接MongoDB!");
}
var collection = MongoClients[context.ClientKey].GetDatabase(context.DbName).GetCollection <BsonDocument>(context.CollectionName);
var count = collection.CountDocuments(filter, options);
return((int)count);
}
Task <long> ICollectionAdapter <TEntity> .CountAsync(
Expression <Func <TEntity, bool> > filter,
CountOptions options,
CancellationToken token)
{
if (filter == null)
{
return(this.collection.CountAsync(new BsonDocument(), options, token));
}
return(this.collection.CountAsync(filter, options, token));
}
/// <summary>
/// Returns the number of items of the requested type in the Mongo collection filtered by the given expression.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public long Count <T>(Expression <Func <T, bool> > expression, Collation collation = null) where T : DataEntityBase
{
CountOptions countOptions = new CountOptions()
{
Collation = collation
};
Logger.Trace($"{nameof(MongoStore)}.{nameof(Count)}",
new LogItem("Event", "Get collection count"), new LogItem("Type", typeof(T).ToString),
new LogItem("Expression", expression.ToString));
return(GetCollection <T>().Count(expression, countOptions));
}
public void CountTest()
{
// Arrange
var items = new int[] { 3, 4, 2 };
var countOptions = new CountOptions();
// Act
ConzoleUtils.Count(items);
// Assert
mockConsole.Verify(c => c.WriteLine(countOptions.ResultFormatter(items.Length)));
mockConsole.Verify(c => c.WriteLine(), Times.Once);
}
public void CountCustomFormatTest()
{
// Arrange
var items = new int[] { 3, 4, 2 };
var countOptions = new CountOptions();
countOptions.PostNewLine = false;
countOptions.ResultFormatter = count => $"aaa {count} bbb";
// Act
ConzoleUtils.Count(items, countOptions);
// Assert
mockConsole.Verify(c => c.WriteLine(countOptions.ResultFormatter(items.Length)));
mockConsole.Verify(c => c.WriteLine(), Times.Never);
}
/// <summary>
///
/// </summary>
/// <param name="limit"></param>
/// <param name="skip"></param>
/// <param name="hint"></param>
/// <returns></returns>
public CountOptions CreateCountOptions(int skip = 0, BsonValue hint = null)
{
CountOptions option = new CountOptions();
if (skip > 0)
{
option.Skip = skip;
}
if (hint != null)
{
option.Hint = hint;
}
return(option);
}
private static async Task <bool> IsCollEmpty(IMongoCollection <LeaderBoardSchema> collection) //Checks if there is at least one doc present in collection
{ //TODO: Can this method be modified to check game state collection as well?
var docType = FilterDefinition <LeaderBoardSchema> .Empty;
var countOptions = new CountOptions {
MaxTime = timeOut
};
var collIsEmpty = true;
if (await collection.CountDocumentsAsync(docType, countOptions) > 0)
{
Debug.Log($"<Color=blue>Attention</color> Collection {collection.GetType()} is NOT empty");
collIsEmpty = false;
}
Debug.Log($"<Color=blue>Attention</color> {nameof(IsCollEmpty)}() Returning {collIsEmpty}.");
return(collIsEmpty);
}
/// <summary>
/// Get the number of children for a relationship
/// </summary>
/// <param name="session">An optional session if using within a transaction</param>
/// <param name="options">An optional AggregateOptions object</param>
/// <param name="cancellation">An optional cancellation token</param>
public Task <long> ChildrenCountAsync(IClientSessionHandle session = null, CountOptions options = null, CancellationToken cancellation = default)
{
parent.ThrowIfUnsaved();
if (isInverse)
{
return(session == null
? JoinCollection.CountDocumentsAsync(j => j.ChildID == parent.ID, options, cancellation)
: JoinCollection.CountDocumentsAsync(session, j => j.ChildID == parent.ID, options, cancellation));
}
else
{
return(session == null
? JoinCollection.CountDocumentsAsync(j => j.ParentID == parent.ID, options, cancellation)
: JoinCollection.CountDocumentsAsync(session, j => j.ParentID == parent.ID, options, cancellation));
}
}
/// <summary>
///
/// </summary>
/// <param name="limit"></param>
/// <param name="skip"></param>
/// <param name="hint"></param>
/// <returns></returns>
public CountOptions CreateCountOptions(int limit = 0, int skip = 0, BsonValue hint = null)
{
CountOptions countOptions = new CountOptions();
if (limit > 0)
{
countOptions.Limit = new long?((long)limit);
}
if (skip > 0)
{
countOptions.Skip = new long?((long)skip);
}
if (hint != null)
{
countOptions.Hint = hint;
}
return(countOptions);
}
public CountOptions CreateCountOptions(int limit = 0, int skip = 0, BsonValue hint = null)
{
CountOptions options = new CountOptions();
if (limit > 0)
{
options.Limit = limit;
}
if (skip > 0)
{
options.Skip = skip;
}
if (hint != null)
{
options.Hint = hint;
}
return(options);
}
public static long MyCount(this IMongoCollection <BsonDocument> collection, IClientSessionHandle session, FilterDefinition <BsonDocument> filter, long skip, long first)
{
if (skip <= 0 && first <= 0)
{
return(collection.CountDocuments(session, filter));
}
var options = new CountOptions();
if (skip > 0)
{
options.Skip = skip;
}
if (first > 0)
{
options.Limit = first;
}
return(collection.CountDocuments(session, filter, options));
}
public long Count(FilterDefinition <T> filter, CountOptions option = null)
{
var database = client.GetDatabase(DatabaseName);
var myCollection = database.GetCollection <T>(collectionName);
var aggregateResult = myCollection.Aggregate().Match(filter).Group(new BsonDocument()
{
{ "_id", "null" },
{ "count", new BsonDocument("$sum", 1) }
});
var results = aggregateResult.ToListAsync().GetAwaiter().GetResult();
if (results.Count == 1)
{
return(Convert.ToInt64(results[0].GetElement("count").Value));
}
else
{
return(0);
}
}
private static async Task <bool> IsDocumentPresent(string _id, IMongoCollection <LeaderBoardSchema> collection)//TODO: Modify this to check for Game State docs
{
LeaderBoardSchema docFound = null;
var docType = FilterDefinition <LeaderBoardSchema> .Empty;
var countOptions = new CountOptions {
MaxTime = timeOut
};
var newProjection = Builders <LeaderBoardSchema> .Projection.Exclude(x => x.list);
var searchOptions = new FindOptions <LeaderBoardSchema> {
Limit = 1, MaxAwaitTime = timeOut, Projection = newProjection
};
var searchFilter = Builders <LeaderBoardSchema> .Filter.Eq("_id", _id);
if (await collection.CountDocumentsAsync(docType, countOptions) > 0)
{
using (IAsyncCursor <LeaderBoardSchema> cursor = await collection.FindAsync(searchFilter, searchOptions))
{
while (await cursor.MoveNextAsync())
{
IEnumerable <LeaderBoardSchema> batch = cursor.Current;
foreach (LeaderBoardSchema document in batch)
{
docFound = document;
Debug.Log($"isDocPresent: {document}");
}
}
}
Debug.Log($"<Color=blue>Attention</color> docFound {docFound}");
return((docFound != null) ? true: false);
}
Debug.Log($"<Color=red>Attention</color> Collection {collection.ToString()} is empty. Returning false.");
return(false);
}
public UnifiedCountDocumentsOperation Build(string targetCollectionId, BsonDocument arguments)
{
var collection = _entityMap.GetCollection(targetCollectionId);
FilterDefinition <BsonDocument> filter = null;
CountOptions options = null;
foreach (var argument in arguments)
{
switch (argument.Name)
{
case "filter":
filter = new BsonDocumentFilterDefinition <BsonDocument>(argument.Value.AsBsonDocument);
break;
default:
throw new FormatException($"Invalid CountDocumentsOperation argument name: '{argument.Name}'.");
}
}
return(new UnifiedCountDocumentsOperation(collection, filter, options));
}
/// <summary>
///
/// </summary>
/// <param name="collectionName"></param>
/// <param name="filter"></param>
/// <param name="options"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <long> CountAsync <TDocument>(string collectionName, FilterDefinition <TDocument> filter, CountOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
{
var collection = this.GetMongoCollection <TDocument>(collectionName);
return(await collection.CountAsync(filter, options, cancellationToken));
}
