CSHARP-1362: Support new Find server command.

Author: rstam

src/MongoDB.Bson.Tests/MongoDB.Bson.Tests.csproj

@@ -154,6 +154,7 @@
     <Compile Include="Serialization\Serializers\KeyValuePairSerializerTests.cs" />
     <Compile Include="Serialization\Serializers\LazyBsonArraySerializerTests.cs" />
     <Compile Include="Serialization\Serializers\LazyBsonDocumentSerializerTests.cs" />
+    <Compile Include="Serialization\Serializers\PartiallyRawBsonDocumentSerializerTests.cs" />
     <Compile Include="Serialization\Serializers\RawBsonArraySerializerTests.cs" />
     <Compile Include="Serialization\Serializers\RawBsonDocumentSerializerTests.cs" />
     <Compile Include="Serialization\Serializers\SerializeFlagsTests.cs" />

src/MongoDB.Bson.Tests/Serialization/Serializers/PartiallyRawBsonDocumentSerializerTests.cs

@@ -0,0 +1,112 @@
+/* Copyright 2015 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.IO;
+using FluentAssertions;
+using MongoDB.Bson.IO;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
+using NUnit.Framework;
+
+namespace MongoDB.Bson.Tests.Serialization.Serializers
+{
+    [TestFixture]
+    public class PartiallyRawBsonDocumentSerializerTests
+    {
+        [Test]
+        public void constructor_should_throw_when_name_is_null()
+        {
+            Action action = () => new PartiallyRawBsonDocumentSerializer(null, BsonDocumentSerializer.Instance);
+
+            action.ShouldThrow<ArgumentNullException>().And.ParamName.Should().Be("name");
+        }
+
+        [Test]
+        public void constructor_should_throw_when_rawSerializer_is_null()
+        {
+            Action action = () => new PartiallyRawBsonDocumentSerializer("name", null);
+
+            action.ShouldThrow<ArgumentNullException>().And.ParamName.Should().Be("rawSerializer");
+        }
+
+        [Test]
+        public void constructor_should_throw_when_rawSerializer_is_not_a_BsonValue_serializer()
+        {
+            Action action = () => new PartiallyRawBsonDocumentSerializer("name", new Int32Serializer());
+
+            action.ShouldThrow<ArgumentException>().And.ParamName.Should().Be("rawSerializer");
+        }
+
+        [Test]
+        public void Deserialize_should_return_partially_raw_BsonDocument()
+        {
+            var document = new BsonDocument
+            {
+                { "a", new BsonDocument("x", 1) },
+                { "b", new BsonDocument("x", 2) },
+                { "c", new BsonDocument("x", 3) }
+            };
+            var bson = document.ToBson();
+            var subject = new PartiallyRawBsonDocumentSerializer("b", RawBsonDocumentSerializer.Instance);
+
+            var result = Deserialize(bson, subject);
+
+            result["a"].Should().BeOfType<BsonDocument>();
+            result["b"].Should().BeOfType<RawBsonDocument>();
+            result["c"].Should().BeOfType<BsonDocument>();
+        }
+
+        [Test]
+        public void Deserialize_should_return_nested_partially_raw_BsonDocument()
+        {
+            var document = new BsonDocument
+            {
+                { "a", new BsonDocument("x", 1) },
+                { "b", new BsonDocument
+                    {
+                        { "d", new BsonDocument("z", 1) },
+                        { "e", new BsonDocument("z", 2) },
+                        { "f", new BsonDocument("z", 3) },
+                    }
+                },
+                { "c", new BsonDocument("x", 3) }
+            };
+            var bson = document.ToBson();
+            var subject = new PartiallyRawBsonDocumentSerializer("b", 
+                new PartiallyRawBsonDocumentSerializer("e", RawBsonDocumentSerializer.Instance));
+
+            var result = Deserialize(bson, subject);
+
+            result["a"].Should().BeOfType<BsonDocument>();
+            result["b"].Should().BeOfType<BsonDocument>();
+            result["c"].Should().BeOfType<BsonDocument>();
+            result["b"]["d"].Should().BeOfType<BsonDocument>();
+            result["b"]["e"].Should().BeOfType<RawBsonDocument>();
+            result["b"]["f"].Should().BeOfType<BsonDocument>();
+        }
+
+        // private methods
+        private BsonDocument Deserialize(byte[] bson, PartiallyRawBsonDocumentSerializer serializer)
+        {
+            using (var stream = new MemoryStream(bson))
+            using (var reader = new BsonBinaryReader(stream))
+            {
+                var context = BsonDeserializationContext.CreateRoot(reader);
+                return serializer.Deserialize(context);
+            }
+        }
+    }
+}

src/MongoDB.Bson/MongoDB.Bson.csproj

@@ -217,6 +217,7 @@
     <Compile Include="Serialization\Serializers\BsonBinaryDataSerializer.cs" />
     <Compile Include="Serialization\Serializers\BsonBooleanSerializer.cs" />
     <Compile Include="Serialization\IBsonSerializerExtensions.cs" />
+    <Compile Include="Serialization\Serializers\PartiallyRawBsonDocumentSerializer.cs" />
     <Compile Include="Serialization\Serializers\ProjectingDeserializer.cs" />
     <Compile Include="Serialization\Serializers\SerializerHelper.cs" />
     <Compile Include="Serialization\Serializers\DiscriminatedWrapperSerializer.cs" />

src/MongoDB.Bson/Serialization/Serializers/PartiallyRawBsonDocumentSerializer.cs

@@ -0,0 +1,87 @@
+/* Copyright 2015 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 MongoDB.Bson.IO;
+
+namespace MongoDB.Bson.Serialization.Serializers
+{
+    /// <summary>
+    /// Represents a serializer for a BsonDocument with some parts raw.
+    /// </summary>
+    public class PartiallyRawBsonDocumentSerializer : SerializerBase<BsonDocument>
+    {
+        // private fields
+        private readonly string _name;
+        private readonly IBsonSerializer _rawSerializer;
+
+        // constructors
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PartiallyRawBsonDocumentSerializer"/> class.
+        /// </summary>
+        /// <param name="name">The name.</param>
+        /// <param name="rawSerializer">The raw serializer.</param>
+        public PartiallyRawBsonDocumentSerializer(string name, IBsonSerializer rawSerializer)
+        {
+            if (name == null)
+            {
+                throw new ArgumentNullException("name");
+            }
+            if (rawSerializer == null)
+            {
+                throw new ArgumentNullException("rawSerializer");
+            }
+            if (!typeof(BsonValue).IsAssignableFrom(rawSerializer.ValueType))
+            {
+                throw new ArgumentException("RawSerializer ValueType must be a BsonValue.", "rawSerializer");
+            }
+
+            _name = name;
+            _rawSerializer = rawSerializer;
+        }
+
+        // public methods
+        /// <inheritdoc/>
+        public override BsonDocument Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
+        {
+            var document = new BsonDocument();
+
+            var reader = context.Reader;
+            reader.ReadStartDocument();
+            while (reader.ReadBsonType() != 0)
+            {
+                var name = reader.ReadName();
+                var serializer = ChooseSerializer(name);
+                var value = (BsonValue)serializer.Deserialize(context);
+                document[name] = value;
+            }
+            reader.ReadEndDocument();
+
+            return document;
+        }
+
+        private IBsonSerializer ChooseSerializer(string name)
+        {
+            if (name == _name)
+            {
+                return _rawSerializer;
+            }
+            else
+            {
+                return BsonValueSerializer.Instance;
+            }
+        }
+    }
+}