MongoDB via Dotnet Core数据映射详解

这个Demo的开发环境是：Mac + VS Code + Dotnet Core 3.1.2。

建立工程：

% dotnet new sln -o demo
The template "Solution file" was created successfully.
% cd demo 
% dotnet new console -o demo
The template "Console Application" was created successfully.

Processing post-creation actions...
Running 'dotnet restore' on demo/demo.csproj...
  Determining projects to restore...
  Restored demo/demo/demo.csproj (in 162 ms).

Restore succeeded.
% dotnet sln add demo/demo.csproj 
Project `demo/demo.csproj` added to the solution.

建立工程完成。

下面，增加包mongodb.driver到工程：

% cd demo
% dotnet add package mongodb.driver
  Determining projects to restore...
info : Adding packagereference for package 'mongodb.driver' into project 'demo/demo/demo.csproj'.
info : Committing restore...
info : Writing assets file to disk. Path: demo/demo/obj/project.assets.Json
log  : Restored /demo/demo/demo.csproj (in 6.01 sec).

项目准备完成。

看一下目录结构：

% tree .
.
├── demo
│   ├── Program.cs
│   ├── demo.csproj
│   └── obj
│       ├── demo.csproj.nuget.dgspec.Json
│       ├── demo.csproj.nuget.g.props
│       ├── demo.csproj.nuget.g.targets
│       ├── project.assets.Json
│       └── project.nuget.cache
└── demo.sln

mongodb.driver是MongoDB官方的数据库SDK，从Nuget上安装即可。

创建数据映射的模型类CollectionModel.cs，现在是个空类，后面所有的数据映射相关内容会在这个类进行说明：

public class CollectionModel
{
}

并修改Program.cs，准备Demo方法，以及连接数据库:

Program
{
    private const string MongoDBConnection = "mongodb://localhost:27031/admin";

    static IMongoClIEnt _clIEnt = new MongoClIEnt(MongoDBConnection);
    static IMongoDatabase _database = _clIEnt.GetDatabase("Test");
    static IMongoCollection<CollectionModel> _collection = _database.GetCollection<CollectionModel>("TestCollection");

    static async Task Main(string[] args)
    {
        await Demo();
        Console.ReadKey();
    }

    ()
    {
    }
}

从上面的代码中，我们看到，在生成Collection对象时，用到了CollectionModel：

IMongoDatabase _database = _clIEnt.GetDatabase("Test");
IMongoCollection<CollectionModel> _collection = _database.GetCollection<CollectionModel>("TestCollection");

这两行，其实就完成了一个映射的工作：把MongoDB中，Test数据库下，TestCollection数据集（就是sql中的数据表），映射到CollectionModel这个数据类中。换句话说，就是用CollectionModel这个类，来完成对数据集TestCollection的所有 *** 作。

保持CollectionModel为空，我们往数据库写入一行数据：

()
{
    CollectionModel new_item = new CollectionModel();
    await _collection.InsertOneAsync(new_item);
}

执行，看一下写入的数据：

{ 
    "_ID" : ObjectID("5ef1d8325327fd4340425ac9")
}

OK，我们已经写进去一条数据了。因为映射类是空的，所以写入的数据，也只有_ID一行内容。

但是，为什么会有一个_ID呢？

MongoDB数据集中存放的数据，称之为文档（document）。每个文档在存放时，都需要有一个ID，而这个ID的名称，固定叫_ID。

当我们建立映射时，如果给出_ID字段，则MongoDB会采用这个ID做为这个文档的ID，如果不给出，MongoDB会自动添加一个_ID字段。

例如：

CollectionModel
{
    public ObjectID _ID { get; set; }
    public string Title { get; string content { get; set; }
}

和

set; }
}

在使用上是完全一样的。唯一的区别是，如果映射类中不写_ID，则MongoDB自动添加_ID时，会用ObjectID作为这个字段的数据类型。

ObjectID是一个全局唯一的数据。

当然，MongoDB允许使用其它类型的数据作为ID，例如：string，int，long，GUID等，但这就需要你自己去保证这些数据不超限并且唯一。

例如，我们可以写成：

public long _ID { get; set; }
}

我们也可以在类中修改_ID名称为别的内容，但需要加一个描述属性BsonID：

