MongoDB stores data in JSON Documents. Actually, they are stored as Binary JSON (BSON) objects on disk, but that's another blog post. In our sample dataset, there is a sample_training with a grades collection. Here's what a sample document in that collection looks like:

{

"_id":{"$oid":"56d5f7eb604eb380b0d8d8ce"},

"student_id":{"$numberDouble":"0"},

"scores":[

{"type":"exam","score":{"$numberDouble":"78.40446309504266"}},

{"type":"quiz","score":{"$numberDouble":"73.36224783231339"}},

{"type":"homework","score":{"$numberDouble":"46.980982486720535"}},

{"type":"homework","score":{"$numberDouble":"76.67556138656222"}}

],

"class_id":{"$numberDouble":"339"}

}

There are 10,000 students in this collection, 0-9,999. Let's add one more by using C#. To do this, we'll need to use another package from NuGet, MongoDB.Bson. I'll start a new Solution in Visual Studio and call it MongoDBCRUDExample. I'll install the MongoDB.Bson and MongoDB.Driver packages and use the connection string provided from MongoDB Atlas. Next, I'll access our specific database and collection, sample_training and grades, respectively.

The collection variable is now our key reference point to our data. Since we are using a BsonDocument when assigning our collection variable, I've indicated that I'm not going to be using a pre-defined schema. This utilizes the power and flexibility of MongoDB's document model. I could define a plain-old-C#-object (POCO) to more strictly define a schema. I'll take a look at that option in a future post. For now, I'll create a new BsonDocument to insert into the database.

Then to Create the document in the sample_training.grades collection, we can do an insert operation.

If you need to do that insert asynchronously, the MongoDB C# driver is fully async compatible. The same operation could be done with:

If you have a need to insert multiple documents at the same time, MongoDB has you covered there as well with the InsertMany or InsertManyAsync methods.

We've seen how to structure a BSON Document in C# and then Create it inside a MongoDB database. The MongoDB C# Driver makes it easy to do with the InsertOne(), InsertOneAsync(), InsertMany(), or InsertManyAsync() methods. Now that we have Created data, we'll want to Read it.

Let's find the document we created and print it out to the console. The first step is to create a filter to query for our specific document.

var filter = Builders<BsonDocument>.Filter.Eq("student_id", 10000);

Here we're setting a filter to look for a document where the student_id is equal to 10000. We can pass the filter into the Find() method to get the first document that matches the query.

returns...

If a document isn't found that matches the query, the Find() method returns null. Finding the first document in a collection, or with a query is a frequent task. However, what about situations when all documents need to be returned, either in a collection or from a query?

For situations in which the expected result set is small, the ToList() or ToListAsync() methods can be used to retrieve all documents from a query or in a collection.

Filters can be passed in here as well, for example, to get documents with exam scores equal or above 95. The filter here looks slightly more complicated, but thanks to the MongoDB driver syntax, it is relatively easy to follow. We're filtering on documents in which inside the scores array there is an exam subdocument with a score value greater than or equal to 95.

For situations where it's necessary to iterate over the documents that are returned there are a couple of ways to accomplish that as well. In a synchronous situation, a C# foreach statement can be used with the ToEnumerable adapter method. In this situation, instead of using the ToList() method, we'll use the ToCursor() method.

This can be accomplished in an asynchronous fashion with the ForEachAsync method as well:

With many documents coming back in the result set, it is often helpful to sort the results. We can use the Sort() method to accomplish this to see which student had the highest exam score.

And we can append the First() method to that to just get the top student.

Based on the Atlas Sample Data Set, the document with a student_id of 9997 should be returned with an exam score of 95.441609472871946.

You can see the full code for both the Create and Read operations I've shown in the gist here.

The C# Driver for MongoDB provides many ways to Read data from the database and supports both synchronous and asynchronous methods for querying the data. By passing a filter into the Find() method, we are able to query for specific records. The syntax to build filters and query the database is straightforward and easy to read, making this step of CRUD operations in C# and MongoDB simple to use.

With the data created and being able to be read, let's take a look at how we can perform Update operations.

To update a document we need two bits to pass into an Update command. We need a filter to determine which documents will be updated. Second, we need what we're wanting to update.

For our example, we want to filter based on the document with student_id equaling 10000.

Next, we want to make the change to the class_id. We can do that with Set() on the Update() method.

Then we use the UpdateOne() method to make the changes. Note here that MongoDB will update at most one document using the UpdateOne() method. If no documents match the filter, no documents will be updated.

Not all changes are as simple as changing a single field. Let's use a different filter, one that selects a document with a particular score type for quizzes:

Now if we want to make the change to the quiz score we can do that with Set() too, but to identify which particular element should be changed is a little different. We can use the positional $ operator to access the quiz score in the array. The $ operator on its own says "change the array element that we matched within the query" - the filter matches with scores.type equal to quiz and that's the element will get updated with the set.

And again we use the UpdateOne() method to make the changes.

If you've been reading along in this blog series I've mentioned that the C# driver supports both sync and async interactions with MongoDB. Performing data Updates is no different. There is also an UpdateOneAsync() method available. Additionally, for those cases in which multiple documents need to be updated at once, there are UpdateMany() or UpdateManyAsync() options. The UpdateMany() and UpdateManyAsync() methods match the documents in the Filter and will update all documents that match the filter requirements.

Update is an important operator in the CRUD world. Not being able to update things as they change would make programming incredibly difficult. Fortunately, C# and MongoDB continue to work well together to make the operations possible and easy to use. Whether it's updating a student's grade or updating a user's address, Update is here to handle the changes. The code for the Create, Read, and Update operations can be found in this gist.

We're winding down this MongoDB C# Quick Start CRUD operation series with only one operation left to explore, Delete.

The first step in the deletion process is to create a filter for the document(s) that need to be deleted. In the example for this series, I've been using a document with a student_id value of 10000 to work with. Since I'll only be deleting that single record, I'll use the DeleteOne() method (for async situations the DeleteOneAsync() method is available). However, when a filter matches more than a single document and all of them need to be deleted, the DeleteMany() or DeleteManyAsync method can be used.

Here's the record I want to delete.

I'll define the filter to match the student_id equal to 10000 document:

Assuming that we have a collection variable assigned to for the grades collection, we next pass the filter into the DeleteOne() method.

If that command is run on the grades collection, the document with student_id equal to 10000 would be gone. Note here that DeleteOne() will delete the first document in the collection that matches the filter. In our example dataset, since there is only a single student with a student_id equal to 10000, we get the desired results.

For the sake of argument, let's imagine that the rules for the educational institution are incredibly strict. If you get below a score of 60 on the first exam, you are automatically dropped from the course. We could use a for loop with DeleteOne() to loop through the entire collection, find a single document that matches an exam score of less than 60, delete it, and repeat. Recall that DeleteOne() only deletes the first document it finds that matches the filter. While this could work, it isn't very efficient as multiple calls to the database are made. How do we handle situations that require deleting multiple records then? We can use DeleteMany().

Let's define a new filter to match the exam score being less than 60:

With the filter defined, we pass it into the DeleteMany() method:

With that command being run, all of the student record documents with low exam scores would be deleted from the collection.

Check out the gist for all of the CRUD commands wrapped into a single file.