After setting up the MongoDB cluster yesterday, I began to plan an understanding of MongoDB and introduce use cases. Here, I will share some notes from the learning process to help readers quickly understand MongoDB and code with C#.
Introduction to MongoDB
What is MongoDB
MongoDB is a NoSQL database that primarily features the storage of structured data. It is an open-source database system based on distributed file storage.
Structured Data
In the past, we used databases like MySQL and SQL Server, where data was stored in rows. The structured data in MongoDB distinguishes itself from this tabular format.
Structured data has a hierarchical relationship:
For example:
{
"name": "MongoDB",
"type": "database",
"count": 1,
"info": {
"x": 203,
"y": 102
}
}
MongoDB and Relational Databases
Since there are no tables, rows, or columns in MongoDB, beginners might find it confusing. Below is a comparison of terms between MongoDB and typical SQL databases.
| SQL Term/Concept | MongoDB Term/Concept | Explanation |
| :---------------- | :------------------- | :--------------------------------------------- |
| database | database | Database |
| table | collection | Database Table/Collection |
| row | document | Data Record Row/Document |
| column | field | Data Field/Domain |
| index | index | Index |
| table joins | | Non-relational databases do not have table relationships |
| primary key | primary key | Primary Key, MongoDB automatically sets the _id field as the primary key |
Source: https://www.runoob.com/mongodb/mongodb-databases-documents-collections.html
Getting Started with MongoDB Commands
After entering the MongoDB shell using mongo, you can execute commands (similar to SQL) for operations.
Note: In MongoDB, there is an automatic _id field, which is automatically set as the primary key by MongoDB.
Show all databases (including system databases):
show dbs
Current database or collection in use:
db
Connect to a specified database:
use {database_name}
Show all collections:
show collections
# or
show tables
View all documents in a collection:
# MyCollection is the name of the collection
db.getCollection("MyCollection").find()
db.getCollection("MyCollection").find().limit(1000).skip(0)
You may not believe it, but I searched on Baidu for a long time and could not find a suitable and friendly article on "how to view all documents in MongoDB," especially with a lot of garbage articles on CSDN. I suggest not to fumble around; download Navicat Premium, which will prompt the commands used at the bottom during operations.
In addition, MongoDB has many useful tools: https://docs.mongodb.com/tools/
Documents
In MongoDB, a document is equivalent to a record (row) in a relational database.
However, in MongoDB, documents in a collection (Collection-Table) do not need to have the same fields. For example:
Document A:
{
"name": "MongoDB",
"type": "database",
"count": 1,
"info": {
"x": 203,
"y": 102
}
}
Document B:
{
"name": "MongoDB",
"typeName": "database",
"dataCount": 1,
"dataInfo": {
"m": 203,
"n": 102
}
}
.NET Core Example
We will start with a basic template.
Create a console application, open Nuget, and install MongoDB.Driver.
var client = new MongoClient("mongodb://{MongoDB}:27017");
IMongoDatabase database = client.GetDatabase("Test");
Collections
You can create a collection using CreateCollection() or CreateCollectionAsync(). Unlike traditional databases, you do not need to specify a structure when creating a collection; just specify the name:
await database.CreateCollectionAsync("Test");
Get Collection
The GetCollection() function allows you to retrieve a collection. If the collection does not exist, it will be created automatically.
IMongoCollection<TDocument> GetCollection<TDocument>()
Since the same collection can have documents with different fields and field types, it can be quite challenging to unify several documents if they differ, for example:
(N/A) indicates that the document does not have this field; if one document has 10 fields and another has 8 fields, but none of their fields are the same, merging them would result in 18 fields. Clearly, they should not be grouped together, but should instead be "archived" using strong types.
Create two classes, Test1 and Test2, with the following content:
public class Test1
{
public string Name { get; set; }
}
public class Test2
{
public string DataType { get; set; }
}
Get the collection with two document types:
var collection1 = database.GetCollection<Test1>("Test");
var collection2 = database.GetCollection<Test2>("Test");
This means you're obtaining the operational capability for documents of this format in the collection.
Insert data into the collection:
collection1.InsertOne(new Test1 { Name = "Test1" });
collection2.InsertOne(new Test2 { DataType = "Test2" });
// await collection.InsertOneAsync(object);
Run and check the results.
InsertMany() can insert multiple data items:
Test1[] datas = new Test1[]
{
new Test1 { Name = "Test1" }
};
collection1.InsertMany(datas);
Counting Documents
To get the total number of documents in a collection:
collection1.CountDocuments(new BsonDocument())
// await collection1.CountDocumentsAsync(new BsonDocument());
For any document collection object, using CountDocuments(new BsonDocument()) obtains the count of all documents in that collection, rather than just the count of that specific document type. For example:
var collection1 = database.GetCollection<Test1>("Test");
collection1.CountDocuments(new BsonDocument())
The result is not the count of Test1 documents but the count of all documents in the collection.
The reason is that CountDocuments() is a filtering function that can use specified conditions to filter the count of the matching documents. This will be discussed further.
Queries
Queries in MongoDB do not operate like expressions in LINQ, based on the IEnumerable or IEnumerable<T> interface, meaning there are no Where or Select query methods provided in the driver.
The Find() function is the query function where you can add extensive expressions to filter documents. Once the data loads into local memory, you can use enriched expressions.
BsonDocument is a type representing the document search conditions. If a BsonDocument object does not add any properties, then by default, all documents meet the condition unless specified otherwise.
We should add a property to both Test1 and Test2 types:
public ObjectId _id { get; set; }
Otherwise, a formatting error may occur: System.FormatException.
How to Serialize Documents
document is the document object, and JsonSerializer is a static class from System.Text.Json.
Console.WriteLine(JsonSerializer.Serialize(document));
Query the First Record
var document = collection1.Find(new BsonDocument()).FirstOrDefault();
Potential Issues Without Conditions
The following code may cause a runtime error:
var documents = await collection1.Find(new BsonDocument()).ToListAsync();
foreach(var item in documents)
{
Console.WriteLine(JsonSerializer.Serialize(item));
}
This is because collection1 is marked as a collection of Test1 documents, but .Find(new BsonDocument()) attempts to query all documents, therefore retrieving Test2 documents.
However, Test2 cannot be converted to Test1, resulting in a runtime error.
View All Documents
var documents = collection1.Find(new BsonDocument()).ToList();
var documents = await collection1.Find(new BsonDocument()).ToListAsync();
As mentioned earlier, if the collection contains other formats of documents, attempting to retrieve all documents may cause an error since Test2 and Test1 are not related.
If the document count is large, use the asynchronous ForEachAsync() query, which operates on a callback principle.
List<Test1> tests = new List<Test1>();
Action<Test1> action = item =>
{
tests.Add(item);
Console.WriteLine(JsonSerializer.Serialize(item));
};
await collection1.Find(new BsonDocument()).ForEachAsync(action);
End of Queries
After using Find() and subsequent functions for querying, if you want to terminate the query (lazy loading), you can use the ToCursor() function to finish; the program will immediately start querying and return data to memory.
Transform Queries
Using ToEnumerable() allows you to query documents with LINQ.
var list = collection1.Find(new BsonDocument()).ToCursor().ToEnumerable();
Filters
Previously, we used .Find(new BsonDocument()) in our queries; BsonDocument is the filter object that holds the filtering rules. However, we cannot set attributes directly in new BsonDocument(). Instead, we need to utilize the builder FilterDefinitionBuilder object, which can be created using MongoDB.Driver.Builders<TDocument>.Filter.
Assuming you have the following data set (documents):
5f8bdf88e63d14cb5f01dd85 小明 19
5f8bdf88e63d14cb5f01dd86 小红 20
5f8bdf88e63d14cb5f01dd87 小张 16
5f8bdf88e63d14cb5f01dd88 小小 17
# -----Code for Inserting Data-----
public class Test
{
public ObjectId _id { get; set; }
public string Name { get; set; }
public int Age { get; set; }
}
var datas = new Test[]
{
new Test{ Name="小明", Age=19},
new Test{ Name="小红", Age=20},
new Test{ Name="小张", Age=16},
new Test{ Name="小小", Age=17}
};
collection.InsertMany(datas);
Using the builder:
FilterDefinition<Test> filter = Builders<Test>.Filter
Querying documents where Age is greater than 18:
FilterDefinition<Test> filter = filterBuilder.Where(item => item.Age >= 18);
Retrieve results:
Test[] documents = collection.Find(filter).ToEnumerable<Test>().ToArray();
Filters also include Gt(), In(), Lte(), and other non-LINQ functions, which require looking at the documentation for learning.
Builders<TDocument>
Builders<TDocument> not only generates filtering builders but also several other types of builders:
// Condition Filters
public static FilterDefinitionBuilder<TDocument> Filter { get; }
// Index Filters
public static IndexKeysDefinitionBuilder<TDocument> IndexKeys { get; }
// Projector, equivalent to using LINQ's .Select() to query only the needed fields
public static ProjectionDefinitionBuilder<TDocument> Projection { get; }
// Sort, creates sorting rules such as sorting by age
public static SortDefinitionBuilder<TDocument> Sort { get; }
// Update, alters the values of certain fields, etc.
public static UpdateDefinitionBuilder<TDocument> Update { get; }
For further details, please refer to https://mongodb.github.io/mongo-csharp-driver/2.10/reference/driver/definitions/#projections.
Name Mapping
Since MongoDB differentiates fields based on case sensitivity, document fields generally use camelCase with a lowercase first letter, while C# field properties start with an uppercase letter. Therefore, it's necessary to map different names.
You can use the BsonElement attribute to set the mapping name.
class Person
{
[BsonElement("fn")]
public string FirstName { get; set; }
[BsonElement("ln")]
public string LastName { get; set; }
}
This is an introduction to MongoDB, but what are the advantages of using MongoDB? You can refer to this article from Alibaba Cloud: https://developer.aliyun.com/article/64352
The following scenarios are summarized:
-
Storing application logs. The logs are structured, easy to search, and can be exported in other formats for secondary use.
-
Adding fields without changing the table structure, allowing for flexible modifications.
-
Supports JSON format import; similar data structures to JSON; can easily restore object properties and store data in one go; traditional databases would require creating multiple tables and setting primary/foreign key relationships.
-
Clustering. Distributed clusters can handle massive amounts of data and are easily scalable; failover ensures service availability.
-
Addressing distributed file storage needs.
-
Flexible indexing methods.
-
... ...
文章评论