C# BsonType类代码示例

 /// <summary>
 /// Initializes a new instance of the DateTimeSerializationOptions class.
 /// </summary>
 /// <param name="kind">The DateTimeKind (Local, Unspecified or Utc).</param>
 /// <param name="representation">The external representation.</param>
 public DateTimeSerializationOptions(
     DateTimeKind kind,
     BsonType representation
 ) {
     this.kind = kind;
     this.representation = representation;
 }

        public int CalculateSize(BsonType t_Type, List<object> value)
        {
            switch (t_Type)
            {
                case BsonType.Object:
                    {
                        foreach (var p in value)
                        {
                            //Console.WriteLine(new { p });

                            Native.document.body += new IHTMLPre { new { p } };

                        }
                        return -1;
                    }

                case BsonType.Integer:
                    return 4;
                case BsonType.Long:
                    return 8;
                case BsonType.Number:
                    return 8;
                case BsonType.Boolean:
                    return 1;
                case BsonType.Null:
                case BsonType.Undefined:
                    return 0;
                case BsonType.Date:
                    return 8;
                default:
                    return 12;
            }
        }

 public CollectionProperty(string name, BsonType type, string fullName)
 {
     _name = name;
     _type = type;
     _fullName = fullName;
     Children = new Dictionary<string, CollectionProperty>();
 }

        public static IBehavior Find(BsonType bsonType)
        {
            IBehavior behavior;

            return DsonBehaviors.TryGetValue(bsonType, out behavior)
                ? behavior
                : null;
        }

 /// <summary>
 /// Initializes a new instance of the RepresentationSerializationOptions class.
 /// </summary>
 /// <param name="representation">The external representation.</param>
 /// <param name="allowOverflow">Whether to allow overflow.</param>
 /// <param name="allowTruncation">Whether to allow truncation.</param>
 public RepresentationSerializationOptions(
     BsonType representation,
     bool allowOverflow,
     bool allowTruncation
 ) {
     this.representation = representation;
     this.allowOverflow = allowOverflow;
     this.allowTruncation = allowTruncation;
 }

 // constructors
 internal JsonReaderBookmark(BsonReaderState state, BsonType currentBsonType, string currentName, JsonReaderContext context, JsonToken currentToken, BsonValue currentValue, JsonToken pushedToken, int position)
     : base(state, currentBsonType, currentName)
 {
     _context = context.Clone();
     _currentToken = currentToken;
     _currentValue = currentValue;
     _pushedToken = pushedToken;
     _position = position;
 }

 public void ReturnToBookmark(PBBsonReaderBookmark bookmark)
 {
     _reader.ReturnToBookmark(bookmark.Bookmark);
     _type = bookmark.Type;
     _name = bookmark.Name;
     _bsonType = bookmark.BsonType;
     _value = bookmark.Value;
     _indent = bookmark.Indent;
     _indentString = bookmark.IndentString;
 }

 protected BsonReaderBookmark(
     BsonReadState state,
     BsonType currentBsonType,
     string currentName
 )
 {
     this.state = state;
     this.currentBsonType = currentBsonType;
     this.currentName = currentName;
 }

 internal BsonDocumentReaderBookmark(
     BsonDocumentReaderContext context,
     BsonReadState state,
     BsonType currentBsonType
 )
 {
     this.context = context.Clone();
     this.state = state;
     this.currentBsonType = currentBsonType;
 }

 public BsonBinaryReader(
     BsonBuffer buffer,
     BsonBinaryReaderSettings settings
 ) {
     this.buffer = buffer ?? new BsonBuffer();
     this.disposeBuffer = buffer == null; // only call Dispose if we allocated the buffer
     this.settings = settings;
     context = null;
     state = BsonReadState.Initial;
     currentBsonType = BsonType.Document;
 }

 // constructors
 /// <summary>
 /// Initializes a new instance of the <see cref="EnumRepresentationConvention" /> class.
 /// </summary>  
 /// <param name="representation">The serialization representation. 0 is used to detect representation
 /// from the enum itself.</param>
 public EnumRepresentationConvention(BsonType representation)
 {
     if (!((representation == 0) ||
         (representation == BsonType.String) ||
         (representation == BsonType.Int32) ||
         (representation == BsonType.Int64)))
     {
         throw new ArgumentException("Enums can only be represented as String, Int32, Int64 or the type of the enum");
     }
     _representation = representation;
 }

 // constructors
 internal BsonDocumentReaderBookmark(
     BsonReaderState state,
     BsonType currentBsonType,
     string currentName,
     BsonDocumentReaderContext context,
     BsonValue currentValue)
     : base(state, currentBsonType, currentName)
 {
     _context = context.Clone();
     _currentValue = currentValue;
 }

 public void TestConvention(BsonType value)
 {
     var convention = new EnumRepresentationConvention(value);
     var classMap = new BsonClassMap<TestClass>();
     var nonEnumMemberMap = classMap.MapMember(x => x.NonEnum);
     var defaultEnumMemberMap = classMap.MapMember(x => x.DefaultEnum);
     var changedEnumMemberMap = classMap.MapMember(x => x.ChangedRepresentationEnum);
     convention.Apply(nonEnumMemberMap);
     convention.Apply(changedEnumMemberMap);
     Assert.AreEqual(value, ((IRepresentationConfigurable)(changedEnumMemberMap.GetSerializer())).Representation);
 }

 // constructors
 internal BsonBinaryReaderBookmark(
     BsonReaderState state,
     BsonType currentBsonType,
     string currentName,
     BsonBinaryReaderContext context,
     int position)
     : base(state, currentBsonType, currentName)
 {
     _context = context.Clone();
     _position = position;
 }

 internal BsonBinaryReaderBookmark(
     BsonBinaryReaderContext context,
     BsonReadState state,
     BsonType currentBsonType,
     int position
 )
 {
     this.context = context;
     this.state = state;
     this.currentBsonType = currentBsonType;
     this.position = position;
 }