CollectionModel
{
    [BsonID]
    public ObjectID topic_ID { get; set; }
}

这儿特别要注意：BsonID属性会告诉映射，topic_ID就是这个文档数据的ID。MongoDB在保存时，会将这个topic_ID转成_ID保存到数据集中。

在MongoDB数据集中，ID字段的名称固定叫_ID。为了代码的阅读方便，可以在类中改为别的名称，但这不会影响MongoDB中存放的ID名称。

修改Demo代码：

new CollectionModel()
    {
        Title = "Demo",
        content = "Demo content",
    };
    await _collection.InsertOneAsync(new_item);
}

跑一下Demo，看看保存的结果：

"5ef1e1b1bc1e18086afe3183"), 
    "Title" : "content" : "Demo content"
}

就是常规的数据字段，直接写就成。

int favor { get; set; }
}

保存后的数据：

"5ef1e9caa9d16208de2962bb"),1); word-wrap: inherit !important; word-break: inherit !important">"favor" : NumberInt(100)
}

说Decimal特殊，是因为MongoDB在早期，是不支持Decimal的。直到MongoDB v3.4开始，数据库才正式支持Decimal。

所以，如果使用的是v3.4以后的版本，可以直接使用，而如果是以前的版本，需要用以下的方式：

[BsonRepresentation(BsonType.Double, AllowTruncation = true)]
public decimal price { get; set; }

其实就是把Decimal通过映射，转为Double存储。

把类作为一个数据集的一个字段。这是MongoDB作为文档Nosql数据库的特色。这样可以很方便的把相关的数据组织到一条记录中，方便展示时的查询。

我们在项目中添加两个类Contact和Author：

Contact
{
    string mobile { get; set; }
}

Author
{
    string name { get; public List<Contact> contacts { get; set; }
}

然后，把Author加到CollectionModel中：

public Author author { get; set; }
}

嗯，开始变得有点复杂了。

完善Demo代码：

100,
        author = new Author
        {
            name = "WangPlus",
            contacts = new List<Contact>(),
        }
    };

    Contact contact_item1 = new Contact()
    {
        mobile = "13800000000",
    };
    Contact contact_item2 = "13811111111",
    };
    new_item.author.contacts.Add(contact_item1);
    new_item.author.contacts.Add(contact_item2);

    await _collection.InsertOneAsync(new_item);
}

保存的数据是这样的：

"5ef1e635ce129908a22dfb5e"),1); word-wrap: inherit !important; word-break: inherit !important">100),
    "author" : {
        "name" : "contacts" : [
            {
                "mobile" : "13800000000"
            }, 
            {
                "13811111111"
            }
        ]
    }
}

这样的数据结构，用着不要太爽！

枚举字段在使用时，跟类字段相似。

创建一个枚举TagEnumeration：

enum TagEnumeration
{
    CSharp = 1,
    Python = 2,
}

加到public TagEnumeration tag { get; set; }
}


修改Demo代码：

/* 后边代码略过 */
}

运行后看数据：

"5ef1eb87cbb6b109031fcc31"),1); word-wrap: inherit !important; word-break: inherit !important">"13811111111"
            }
        ]
    },1); word-wrap: inherit !important; word-break: inherit !important">"tag" : NumberInt(1)
}

在这里，tag保存了枚举的值。

我们也可以保存枚举的字符串。只要在CollectionModel中，tag声明上加个属性：

set; }
    [BsonRepresentation(BsonType.String)]
    set; }
}

数据会变成：

"5ef1ec448f1d540919d15904"),1); word-wrap: inherit !important; word-break: inherit !important">"tag" : "CSharp"
}

日期字段会稍微有点坑。

这个坑其实并不源于MongoDB，而是源于C#的DateTime类。我们知道，时间根据时区不同，时间也不同。而DateTime并不准确描述时区的时间。

我们先在CollectionModel中增加一个时间字段：

public DateTime post_time { get; set; }
}

修改Demo：

new CollectionModel()
    {
        /* 前边代码略过 */
        post_time = DateTime.Now, /* 2020-06-23T20:12:40.463+0000 */
    };
    /* 后边代码略过 */
}

运行看数据：

