.NET生成MongoDB中的主键ObjectId

淡月无痕 發表於 2023-3-23 23:04:00

<h2>前言</h2>
因为很多场景下我们需要在创建MongoDB数据的时候提前生成好主键，像在EF中我们可以通过Guid.NewGuid()来生成主键，本来想着要不要实现一套MongoDB中ObjectId的，结果发现网上各种各样的实现都有，不过好在阅读C#MongoDB驱动mongo-csharp-driver代码的时候发现有ObjectId.GenerateNewId()的方法提供，我们可以直接调用即可，不需要我们在花费多余的时间设计重写了。
<h2>MongoDB ObjectId类型概述</h2>
<blockquote>
 每次插入一条数据系统都会自动插入一个_id键，键值不可以重复，它可以是任何类型的，也可以手动的插入，默认情况下它的数据类型是ObjectId，由于MongoDB在设计之初就是用作分布式数据库，所以使用ObjectId可以避免不同数据库中_id的重复（如果使用自增的方式在分布式系统中就会出现重复的_id的值）。 ObjectId使用12字节的存储空间，每个字节可以存储两个十六进制数字，所以一共可以存储24个十六进制数字组成的字符串，在这24个字符串中，前8位表示时间戳，接下来6位是一个机器码，接下来4位表示进程id，最后6位表示计数器。

</blockquote>
MongoDB 采用 ObjectId 来表示主键的类型，数据库中每个文档都拥有一个_id 字段表示主键，_id 的生成规则如下：
<blockquote>
其中包括：4-byte Unix 时间戳，3-byte 机器 ID，2-byte 进程 ID，3-byte 计数器(初始化随机)。

