C# IO.BsonDocumentWriter类代码示例

        public void TestNoCircularReference()
        {
            var c2 = new C { X = 2 };
            var c1 = new C { X = 1, NestedDocument = c2 };

            var json = c1.ToJson();
            var expected = "{ 'X' : 1, 'NestedDocument' : { 'X' : 2, 'NestedDocument' : null, 'BsonArray' : { '_csharpnull' : true } }, 'BsonArray' : { '_csharpnull' : true } }".Replace("'", "\"");
            Assert.AreEqual(expected, json);

            var memoryStream = new MemoryStream();
            using (var writer = new BsonBinaryWriter(memoryStream))
            {
                BsonSerializer.Serialize(writer, c1);
                Assert.AreEqual(0, writer.SerializationDepth);
            }

            var document = new BsonDocument();
            using (var writer = new BsonDocumentWriter(document))
            {
                BsonSerializer.Serialize(writer, c1);
                Assert.AreEqual(0, writer.SerializationDepth);
            }

            var stringWriter = new StringWriter();
            using (var writer = new JsonWriter(stringWriter))
            {
                BsonSerializer.Serialize(writer, c1);
                Assert.AreEqual(0, writer.SerializationDepth);
            }
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="nominalType"></param>
 /// <param name="value"></param>
 /// <param name="options"></param>
 /// <returns></returns>
 public static BsonDocument Serialize(Type nominalType, object value, IBsonSerializationOptions options)
 {
     var document = new BsonDocument();
     var writerSettings = new BsonDocumentWriterSettings();
     var writer = new BsonDocumentWriter(document, writerSettings);
     BsonSerializer.Serialize(writer, nominalType, value, options);
     return document;
 }

        public BsonDocument Serizalize(IEvent @event)
        {
            if (@event == null) throw new ArgumentNullException(nameof(@event));

            var document = new BsonDocument();

            using (var writer = new BsonDocumentWriter(document))
            {
                BsonSerializer.Serialize(writer, @event);
            }

            return document;
        }

 public void TestOneEmptyArray()
 {
     var document = new BsonDocument();
     using (var writer = new BsonDocumentWriter(document))
     {
         writer.WriteStartDocument();
         writer.WriteStartArray("a");
         writer.WriteEndArray();
         writer.WriteEndDocument();
     }
     var json = document.ToJson();
     var expected = "{ 'a' : [] }".Replace("'", "\"");
     Assert.Equal(expected, json);
 }

        public static BsonValue SerializeValue(this ISerializationExpression field, object value)
        {
            Ensure.IsNotNull(field, nameof(field));

            var tempDocument = new BsonDocument();
            using (var bsonWriter = new BsonDocumentWriter(tempDocument))
            {
                var context = BsonSerializationContext.CreateRoot(bsonWriter);
                bsonWriter.WriteStartDocument();
                bsonWriter.WriteName("value");
                field.Serializer.Serialize(context, value);
                bsonWriter.WriteEndDocument();
                return tempDocument[0];
            }
        }

 public void TestTwoNestedEmptyArrays()
 {
     var document = new BsonDocument();
     using (var writer = new BsonDocumentWriter(document))
     {
         writer.WriteStartDocument();
         writer.WriteStartDocument("nested");
         writer.WriteStartArray("a");
         writer.WriteEndArray();
         writer.WriteStartArray("b");
         writer.WriteEndArray();
         writer.WriteEndDocument();
         writer.WriteEndDocument();
     }
     var json = document.ToJson();
     var expected = "{ 'nested' : { 'a' : [], 'b' : [] } }".Replace("'", "\"");
     Assert.AreEqual(expected, json);
 }

 public void TestArrayWithNestedArrayWithTwoElements()
 {
     var document = new BsonDocument();
     using (var writer = new BsonDocumentWriter(document))
     {
         writer.WriteStartDocument();
         writer.WriteStartArray("a");
         writer.WriteStartArray();
         writer.WriteString("a");
         writer.WriteString("b");
         writer.WriteEndArray();
         writer.WriteEndArray();
         writer.WriteEndDocument();
     }
     var json = document.ToJson();
     var expected = "{ 'a' : [['a', 'b']] }".Replace("'", "\"");
     Assert.Equal(expected, json);
 }

        public static BsonArray SerializeValues(this ISerializationExpression field, IEnumerable values)
        {
            var tempDocument = new BsonDocument();
            using (var bsonWriter = new BsonDocumentWriter(tempDocument))
            {
                var context = BsonSerializationContext.CreateRoot(bsonWriter);
                bsonWriter.WriteStartDocument();
                bsonWriter.WriteName("values");
                bsonWriter.WriteStartArray();
                foreach (var value in values)
                {
                    field.Serializer.Serialize(context, value);
                }
                bsonWriter.WriteEndArray();
                bsonWriter.WriteEndDocument();

                return (BsonArray)tempDocument[0];
            }
        }

        public void TestSerializeDeserialize()
        {
            var path = "c:/a/b/c/f.txt";
            var data = new Data
            {
                Path = new ParsedPath(path, PathType.File)
            };

            var doc = new BsonDocument();

            using (var writer = new BsonDocumentWriter(doc, new BsonDocumentWriterSettings()))
            {
                BsonSerializer.Serialize(writer, data);
            }

            Assert.AreEqual(doc["Path"], new BsonString(path));

            using (var reader = new BsonDocumentReader(doc, new BsonDocumentReaderSettings()))
            {
                data = BsonSerializer.Deserialize<Data>(doc);
            }

            Assert.AreEqual(data.Path, new ParsedPath(path, PathType.File));
        }

 public void TestTwoInt64s()
 {
     var document = new BsonDocument();
     using (var writer = new BsonDocumentWriter(document))
     {
         writer.WriteStartDocument();
         writer.WriteInt64("a", 1);
         writer.WriteInt64("b", 2);
         writer.WriteEndDocument();
     }
     var json = document.ToJson();
     var expected = "{ 'a' : NumberLong(1), 'b' : NumberLong(2) }".Replace("'", "\""); ;
     Assert.Equal(expected, json);
 }

 public void TestTwoDoubles()
 {
     var document = new BsonDocument();
     using (var writer = new BsonDocumentWriter(document))
     {
         writer.WriteStartDocument();
         writer.WriteDouble("a", 1.5);
         writer.WriteDouble("b", 2.5);
         writer.WriteEndDocument();
     }
     var json = document.ToJson();
     var expected = "{ 'a' : 1.5, 'b' : 2.5 }".Replace("'", "\""); ;
     Assert.Equal(expected, json);
 }

 public void TestTwoDateTimes()
 {
     var document = new BsonDocument();
     using (var writer = new BsonDocumentWriter(document))
     {
         writer.WriteStartDocument();
         writer.WriteDateTime("a", 0);
         writer.WriteDateTime("b", 0);
         writer.WriteEndDocument();
     }
     var json = document.ToJson();
     var expected = "{ 'a' : ISODate('1970-01-01T00:00:00Z'), 'b' : ISODate('1970-01-01T00:00:00Z') }".Replace("'", "\""); ;
     Assert.Equal(expected, json);
 }

 public void TestTwoBooleans()
 {
     var document = new BsonDocument();
     using (var writer = new BsonDocumentWriter(document))
     {
         writer.WriteStartDocument();
         writer.WriteBoolean("a", true);
         writer.WriteBoolean("b", false);
         writer.WriteEndDocument();
     }
     var json = document.ToJson();
     var expected = "{ 'a' : true, 'b' : false }".Replace("'", "\""); ;
     Assert.Equal(expected, json);
 }

 public void TestTwoNestedTimestamps()
 {
     var document = new BsonDocument();
     using (var writer = new BsonDocumentWriter(document))
     {
         writer.WriteStartDocument();
         writer.WriteStartDocument("nested");
         writer.WriteTimestamp("a", 1);
         writer.WriteTimestamp("b", 2);
         writer.WriteEndDocument();
         writer.WriteEndDocument();
     }
     var json = document.ToJson();
     var expected = "{ 'nested' : { 'a' : Timestamp(0, 1), 'b' : Timestamp(0, 2) } }".Replace("'", "\"");
     Assert.Equal(expected, json);
 }

 public void TestTwoMinKeys()
 {
     var document = new BsonDocument();
     using (var writer = new BsonDocumentWriter(document))
     {
         writer.WriteStartDocument();
         writer.WriteMinKey("a");
         writer.WriteMinKey("b");
         writer.WriteEndDocument();
     }
     var json = document.ToJson();
     var expected = "{ 'a' : MinKey, 'b' : MinKey }".Replace("'", "\""); ;
     Assert.Equal(expected, json);
 }