"5ef1f1b9a75023095e995d9f"),1); word-wrap: inherit !important; word-break: inherit !important">"CSharp",1); word-wrap: inherit !important; word-break: inherit !important">"post_time" : ISODate("2020-06-23T12:12:40.463+0000")
}

对比代码时间和数据时间，会发现这两个时间差了8小时 - 正好的中国的时区时间。

MongoDB规定，在数据集中存储时间时，只会保存UTC时间。

如果只是保存（像上边这样），或者查询时使用时间作为条件（例如查询post_time < DateTime.Now的数据）时，是可以使用的，不会出现问题。

但是，如果是查询结果中有时间字段，那这个字段，会被DateTime默认设置为DateTimeKind.UnspecifIEd类型。而这个类型，是无时区信息的，输出显示时，会造成混乱。

为了避免这种情况，在进行时间字段的映射时，需要加上属性：

[BsonDateTimeOptions(Kind = DateTimeKind.Local)]
set; }

这样做，会强制DateTime类型的字段为DateTimeKind.Local类型。这时候，从显示到使用就正确了。

但是，别高兴的太早，这儿还有一个但是。

这个但是是这样的：数据集中存放的是UTC时间，跟我们正常的时间有8小时时差，如果我们需要按日统计，比方每天的销售额/点击量，怎么搞？上面的方式，解决不了。

当然，基于MongoDB自由的字段处理，可以把需要统计的字段，按年月日时分秒拆开存放，像下面这样的：

Post_Time
{
    int year { get; int month { get; int day { get; int hour { get; int minute { get; int second { get; set; }
}

能解决，但是Low哭了有没有？

下面，终极方案来了。它就是：改写MongoDB中对于DateTime字段的序列化类。当当当～～～

先创建一个类MyDateTimeSerializer：

MyDateTimeSerializer : DateTimeSerializer
{
    public overrIDe DateTime Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
    {
        var obj = base.Deserialize(context, args);
        return new DateTime(obj.Ticks, DateTimeKind.UnspecifIEd);
    }
    public overrIDe voID Serialize(BsonSerializationContext context, BsonSerializationArgs args, DateTime value)
    {
        var utcValue = new DateTime(value.Ticks, DateTimeKind.Utc);
        base.Serialize(context, args, utcValue);
    }
}

代码简单，一看就懂。

注意，使用这个方法，上边那个对于时间加的属性[BsonDateTimeOptions(Kind = DateTimeKind.Local)]一定不要添加，要不然就等着哭吧:P

创建完了，怎么用？

如果你只想对某个特定映射的特定字段使用，比方只对CollectionModel的post_time字段来使用，可以这么写：

[BsonSerializer(typeof(MyDateTimeSerializer))]
set; }

或者全局使用：

BsonSerializer.RegisterSerializer(typeof(DateTime), new MongoDBDateTimeSerializer());

BsonSerializer是MongoDB.Driver的全局对象。所以这个代码，可以放到使用数据库前的任何地方。例如在Demo中，我放在Main里了：

string[] args)
{
    BsonSerializer.RegisterSerializer(typeof(DateTime),1); word-wrap: inherit !important; word-break: inherit !important">new MyDateTimeSerializer());

    ();
    Console.ReadKey();
}

这回看数据，数据集中的post_time跟当前时间显示完全一样了，你统计，你分组，可以随便霍霍了。

public Dictionary<string,1); word-wrap: inherit !important; word-break: inherit !important">int> extra_info { get; set; }

[BsonDictionaryOptions(DictionaryRepresentation.ArrayOfdocuments)]
set; }

"extra_info" : {
        "type" : NumberInt(1),1); word-wrap: inherit !important; word-break: inherit !important">"mode" : NumberInt(2)
    }
}

"extra_info" : [
        {
            "k" : "type", 
            "v" : NumberInt(1)
        }, 
        {
            "mode",1); word-wrap: inherit !important; word-break: inherit !important">2)
        }
    ]
}

"extra_info" : [
        [
            1)
        ], 
        [
            2)
        ]
    ]
}

[BsonElement("pt")]
set; }

[BsonDefaultValue("This is a default Title")]
set; }

[BsonRepresentation(BsonType.String)]
set; }

[BsonIgnore]
string ignore_string { get; set; }