/// <summary>
/// 插入单条数据
/// </summary>
/// <param name="collName"></param>
/// <param name="saveDoc"></param>
/// <returns></returns>
public InvokeResult Save(string collName, BsonDocument saveDoc)
{
InvokeResult result = new InvokeResult()
{
Status = Status.Failed
};
try
{
MongoCollection <BsonDocument> entityColl = _mongoDatabase.GetCollection(collName);
using (_mongoServer.RequestStart(_mongoDatabase))
{
entityColl.Save(saveDoc); //非安全模式,即无返回消息
//SafeModeResult safeResult = entityColl.Save(saveDoc, SafeMode.True);
//if (safeResult.HasLastErrorMessage) throw new Exception(safeResult.LastErrorMessage);
}
result.Status = Status.Successful;
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return(result);
}
public void TestText()
{
if (_primary.Supports(FeatureId.TextSearchQuery))
{
using (_server.RequestStart(null, _primary))
{
var collection = _database.GetCollection <BsonDocument>("test_text");
collection.Drop();
collection.CreateIndex(IndexKeys.Text("textfield"));
collection.Insert(new BsonDocument
{
{ "_id", 1 },
{ "textfield", "The quick brown fox" }
});
collection.Insert(new BsonDocument
{
{ "_id", 2 },
{ "textfield", "over the lazy brown dog" }
});
var query = Query.Text("fox");
var results = collection.Find(query).ToArray();
Assert.AreEqual(1, results.Length);
Assert.AreEqual(1, results[0]["_id"].AsInt32);
}
}
}
public Warehouse Save(string name)
{
var warstoryDocuments = _server.GetDatabase("warstory-documents");
Warehouse warehouseDocument = null;
using (_server.RequestStart(warstoryDocuments))
{
var warehouseDocuments = warstoryDocuments.GetCollection <Warehouse>("warehouse-documents");
var query = Query.EQ("_id", name);
warehouseDocument = warehouseDocuments.FindAs <Warehouse>(query).SingleOrDefault();
if (warehouseDocument != null)
{
warehouseDocument.Action();
warehouseDocuments.Save <Warehouse>(warehouseDocument);
}
else
{
warehouseDocument = new Warehouse {
Name = "Chavp"
};
warehouseDocuments.Save <Warehouse>(warehouseDocument);
}
}
return(warehouseDocument);
}
private void LlenarGrilla()
{
using (Server.RequestStart(Database))
{
MongoCollection Contactos = Database.GetCollection <Contact>("contacts");
dgvEmpleados.DataSource = Contactos.FindAllAs <Contact>().ToList <Contact>();
}
}
public void TestRequestStart()
{
Assert.AreEqual(0, _server.RequestNestingLevel);
using (_server.RequestStart())
{
Assert.AreEqual(1, _server.RequestNestingLevel);
}
Assert.AreEqual(0, _server.RequestNestingLevel);
}
public void RemoveAllPOI(List <OCM.API.Common.Model.ChargePoint> poiList, MongoCollection <POIMongoDB> poiCollection)
{
using (server.RequestStart(database))
{
foreach (var poi in poiList)
{
var query = Query.EQ("ID", poi.ID);
poiCollection.Remove(query);
}
}
}
public void GetPerformance()
{
using (mServer.RequestStart(mLogs))
{
var servicePerformances = mLogs.GetCollection("service_performance");
var map = new BsonJavaScript(@"
function() {
var key = {};
key.class = this.class;
key.method = this.method;
key.machineName = this.machineName;
emit(key, { count: 1 });
}");
var reduce = new BsonJavaScript(@"
function(key, values) {
var result = { count: 0 };
values.forEach(function(value){
result.count += value.count;
});
return result
}");
var finalize = new BsonJavaScript(@"
function(key, value){
return value;
}");
var options = new MapReduceOptionsBuilder();
options.SetFinalize(finalize);
options.SetOutput(MapReduceOutput.Inline);
var results = servicePerformances.MapReduce(map, reduce, options);
int totalCal = 0;
foreach (var result in results.GetResults())
{
var doc = result.ToBsonDocument();
var id = doc["_id"].AsBsonDocument;
var value = doc["value"].AsBsonDocument;
totalCal += Convert.ToInt32(value["count"].AsDouble);
string className = id["class"].AsString;
string method = id["method"].AsString;
string machineName = id["machineName"].AsString;
}
var all = servicePerformances.FindAll().ToList().Count;
Assert.AreEqual(all, totalCal);
}
}
/// <summary>
/// Copies a GridFS file.
/// </summary>
/// <param name="destFileName">The destination file name.</param>
/// <param name="createOptions">The create options.</param>
/// <returns>The file info of the new GridFS file.</returns>
public MongoGridFSFileInfo CopyTo(string destFileName, MongoGridFSCreateOptions createOptions)
{
EnsureServerInstanceIsPrimary();
using (_server.RequestStart(_serverInstance))
{
// note: we are aware that the data is making a round trip from and back to the server
// but we choose not to use a script to copy the data locally on the server
// because that would lock the database for too long
var gridFS = new MongoGridFS(_server, _databaseName, _settings);
var stream = OpenRead();
return(gridFS.Upload(stream, destFileName, createOptions));
}
}
IList <BsonDocument> getAllDocuments(string collectionName)
{
IList <BsonDocument> docList = new List <BsonDocument>();
using (_ms.RequestStart(_mdb)) {
MongoCollection mc = _mdb.GetCollection("csharp");
MongoCursor <BsonDocument> cur = mc.FindAllAs <BsonDocument> ();
System.Collections.Generic.IEnumerator <BsonDocument> e = cur.GetEnumerator();
while (e.MoveNext())
{
docList.Add(e.Current);
}
}
return(docList);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="connectionString"></param>
/// <param name="databaseName"></param>
/// <param name="collectionName"></param>
/// <param name="query">条件查询。 调用示例：Query.Matches("Title", "感冒") 或者 Query.EQ("Title", "感冒") 或者Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc")) 等等</param>
/// <returns></returns>
public static T GetOne <T>(string connectionString, string databaseName, string collectionName, IMongoQuery query)
{
MongoServer server = MongoServer.Create(connectionString);
//获取数据库或者创建数据库（不存在的话）。
MongoDatabase database = server.GetDatabase(databaseName);
T result = default(T);
using (server.RequestStart(database))//开始连接数据库。
{
MongoCollection <BsonDocument> myCollection = database.GetCollection <BsonDocument>(collectionName);
if (null == query)
{
result = myCollection.FindOneAs <T>();
}
else
{
result = myCollection.FindOneAs <T>(query);
}
}
return(result);
}
public static SafeModeResult Delete(string connectionString, string databaseName, string collectionName, string _id)
{
SafeModeResult result;
ObjectId id;
if (!ObjectId.TryParse(_id, out id))
{
return(null);
}
MongoServer server = MongoServer.Create(connectionString);
//获取数据库或者创建数据库（不存在的话）。
MongoDatabase database = server.GetDatabase(databaseName);
using (server.RequestStart(database))//开始连接数据库。
{
MongoCollection <BsonDocument> myCollection = database.GetCollection <BsonDocument>(collectionName);
result = myCollection.Remove(Query.EQ("_id", id));
}
return(result);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="connectionString"></param>
/// <param name="databaseName"></param>
/// <param name="collectionName"></param>
/// <param name="query">条件查询。 调用示例：Query.Matches("Title", "感冒") 或者 Query.EQ("Title", "感冒") 或者Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc")) 等等</param>
/// <param name="pagerInfo"></param>
/// <param name="sortBy">排序用的。调用示例：SortBy.Descending("Title") 或者 SortBy.Descending("Title").Ascending("Author")等等</param>
/// <param name="fields">只返回所需要的字段的数据。调用示例："Title" 或者 new string[] { "Title", "Author" }等等</param>
/// <returns></returns>
public static List <T> GetAll <T>(string connectionString, string databaseName, string collectionName, IMongoQuery query, PagerInfo pagerInfo, IMongoSortBy sortBy, params string[] fields)
{
MongoServer server = MongoServer.Create(connectionString);
//获取数据库或者创建数据库（不存在的话）。
MongoDatabase database = server.GetDatabase(databaseName);
List <T> result = new List <T>();
using (server.RequestStart(database))//开始连接数据库。
{
MongoCollection <BsonDocument> myCollection = database.GetCollection <BsonDocument>(collectionName);
MongoCursor <T> myCursor;
if (null == query)
{
myCursor = myCollection.FindAllAs <T>();
}
else
{
myCursor = myCollection.FindAs <T>(query);
}
if (null != sortBy)
{
myCursor.SetSortOrder(sortBy);
}
if (null != fields)
{
myCursor.SetFields(fields);
}
foreach (T entity in myCursor.SetSkip((pagerInfo.Page - 1) * pagerInfo.PageSize).SetLimit(pagerInfo.PageSize))//.SetSkip(100).SetLimit(10)是指读取第一百条后的10条数据。
{
result.Add(entity);
}
}
return(result);
}
public void TestUploadAndDownload()
{
MongoGridFSFileInfo uploadedFileInfo;
var text = "HelloWorld";
var bytes = Encoding.UTF8.GetBytes(text);
using (var stream = new MemoryStream(bytes))
{
uploadedFileInfo = _database.GridFS.Upload(stream, "HelloWorld.txt");
}
// use RequestStart so that if we are running this test against a replica set we will bind to a specific secondary
using (_server.RequestStart(_database, ReadPreference.SecondaryPreferred))
{
// wait for the GridFS file to be replicated before trying to Download it
var timeoutAt = DateTime.UtcNow.AddSeconds(30);
while (!_database.GridFS.Exists(Query.EQ("_id", uploadedFileInfo.Id)))
{
if (DateTime.UtcNow >= timeoutAt)
{
throw new TimeoutException("HelloWorld.txt failed to propagate to secondary");
}
Thread.Sleep(TimeSpan.FromMilliseconds(1));
}
using (var stream = new MemoryStream())
{
_database.GridFS.Download(stream, "HelloWorld.txt");
var downloadedBytes = stream.ToArray();
var downloadedText = Encoding.UTF8.GetString(downloadedBytes);
Assert.AreEqual("HelloWorld", downloadedText);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="connectionString"></param>
/// <param name="databaseName"></param>
/// <param name="collectionName"></param>
/// <param name="query">条件查询。 调用示例：Query.Matches("Title", "感冒") 或者 Query.EQ("Title", "感冒") 或者Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc")) 等等</param>
/// <returns></returns>
public static SafeModeResult DeleteAll(string connectionString, string databaseName, string collectionName, IMongoQuery query)
{
MongoServer server = MongoServer.Create(connectionString);
//获取数据库或者创建数据库（不存在的话）。
MongoDatabase database = server.GetDatabase(databaseName);
SafeModeResult result;
using (server.RequestStart(database))//开始连接数据库。
{
MongoCollection <BsonDocument> myCollection = database.GetCollection <BsonDocument>(collectionName);
if (null == query)
{
result = myCollection.RemoveAll();
}
else
{
result = myCollection.Remove(query);
}
}
return(result);
}
private static void InsertGroupPost(MongoServer mongo, MongoDatabase db, SqlCommand cmd)
{
cmd.CommandText = "delete from DoubanPost";
cmd.ExecuteNonQuery();
using (mongo.RequestStart(db))
{
var collection = db.GetCollection<BsonDocument>("postinfo_collection");
foreach (var item in collection.FindAll())
{
var list = item.RawValues.ToList();
cmd.CommandText = "insert into DoubanPost values (@v1,@v2,@v3)";
int v3;
if (!int.TryParse(list[3].ToString(), out v3))
{
v3 = -1;
}
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@v1", list[1].ToString());
cmd.Parameters.AddWithValue("@v2", list[2].ToString());
cmd.Parameters.AddWithValue("@v3", v3);
cmd.ExecuteNonQuery();
}
}
}
public static void CreateIndex(string connectionString, string databaseName, string collectionName, params string[] keyNames)
{
SafeModeResult result = new SafeModeResult();
if (null == keyNames)
{
return;
}
MongoServer server = MongoServer.Create(connectionString);
//获取数据库或者创建数据库（不存在的话）。
MongoDatabase database = server.GetDatabase(databaseName);
using (server.RequestStart(database))//开始连接数据库。
{
MongoCollection <BsonDocument> myCollection = database.GetCollection <BsonDocument>(collectionName);
if (!myCollection.IndexExists(keyNames))
{
myCollection.EnsureIndex(keyNames);
}
}
}
//TODO: come back and reduce number of reads on DB
/// <summary>
/// This method returns all historical orders.
/// </summary>
/// <returns>ArrayList of order objects</returns>
public ArrayList getAllOrders()
{
dLog.Info("Entering method getAllOrders");
ArrayList result = new ArrayList();
try
{
MongoServer server = MongoServer.Create();
MongoDatabase db = server.GetDatabase("neatoBurrito");
//MongoCredentials credentials = new MongoCredentials("username", "password");
//MongoDatabase salaries = server.GetDatabase("salaries", credentials);
using (server.RequestStart(db))
{
MongoCollection <BsonDocument> coll = db.GetCollection("order");
MongoCursor cur = coll.FindAll();
foreach (var doc in cur)
{
result.Add(getOrder(((BsonDocument)doc)["id"].AsInt32));
}
}
}
catch (Exception e2)
{
dLog.Error("Exception in getAllOrders: " + e2.Message);
}
finally
{
//using statement above already calls RequestDone()
}
return(result);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="connectionString"></param>
/// <param name="databaseName"></param>
/// <param name="collectionName"></param>
/// <param name="query">条件查询。 调用示例：Query.Matches("Title", "感冒") 或者 Query.EQ("Title", "感冒") 或者Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc")) 等等</param>
/// <param name="update">更新设置。调用示例：Update.Set("Title", "yanc") 或者 Update.Set("Title", "yanc").Set("Author", "yanc2") 等等</param>
/// <returns></returns>
public static SafeModeResult UpdateAll <T>(string connectionString, string databaseName, string collectionName, IMongoQuery query, IMongoUpdate update)
{
SafeModeResult result;
if (null == query || null == update)
{
return(null);
}
MongoServer server = MongoServer.Create(connectionString);
//获取数据库或者创建数据库（不存在的话）。
MongoDatabase database = server.GetDatabase(databaseName);
using (server.RequestStart(database))//开始连接数据库。
{
MongoCollection <BsonDocument> myCollection = database.GetCollection <BsonDocument>(collectionName);
result = myCollection.Update(query, update, UpdateFlags.Multi);
}
return(result);
}
public void TestLastErrorMessage()
{
using (_server.RequestStart(_database))
{
var c = new C {
List = new List <int>()
};
// insert it once
_collection.Insert(c);
var lastError = _server.GetLastError();
Assert.AreEqual(0, lastError.DocumentsAffected);
Assert.IsFalse(lastError.HasLastErrorMessage);
Assert.IsNull(lastError.LastErrorMessage);
Assert.IsFalse(lastError.UpdatedExisting);
// insert it again (expect duplicate key error)
_collection.Insert(c);
lastError = _server.GetLastError();
Assert.AreEqual(0, lastError.DocumentsAffected);
Assert.IsTrue(lastError.HasLastErrorMessage);
Assert.IsNotNull(lastError.LastErrorMessage);
Assert.IsFalse(lastError.UpdatedExisting);
}
}
public static T GetOne <T>(string connectionString, string databaseName, string collectionName, string _id)
{
T result = default(T);
ObjectId id;
if (!ObjectId.TryParse(_id, out id))
{
return(default(T));
}
MongoServer server = MongoServer.Create(connectionString);
//获取数据库或者创建数据库（不存在的话）。
MongoDatabase database = server.GetDatabase(databaseName);
using (server.RequestStart(database))//开始连接数据库。
{
MongoCollection <BsonDocument> myCollection = database.GetCollection <BsonDocument>(collectionName);
result = myCollection.FindOneAs <T>(Query.EQ("_id", id));
}
return(result);
}
public void Dispose()
{
if (!_disposed)
{
try
{
try
{
_request.Dispose();
}
finally
{
if (_wasSet)
{
// use a new request to set the mode off because the original connection could be closed if an error occurred
using (_server.RequestStart(_serverInstance))
{
SetMode("off");
}
}
}
}
finally
{
_disposed = true;
}
}
}
public static void performOperation()
{
MongoClient mc = new MongoClient("mongodb://aks-osx.local:27017,aks-osx.local:27018,aks-osx.local:27019/?readPreference=primaryPreferred");
IList cursorList = new ArrayList();
long counter = 0;
MongoServer ms = mc.GetServer();
MongoDatabase mDb = ms.GetDatabase("test");
using (ms.RequestStart(mDb)) {
while (true)
{
++counter;
try {
bool collExists = mDb.CollectionExists("data");
var coll = mDb.GetCollection("data");
long collCount = coll.Count();
if (counter % 100 == 0)
{
Console.WriteLine("Collection Stats [Thread: " + Thread.CurrentThread.ManagedThreadId
+ ", Exists: " + collExists
+ ", Count: " + collCount + ", listSize: " + cursorList.Count + "]");
}
cursorList.Add(coll.FindAll());
} catch (Exception ex) {
Console.WriteLine("Caught Exception within While Loop: " + ex.StackTrace);
}
}
}
}
// constructors
public FailPoint(string name, MongoServer server, MongoServerInstance serverInstance)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (server == null)
{
throw new ArgumentNullException("server");
}
if (serverInstance == null)
{
throw new ArgumentNullException("serverInstance");
}
if (server.RequestServerInstance != null)
{
throw new InvalidOperationException("FailPoint cannot be used when you are already in a RequestStart.");
}
_name = name;
_server = server;
_serverInstance = serverInstance;
_adminDatabase = server.GetDatabase("admin");
_request = server.RequestStart(serverInstance);
}
/// <summary>
/// 单实体数据查询
/// </summary>
/// <typeparam name="T">泛型对象</typeparam>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="databaseName">数据库名称</param>
/// <param name="collectionName">集合名称</param>
/// <param name="query">
/// 查询条件
/// <para>调用示例：</para>
/// <para> Query.Matches("Title", "感冒")</para>
/// <para> Query.EQ("Title", "感冒")</para>
/// <para> Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc"))</para>
/// <para></para>
/// </param>
/// <returns>泛型对象集合信息</returns>
public static T Select <T>(string connectionString, string databaseName, string collectionName, IMongoQuery query)
{
if (string.IsNullOrEmpty(connectionString) ||
string.IsNullOrEmpty(databaseName) ||
string.IsNullOrEmpty(collectionName) ||
null == query)
{
return(default(T));
}
MongoServer server = MongoServer.Create(connectionString);
MongoDatabase database = server.GetDatabase(databaseName);
T result = default(T);
using (server.RequestStart(database)) {
MongoCollection <BsonDocument> myCollection = database.GetCollection <BsonDocument>(collectionName);
if (null == query)
{
result = myCollection.FindOneAs <T>();
}
else
{
result = myCollection.FindOneAs <T>(query);
}
}
return(result);
}
/// <summary>
/// 单实体数据查询
/// </summary>
/// <typeparam name="T">泛型对象</typeparam>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="databaseName">数据库名称</param>
/// <param name="collectionName">集合名称</param>
/// <param name="_id">系统内置编号</param>
/// <returns>泛型对象集合信息</returns>
public static T Select <T>(string connectionString, string databaseName, string collectionName, string _id)
{
if (string.IsNullOrEmpty(connectionString) ||
string.IsNullOrEmpty(databaseName) ||
string.IsNullOrEmpty(collectionName) ||
string.IsNullOrEmpty(_id))
{
return(default(T));
}
T result = default(T);
ObjectId id;
if (!ObjectId.TryParse(_id, out id))
{
return(default(T));
}
MongoServer server = MongoServer.Create(connectionString);
MongoDatabase database = server.GetDatabase(databaseName);
using (server.RequestStart(database)) {
MongoCollection <BsonDocument> myCollection = database.GetCollection <BsonDocument>(collectionName);
result = myCollection.FindOneAs <T>(Query.EQ("_id", id));
}
return(result);
}
static void Main(string[] args)
{
string connectionString = "mongodb://localhost";
MongoServer server = MongoServer.Create(connectionString);
MongoDatabase database = server.GetDatabase("test");
using (server.RequestStart(database))
{
// a series of operations that must be performed on the same connection
}
}
/// <summary>
/// 分页查询 指定索引最后项-PageSize模式
/// </summary>
/// <typeparam name="T">所需查询的数据的实体类型</typeparam>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="databaseName">数据库名称</param>
/// <param name="collectionName">集合名称</param>
/// <param name="query">查询的条件 没有可以为null</param>
/// <param name="indexName">索引名称</param>
/// <param name="lastKeyValue">最后索引的值</param>
/// <param name="pageSize">分页大小</param>
/// <param name="sortType">排序类型 1升序 -1降序 仅仅针对该索引</param>
/// <param name="fields">字段设置</param>
/// <returns>返回一个List列表数据</returns>
public static List <T> Select <T>(string connectionString, string databaseName, string collectionName, IMongoQuery query, string indexName, object lastKeyValue, int pageSize, int sortType, params string[] fields)
{
if (string.IsNullOrEmpty(connectionString) ||
string.IsNullOrEmpty(databaseName) ||
string.IsNullOrEmpty(collectionName) ||
string.IsNullOrEmpty(indexName))
{
return(null);
}
if (pageSize <= 0)
{
pageSize = 200;
}
MongoServer server = MongoServer.Create(connectionString);
MongoDatabase database = server.GetDatabase(databaseName);
List <T> result = new List <T>();
using (server.RequestStart(database)) {
MongoCollection <T> mc = database.GetCollection <T>(collectionName);
MongoCursor <T> myCursor = null;
//当查询为空时 附加恒真的条件 类似SQL：1=1的语法
if (null == query)
{
query = Query.Exists("_id");
}
if (null != fields)
{
myCursor.SetFields(fields);
}
//判断升降序后进行查询
if (sortType > 0) //升序
{
if (lastKeyValue != null)
{
//有上一个主键的值传进来时才添加上一个主键的值的条件
query = Query.And(query, Query.GT(indexName, BsonValue.Create(lastKeyValue)));
}
//先按条件查询 再排序 再取数
myCursor = mc.Find(query).SetSortOrder(new SortByDocument(indexName, 1)).SetLimit(pageSize);
}
else //降序
{
if (lastKeyValue != null)
{
query = Query.And(query, Query.LT(indexName, BsonValue.Create(lastKeyValue)));
}
myCursor = mc.Find(query).SetSortOrder(new SortByDocument(indexName, -1)).SetLimit(pageSize);
}
result = myCursor.ToList <T>();
}
return(result);
}
static void Main(string[] args)
{
string[] lines = System.IO.File.ReadAllLines(@"C:\teste\teste.txt"); //Abre o arquivo
MongoServer mongo = MongoServer.Create(); // prepara para a conectar
mongo.Connect(); // conecta
var db = mongo.GetDatabase("mongoTempo"); //seleciona o DB
Stopwatch iw = new Stopwatch(); // prepara para contar o tempo
Stopwatch qw = new Stopwatch(); // prepara para contar o tempo
iw.Start(); // inicia a contagem de tempo de inserção
using (mongo.RequestStart(db))
{
var collection = db.GetCollection <BsonDocument>("dados"); //seleciona a tabela
foreach (string line in lines) //loop para percorrer as linhas
{
string[] exploded = line.Split(','); //função para separar os dados id, data, dados geograficos
if (exploded.Length == 4)
{
BsonDocument dados = new BsonDocument() //preparação das colunas
.Add("_id", exploded[0]) //prepara a coluna de id
.Add("data", exploded[1]) //prepara a coluna de data
.Add("local", exploded[2] + ';' + exploded[3]); //prepara a coluna de local
collection.Insert(dados); //insere os dados no BD
}
else
{
Console.WriteLine(line);
}
}
iw.Stop(); //finaliza a contagem de tempo da incercao
var query = new QueryDocument("data", "2008"); //variavel que guarda os dados de pesquisa (primeiro dado o nome da coluna, segundo dado o valor de pesquisa
qw.Start(); // inicia a contagem de tempo
foreach (BsonDocument item in collection.Find(query)) //executa a pesquisa dentro de um foreach para caso ter mais de um resultado ser listado
{
string json = item.ToJson(); //lista os resultados em formato Json;
}
qw.Stop(); //finaliza a contagem de tempo da busca
}
Console.WriteLine("Insercao no MongoDB completada em: " + (iw.ElapsedTicks / Stopwatch.Frequency) + " (s) e busca feita em: " + (qw.ElapsedTicks / Stopwatch.Frequency) + " (segundos)");// mostra o tempo em segundos
Console.WriteLine("Insercao no MongoDB completada em: " + (iw.ElapsedTicks * 1000 / Stopwatch.Frequency) + " (ms) e busca feita em: " + (qw.ElapsedTicks * 1000 / Stopwatch.Frequency) + " (ms)"); // mostra o tempo em milisegundos
System.Console.ReadKey();//não finaliza o programa até precionar uma tecla
}
public static SafeModeResult UpdateOne <T>(string connectionString, string databaseName, string collectionName, T entity)
{
MongoServer server = MongoServer.Create(connectionString);
//获取数据库或者创建数据库（不存在的话）。
MongoDatabase database = server.GetDatabase(databaseName);
SafeModeResult result;
using (server.RequestStart(database))//开始连接数据库。
{
MongoCollection <BsonDocument> myCollection = database.GetCollection <BsonDocument>(collectionName);
result = myCollection.Save(entity);
}
return(result);
}
/// <summary>
/// gets a document, change him with function and save
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <param name="collectionName"></param>
/// <param name="function"></param>
public void EditDocument <T>(IMongoQuery query, string collectionName, Action <T> function)
{
using (_server.RequestStart(_database))
{
T doc = this.GetDocument <T>(query, collectionName);
if (doc == null)
{
Log.Error("MongoDBContext.EditDocument", "No document found", query, collectionName);
}
else
{
function(doc);
this.SaveDocument <T>(doc, collectionName);
}
}
}
/// <summary>
/// 数据删除
/// <remarks>数据库不存在创建数据库</remarks>
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="databaseName">数据库名称</param>
/// <param name="collectionName">集合名称</param>
/// <param name="keyName">键名称</param>
/// <param name="keyValue">键值</param>
/// <returns>安全模式的结果</returns>
public static SafeModeResult Delete(string connectionString, string databaseName, string collectionName, string keyName, string keyValue)
{
if (string.IsNullOrEmpty(keyName) || string.IsNullOrEmpty(keyValue))
{
return(null);
}
SafeModeResult result;
MongoServer server = MongoServer.Create(connectionString);
MongoDatabase database = server.GetDatabase(databaseName);
using (server.RequestStart(database)) {
MongoCollection <BsonDocument> myCollection = database.GetCollection <BsonDocument>(collectionName);
result = myCollection.Remove(Query.EQ(keyName, keyValue));
}
return(result);
}
// constructors
public FailPoint(string name, MongoServer server, MongoServerInstance serverInstance)
{
if (name == null) { throw new ArgumentNullException("name"); }
if (server == null) { throw new ArgumentNullException("server"); }
if (serverInstance == null) { throw new ArgumentNullException("serverInstance"); }
if (server.RequestConnection != null)
{
throw new InvalidOperationException("FailPoint cannot be used when you are already in a RequestStart.");
}
_name = name;
_server = server;
_serverInstance = serverInstance;
_adminDatabase = server.GetDatabase("admin");
_request = server.RequestStart(_adminDatabase, serverInstance);
}
