// methods /// <inheritdoc/> public UpdateMessage ReadMessage() { var jsonReader = CreateJsonReader(); var messageContext = BsonDeserializationContext.CreateRoot(jsonReader); var messageDocument = BsonDocumentSerializer.Instance.Deserialize(messageContext); var opcode = messageDocument["opcode"].AsString; if (opcode != "update") { throw new FormatException("Opcode is not update."); } var requestId = messageDocument["requestId"].ToInt32(); var databaseName = messageDocument["database"].AsString; var collectionName = messageDocument["collection"].AsString; var query = messageDocument["query"].AsBsonDocument; var update = messageDocument["update"].AsBsonDocument; var isMulti = messageDocument.GetValue("isMulti", false).ToBoolean(); var isUpsert = messageDocument.GetValue("isUpsert", false).ToBoolean(); return(new UpdateMessage( requestId, new CollectionNamespace(databaseName, collectionName), query, update, NoOpElementNameValidator.Instance, isMulti, isUpsert)); }
public DeleteMessage ReadMessage() { if (_binaryReader == null) { throw new InvalidOperationException("No binaryReader was provided."); } var streamReader = _binaryReader.StreamReader; var messageSize = streamReader.ReadInt32(); var requestId = streamReader.ReadInt32(); var responseTo = streamReader.ReadInt32(); var opcode = (Opcode)streamReader.ReadInt32(); var reserved = streamReader.ReadInt32(); var fullCollectionName = streamReader.ReadCString(); var flags = (DeleteFlags)streamReader.ReadInt32(); var context = BsonDeserializationContext.CreateRoot <BsonDocument>(_binaryReader); var query = BsonDocumentSerializer.Instance.Deserialize(context); var firstDot = fullCollectionName.IndexOf('.'); var databaseName = fullCollectionName.Substring(0, firstDot); var collectionName = fullCollectionName.Substring(firstDot + 1); var isMulti = !flags.HasFlag(DeleteFlags.Single); return(new DeleteMessage( requestId, databaseName, collectionName, query, isMulti)); }
public void Deserialize_should_support_duplicate_element_names_in_full_document() { var json = "{ fullDocument : { x : 1, x : 2 } }"; var subject = CreateSubject(); ChangeStreamDocument <BsonDocument> result; using (var reader = new JsonReader(json)) { var context = BsonDeserializationContext.CreateRoot(reader); result = subject.Deserialize(context); } var fullDocument = result.FullDocument; fullDocument.ElementCount.Should().Be(2); var firstElement = fullDocument.GetElement(0); firstElement.Name.Should().Be("x"); firstElement.Value.Should().Be(1); var secondElement = fullDocument.GetElement(1); secondElement.Name.Should().Be("x"); secondElement.Value.Should().Be(2); }
public static async void InsertGrades(IMongoDatabase db) { string jsonPath = @"C:\Codec\MongoDB\Uni\week_2_crud.bf5486e303a0\homework_2_1\grades.json"; try { await db.DropCollectionAsync("grades"); var collection = db.GetCollection <Grades>("grades"); using (var streamReader = new StreamReader(jsonPath)) { string line; while ((line = await streamReader.ReadLineAsync()) != null) { using (var jsonReader = new JsonReader(line)) { var context = BsonDeserializationContext.CreateRoot(jsonReader); var document = collection.DocumentSerializer.Deserialize(context); await collection.InsertOneAsync(document); } } } Console.WriteLine("Successfully Uploaded Grades"); Console.WriteLine("Querying all documents"); await QueryAllDocuments(db, "grades"); } catch (Exception ex) { Console.WriteLine("Exception \n\n"); Console.WriteLine(ex.Message); } }
internal DeleteMessage ReadMessage <TDocument>(IBsonSerializer <TDocument> serializer) where TDocument : BsonDocument { var binaryReader = CreateBinaryReader(); var stream = binaryReader.BsonStream; stream.ReadInt32(); // messageSize var requestId = stream.ReadInt32(); stream.ReadInt32(); // responseTo stream.ReadInt32(); // opcode stream.ReadInt32(); // reserved var fullCollectionName = stream.ReadCString(Encoding); var flags = (DeleteFlags)stream.ReadInt32(); var context = BsonDeserializationContext.CreateRoot(binaryReader); var query = serializer.Deserialize(context); var isMulti = (flags & DeleteFlags.Single) != DeleteFlags.Single; return(new DeleteMessage( requestId, CollectionNamespace.FromFullName(fullCollectionName), query, isMulti)); }
/// <summary> /// Writes a raw BSON array. /// </summary> /// <param name="slice">The byte buffer containing the raw BSON array.</param> public virtual void WriteRawBsonArray(IByteBuffer slice) { // overridden in BsonBinaryWriter to write the raw bytes to the stream // for all other streams, deserialize the raw bytes and serialize the resulting array instead using (var chunkSource = new InputBufferChunkSource(BsonChunkPool.Default)) using (var buffer = new MultiChunkBuffer(chunkSource)) using (var stream = new ByteBufferStream(buffer)) { // wrap the array in a fake document so we can deserialize it var documentLength = slice.Length + 8; buffer.EnsureCapacity(documentLength); stream.WriteInt32(documentLength); stream.WriteBsonType(BsonType.Array); stream.WriteByte((byte)'x'); stream.WriteByte(0); stream.WriteSlice(slice); stream.WriteByte(0); buffer.MakeReadOnly(); stream.Position = 0; using (var reader = new BsonBinaryReader(stream, BsonBinaryReaderSettings.Defaults)) { var deserializationContext = BsonDeserializationContext.CreateRoot(reader); reader.ReadStartDocument(); reader.ReadName("x"); var array = BsonArraySerializer.Instance.Deserialize(deserializationContext); reader.ReadEndDocument(); var serializationContext = BsonSerializationContext.CreateRoot(this); BsonArraySerializer.Instance.Serialize(serializationContext, array); } } }
// public methods /// <summary> /// Reads the message. /// </summary> /// <returns>A message.</returns> public CompressedMessage ReadMessage() { var reader = CreateJsonReader(); var context = BsonDeserializationContext.CreateRoot(reader); var messageDocument = BsonDocumentSerializer.Instance.Deserialize(context); var opcode = (Opcode)messageDocument["opcode"].ToInt32(); if (opcode != Opcode.Compressed) { throw new FormatException($"Command message invalid opcode: \"{opcode}\"."); } var compressorId = (CompressorType)messageDocument["compressorId"].ToInt32(); var compressedMessage = messageDocument["compressedMessage"].AsString; using (var originalTextReader = new StringReader(compressedMessage)) { var jsonEncoderFactory = new JsonMessageEncoderFactory(originalTextReader, _encoderSettings); var originalEncoder = _originalEncoderSelector.GetEncoder(jsonEncoderFactory); var originalMessage = originalEncoder.ReadMessage(); return(new CompressedMessage(originalMessage, null, compressorId)); } }
public void Deserializer_should_return_expected_result_when_representation_is_binary( GuidRepresentationMode defaultGuidRepresentationMode, GuidRepresentation defaultGuidRepresentation, GuidRepresentation serializerGuidRepresentation, GuidRepresentation readerGuidRepresentation, GuidRepresentation expectedGuidRepresentation) { GuidMode.Set(defaultGuidRepresentationMode, defaultGuidRepresentation); var subject = new GuidSerializer(serializerGuidRepresentation); var documentBytes = new byte[] { 29, 0, 0, 0, 5, 120, 0, 16, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0 }; var documentSubType = GuidConverter.GetSubType(expectedGuidRepresentation); documentBytes[11] = (byte)documentSubType; var readerSettings = new BsonBinaryReaderSettings(); if (defaultGuidRepresentationMode == GuidRepresentationMode.V2) { #pragma warning disable 618 readerSettings.GuidRepresentation = readerGuidRepresentation; #pragma warning restore 618 } var reader = new BsonBinaryReader(new MemoryStream(documentBytes), readerSettings); reader.ReadStartDocument(); reader.ReadName("x"); var context = BsonDeserializationContext.CreateRoot(reader); var args = new BsonDeserializationArgs(); var result = subject.Deserialize(context, args); var guidBytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; var expectedGuid = GuidConverter.FromBytes(guidBytes, expectedGuidRepresentation); result.Should().Be(expectedGuid); }
public void Deserialize_should_throw_when_representation_is_binary_and_guid_representation_is_unspecified( GuidRepresentationMode defaultGuidRepresentationMode, GuidRepresentation defaultGuidRepresentation, GuidRepresentation?readerGuidRepresentation) { GuidMode.Set(defaultGuidRepresentationMode, defaultGuidRepresentation); var subject = new GuidSerializer(GuidRepresentation.Unspecified); var documentBytes = new byte[] { 29, 0, 0, 0, 5, 120, 0, 16, 0, 0, 0, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0 }; var readerSettings = new BsonBinaryReaderSettings(); if (defaultGuidRepresentationMode == GuidRepresentationMode.V2 && readerGuidRepresentation.HasValue) { #pragma warning disable 618 readerSettings.GuidRepresentation = readerGuidRepresentation.Value; #pragma warning restore 618 } var reader = new BsonBinaryReader(new MemoryStream(documentBytes), readerSettings); reader.ReadStartDocument(); reader.ReadName("x"); var context = BsonDeserializationContext.CreateRoot(reader); var args = new BsonDeserializationArgs(); var exception = Record.Exception(() => subject.Deserialize(context, args)); exception.Should().BeOfType <BsonSerializationException>(); }
/// <summary> /// Creates document. /// </summary> /// <param name="mongoDoc">The mongo doc.</param> /// <returns> /// The document. /// </returns> public ActionResult <object> CreateDocument(MongoDocument mongoDoc) { MongoClient client = Helper.GetMongoClient(mongoDoc); var database = client.GetDatabase(mongoDoc.DatabaseName); var collection = database.GetCollection <BsonDocument>(mongoDoc.CollectionName); BsonDocument document = null; if (!string.IsNullOrWhiteSpace(mongoDoc.Id)) { ObjectId oid; if (ObjectId.TryParse(mongoDoc.Id, out oid)) { document = collection.Find($"{{ _id: ObjectId('{mongoDoc.Id}') }}").FirstOrDefault(); } else { document = collection.Find(x => x["_id"] == mongoDoc.Id).FirstOrDefault(); } } if (document == null) { using (var reader = new MongoDB.Bson.IO.JsonReader(mongoDoc.DocumentData)) { var context = BsonDeserializationContext.CreateRoot(reader); document = BsonDocumentSerializer.Instance.Deserialize(context); } collection.InsertOne(document); } var doc = document.ToString(); return(CreatedAtAction(nameof(GetByDocumentId), new { id = document["_id"].ToString(), mongoDoc = mongoDoc }, doc)); }
public InsertMessage <TDocument> ReadMessage() { var binaryReader = CreateBinaryReader(); var streamReader = binaryReader.StreamReader; var startPosition = streamReader.Position; var messageSize = streamReader.ReadInt32(); var requestId = streamReader.ReadInt32(); var responseTo = streamReader.ReadInt32(); var opcode = (Opcode)streamReader.ReadInt32(); var flags = (InsertFlags)streamReader.ReadInt32(); var fullCollectionName = streamReader.ReadCString(); var documents = new List <TDocument>(); while (streamReader.Position < startPosition + messageSize) { var context = BsonDeserializationContext.CreateRoot <TDocument>(binaryReader); var document = _serializer.Deserialize(context); documents.Add(document); } var documentSource = new BatchableSource <TDocument>(documents); var maxBatchCount = 0; var maxMessageSize = 0; var continueOnError = flags.HasFlag(InsertFlags.ContinueOnError); return(new InsertMessage <TDocument>( requestId, CollectionNamespace.FromFullName(fullCollectionName), _serializer, documentSource, maxBatchCount, maxMessageSize, continueOnError)); }
// methods public DeleteMessage ReadMessage() { if (_jsonReader == null) { throw new InvalidOperationException("No jsonReader was provided."); } var messageContext = BsonDeserializationContext.CreateRoot <BsonDocument>(_jsonReader); var messageDocument = BsonDocumentSerializer.Instance.Deserialize(messageContext); var opcode = messageDocument["opcode"].AsString; if (opcode != "delete") { throw new FormatException("Opcode is not delete."); } var requestId = messageDocument["requestId"].ToInt32(); var databaseName = messageDocument["database"].AsString; var collectionName = messageDocument["collection"].AsString; var query = messageDocument["query"].AsBsonDocument; var isMulti = messageDocument["isMulti"].ToBoolean(); return(new DeleteMessage( requestId, databaseName, collectionName, query, isMulti)); }
public void Deserialize_should_return_expected_result( string json, string expectedResumeTokenJson, ChangeStreamOperationType expectedOperationType, string expectedDatabaseName, string expectedCollectionName, string expectedDocumentKeyJson, string expectedUpdateDescriptionJson, string expectedFullDocumentJson ) { var subject = CreateSubject(); var expectedCollectionNamespace = CreateCollectionNamespace(expectedDatabaseName, expectedCollectionName); var expectedDocumentKey = ParseBsonDocument(expectedDocumentKeyJson); var expectedFullDocument = ParseBsonDocument(expectedFullDocumentJson); var expectedResumeToken = ParseBsonDocument(expectedResumeTokenJson); var expectedUpdateDescription = ParseUpdateDescription(expectedUpdateDescriptionJson); ChangeStreamDocument <BsonDocument> result; using (var reader = new JsonReader(json)) { var context = BsonDeserializationContext.CreateRoot(reader); result = subject.Deserialize(context); } result.CollectionNamespace.Should().Be(expectedCollectionNamespace); result.DocumentKey.Should().Be(expectedDocumentKey); result.FullDocument.Should().Be(expectedFullDocument); result.OperationType.Should().Be(expectedOperationType); result.ResumeToken.Should().Be(expectedResumeToken); result.UpdateDescription.ShouldBeEquivalentTo(expectedUpdateDescription); }
public void TestCustomDictionarySerializerSerializeAndDeserialize() { var map = new Dictionary <object, object> { { "power", 9001 } }; var serializer = new CustomDictionarySerializer <object, object>(); var expected = @"{ ""power"" : 9001 }"; var json = map.ToJson(writerSettings: null, serializer: serializer); Assert.Equal(expected, json); var bson = map.ToBson(serializer: serializer); using (var buffer = new ByteArrayBuffer(bytes: bson, isReadOnly: true)) using (var stream = new ByteBufferStream(buffer)) using (var bsonReader = new BsonBinaryReader(stream)) { var context = BsonDeserializationContext.CreateRoot(reader: bsonReader, configurator: null); var rehydrated = serializer.Deserialize(context); Assert.True(bson.SequenceEqual(rehydrated.ToBson())); } }
/// <summary> /// Tries to get the value of an element of this document. /// </summary> /// <param name="name">The name of the element.</param> /// <param name="value">The value of the element.</param> /// <returns> /// True if an element with that name was found. /// </returns> public override bool TryGetValue(string name, out BsonValue value) { ThrowIfDisposed(); using (var stream = new ByteBufferStream(_slice, ownsBuffer: false)) using (var bsonReader = new BsonBinaryReader(stream, _readerSettings)) { var context = BsonDeserializationContext.CreateRoot(bsonReader); bsonReader.ReadStartDocument(); while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { if (bsonReader.ReadName() == name) { value = DeserializeBsonValue(context); return(true); } bsonReader.SkipValue(); } bsonReader.ReadEndDocument(); value = null; return(false); } }
public void Deserialize_should_throw_when_representation_is_binary_and_sub_type_does_not_match( GuidRepresentationMode defaultGuidRepresentationMode, GuidRepresentation defaultGuidRepresentation, GuidRepresentation serializerGuidRepresentation, GuidRepresentation?readerGuidRepresentation, BsonBinarySubType expectedSubType) { GuidMode.Set(defaultGuidRepresentationMode, defaultGuidRepresentation); var subject = new GuidSerializer(serializerGuidRepresentation); var documentBytes = new byte[] { 29, 0, 0, 0, 5, 120, 0, 16, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0 }; var nonMatchingSubType = expectedSubType == BsonBinarySubType.UuidLegacy ? BsonBinarySubType.UuidStandard : BsonBinarySubType.UuidLegacy; documentBytes[11] = (byte)nonMatchingSubType; var readerSettings = new BsonBinaryReaderSettings(); if (defaultGuidRepresentationMode == GuidRepresentationMode.V2 && readerGuidRepresentation.HasValue) { #pragma warning disable 618 readerSettings.GuidRepresentation = readerGuidRepresentation.Value; #pragma warning restore 618 } var reader = new BsonBinaryReader(new MemoryStream(documentBytes), readerSettings); reader.ReadStartDocument(); reader.ReadName("x"); var context = BsonDeserializationContext.CreateRoot(reader); var args = new BsonDeserializationArgs(); var exception = Record.Exception(() => subject.Deserialize(context, args)); exception.Should().BeOfType <FormatException>(); }
/// <summary> /// Writes a raw BSON array. /// </summary> /// <param name="slice">The byte buffer containing the raw BSON array.</param> public virtual void WriteRawBsonArray(IByteBuffer slice) { // overridden in BsonBinaryWriter to write the raw bytes to the stream // for all other streams, deserialize the raw bytes and serialize the resulting array instead var documentLength = slice.Length + 8; using (var memoryStream = new MemoryStream(documentLength)) { // wrap the array in a fake document so we can deserialize it var streamWriter = new BsonStreamWriter(memoryStream, Utf8Encodings.Strict); streamWriter.WriteInt32(documentLength); streamWriter.WriteBsonType(BsonType.Array); streamWriter.WriteByte((byte)'x'); streamWriter.WriteByte(0); slice.WriteTo(streamWriter.BaseStream); streamWriter.WriteByte(0); memoryStream.Position = 0; using (var bsonReader = new BsonBinaryReader(memoryStream, BsonBinaryReaderSettings.Defaults)) { var deserializationContext = BsonDeserializationContext.CreateRoot <BsonDocument>(bsonReader); bsonReader.ReadStartDocument(); bsonReader.ReadName("x"); var array = deserializationContext.DeserializeWithChildContext(BsonArraySerializer.Instance); bsonReader.ReadEndDocument(); var serializationContext = BsonSerializationContext.CreateRoot <BsonArray>(this); BsonArraySerializer.Instance.Serialize(serializationContext, array); } } }
// methods public GetMoreMessage ReadMessage() { var jsonReader = CreateJsonReader(); var messageContext = BsonDeserializationContext.CreateRoot(jsonReader); var messageDocument = BsonDocumentSerializer.Instance.Deserialize(messageContext); var opcode = messageDocument["opcode"].AsString; if (opcode != "getMore") { throw new FormatException("Opcode is not getMore."); } var requestId = messageDocument["requestId"].ToInt32(); var databaseName = messageDocument["database"].AsString; var collectionName = messageDocument["collection"].AsString; var cursorId = messageDocument["cursorId"].ToInt32(); var batchSize = messageDocument["batchSize"].ToInt32(); return(new GetMoreMessage( requestId, new CollectionNamespace(databaseName, collectionName), cursorId, batchSize)); }
public override T Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args) { var bookmark = context.Reader.GetBookmark(); object original; using (var originalReader = new FieldHidingBsonReader(context.Reader, fieldName => fieldName == _joinedFieldName)) { var childContext = BsonDeserializationContext.CreateRoot(originalReader); original = _sourceSerializer.Deserialize(childContext); } context.Reader.ReturnToBookmark(bookmark); object joined = null; context.Reader.ReadStartDocument(); while (context.Reader.ReadBsonType() != BsonType.EndOfDocument) { var name = context.Reader.ReadName(); if (name != _joinedFieldName) { context.Reader.SkipValue(); } else { joined = _joinedSerializer.Deserialize(context); } } context.Reader.ReadEndDocument(); return((T)_creator(original, joined)); }
// public methods /// <summary> /// Gets the actual type of an object by reading the discriminator from a BsonReader. /// </summary> /// <param name="bsonReader">The reader.</param> /// <param name="nominalType">The nominal type.</param> /// <returns>The actual type.</returns> public Type GetActualType(BsonReader bsonReader, Type nominalType) { // the BsonReader is sitting at the value whose actual type needs to be found var bsonType = bsonReader.GetCurrentBsonType(); if (bsonType == BsonType.Document) { // ensure KnownTypes of nominalType are registered (so IsTypeDiscriminated returns correct answer) BsonSerializer.EnsureKnownTypesAreRegistered(nominalType); // we can skip looking for a discriminator if nominalType has no discriminated sub types if (BsonSerializer.IsTypeDiscriminated(nominalType)) { var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); var actualType = nominalType; if (bsonReader.FindElement(_elementName)) { var context = BsonDeserializationContext.CreateRoot <BsonValue>(bsonReader); var discriminator = BsonValueSerializer.Instance.Deserialize(context); if (discriminator.IsBsonArray) { discriminator = discriminator.AsBsonArray.Last(); // last item is leaf class discriminator } actualType = BsonSerializer.LookupActualType(nominalType, discriminator); } bsonReader.ReturnToBookmark(bookmark); return(actualType); } } return(nominalType); }
/// <summary> /// Reads a raw BSON array. /// </summary> /// <returns>The raw BSON array.</returns> public virtual IByteBuffer ReadRawBsonArray() { // overridden in BsonBinaryReader to read the raw bytes from the stream // for all other streams, deserialize the array and reserialize it using a BsonBinaryWriter to get the raw bytes var deserializationContext = BsonDeserializationContext.CreateRoot(this); var array = BsonArraySerializer.Instance.Deserialize(deserializationContext); using (var memoryStream = new MemoryStream()) using (var bsonWriter = new BsonBinaryWriter(memoryStream, BsonBinaryWriterSettings.Defaults)) { var serializationContext = BsonSerializationContext.CreateRoot(bsonWriter); bsonWriter.WriteStartDocument(); var startPosition = memoryStream.Position + 3; // just past BsonType, "x" and null byte bsonWriter.WriteName("x"); BsonArraySerializer.Instance.Serialize(serializationContext, array); var endPosition = memoryStream.Position; bsonWriter.WriteEndDocument(); byte[] memoryStreamBuffer; #if NETSTANDARD1_5 || NETSTANDARD1_6 memoryStreamBuffer = memoryStream.ToArray(); #else memoryStreamBuffer = memoryStream.GetBuffer(); #endif var buffer = new ByteArrayBuffer(memoryStreamBuffer, (int)memoryStream.Length, isReadOnly: true); return(new ByteBufferSlice(buffer, (int)startPosition, (int)(endPosition - startPosition))); } }
private IEnumerable <BsonElement> MaterializeThisLevel() { var elements = new List <BsonElement>(); using (var stream = new ByteBufferStream(_slice, ownsBuffer: false)) using (var bsonReader = new BsonBinaryReader(stream, _readerSettings)) { var context = BsonDeserializationContext.CreateRoot(bsonReader); bsonReader.ReadStartDocument(); BsonType bsonType; while ((bsonType = bsonReader.ReadBsonType()) != BsonType.EndOfDocument) { var name = bsonReader.ReadName(); BsonValue value; switch (bsonType) { case BsonType.Array: value = DeserializeLazyBsonArray(bsonReader); break; case BsonType.Document: value = DeserializeLazyBsonDocument(bsonReader); break; default: value = BsonValueSerializer.Instance.Deserialize(context); break; } elements.Add(new BsonElement(name, value)); } bsonReader.ReadEndDocument(); } return(elements); }
private TResult ProcessCommandResult(ConnectionId connectionId, RawBsonDocument rawBsonDocument) { var binaryReaderSettings = new BsonBinaryReaderSettings { Encoding = _messageEncoderSettings.GetOrDefault <UTF8Encoding>(MessageEncoderSettingsName.ReadEncoding, Utf8Encodings.Strict), GuidRepresentation = _messageEncoderSettings.GetOrDefault <GuidRepresentation>(MessageEncoderSettingsName.GuidRepresentation, GuidRepresentation.CSharpLegacy) }; BsonValue writeConcernError; if (rawBsonDocument.TryGetValue("writeConcernError", out writeConcernError)) { var message = writeConcernError["errmsg"].AsString; var response = rawBsonDocument.Materialize(binaryReaderSettings); var writeConcernResult = new WriteConcernResult(response); throw new MongoWriteConcernException(connectionId, message, writeConcernResult); } using (var stream = new ByteBufferStream(rawBsonDocument.Slice, ownsBuffer: false)) using (var reader = new BsonBinaryReader(stream, binaryReaderSettings)) { var context = BsonDeserializationContext.CreateRoot(reader); return(_resultSerializer.Deserialize(context)); } }
// protected methods /// <summary> /// Deserializes a value. /// </summary> /// <param name="context">The deserialization context.</param> /// <returns>The value.</returns> protected override GeoJsonBoundingBox <TCoordinates> DeserializeValue(BsonDeserializationContext context) { var bsonReader = context.Reader; var flattenedArray = BsonArraySerializer.Instance.Deserialize(context.CreateChild(typeof(BsonArray))); if ((flattenedArray.Count % 2) != 0) { throw new FormatException("Bounding box array does not have an even number of values."); } var half = flattenedArray.Count / 2; // create a dummy document with a min and a max and then deserialize the min and max coordinates from there var document = new BsonDocument { { "min", new BsonArray(flattenedArray.Take(half)) }, { "max", new BsonArray(flattenedArray.Skip(half)) } }; using (var documentReader = new BsonDocumentReader(document)) { var documentContext = BsonDeserializationContext.CreateRoot(documentReader, typeof(BsonDocument)); documentReader.ReadStartDocument(); documentReader.ReadName("min"); var min = documentContext.DeserializeWithChildContext(_coordinatesSerializer); documentReader.ReadName("max"); var max = documentContext.DeserializeWithChildContext(_coordinatesSerializer); documentReader.ReadEndDocument(); return(new GeoJsonBoundingBox <TCoordinates>(min, max)); } }
public static BsonArray GetBsonArray(string uri) { using (HttpClient http = new HttpClient()) { string data = http.GetStringAsync(uri).Result; if (data == "unauthorized permission requested") { throw new Exceptions.TrelloDriverRequestException("Key or token invalid"); } else if (data == "The requested resource was not found.") { throw new Exceptions.TrelloDriverRequestException("Invalid Action id"); } using (var jsonReader = new JsonReader(data)) { var serializer = new BsonArraySerializer(); try { BsonArray array = serializer.Deserialize(BsonDeserializationContext.CreateRoot(jsonReader)); return(array); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); throw; } } } }
// methods /// <summary> /// Reads the message. /// </summary> /// <returns>A message.</returns> public DeleteMessage ReadMessage() { var jsonReader = CreateJsonReader(); var messageContext = BsonDeserializationContext.CreateRoot(jsonReader); var messageDocument = BsonDocumentSerializer.Instance.Deserialize(messageContext); var opcode = messageDocument["opcode"].AsString; if (opcode != "delete") { throw new FormatException("Opcode is not delete."); } var requestId = messageDocument["requestId"].ToInt32(); var databaseName = messageDocument["database"].AsString; var collectionName = messageDocument["collection"].AsString; var query = messageDocument["query"].AsBsonDocument; var isMulti = messageDocument["isMulti"].ToBoolean(); return(new DeleteMessage( requestId, new CollectionNamespace(databaseName, collectionName), query, isMulti)); }
/***************************************************/ /**** Interface Methods ****/ /***************************************************/ public Type GetActualType(IBsonReader bsonReader, Type nominalType) { Type actualType = nominalType; // the BsonReader is sitting at the value whose actual type needs to be found BsonType bsonType = bsonReader.GetCurrentBsonType(); if (bsonType == BsonType.Document) { var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); if (bsonReader.FindElement(ElementName)) { var context = BsonDeserializationContext.CreateRoot(bsonReader); var discriminator = BsonValueSerializer.Instance.Deserialize(context); if (discriminator.IsBsonArray) { discriminator = discriminator.AsBsonArray.Last(); // last item is leaf class discriminator } if (BsonSerializer.IsTypeDiscriminated(nominalType)) { actualType = BsonSerializer.LookupActualType(nominalType, discriminator); } } bsonReader.ReturnToBookmark(bookmark); } return(actualType); }
/// <summary> /// Gets the value of an element. /// </summary> /// <param name="index">The zero based index of the element.</param> /// <returns> /// The value of the element. /// </returns> public override BsonValue GetValue(int index) { if (index < 0) { throw new ArgumentOutOfRangeException("index"); } ThrowIfDisposed(); using (var stream = new ByteBufferStream(_slice, ownsBuffer: false)) using (var bsonReader = new BsonBinaryReader(stream, _readerSettings)) { var context = BsonDeserializationContext.CreateRoot(bsonReader); bsonReader.ReadStartDocument(); var i = 0; while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { bsonReader.SkipName(); if (i == index) { return(DeserializeBsonValue(context)); } bsonReader.SkipValue(); i++; } bsonReader.ReadEndDocument(); throw new ArgumentOutOfRangeException("index"); } }
public UpdateMessage ReadMessage() { var binaryReader = CreateBinaryReader(); var streamReader = binaryReader.StreamReader; streamReader.ReadInt32(); // messageSize var requestId = streamReader.ReadInt32(); streamReader.ReadInt32(); // responseTo streamReader.ReadInt32(); // opcode streamReader.ReadInt32(); // reserved var fullCollectionName = streamReader.ReadCString(); var flags = (UpdateFlags)streamReader.ReadInt32(); var context = BsonDeserializationContext.CreateRoot(binaryReader); var query = BsonDocumentSerializer.Instance.Deserialize(context); var update = BsonDocumentSerializer.Instance.Deserialize(context); var isMulti = (flags & UpdateFlags.Multi) == UpdateFlags.Multi; var isUpsert = (flags & UpdateFlags.Upsert) == UpdateFlags.Upsert; return(new UpdateMessage( requestId, CollectionNamespace.FromFullName(fullCollectionName), query, update, NoOpElementNameValidator.Instance, isMulti, isUpsert)); }
private IReadOnlyList <IAsyncCursor <TDocument> > CreateCursors(IChannelSourceHandle channelSource, BsonDocument command, BsonDocument result) { var cursors = new List <AsyncCursor <TDocument> >(); foreach (var cursorDocument in result["cursors"].AsBsonArray.Select(v => v["cursor"].AsBsonDocument)) { var cursorId = cursorDocument["id"].ToInt64(); var firstBatch = cursorDocument["firstBatch"].AsBsonArray.Select(v => { var bsonDocument = (BsonDocument)v; using (var reader = new BsonDocumentReader(bsonDocument)) { var context = BsonDeserializationContext.CreateRoot(reader); var document = _serializer.Deserialize(context); return(document); } }) .ToList(); var cursor = new AsyncCursor <TDocument>( channelSource.Fork(), _collectionNamespace, command, firstBatch, cursorId, _batchSize ?? 0, 0, // limit _serializer, _messageEncoderSettings); cursors.Add(cursor); } return(cursors); }