public void Data_DatabaseWriter_RepeatingQueries() { var dbWriter = DatabaseWriter <CustomerInfo> .Construct(); var customer = new CustomerInfo(); // Multiple Gets var a = dbWriter.GetAll().ToList(); var aCount = a.Count; var b = dbWriter.GetAll().ToList(); var bCount = b.Count; // datastore.Save customer = dbWriter.GetByID(a.FirstOrDefaultSafe().ID); customer.FirstName = DateTime.UtcNow.Ticks.ToString(); dbWriter = DatabaseWriter <CustomerInfo> .Construct(customer); dbWriter.Save(); // Save check var c = dbWriter.GetAll().ToList(); var cCount = c.Count; Assert.IsTrue(aCount == bCount && bCount == cCount); // customer.save customer.Update(); // Multiple Gets var x = dbWriter.GetAll().ToList(); var xCount = x.Count; var y = dbWriter.GetAll().ToList(); var yCount = y.Count; var z = dbWriter.GetAll().ToList(); var zCount = z.Count; Assert.IsTrue(xCount == yCount && yCount == zCount); }
private void Save(Action <DatabaseWriter> save) { IsEnabled = false; var info = Cache.DbInfo; var database = Cache.Database; var writer = new DatabaseWriter(); info.OpenDatabaseFile(x => writer .LoadExisting(x, info.Data.MasterKey)); save(writer); info.SetDatabase(x => writer.Save( x, database.RecycleBin)); IsEnabled = true; ThreadPool.QueueUserWorkItem(_ => ListItems( _group, Cache.Database.RecycleBin)); Cache.UpdateRecents(); lstHistory.ItemsSource = null; ThreadPool.QueueUserWorkItem(_ => ListHistory(database)); Dispatcher.BeginInvoke(() => info.NotifyIfNotSyncable()); }
public void Data_DatabaseWriter_CountAny() { var db = DatabaseWriter <CustomerType> .Construct(); // GetAll() count and any var resultsAll = db.GetAll(); Assert.IsTrue(resultsAll.Count() > 0); Assert.IsTrue(resultsAll.Any()); // GetAll().Take(1) count and any var resultsTake = db.GetAll().Take(1); Assert.IsTrue(resultsTake.Count() == 1); Assert.IsTrue(resultsTake.Any()); // Get an ID to test var id = db.GetAllExcludeDefault().FirstOrDefaultSafe().ID; Assert.IsTrue(id != TypeExtension.DefaultInteger); // GetAll().Where count and any var resultsWhere = db.GetAll().Where(x => x.ID == id); Assert.IsTrue(resultsWhere.Count() > 0); Assert.IsTrue(resultsWhere.Any()); }
public void Data_DatabaseWriter_Update() { var testEntity = new CustomerInfo(); var saver = DatabaseWriter <CustomerInfo> .Construct(); var oldFirstName = TypeExtension.DefaultString; var newFirstName = DateTime.UtcNow.Ticks.ToString(); int entityID = TypeExtension.DefaultInteger; var entityKey = TypeExtension.DefaultGuid; // Create and capture original data this.Data_DatabaseWriter_Insert(); testEntity = saver.GetAll().OrderByDescending(x => x.CreatedDate).FirstOrDefaultSafe(); oldFirstName = testEntity.FirstName; entityID = testEntity.ID; entityKey = testEntity.Key; testEntity.FirstName = newFirstName; Assert.IsTrue(testEntity.IsNew == false); Assert.IsTrue(testEntity.ID != TypeExtension.DefaultInteger); Assert.IsTrue(testEntity.Key != TypeExtension.DefaultGuid); // Do Update saver = DatabaseWriter <CustomerInfo> .Construct(testEntity); saver.Save(); // Pull from DB and retest testEntity = saver.GetByID(entityID); Assert.IsTrue(testEntity.IsNew == false); Assert.IsTrue(testEntity.ID == entityID); Assert.IsTrue(testEntity.Key == entityKey); Assert.IsTrue(testEntity.ID != TypeExtension.DefaultInteger); Assert.IsTrue(testEntity.Key != TypeExtension.DefaultGuid); }
public void Data_DatabaseWriter_Delete() { var dbWriter = DatabaseWriter <CustomerInfo> .Construct(); var testEntity = new CustomerInfo(); var oldID = TypeExtension.DefaultInteger; var oldKey = TypeExtension.DefaultGuid; // Insert and baseline test this.Data_DatabaseWriter_Insert(); testEntity = dbWriter.GetAll().OrderByDescending(x => x.CreatedDate).FirstOrDefaultSafe(); oldID = testEntity.ID; oldKey = testEntity.Key; Assert.IsTrue(testEntity.IsNew == false); Assert.IsTrue(testEntity.ID != TypeExtension.DefaultInteger); Assert.IsTrue(testEntity.Key != TypeExtension.DefaultGuid); // Do delete dbWriter = DatabaseWriter <CustomerInfo> .Construct(testEntity); dbWriter.Delete(); // Pull from DB and retest testEntity = dbWriter.GetAll().Where(x => x.ID == oldID).FirstOrDefaultSafe(); Assert.IsTrue(testEntity.IsNew); Assert.IsTrue(testEntity.ID != oldID); Assert.IsTrue(testEntity.Key != oldKey); Assert.IsTrue(testEntity.IsNew); Assert.IsTrue(testEntity.Key == TypeExtension.DefaultGuid); // Add to recycle bin for cleanup DatabaseWriterTests.RecycleBin.Add(testEntity.ID); }
protected void lnkViewForm_Click(object sender, EventArgs e) { var btn = sender as LinkButton; if (btn != null) { var row = btn.NamingContainer as GridViewRow; if (row != null) { gvCBC.SelectedIndex = row.RowIndex; if (gvCBC.SelectedDataKey != null) { var year = gvCBC.SelectedDataKey[0].ToString(); var id = gvCBC.SelectedDataKey[1].ToString(); var taxRefNo = btn.CommandArgument.Split('|')[0]; var request = Request.QueryString["New"] == null ? 0 : Convert.ToInt32(Request.QueryString["New"]); if (request == 0) { DatabaseWriter.UpdateViewedCBC(Convert.ToDecimal(id)); } Response.Redirect( string.Format( "~/pages/cbcForm.aspx?incLocal={0}&refno={1}&year={2}&bck={3}&mspecId={4}" , 1 , taxRefNo , year , Request.Url.PathAndQuery.ToBase64String() , 0)); } } } }
public void Data_DatabaseWriter_GetWhere() { // Plain EntityInfo object var testData2 = DatabaseWriter <CustomerInfo> .Construct(); var testEntity2 = new CustomerInfo(); var testId2 = testData2.GetAllExcludeDefault().FirstOrDefaultSafe().ID; testEntity2 = testData2.GetAll().Where(x => x.ID == testId2).FirstOrDefaultSafe(); Assert.IsTrue(testEntity2.IsNew == false); Assert.IsTrue(testEntity2.ID != TypeExtension.DefaultInteger); Assert.IsTrue(testEntity2.Key != TypeExtension.DefaultGuid); // CrudEntity object this.Data_DatabaseWriter_Insert(); var testData = DatabaseWriter <CustomerInfo> .Construct(); var testEntity = new CustomerInfo(); var testId = testData.GetAllExcludeDefault().FirstOrDefaultSafe().ID; testEntity = testData.GetAll().Where(x => x.ID == testId).FirstOrDefaultSafe(); Assert.IsTrue(testEntity.IsNew == false); Assert.IsTrue(testEntity.ID != TypeExtension.DefaultInteger); Assert.IsTrue(testEntity.Key != TypeExtension.DefaultGuid); }
public ProfileController() { client = new DatabaseClient(); reader = new DatabaseReader(); writer = new DatabaseWriter(); updater = new DatabaseUpdater(); }
public void Data_DatabaseWriter_GetByID() { var custData = DatabaseWriter <CustomerInfo> .Construct(); var custEntity = new CustomerInfo(); var randomID = custData.GetAll().FirstOrDefaultSafe().ID; var randomID2 = custData.GetAll().OrderByDescending(x => x.ID).FirstOrDefaultSafe().ID; // GetByID var custGetByID = custData.GetByID(randomID); var custFirstName = custGetByID.FirstName; Assert.IsTrue(custGetByID.ID != TypeExtension.DefaultInteger); Assert.IsTrue(custGetByID.Key != TypeExtension.DefaultGuid); // By custom where var fname = custData.GetAll().Where(y => y.FirstName == custFirstName); Assert.IsTrue(fname.Any()); var fnEntity = fname.FirstOrDefaultSafe(); Assert.IsTrue(fnEntity.IsNew == false); Assert.IsTrue(fnEntity.FirstName != TypeExtension.DefaultString); // Where 1 record custEntity = custData.GetAll().Take(1).FirstOrDefaultSafe(); Assert.IsTrue(custEntity.ID == randomID); Assert.IsTrue(custEntity.IsNew == false); }
public void WriteAsyncWhenResultIsValidShouldWriteToDatabase() { var factory = DatabaseHelper.GetMockConnectionFactory(); using (var connection = factory.CreateConnectionAsync().Result) { DatabaseHelper.CreateTablesIfNotExist(); var deviceId = AddDummyDevviceToInMemoryDatabase(); var result = new ConveyorSimulator.SimulationResult { Id = deviceId, Speed = 213, DateTime = DateTime.UtcNow, PackageTrackingAlarmState = PackageTrackingAlarmState.Okay, CurrentRecipeCount = 2, CurrentBoards = 3 }; var writer = new DatabaseWriter(factory, Mock.Of <ILogger>()); writer.WriteAsync(result).Wait(); var results = connection.Query("SELECT * FROM DeviceReadings"); Assert.AreEqual(1, results.Count()); } }
public void ApproveCBCReport(string taxRefNo, int year, int approved, string userId) { var result = DatabaseWriter.UpdateCBCStatus(approved, taxRefNo, year, userId); if (approved == 1) { string Subject = ""; var email = string.IsNullOrEmpty(ADUser.CurrentUser.Mail) ? "*****@*****.**" : ADUser.CurrentUser.Mail; string[] senderEmail = { email }; if (result.HasRows) { DateTime repperiod = Convert.ToDateTime(result.Tables[0].Rows[0]["ReportingPeriod"].ToString()); var reportingPeriod = repperiod.ToString("yyyy-MM-dd"); Subject = string.Format("New data came in for the reporting period {0} ", reportingPeriod); Common.SendEmailToUsers(result, reportingPeriod, Subject, FDRPage.Statuses.DeletePackage, senderEmail); Common.SendEmailToRole("Approver", reportingPeriod, Subject, FDRPage.Statuses.DeletePackage, senderEmail); } else { // DatabaseWriter.ApproveOutgoingCBC(outCBC.Id, countryCode, year, statusId, ADUser.CurrentSID); Subject = string.Format("CBC for Tax No: {0} has been Accepted ", taxRefNo); Common.SendEmailToRole("Reviewer", taxRefNo, Subject, FDRPage.Statuses.Accepted, senderEmail); } } }
public int AddNewMne( decimal partyId , string taxpayerReferenceNumber , int yearofAssessment , string registeredName , string tradingName , string registrationNumber , DateTime financialYearEnd , decimal turnoverAmount , string nameUltimateHoldingCo , string ultimateHoldingCompanyResOutSaInd , string taxResidencyCountryCodeUltimateHoldingCompany , string ultimateHoldingCoIncomeTaxRefNo , string masterLocalFileRequiredInd , string cbCReportRequiredInd , DateTime datestamp) { return(DatabaseWriter.SaveNewEntity( partyId, taxpayerReferenceNumber, yearofAssessment, registeredName, tradingName, registrationNumber, financialYearEnd, turnoverAmount, nameUltimateHoldingCo, ultimateHoldingCompanyResOutSaInd, taxResidencyCountryCodeUltimateHoldingCompany, ultimateHoldingCoIncomeTaxRefNo, masterLocalFileRequiredInd, cbCReportRequiredInd, datestamp )); }
public void WriteRecord_MultipleRecordsWithoutTransactionAndNoCommit_ChangesAreCommitted() { var people = Person.Faker.Generate(2); var commands = new SqlCommand[] { DatabaseWriterTests.GenerateInsertPersonCommand(people[0]), DatabaseWriterTests.GenerateInsertPersonCommand(people[1]) }; var commandFactory = MockRepository.GenerateMock <IDatabaseWriterCommandFactory>(); commandFactory.Stub(x => x.Create(Arg <object> .Is.Equal(people[0]))).Return(commands[0]); commandFactory.Stub(x => x.Create(Arg <object> .Is.Equal(people[1]))).Return(commands[1]); using (var databaseWriter = new DatabaseWriter(commandFactory, DatabaseWriterTests.DbConnectionString, false)) { databaseWriter.Open(); databaseWriter.WriteRecord(people[0]); databaseWriter.WriteRecord(people[1]); } using (var testDb = new TestDb(DatabaseWriterTests.DbConnectionString)) { var records = testDb.Delete("dbo.Person", people.ToArray()); Assert.AreEqual(2, records.Length); } }
private void Save() { progBusy.IsBusy = true; string groupId; if (!NavigationContext.QueryString .TryGetValue("group", out groupId)) { groupId = null; } ThreadPool.QueueUserWorkItem(_ => { var info = Cache.DbInfo; var database = Cache.Database; var writer = new DatabaseWriter(); info.OpenDatabaseFile(x => writer .LoadExisting(x, info.Data.MasterKey)); if (_entry.ID != null) { _binding.Save(); writer.Details(_entry); } else { database.AddNew( _entry, groupId); writer.New(_entry); } info.SetDatabase(x => writer.Save( x, database.RecycleBin)); Dispatcher.BeginInvoke(() => { UpdateNotes(); progBusy.IsBusy = false; _binding.HasChanges = false; if (!info.NotifyIfNotSyncable()) { new ToastPrompt { Title = Properties.Resources.SavedTitle, Message = Properties.Resources.SavedCaption, TextOrientation = System.Windows.Controls .Orientation.Vertical, }.Show(); } }); ThreadPool.QueueUserWorkItem( __ => Cache.AddRecent(_entry.ID)); }); }
public readonly Stream stream; //Stream is always open and is never closed. public void SaveNow(string filename) { File.Delete(filename); using (FileStream fs = new FileStream(filename, FileMode.Create)) { DatabaseWriter.WriteDatabase(fs, tables); } }
public void WriteAsyncWhenResultIsNullShouldThrowArgumentNullException() { var writer = new DatabaseWriter(DatabaseHelper.GetMockConnectionFactory(), Mock.Of <ILogger>()); Func <Task> target = () => writer.WriteAsync(null); Assert.ThrowsExceptionAsync <ArgumentNullException>(target); }
public GameController() { client = new DatabaseClient(); reader = new DatabaseReader(); writer = new DatabaseWriter(); updater = new DatabaseUpdater(); rand = new Random(); }
public static void RemoveInstantElement <T>(this T table) where T : ITable { lock (Locker) { DatabaseWriter <T> .Remove(table); ITableManager.RemoveFromCache(table); } }
public static void AddInstantElement <T>(this T table) where T : ITable { lock (Locker) { DatabaseWriter <T> .Insert(table); ITableManager.AddToCache(table); } }
public static void Cleanup() { var db = DatabaseWriter <CustomerInfo> .Construct(); foreach (int item in CrudEntityTests.RecycleBin) { db.GetByID(item).Delete(); } }
public void DatabaseWriter_Write_NotImplimented() { //arange Writer w = new DatabaseWriter(); //act bool sucess = w.Write("test"); //assert Assert.IsTrue(sucess); }
protected void btnGenerate_Click(object sender, EventArgs e) { Button btnGenerate = (Button)sender; GridViewRow gvRow = (GridViewRow)btnGenerate.Parent.Parent; Guid newUID = new Guid(); var xmldoc = new XmlDocument(); XmlNode messageSpec = xmldoc.CreateNode(XmlNodeType.Element, "MessageSpec", null); var countryCode = gvRow.Cells[0].Text.Split('-')[1].Trim(); var country = gvRow.Cells[0].Text.Split('-')[0].Trim(); var year = int.Parse(gvRow.Cells[1].Text); if (ValidateRequiredFields(year)) { decimal id = 0; var package = Common.GenerateNewPackage(countryCode, dpReportingPeriod.Text, ref messageSpec, id); if (!string.IsNullOrEmpty(package.ToString())) { var outgoingCBC = new OutGoingCBCDeclarations() { Id = id, Country = countryCode, CBCData = package.ToString(), NSCBCData = null, StatusId = 2, Year = year, ReportingPeriod = DateTime.Parse(dpReportingPeriod.Text), CreatedBy = Sars.Systems.Security.ADUser.CurrentSID }; id = DatabaseWriter.SaveOutgoingCBC(outgoingCBC, ref newUID); if (id > 0) { var newPackage = Common.GenerateNewPackage(countryCode, dpReportingPeriod.Text, ref messageSpec, id); var newMessageSpec = messageSpec; var nmPackage = Common.GenerateNMPackage(countryCode, dpReportingPeriod.Text, newMessageSpec); var newPackagedCBC = new OutGoingCBCDeclarations() { Id = id, Country = countryCode, CBCData = newPackage.ToString(), NSCBCData = nmPackage, StatusId = 2, Year = year, CreatedBy = Sars.Systems.Security.ADUser.CurrentSID }; var saved = DatabaseWriter.SaveOutgoingCBC(newPackagedCBC, ref newUID); } DBWriteManager.Insert_OutgoingPackageAuditTrail(newUID, Sars.Systems.Security.ADUser.CurrentSID, string.Format("Package for {0} generated", country)); LoadCBC(); MessageBox.Show(string.Format("Package for {0} was successfully generated", country)); } } }
private void Init(string dbName) { if (init) // Close existing connections { Close(); } init = true; dbWriter = new DatabaseWriter(dbName); dbReader = new DatabaseReader(dbName); Console.WriteLine("[DBADAPTER] Inited Database: " + dbName); }
public static void RemoveInstantElement <T>(this T table, bool removefromList = true) where T : ITable { lock (Locker) { DatabaseWriter <T> .InstantRemove(table); if (removefromList) { SaveTask.RemoveFromList(table); } } }
public static void AddInstantElement <T>(this T table, bool addtolist = true) where T : ITable { lock (Locker) { DatabaseWriter <T> .InstantInsert(table); if (addtolist) { SaveTask.AddToList(table); } } }
public static void Cleanup() { var dbWriter = DatabaseWriter <CustomerInfo> .Construct(); var toDelete = new CustomerInfo(); foreach (int item in DatabaseWriterTests.RecycleBin) { toDelete = dbWriter.GetAll().Where(x => x.ID == item).FirstOrDefaultSafe(); dbWriter = DatabaseWriter <CustomerInfo> .Construct(toDelete); dbWriter.Delete(); } }
protected override List <Order> PreparePlaceOrders() { WriteToLogDB("PreparePlaceOrders", "Started"); Bar bar = DatabaseReader.SelectLastPrice(Symbol); double lastPrice = bar.Close; double buyPrice = RoundToStep(lastPrice - 0.02); double sellPrice = RoundToStep(lastPrice + 0.02); int buyVol = 0; int sellVol = 0; if (CurrentState.Position == 0) { buyVol = ContractsToTrade; sellVol = ContractsToTrade; } else if (CurrentState.Position < 0) { buyVol = ContractsToTrade; sellVol = ContractsToTrade - Math.Abs(CurrentState.Position); } else { buyVol = ContractsToTrade - Math.Abs(CurrentState.Position); sellVol = ContractsToTrade; } if (buyPrice >= sellPrice || (buyPrice <= 0 && buyVol != 0) || (sellPrice <= 0 && sellVol != 0)) { throw new SmartException(ExceptionImportanceLevel.HIGH, "PreparePlaceOrders", "ContrTrendStrat", "buyPrice = " + buyPrice + ", sellPrice = " + sellPrice); } WriteToLogDB("PreparePlaceOrders", "Buy: Price = " + buyPrice + ", Volume = " + buyVol + "; Sell: Price = " + sellPrice + ", Volume = " + sellVol); List <Order> placeOrders = new List <Order>(); DateTime dTime = ServerTime.GetRealTime(); DatabaseWriter.InsertDecision(dTime, Symbol, ActionEnum.BUY, buyPrice, buyVol, 0); DatabaseWriter.InsertDecision(dTime, Symbol, ActionEnum.SELL, sellPrice, sellVol, 0); if (buyVol > 0) { placeOrders.Add(new Order(Symbol, GenerateCookie(), "", buyVol, 0, buyPrice, 0, ActionEnum.BUY, OrderTypeEnum.LIMIT)); } if (sellVol > 0) { placeOrders.Add(new Order(Symbol, GenerateCookie(), "", sellVol, 0, sellPrice, 0, ActionEnum.SELL, OrderTypeEnum.LIMIT)); } WriteToLogDB("PreparePlaceOrders", "Finished"); return(placeOrders); }
private void SavePackage(StringBuilder package, decimal id, string countryCode, int year) { Guid newUid = new Guid(); var outgoingCBC = new OutGoingCBCDeclarations() { Id = id, Country = countryCode, NSCBCData = package.ToString(), StatusId = 3, Year = year, CreatedBy = Sars.Systems.Security.ADUser.CurrentSID }; decimal saved = DatabaseWriter.SaveOutgoingCBC(outgoingCBC, ref newUid); }
public void Data_DatabaseWriter_GetAll() { var typeDB = DatabaseWriter <CustomerType> .Construct(); var typeResults = typeDB.GetAll().Take(1); Assert.IsTrue(typeResults.Count() > 0); this.Data_DatabaseWriter_Insert(); var custDB = DatabaseWriter <CustomerInfo> .Construct(); var custResults = custDB.GetAll().Take(1); Assert.IsTrue(custResults.Count() > 0); }
public void Data_DatabaseWriter_GetByKey() { // Should create 1 record var custData = DatabaseWriter <CustomerInfo> .Construct(); var custCount = custData.GetAll().Count(); Assert.IsTrue(custCount > 0); // ByKey Should return 1 record var existingKey = custData.GetAll().FirstOrDefaultSafe().Key; var custWhereKey = custData.GetByKey(existingKey); Assert.IsTrue(custWhereKey.Key == existingKey); Assert.IsTrue(custWhereKey.ID != TypeExtension.DefaultInteger); }
public async void Test() { _databaseConnection.Connect(); ///////////////////////////////////// // OPERATIONAL, CONTEXUAL SCOPE... // ///////////////////////////////////// // create a Writer to write to the database IWriter writer = new Writer(_databaseConnection); // create a Reader to read from the database IReader reader = new Reader(_databaseConnection); // create an Updater to update the database IUpdater updater = new Updater(_databaseConnection); Entry exampleMongoDBEntry = new Entry(); exampleMongoDBEntry.Message = "Hello"; // write the object to the "MyFirstCollection" Collection that exists within the // previously referenced "MyFirstDatabase" that was used to create the "writer" object writer.Write<Entry>("MyFirstCollection", exampleMongoDBEntry); IEnumerable<Entry> readEntrys = reader.Read<Entry>("MyFirstCollection", // within this collection... "Message",// for the object field "Description" "Hello");// return matches for 'Hello' Assert.AreEqual(1, readEntrys.Count()); //////////////////////////////////// // AND ASYNCHRONOUS OPERATIONS... // //////////////////////////////////// // read, write and update asynchronously using System.Threading.Task IAsyncReader asyncReader = new AsyncReader(reader); readEntrys = await asyncReader.ReadAsync<Entry>("MyFirstCollection", "Message", "Hello"); Assert.AreEqual(1, readEntrys.Count()); IAsyncWriter asyncWriter = new AsyncWriter(writer); IAsyncUpdater asyncUpdater = new AsyncUpdater(updater); // or delegate call backs IAsyncDelegateReader asyncDelegateReader = new AsyncDelegateReader(reader); asyncDelegateReader.AsyncReadCompleted += new ReadCompletedEvent(readerCallBack); asyncDelegateReader.ReadAsync<Entry>("MyFirstCollection", "Message", "Hello"); _readerAutoResetEvent.WaitOne(); Assert.AreEqual(1, _asyncReadResults.Count()); IAsyncDelegateWriter asyncDelegateWriter = new AsyncDelegateWriter(writer); IAsyncDelegateUpdater asyncDelegateUpdater = new AsyncDelegateUpdater(updater); ///////////////////////////////////////////// // FOR A SERVER, DATABASE OR COLLECTION... // ///////////////////////////////////////////// // get a little higher level with the EasyMongo.Database namespace to target a database for operations IDatabaseReader databaseReader = new DatabaseReader(reader, asyncReader); IDatabaseWriter databaseWriter = new DatabaseWriter(writer, asyncWriter); IDatabaseUpdater databaseUpdater = new DatabaseUpdater(updater, asyncUpdater); // or a little lower level with the EasyMongo.Collection namespace to target a specific Collection ICollectionReader collectionReader = new CollectionReader(databaseReader, "MyFirstCollection"); ICollectionWriter collectionWriter = new CollectionWriter(databaseWriter, "MyFirstCollection"); ICollectionUpdater collectionUpdater = new CollectionUpdater(databaseUpdater, "MyFirstCollection"); /////////////////////////////////////////////// // TO RESTRICT CLIENT SCOPE (LAW OF DEMETER) // /////////////////////////////////////////////// // operate only against "MyFirstDatabase"'s "MySecondCollection" readEntrys = collectionReader.Read<Entry>("Message", "Hello"); Assert.AreEqual(1, readEntrys.Count()); ///////////////////// // GENERIC CLASSES // ///////////////////// // Instead of defining generic type arguments at the method level, // you can do it once at the class declaration IWriter<Entry> writerT = new Writer<Entry>(writer); writerT.Write("MySecondCollection", new Entry() { Message = "Goodbye World (Generically)" }); /////////////////////////////// // SIMPLIFY CREATION VIA IoC // /////////////////////////////// // because EasyMongo is a componentized framework built with blocks of functionality, EasyMongo // works great with DI containers and Inversion of Control. // here's an example of using the nuget Ninject extension to load EasyMongo mappings and a conn // string from configuration Ninject.IKernel kernel = new Ninject.StandardKernel(); ICollectionUpdater<Entry> collectionUpdaterT = kernel.TryGet<ICollectionUpdater<Entry>>(); // the alternative to this would be: IServerConnection serverConn = new ServerConnection(LOCAL_MONGO_SERVER_CONNECTION_STRING); IDatabaseConnection databaseConnn = new DatabaseConnection(serverConn, "MyFirstDatabase"); IDatabaseUpdater databaseUpdatr = new DatabaseUpdater(updater, asyncUpdater); ICollectionUpdater collectionUpdaterTheHardWay = new CollectionUpdater(databaseUpdater, "MySecondCollection"); ///////////////////////// // SIMPLE QUERIES... // ///////////////////////// databaseReader.Read<Entry>("MyFirstCollection", "Message", "Hello"); readEntrys = await databaseReader.ReadAsync<Entry>("MyFirstCollection", "Message", "Hello"); Assert.AreEqual(1, readEntrys.Count()); ///////////////////////// // POWERFUL QUERIES... // ///////////////////////// // when more robust querying is needed leverage power of underlying MongoDB driver IMongoQuery IMongoQuery query1 = Query.Matches("Message", new BsonRegularExpression("HE", "i")); IEnumerable<Entry> queryResults = reader.Execute<Entry>("MyFirstCollection", query1); Assert.AreEqual(1, queryResults.Count()); Assert.AreEqual("Hello", queryResults.ElementAt(0).Message); ////////////////////// // AND COMBINATIONS // ////////////////////// Entry exampleMongoDBEntry2 = new Entry(); exampleMongoDBEntry2.Message = "Hello Again"; Entry exampleMongoDBEntry3 = new Entry(); exampleMongoDBEntry3.Message = "Goodbye"; writer.Write<Entry>("MyFirstCollection", exampleMongoDBEntry2); writer.Write<Entry>("MyFirstCollection", exampleMongoDBEntry3); // "AND" multiple IMongoQueries... IMongoQuery query2 = Query.Matches("Message", new BsonRegularExpression("Again")); queryResults = reader.ExecuteAnds<Entry>("MyFirstCollection", new []{ query1, query2}); Assert.AreEqual(1, queryResults.Count()); Assert.AreEqual("Hello Again", queryResults.ElementAt(0).Message); // "OR" multiple IMongoQueries... IMongoQuery query3 = Query.Matches("Message", new BsonRegularExpression("Goo")); queryResults = reader.ExecuteOrs<Entry>("MyFirstCollection", new[] { query1, query2, query3 }); Assert.AreEqual(3, queryResults.Count()); Assert.AreEqual("Hello", queryResults.ElementAt(0).Message); Assert.AreEqual("Hello Again", queryResults.ElementAt(1).Message); Assert.AreEqual("Goodbye", queryResults.ElementAt(2).Message); }