</blockquote>
<img src="https://img2023.cnblogs.com/blog/1336199/202303/1336199-20230327213834087-2092438723.png" alt="" loading="lazy">
<div class="cnblogs_code">
<pre>601e2b6ba3203cc89f 2d31aa
↑ ↑ ↑ ↑
时间戳机器码进程ID 随机数</pre>
</div>
<h2>MongoDB.Driver驱动安装</h2>
<h3>1、直接命令自动安装</h3>
<div class="cnblogs_code">
<pre>Install-Package MongoDB.Driver</pre>
</div>
<h3>2、搜索Nuget手动安装</h3>
<img src="https://img2023.cnblogs.com/blog/1336199/202303/1336199-20230301003335511-1864259395.png" alt="" class="medium-zoom-image" loading="lazy">
<div>
<h2>调用生成主键ObjectId</h2>
<div class="cnblogs_code">
<pre>var primarykeyId = ObjectId.GenerateNewId(); //输出：641c54b2e674000035001dc2</pre>
</div>
<h2>mongo-csharp-driver ObjectId详解</h2>
<blockquote>
关于ObjectId的生成原理大家阅读如下源码即可。
</blockquote>
源码地址：https://github.com/mongodb/mongo-csharp-driver/blob/ec74978f7e827515f29cc96fba0c727828e8df7c/src/MongoDB.Bson/ObjectModel/ObjectId.cs
<div class="cnblogs_code">
<pre>/* Copyright 2010-present MongoDB Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Security;
using System.Threading;

namespace MongoDB.Bson
{
/// <summary>
/// Represents an ObjectId (see also BsonObjectId).
/// </summary>
#if NET45

#endif
public struct ObjectId : IComparable<ObjectId>, IEquatable<ObjectId>, IConvertible
{
 // private static fields
 private static readonly ObjectId __emptyInstance = default(ObjectId);
 private static readonly int __staticMachine = (GetMachineHash() + GetAppDomainId()) & 0x00ffffff;
 private static readonly short __staticPid = GetPid();
 private static int __staticIncrement = (new Random()).Next();

 // private fields
 private readonly int _a;
 private readonly int _b;
 private readonly int _c;

 // constructors
 /// <summary>
 /// Initializes a new instance of the ObjectId class.
 /// </summary>
 /// <param name="bytes">The bytes.</param>
 public ObjectId(byte[] bytes)
 {
 if (bytes == null)
 {
 throw new ArgumentNullException("bytes");
 }
 if (bytes.Length != 12)
 {
 throw new ArgumentException("Byte array must be 12 bytes long", "bytes");
 }

 FromByteArray(bytes, 0, out _a, out _b, out _c);
 }

 /// <summary>
 /// Initializes a new instance of the ObjectId class.
 /// </summary>
 /// <param name="bytes">The bytes.</param>
 /// <param name="index">The index into the byte array where the ObjectId starts.</param>
 internal ObjectId(byte[] bytes, int index)
 {
 FromByteArray(bytes, index, out _a, out _b, out _c);
 }

 /// <summary>
 /// Initializes a new instance of the ObjectId class.
 /// </summary>
 /// <param name="timestamp">The timestamp (expressed as a DateTime).</param>
 /// <param name="machine">The machine hash.</param>
 /// <param name="pid">The PID.</param>
 /// <param name="increment">The increment.</param>
 public ObjectId(DateTime timestamp, int machine, short pid, int increment)
 : this(GetTimestampFromDateTime(timestamp), machine, pid, increment)
 {
 }

 /// <summary>
 /// Initializes a new instance of the ObjectId class.
 /// </summary>
 /// <param name="timestamp">The timestamp.</param>
 /// <param name="machine">The machine hash.</param>
 /// <param name="pid">The PID.</param>
 /// <param name="increment">The increment.</param>
 public ObjectId(int timestamp, int machine, short pid, int increment)
 {
 if ((machine & 0xff000000) != 0)
 {
 throw new ArgumentOutOfRangeException("machine", "The machine value must be between 0 and 16777215 (it must fit in 3 bytes).");
 }
 if ((increment & 0xff000000) != 0)
 {
 throw new ArgumentOutOfRangeException("increment", "The increment value must be between 0 and 16777215 (it must fit in 3 bytes).");
 }

 _a = timestamp;
 _b = (machine << 8) | (((int)pid >> 8) & 0xff);
 _c = ((int)pid << 24) | increment;
 }

 /// <summary>
 /// Initializes a new instance of the ObjectId class.
 /// </summary>
 /// <param name="value">The value.</param>
 public ObjectId(string value)
 {
 if (value == null)
 {
 throw new ArgumentNullException("value");
 }

 var bytes = BsonUtils.ParseHexString(value);
 FromByteArray(bytes, 0, out _a, out _b, out _c);
 }

 // public static properties
 /// <summary>
 /// Gets an instance of ObjectId where the value is empty.
 /// </summary>
 public static ObjectId Empty
 {
 get { return __emptyInstance; }
 }

 // public properties
 /// <summary>
 /// Gets the timestamp.
 /// </summary>
 public int Timestamp
 {
 get { return _a; }
 }

 /// <summary>
 /// Gets the machine.
 /// </summary>
 public int Machine
 {
 get { return (_b >> 8) & 0xffffff; }
 }

 /// <summary>
 /// Gets the PID.
 /// </summary>
 public short Pid
 {
 get { return (short)(((_b << 8) & 0xff00) | ((_c >> 24) & 0x00ff)); }
 }

 /// <summary>
 /// Gets the increment.
 /// </summary>
 public int Increment
 {
 get { return _c & 0xffffff; }
 }

 /// <summary>
 /// Gets the creation time (derived from the timestamp).
 /// </summary>
 public DateTime CreationTime
 {
 get { return BsonConstants.UnixEpoch.AddSeconds(Timestamp); }
 }

 // public operators
 /// <summary>
 /// Compares two ObjectIds.
 /// </summary>
 /// <param name="lhs">The first ObjectId.</param>
 /// <param name="rhs">The other ObjectId</param>
 /// <returns>True if the first ObjectId is less than the second ObjectId.</returns>
 public static bool operator <(ObjectId lhs, ObjectId rhs)
 {
 return lhs.CompareTo(rhs) < 0;
 }

 /// <summary>
 /// Compares two ObjectIds.
 /// </summary>
 /// <param name="lhs">The first ObjectId.</param>
 /// <param name="rhs">The other ObjectId</param>
 /// <returns>True if the first ObjectId is less than or equal to the second ObjectId.</returns>
 public static bool operator <=(ObjectId lhs, ObjectId rhs)
 {
 return lhs.CompareTo(rhs) <= 0;
 }

 /// <summary>
 /// Compares two ObjectIds.
 /// </summary>
 /// <param name="lhs">The first ObjectId.</param>
 /// <param name="rhs">The other ObjectId.</param>
 /// <returns>True if the two ObjectIds are equal.</returns>
 public static bool operator ==(ObjectId lhs, ObjectId rhs)
 {
 return lhs.Equals(rhs);
 }

 /// <summary>
 /// Compares two ObjectIds.
 /// </summary>
 /// <param name="lhs">The first ObjectId.</param>
 /// <param name="rhs">The other ObjectId.</param>
 /// <returns>True if the two ObjectIds are not equal.</returns>
 public static bool operator !=(ObjectId lhs, ObjectId rhs)
 {
 return !(lhs == rhs);
 }

 /// <summary>
 /// Compares two ObjectIds.
 /// </summary>
 /// <param name="lhs">The first ObjectId.</param>
 /// <param name="rhs">The other ObjectId</param>
 /// <returns>True if the first ObjectId is greather than or equal to the second ObjectId.</returns>
 public static bool operator >=(ObjectId lhs, ObjectId rhs)
 {
 return lhs.CompareTo(rhs) >= 0;
 }

 /// <summary>
 /// Compares two ObjectIds.
 /// </summary>
 /// <param name="lhs">The first ObjectId.</param>
 /// <param name="rhs">The other ObjectId</param>
 /// <returns>True if the first ObjectId is greather than the second ObjectId.</returns>
 public static bool operator >(ObjectId lhs, ObjectId rhs)
 {
 return lhs.CompareTo(rhs) > 0;
 }

 // public static methods
 /// <summary>
 /// Generates a new ObjectId with a unique value.
 /// </summary>
 /// <returns>An ObjectId.</returns>
 public static ObjectId GenerateNewId()
 {
 return GenerateNewId(GetTimestampFromDateTime(DateTime.UtcNow));
 }

 /// <summary>
 /// Generates a new ObjectId with a unique value (with the timestamp component based on a given DateTime).
 /// </summary>
 /// <param name="timestamp">The timestamp component (expressed as a DateTime).</param>
 /// <returns>An ObjectId.</returns>
 public static ObjectId GenerateNewId(DateTime timestamp)
 {
 return GenerateNewId(GetTimestampFromDateTime(timestamp));
 }

 /// <summary>
 /// Generates a new ObjectId with a unique value (with the given timestamp).
 /// </summary>
 /// <param name="timestamp">The timestamp component.</param>
 /// <returns>An ObjectId.</returns>
 public static ObjectId GenerateNewId(int timestamp)
 {
 int increment = Interlocked.Increment(ref __staticIncrement) & 0x00ffffff; // only use low order 3 bytes
 return new ObjectId(timestamp, __staticMachine, __staticPid, increment);
 }

 /// <summary>
 /// Packs the components of an ObjectId into a byte array.
 /// </summary>
 /// <param name="timestamp">The timestamp.</param>
 /// <param name="machine">The machine hash.</param>
 /// <param name="pid">The PID.</param>
 /// <param name="increment">The increment.</param>
 /// <returns>A byte array.</returns>
 public static byte[] Pack(int timestamp, int machine, short pid, int increment)
 {
 if ((machine & 0xff000000) != 0)
 {
 throw new ArgumentOutOfRangeException("machine", "The machine value must be between 0 and 16777215 (it must fit in 3 bytes).");
 }
 if ((increment & 0xff000000) != 0)
 {
 throw new ArgumentOutOfRangeException("increment", "The increment value must be between 0 and 16777215 (it must fit in 3 bytes).");
 }

 byte[] bytes = new byte[12];
 bytes[0] = (byte)(timestamp >> 24);
 bytes[1] = (byte)(timestamp >> 16);
 bytes[2] = (byte)(timestamp >> 8);
 bytes[3] = (byte)(timestamp);
 bytes[4] = (byte)(machine >> 16);
 bytes[5] = (byte)(machine >> 8);
 bytes[6] = (byte)(machine);
 bytes[7] = (byte)(pid >> 8);
 bytes[8] = (byte)(pid);
 bytes[9] = (byte)(increment >> 16);
 bytes[10] = (byte)(increment >> 8);
 bytes[11] = (byte)(increment);
 return bytes;
 }

 /// <summary>
 /// Parses a string and creates a new ObjectId.
 /// </summary>
 /// <param name="s">The string value.</param>
 /// <returns>A ObjectId.</returns>
 public static ObjectId Parse(string s)
 {
 if (s == null)
 {
 throw new ArgumentNullException("s");
 }

 ObjectId objectId;
 if (TryParse(s, out objectId))
 {
 return objectId;
 }
 else
 {
 var message = string.Format("'{0}' is not a valid 24 digit hex string.", s);
 throw new FormatException(message);
 }
 }

 /// <summary>
 /// Tries to parse a string and create a new ObjectId.
 /// </summary>
 /// <param name="s">The string value.</param>
 /// <param name="objectId">The new ObjectId.</param>
 /// <returns>True if the string was parsed successfully.</returns>
 public static bool TryParse(string s, out ObjectId objectId)
 {
 // don't throw ArgumentNullException if s is null
 if (s != null && s.Length == 24)
 {
 byte[] bytes;
 if (BsonUtils.TryParseHexString(s, out bytes))
 {
 objectId = new ObjectId(bytes);
 return true;
 }
 }

 objectId = default(ObjectId);
 return false;
 }

 /// <summary>
 /// Unpacks a byte array into the components of an ObjectId.
 /// </summary>
 /// <param name="bytes">A byte array.</param>
 /// <param name="timestamp">The timestamp.</param>
 /// <param name="machine">The machine hash.</param>
 /// <param name="pid">The PID.</param>
 /// <param name="increment">The increment.</param>
 public static void Unpack(byte[] bytes, out int timestamp, out int machine, out short pid, out int increment)
 {
 if (bytes == null)
 {
 throw new ArgumentNullException("bytes");
 }
 if (bytes.Length != 12)
 {
 throw new ArgumentOutOfRangeException("bytes", "Byte array must be 12 bytes long.");
 }

 timestamp = (bytes[0] << 24) + (bytes[1] << 16) + (bytes[2] << 8) + bytes[3];
 machine = (bytes[4] << 16) + (bytes[5] << 8) + bytes[6];
 pid = (short)((bytes[7] << 8) + bytes[8]);
 increment = (bytes[9] << 16) + (bytes[10] << 8) + bytes[11];
 }

 // private static methods
 private static int GetAppDomainId()
 {
#if NETSTANDARD1_5 || NETSTANDARD1_6
 return 1;
#else
 return AppDomain.CurrentDomain.Id;
#endif
 }

 /// <summary>
 /// Gets the current process id.This method exists because of how CAS operates on the call stack, checking
 /// for permissions before executing the method.Hence, if we inlined this call, the calling method would not execute
 /// before throwing an exception requiring the try/catch at an even higher level that we don't necessarily control.
 /// </summary>

 private static int GetCurrentProcessId()
 {
 return Process.GetCurrentProcess().Id;
 }

 private static int GetMachineHash()
 {
 // use instead of Dns.HostName so it will work offline
 var machineName = GetMachineName();
 return 0x00ffffff & machineName.GetHashCode(); // use first 3 bytes of hash
 }

 private static string GetMachineName()
 {
 return Environment.MachineName;
 }

 private static short GetPid()
 {
 try
 {
 return (short)GetCurrentProcessId(); // use low order two bytes only
 }
 catch (SecurityException)
 {
 return 0;
 }
 }

 private static int GetTimestampFromDateTime(DateTime timestamp)
 {
 var secondsSinceEpoch = (long)Math.Floor((BsonUtils.ToUniversalTime(timestamp) - BsonConstants.UnixEpoch).TotalSeconds);
 if (secondsSinceEpoch < int.MinValue || secondsSinceEpoch > int.MaxValue)
 {
 throw new ArgumentOutOfRangeException("timestamp");
 }
 return (int)secondsSinceEpoch;
 }

 private static void FromByteArray(byte[] bytes, int offset, out int a, out int b, out int c)
 {
 a = (bytes << 24) | (bytes << 16) | (bytes << 8) | bytes;
 b = (bytes << 24) | (bytes << 16) | (bytes << 8) | bytes;
 c = (bytes << 24) | (bytes << 16) | (bytes << 8) | bytes;
 }

 // public methods
 /// <summary>
 /// Compares this ObjectId to another ObjectId.
 /// </summary>
 /// <param name="other">The other ObjectId.</param>
 /// <returns>A 32-bit signed integer that indicates whether this ObjectId is less than, equal to, or greather than the other.</returns>
 public int CompareTo(ObjectId other)
 {
 int result = ((uint)_a).CompareTo((uint)other._a);
 if (result != 0) { return result; }
 result = ((uint)_b).CompareTo((uint)other._b);
 if (result != 0) { return result; }
 return ((uint)_c).CompareTo((uint)other._c);
 }

 /// <summary>
 /// Compares this ObjectId to another ObjectId.
 /// </summary>
 /// <param name="rhs">The other ObjectId.</param>
 /// <returns>True if the two ObjectIds are equal.</returns>
 public bool Equals(ObjectId rhs)
 {
 return
 _a == rhs._a &&
 _b == rhs._b &&
 _c == rhs._c;
 }

 /// <summary>
 /// Compares this ObjectId to another object.
 /// </summary>
 /// <param name="obj">The other object.</param>
 /// <returns>True if the other object is an ObjectId and equal to this one.</returns>
 public override bool Equals(object obj)
 {
 if (obj is ObjectId)
 {
 return Equals((ObjectId)obj);
 }
 else
 {
 return false;
 }
 }

 /// <summary>
 /// Gets the hash code.
 /// </summary>
 /// <returns>The hash code.</returns>
 public override int GetHashCode()
 {
 int hash = 17;
 hash = 37 * hash + _a.GetHashCode();
 hash = 37 * hash + _b.GetHashCode();
 hash = 37 * hash + _c.GetHashCode();
 return hash;
 }

 /// <summary>
 /// Converts the ObjectId to a byte array.
 /// </summary>
 /// <returns>A byte array.</returns>
 public byte[] ToByteArray()
 {
 var bytes = new byte[12];
 ToByteArray(bytes, 0);
 return bytes;
 }

 /// <summary>
 /// Converts the ObjectId to a byte array.
 /// </summary>
 /// <param name="destination">The destination.</param>
 /// <param name="offset">The offset.</param>
 public void ToByteArray(byte[] destination, int offset)
 {
 if (destination == null)
 {
 throw new ArgumentNullException("destination");
 }
 if (offset + 12 > destination.Length)
 {
 throw new ArgumentException("Not enough room in destination buffer.", "offset");
 }

 destination = (byte)(_a >> 24);
 destination = (byte)(_a >> 16);
 destination = (byte)(_a >> 8);
 destination = (byte)(_a);
 destination = (byte)(_b >> 24);
 destination = (byte)(_b >> 16);
 destination = (byte)(_b >> 8);
 destination = (byte)(_b);
 destination = (byte)(_c >> 24);
 destination = (byte)(_c >> 16);
 destination = (byte)(_c >> 8);
 destination = (byte)(_c);
 }

 /// <summary>
 /// Returns a string representation of the value.
 /// </summary>
 /// <returns>A string representation of the value.</returns>
 public override string ToString()
 {
 var c = new char[24];
 c[0] = BsonUtils.ToHexChar((_a >> 28) & 0x0f);
 c[1] = BsonUtils.ToHexChar((_a >> 24) & 0x0f);
 c[2] = BsonUtils.ToHexChar((_a >> 20) & 0x0f);
 c[3] = BsonUtils.ToHexChar((_a >> 16) & 0x0f);
 c[4] = BsonUtils.ToHexChar((_a >> 12) & 0x0f);
 c[5] = BsonUtils.ToHexChar((_a >> 8) & 0x0f);
 c[6] = BsonUtils.ToHexChar((_a >> 4) & 0x0f);
 c[7] = BsonUtils.ToHexChar(_a & 0x0f);
 c[8] = BsonUtils.ToHexChar((_b >> 28) & 0x0f);
 c[9] = BsonUtils.ToHexChar((_b >> 24) & 0x0f);
 c[10] = BsonUtils.ToHexChar((_b >> 20) & 0x0f);
 c[11] = BsonUtils.ToHexChar((_b >> 16) & 0x0f);
 c[12] = BsonUtils.ToHexChar((_b >> 12) & 0x0f);
 c[13] = BsonUtils.ToHexChar((_b >> 8) & 0x0f);
 c[14] = BsonUtils.ToHexChar((_b >> 4) & 0x0f);
 c[15] = BsonUtils.ToHexChar(_b & 0x0f);
 c[16] = BsonUtils.ToHexChar((_c >> 28) & 0x0f);
 c[17] = BsonUtils.ToHexChar((_c >> 24) & 0x0f);
 c[18] = BsonUtils.ToHexChar((_c >> 20) & 0x0f);
 c[19] = BsonUtils.ToHexChar((_c >> 16) & 0x0f);
 c[20] = BsonUtils.ToHexChar((_c >> 12) & 0x0f);
 c[21] = BsonUtils.ToHexChar((_c >> 8) & 0x0f);
 c[22] = BsonUtils.ToHexChar((_c >> 4) & 0x0f);
 c[23] = BsonUtils.ToHexChar(_c & 0x0f);
 return new string(c);
 }

 // explicit IConvertible implementation
 TypeCode IConvertible.GetTypeCode()
 {
 return TypeCode.Object;
 }

 bool IConvertible.ToBoolean(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }

 byte IConvertible.ToByte(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }

 char IConvertible.ToChar(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }

 DateTime IConvertible.ToDateTime(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }

 decimal IConvertible.ToDecimal(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }

 double IConvertible.ToDouble(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }

 short IConvertible.ToInt16(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }

 int IConvertible.ToInt32(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }

 long IConvertible.ToInt64(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }

 sbyte IConvertible.ToSByte(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }

 float IConvertible.ToSingle(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }

 string IConvertible.ToString(IFormatProvider provider)
 {
 return ToString();
 }

 object IConvertible.ToType(Type conversionType, IFormatProvider provider)
 {
 switch (Type.GetTypeCode(conversionType))
 {
 case TypeCode.String:
 return ((IConvertible)this).ToString(provider);
 case TypeCode.Object:
 if (conversionType == typeof(object) || conversionType == typeof(ObjectId))
 {
 return this;
 }
 if (conversionType == typeof(BsonObjectId))
 {
 return new BsonObjectId(this);
 }
 if (conversionType == typeof(BsonString))
 {
 return new BsonString(((IConvertible)this).ToString(provider));
 }
 break;
 }

 throw new InvalidCastException();
 }

 ushort IConvertible.ToUInt16(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }

 uint IConvertible.ToUInt32(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }

 ulong IConvertible.ToUInt64(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }
}
}</pre>
</div>
</div>

</div>
<div id="MySignature" role="contentinfo">
<blockquote >
作者名称：追逐时光者
作者简介：一个热爱编程、善于分享、喜欢学习、探索、尝试新事物和新技术的全栈软件工程师。

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文链接，否则保留追究法律责任的权利。如果该篇文章对您有帮助的话，可以点一下右下角的【&hearts;推荐&hearts;】，希望能够持续的为大家带来好的技术文章，文中可能存在描述不正确的地方，欢迎指正或补充，不胜感激。

</blockquote> 
来源：https://www.cnblogs.com/Can-daydayup/p/17249852.html

頁: [1]

琼殿技术论坛's Archiver

.NET生成MongoDB中的主键ObjectId