C# BsonDocument.ToJson方法代码示例

        public void TestJsonWriterLocalDateTimeSetting()
        {
            var testDateTime = DateTime.ParseExact("2015-10-28T00:00:00Z", "yyyy-MM-ddTHH:mm:ss.FFFZ", System.Globalization.CultureInfo.InvariantCulture).ToUniversalTime();
            var document = new BsonDocument();
            document.Add("DateTimeField", testDateTime);
            var json = document.ToJson(new Bson.IO.JsonWriterSettings() { UseLocalTime = true });
            var expected = ("{ 'DateTimeField' : ISODate('" + testDateTime.ToLocalTime().ToString("yyyy-MM-ddTHH:mm:ss.FFFzzz") + "') }").Replace("'", "\"");
            Assert.AreEqual(expected, json);

            var bson = document.ToBson();
            var rehydrated = BsonDocument.Parse(json);
            Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));

            //test without settings, should work as before
            json = document.ToJson();
            expected = ("{ 'DateTimeField' : ISODate('" + testDateTime.ToString("yyyy-MM-ddTHH:mm:ss.FFFZ") + "') }").Replace("'", "\"");
            Assert.AreEqual(expected, json);
            bson = document.ToBson();
            rehydrated = BsonDocument.Parse(json);
            Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));

            //test with parameter, with no setting specified, should work as before
            json = document.ToJson(new Bson.IO.JsonWriterSettings());
            expected = ("{ 'DateTimeField' : ISODate('" + testDateTime.ToString("yyyy-MM-ddTHH:mm:ss.FFFZ") + "') }").Replace("'", "\"");
            Assert.AreEqual(expected, json);
            bson = document.ToBson();
            rehydrated = BsonDocument.Parse(json);
            Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson()));
        }

 public void TestDateTime()
 {
     DateTime jan_1_2010 = new DateTime(2010, 1, 1);
     BsonDocument document = new BsonDocument() {
         { "date", jan_1_2010 }
     };
     var settings = new BsonJsonWriterSettings { OutputMode = BsonJsonOutputMode.Strict };
     string json = document.ToJson(settings);
     string expected = "{ \"date\" : { \"$date\" : 1262322000000 } }";
     Assert.AreEqual(expected, json);
     settings = new BsonJsonWriterSettings { OutputMode = BsonJsonOutputMode.JavaScript };
     json = document.ToJson(settings);
     expected = "{ \"date\" : Date(1262322000000) }";
     Assert.AreEqual(expected, json);
 }

 public void TestDateTime()
 {
     DateTime jan_1_2010 = new DateTime(2010, 1, 1);
     double expectedValue = (jan_1_2010.ToUniversalTime() - BsonConstants.UnixEpoch).TotalMilliseconds;
     BsonDocument document = new BsonDocument() {
         { "date", jan_1_2010 }
     };
     var settings = new JsonWriterSettings { OutputMode = JsonOutputMode.Strict };
     string json = document.ToJson(settings);
     string expected = "{ \"date\" : { \"$date\" : # } }".Replace("#", expectedValue.ToString());
     Assert.AreEqual(expected, json);
     settings = new JsonWriterSettings { OutputMode = JsonOutputMode.JavaScript };
     json = document.ToJson(settings);
     expected = "{ \"date\" : Date(#) }".Replace("#", expectedValue.ToString());
     Assert.AreEqual(expected, json);
 }

 public static Resource ParseResource(BsonDocument document)
 {
     RemoveMetadata(document);
     string json = document.ToJson();
     Resource resource = FhirParser.ParseResourceFromJson(json);
     return resource;
 }

        public static void ExportSalesByProductReport(IList<SalesReport> reports)
        {
            const string path = @"..\..\Exported-Files\Json-Reports\";

            var client = new MongoClient();
            var database = client.GetDatabase("Reports");
            database.DropCollectionAsync("SalesByProductReports");
            var collection = database.GetCollection<BsonDocument>("SalesByProductReports");

            ClearDirectory(path);
            foreach (var report in reports)
            {
                var currentReport = new BsonDocument
                {
                    { "product-id", report.ProductId },
                    { "product-name", report.ProductName },
                    { "vendor-name", report.VendorName },
                    { "total-quantity-sold", report.TotalQuantitySold },
                    { "total-incomes", report.TotalIncomes.ToString() }
                };

                File.WriteAllText(path + report.ProductId + ".json", currentReport.ToJson());
                collection.InsertOneAsync(currentReport).Wait();
            }
        }

 public void AddBsonArray()
 {
     var person = new BsonDocument();
     person.Add("Name", new BsonString("Nameirakpam"));
     person.Add("address", new BsonArray(new[] {"Swapanalok","D-504","Pade Basti","Phursungi","Hadapsar"}));
     Console.WriteLine(person.ToJson());
 }

        public void Run()
        {
            var doc = new BsonDocument();
            IDictionary<string,string> seen = new Dictionary<string,string>(StringComparer.InvariantCultureIgnoreCase);

            foreach(var dir in Directory.EnumerateDirectories(".", "*", SearchOption.AllDirectories).Where(d=>!Ignore(d)))
            {
                var directoryName = dir;

                var assemblyName = Path.GetFileName(dir);
                if (assemblyName == null) continue;

                var nuspecFile = Path.Combine(dir, assemblyName + ".nuspec");
                if(!File.Exists(nuspecFile)) continue;

                const string s = ".\\";
                if (directoryName.StartsWith(s))
                    directoryName = directoryName.Substring(s.Length);

                if (seen.ContainsKey(assemblyName))
                {
                    _out.WriteLine("Conflict: {0} in both '{1}' and '{2}'", assemblyName, directoryName, seen[assemblyName]);
                }
                seen[assemblyName] = directoryName;
                doc[assemblyName] = directoryName;
            }
            File.WriteAllText("source_index.nugetine.json", doc.ToJson(_settings));
        }

 public void TestInt64TenGen() {
     var document = new BsonDocument { { "a", 1L } };
     var settings = new JsonWriterSettings { OutputMode = JsonOutputMode.TenGen };
     var json = document.ToJson(settings);
     var expected = "{ 'a' : NumberLong(1) }".Replace("'", "\"");
     Assert.AreEqual(expected, json);
 }

 public void TestIndentedTwoElements() {
     BsonDocument document = new BsonDocument() { { "a", "x" }, { "b", "y" } };
     var settings = new JsonWriterSettings { Indent = true };
     string json = document.ToJson(settings);
     string expected = "{\r\n  \"a\" : \"x\",\r\n  \"b\" : \"y\"\r\n}";
     Assert.AreEqual(expected, json);
 }

 public void TestIndentedOneElement() {
     BsonDocument document = new BsonDocument() { { "name", "value" } };
     var settings = new JsonWriterSettings { Indent = true };
     string json = document.ToJson(settings);
     string expected = "{\r\n  \"name\" : \"value\"\r\n}";
     Assert.AreEqual(expected, json);
 }

 public void TestIndentedEmptyDocument() {
     BsonDocument document = new BsonDocument();
     var settings = new JsonWriterSettings { Indent = true };
     string json = document.ToJson(settings);
     string expected = "{ }";
     Assert.AreEqual(expected, json);
 }

        public void JsonReader_should_support_reading_multiple_documents(
            [Range(0, 3)]
            int numberOfDocuments)
        {
            var document = new BsonDocument("x", 1);
            var json = document.ToJson();
            var input = Enumerable.Repeat(json, numberOfDocuments).Aggregate("", (a, j) => a + j);
            var expectedResult = Enumerable.Repeat(document, numberOfDocuments);

            using (var jsonReader = new JsonReader(input))
            {
                var result = new List<BsonDocument>();

                while (!jsonReader.IsAtEndOfFile())
                {
                    jsonReader.ReadStartDocument();
                    var name = jsonReader.ReadName();
                    var value = jsonReader.ReadInt32();
                    jsonReader.ReadEndDocument();

                    var resultDocument = new BsonDocument(name, value);
                    result.Add(resultDocument);
                }

                result.Should().Equal(expectedResult);
            }
        }

 public void TestAddHashtableWithOneEntry()
 {
     var hashtable = new Hashtable { { "A", 1 } };
     var document = new BsonDocument(hashtable);
     var json = document.ToJson();
     var expected = "{ 'A' : 1 }".Replace("'", "\"");
     Assert.AreEqual(expected, json);
 }

 public void TestBinary()
 {
     var document = new BsonDocument {
         { "bin", new BsonBinaryData(new byte[] { 1, 2, 3 }) }
     };
     string expected = "{ \"bin\" : { \"$binary\" : \"AQID\", \"$type\" : \"00\" } }";
     string actual = document.ToJson();
     Assert.AreEqual(expected, actual);
 }

 public void TestArray()
 {
     BsonDocument document = new BsonDocument() {
         { "array", new BsonArray { 1, 2, 3 } }
     };
     string json = document.ToJson();
     string expected = "{ \"array\" : [1, 2, 3] }";
     Assert.AreEqual(expected, json);
 }