public override BsonDocument Render(
IBsonSerializer documentSerializer,
IBsonSerializerRegistry serializerRegistry)
{
StringFieldDefinitionHelper.Resolve(
_path,
documentSerializer,
out string?resolvedFieldName,
out IBsonSerializer? resolvedFieldSerializer);
resolvedFieldSerializer ??= documentSerializer;
if (_value is BsonDocument bsonDocument)
{
return(new BsonDocument(resolvedFieldName, bsonDocument));
}
if (_value is BsonValue bsonValue)
{
return(new BsonDocument(resolvedFieldName, bsonValue));
}
if (_value is MongoDbFilterDefinition mongoDbOperation)
{
if (_path is "")
{
return(mongoDbOperation.Render(resolvedFieldSerializer, serializerRegistry));
}
return(new BsonDocument(
resolvedFieldName,
mongoDbOperation.Render(resolvedFieldSerializer, serializerRegistry)));
}
var document = new BsonDocument();
using var bsonWriter = new BsonDocumentWriter(document);
var context = BsonSerializationContext.CreateRoot(bsonWriter);
bsonWriter.WriteStartDocument();
bsonWriter.WriteName(resolvedFieldName);
if (_value is IList values)
{
bsonWriter.WriteStartArray();
foreach (var value in values)
{
resolvedFieldSerializer.Serialize(context, value);
}
bsonWriter.WriteEndArray();
}
else
{
resolvedFieldSerializer.Serialize(context, _value);
}
bsonWriter.WriteEndDocument();
return(document);
}
ReplaceOneResult ReplaceOneInternal(IClientSessionHandle session, FilterDefinition <TDocument> filter, TDocument replacement, CancellationToken cancellationToken = default)
{
var filteredDocs = Filter(filter);
if (filteredDocs.Count > 1)
{
throw new InvalidOperationException();
}
else if (filteredDocs.Count == 0)
{
return(ReplaceOneResult.Unacknowledged.Instance);
}
var docObject = filteredDocs[0];
var docIndex = docObjects.IndexOf(docObject);
if (docIndex == -1)
{
throw new InvalidOperationException();
}
var doc = docs[docIndex];
var docId = GetDocumentIdValue(doc);
var replacedDoc = new BsonDocument();
using (var bsonReader = new BsonDocumentWriter(replacedDoc))
{
var bsonSerializationContext = BsonSerializationContext.CreateRoot(bsonReader);
DocumentSerializer.Serialize(bsonSerializationContext, default, docObject);
public void ReserializationWithoutDataLoss()
{
EntityMapping.AddMappingProcessor(new TypeDiscoveryProcessor());
EntityMapping.RegisterType(typeof(CollectionBaseModel));
var initialEntity = new CollectionBaseModel
{
KnownList = new List <KnownBaseModel>
{
new KnownBaseModel(),
new UnknownChildModel(),
new UnknownGrandChildModel()
}
};
var document = new BsonDocument();
using (var writer = new BsonDocumentWriter(document))
{
BsonSerializer.Serialize(writer, initialEntity);
}
var deserializedResult = BsonSerializer.Deserialize <CollectionBaseModel>(document);
Assert.AreEqual(3, deserializedResult.KnownList.Count);
Assert.IsInstanceOfType(deserializedResult.KnownList[0], typeof(KnownBaseModel));
Assert.IsInstanceOfType(deserializedResult.KnownList[1], typeof(UnknownChildModel));
Assert.IsInstanceOfType(deserializedResult.KnownList[2], typeof(UnknownGrandChildModel));
}
private void InsertDocument(TDocument document)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
var bsonDocument = new BsonDocument();
using (var bsonReader = new BsonDocumentWriter(bsonDocument))
{
var bsonSerializationContext = BsonSerializationContext.CreateRoot(bsonReader);
DocumentSerializer.Serialize(bsonSerializationContext, new BsonSerializationArgs {
SerializeIdFirst = true
}, document);
}
var id = GetDocumentIdValue(bsonDocument);
if (docIds.ContainsKey(id))
{
throw new InvalidOperationException($"Document by id {id} already exists.");
}
var index = docIds.Count;
docIds.Add(id, index);
docs.Add(bsonDocument);
docObjects.Add(document);
}
public static void UpdateOrInsert <T>(this IMongoCollection <T> collection, T prototype, UpdateOptions options = null)
{
if (options == null)
{
options = new UpdateOptions {
IsUpsert = true
};
}
var doc = new BsonDocument();
var wr = new BsonDocumentWriter(doc);
BsonSerializer.Serialize(wr, prototype);
var update = Builders <T> .Update;
UpdateDefinition <T> definition = null;
foreach (var el in doc)
{
if (el.Name != IdName)
{
definition = definition == null?update.Set(el.Name, el.Value) : definition.Set(el.Name, el.Value);
}
}
collection.UpdateOne(Builders <T> .Filter.Eq(IdName, doc[IdName]), definition, options);
}
public static BsonArray SerializeValues(this ISerializationExpression field, Type itemType, IEnumerable values)
{
Ensure.IsNotNull(field, nameof(field));
Ensure.IsNotNull(itemType, nameof(itemType));
Ensure.IsNotNull(values, nameof(values));
var itemSerializer = FieldValueSerializerHelper.GetSerializerForValueType(field.Serializer, BsonSerializer.SerializerRegistry, itemType);
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)
{
itemSerializer.Serialize(context, value);
}
bsonWriter.WriteEndArray();
bsonWriter.WriteEndDocument();
return((BsonArray)tempDocument[0]);
}
}
public void Should_serialize_and_deserialize_status()
{
TypeConverterStringSerializer <Status> .Register();
var source = new TestObject
{
Status = Status.Published
};
var document = new BsonDocument();
using (var writer = new BsonDocumentWriter(document))
{
BsonSerializer.Serialize(writer, source);
writer.Flush();
}
using (var reader = new BsonDocumentReader(document))
{
var result = BsonSerializer.Deserialize <TestObject>(reader);
Assert.Equal(source.Status, result.Status);
}
}
/// <summary>
/// Serializes a value.
/// </summary>
/// <param name="context">The serialization context.</param>
/// <param name="args">The serialization args.</param>
/// <param name="value">The value.</param>
protected override void SerializeValue(BsonSerializationContext context, BsonSerializationArgs args, GeoJsonBoundingBox <TCoordinates> value)
{
var bsonWriter = context.Writer;
// serialize min and max to a dummy document and then flatten the two arrays and serialize that
var document = new BsonDocument();
using (var documentWriter = new BsonDocumentWriter(document))
{
var documentContext = BsonSerializationContext.CreateRoot(documentWriter);
documentWriter.WriteStartDocument();
documentWriter.WriteName("min");
_coordinatesSerializer.Serialize(documentContext, value.Min);
documentWriter.WriteName("max");
_coordinatesSerializer.Serialize(documentContext, value.Max);
documentWriter.WriteEndDocument();
}
var flattenedArray = new BsonArray();
flattenedArray.AddRange(document["min"].AsBsonArray);
flattenedArray.AddRange(document["max"].AsBsonArray);
BsonArraySerializer.Instance.Serialize(context, flattenedArray);
}
public void ReserializationWithoutDataLoss()
{
var entityMapper = new EntityMapper <CollectionBaseModel>();
var initialEntity = new CollectionBaseModel
{
KnownList = new List <KnownBaseModel>
{
new KnownBaseModel(),
new UnknownChildModel(),
new UnknownGrandChildModel()
}
};
var document = new BsonDocument();
using (var writer = new BsonDocumentWriter(document))
{
BsonSerializer.Serialize(writer, initialEntity);
}
var deserializedResult = BsonSerializer.Deserialize <CollectionBaseModel>(document);
Assert.AreEqual(3, deserializedResult.KnownList.Count);
Assert.AreEqual(typeof(KnownBaseModel), deserializedResult.KnownList[0].GetType());
Assert.AreEqual(typeof(UnknownChildModel), deserializedResult.KnownList[1].GetType());
Assert.AreEqual(typeof(UnknownGrandChildModel), deserializedResult.KnownList[2].GetType());
}
public async Task UpdateDocument <T>(ObjectId Id, T item)
{
var startTime = DateTime.UtcNow;
try
{
var bsonWriter = new BsonDocumentWriter(new BsonDocument(), BsonDocumentWriterSettings.Defaults);
BsonSerializer.Serialize <GlobalModel_Root>(bsonWriter, GlobalModel.rootGM);
var doc = bsonWriter.Document;
var collection = _db.GetCollection <BsonDocument>(typeof(T).Name);
var filter = Builders <BsonDocument> .Filter.Eq("_id", Id);
var entity = collection.Find(filter).FirstOrDefault();
using (var timeoutCancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(60)))
{
await collection.ReplaceOneAsync(filter, doc, null, timeoutCancellationTokenSource.Token);
}
}
catch (OperationCanceledException ex)
{
var endTime = DateTime.UtcNow;
var elapsed = endTime - startTime;
Console.WriteLine("Operation was cancelled after {0} seconds.", elapsed.TotalSeconds);
}
}
public static void TestSer()
{
BsonClassMap.RegisterClassMap <SagaTest.MyState>(
x =>
{
x.AutoMap();
x.SetIgnoreExtraElements(true);
});
var bd = new MongoDB.Bson.BsonDocument();
MongoDB.Bson.IO.BsonDocumentWriter bdw = (BsonDocumentWriter)BsonDocumentWriter.Create(bd);
var obj = new SagaTest.MyState {
Collected = new List <int>(), Last = DateTime.Now
};
MongoDB.Bson.Serialization.BsonSerializer.Serialize(bdw, obj);
bdw.Flush();
/*
* bd["_t"] = MongoDB.Bson.Serialization.TypeNameDiscriminator.GetDiscriminator(obj.GetType());
* bd["version"] = "3823424";
* Console.WriteLine(bd.ToJson());
* Type t = TypeNameDiscriminator.GetActualType(bd["_t"].AsString);
* var obj2 = BsonSerializer.Deserialize(bd, t);
* Console.WriteLine("deser: " + obj2);
*/
}
// =====================================================
public override bool Insert(HockeyPlayer hockeyPlayer)
// =====================================================
{
bool insertSuccess = false;
if (Connected())
{
var builder = Builders <BsonDocument> .Filter;
var filterFN = builder.Eq("FirstName", hockeyPlayer.FirstName);
var filterLN = builder.Eq("LastName", hockeyPlayer.LastName);
var filter = filterFN & filterLN;
// Check to see if the player is already in the database
if (_mongoCollection.Find(filter).FirstOrDefault() == null)
{
// If the player is not then insert him
var player = new MongoDbHockeyPlayer(hockeyPlayer);
var playerDoc = new BsonDocument();
var bsonWriter = new BsonDocumentWriter(playerDoc);
BsonSerializer.Serialize(bsonWriter, player); // Serialize MongoDbHockeyPlayer to BsonDocument
_mongoCollection.InsertOne(playerDoc); // Insert the BsonDocument into the database
insertSuccess = true;
}
else
{
Console.WriteLine("Player is already in the database.");
}
}
return(insertSuccess);
}
static void VerifyBsonSerializerFor(Type sagaDataType)
{
Exception GetException(string error) => new BsonSchemaValidationException(sagaDataType, $@"The test serialization of {sagaDataType} failed - {error}.
This is most likely because the BSON serializer (which is global!) has been customized in a way that interferes with Rebus.
If you customize how your saga data is serialized, you need to ensure that
* 'Id' from your saga data is mapped to '_id'
* 'Revision' from your saga data is mapped to 'Revision'
in BSON documents.");
var testInstance = Activator.CreateInstance(sagaDataType);
var target = new BsonDocument();
using (var writer = new BsonDocumentWriter(target))
{
BsonSerializer.Serialize(writer, sagaDataType, testInstance);
}
if (!target.Contains("_id"))
{
throw GetException("could not find '_id' in the serialied BSON document");
}
if (!target.Contains("Revision"))
{
throw GetException("could not find 'Revision' in the serialied BSON document");
}
}
protected BsonDocument Serialize <T>(T obj)
{
var bsonDoc = new BsonDocument();
using (var writer = new BsonDocumentWriter(bsonDoc))
BsonSerializer.Serialize(writer, obj);
return(bsonDoc);
}
private static BsonDocument SerializeBson(ContractTypeSerializer serializer, ICommandMessage message)
{
BsonDocument result = new BsonDocument();
using var writer = new BsonDocumentWriter(result);
serializer.Serialize(new MongoWriterAdapter(writer), message);
return(result);
}
private static BsonDocumentWriter CreateVersionWriter()
{
var writer = new BsonDocumentWriter(new BsonDocument());
writer.WriteStartDocument();
writer.WriteName("version");
return(writer);
}
protected static BsonDocument CloneExternalDocument(BsonDocument externalDocument)
{
var internalDocument = new BsonDocument();
using (var writer = new BsonDocumentWriter(internalDocument))
BsonSerializer.Serialize(writer, externalDocument);
return(internalDocument);
}
// public methods
/// <summary>
/// Converts the GeoNearLocation into a BsonValue for the GeoNear command.
/// </summary>
/// <returns></returns>
public override BsonValue ToGeoNearCommandField()
{
var document = new BsonDocument();
using (var writer = new BsonDocumentWriter(document, BsonDocumentWriterSettings.Defaults))
{
new GeoJsonPointSerializer <TCoordinates>().Serialize(writer, typeof(GeoJsonPoint <TCoordinates>), _point, null);
}
return(document);
}
public BsonDocument Serialize(Object obj)
{
var data = new BsonDocument();
var writer = new BsonDocumentWriter(data);
BsonSerializer.Serialize(writer, obj.GetType(), obj);
data.Remove("_t");
return(data);
}
// internal methods
/// <summary>
/// Converts the GeoNearPoint into a BsonValue for the GeoNear command.
/// </summary>
/// <returns>A BsonValue.</returns>
internal override BsonValue ToGeoNearCommandValue()
{
var document = new BsonDocument();
using (var writer = new BsonDocumentWriter(document, BsonDocumentWriterSettings.Defaults))
{
var context = BsonSerializationContext.CreateRoot(writer);
new GeoJsonPointSerializer <TCoordinates>().Serialize(context, _value);
}
return(document);
}
//public static BsonDocument Serialize(object instance)
//{
// throw new NotImplementedException();
//}
public static BsonDocument Serialize <T>(T instance)
{
BsonDocument doc = new BsonDocument();
BsonDocumentWriter writer = new BsonDocumentWriter(doc, new BsonDocumentWriterSettings()
{
GuidRepresentation = GuidRepresentation.Standard
});
ICommodityWriter commodityWriter = new BsonCommodityWriter(writer);
CommoditySerializer.Serialize(commodityWriter, instance);
return(doc);
}
public static BsonDocument AsBsonDocument(this DateTime dateTime)
{
var document = new BsonDocument();
using (var writer = new BsonDocumentWriter(document, new BsonDocumentWriterSettings()))
{
var dateTimeSerializer = new DateTimeSerializer();
dateTimeSerializer.Serialize(writer, typeof(DateTime), dateTime,
new DateTimeSerializationOptions(DateTimeKind.Utc, BsonType.Document));
}
return(document);
}
// protected methods
/// <summary>
/// Materializes the BsonDocument.
/// </summary>
/// <returns>The materialized elements.</returns>
protected override IEnumerable <BsonElement> Materialize()
{
var bsonDocument = new BsonDocument();
var writerSettings = BsonDocumentWriterSettings.Defaults;
using (var bsonWriter = new BsonDocumentWriter(bsonDocument, writerSettings))
{
BsonDocumentWrapperSerializer.Instance.Serialize(bsonWriter, typeof(BsonDocumentWrapper), this, null);
}
return(bsonDocument.Elements);
}
/// <inheritdoc />
public override BsonDocument Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry)
{
var renderedFieldDefinition = _field.Render(documentSerializer, serializerRegistry, true);
var document = new BsonDocument();
using var writer = new BsonDocumentWriter(document);
writer.WriteStartDocument();
writer.WriteName(renderedFieldDefinition.FieldName);
RenderEqualityQuery(writer);
writer.WriteEndDocument();
return(document);
}
public BsonDocument ConvertToBsonDocument(T poco)
{
var bsonDocument = new BsonDocument();
var writerSettings = BsonDocumentWriterSettings.Defaults;
using (var bsonWriter = new BsonDocumentWriter(bsonDocument, writerSettings))
{
var context = BsonSerializationContext.CreateRoot(bsonWriter);
var serializer = BsonSerializer.LookupSerializer(_trackableType);
serializer.Serialize(context, poco);
}
return(bsonDocument);
}
// protected methods
/// <summary>
/// Materializes the BsonDocument.
/// </summary>
/// <returns>The materialized elements.</returns>
protected override IEnumerable <BsonElement> Materialize()
{
var bsonDocument = new BsonDocument();
var writerSettings = BsonDocumentWriterSettings.Defaults;
using (var bsonWriter = new BsonDocumentWriter(bsonDocument, writerSettings))
{
var context = BsonSerializationContext.CreateRoot(bsonWriter, _serializer.ValueType);
_serializer.Serialize(context, _wrapped);
}
return(bsonDocument.Elements);
}
public void Serialize()
{
var doc = new Document {
Id = Guid.NewGuid(), Title = "test"
};
var serializedDocument = new BsonDocument();
using (var bsonReader = new BsonDocumentWriter(serializedDocument))
{
var serializer = BsonSerializer.LookupSerializer <Document>();
var bsonSerializationContext = BsonSerializationContext.CreateRoot(bsonReader);
serializer.Serialize(bsonSerializationContext, default, doc);
/// <summary>
/// Serializes the value.
/// </summary>
/// <param name="value">The value.</param>
/// <returns>The serialized value.</returns>
public BsonValue SerializeValue(object value)
{
var tempDocument = new BsonDocument();
using (var bsonWriter = new BsonDocumentWriter(tempDocument))
{
var context = BsonSerializationContext.CreateRoot <BsonDocument>(bsonWriter);
bsonWriter.WriteStartDocument();
bsonWriter.WriteName("value");
context.SerializeWithChildContext(_serializer, value);
bsonWriter.WriteEndDocument();
return(tempDocument[0]);
}
}
public static BsonDocument SerializeToDocument(object objectToSerialize)
{
new { objectToSerialize }.Must().NotBeNull();
var document = new BsonDocument();
using (var writer = new BsonDocumentWriter(document))
{
BsonSerializer.Serialize(writer, objectToSerialize.GetType(), objectToSerialize);
writer.Close();
}
return(document);
}
/// <summary>
/// Converts a value to a BsonValue by serializing it.
/// </summary>
/// <typeparam name="TValue">The type of the value.</typeparam>
/// <param name="serializer">The serializer.</param>
/// <param name="value">The value.</param>
/// <returns>The serialized value.</returns>
public static BsonValue ToBsonValue <TValue>(this IBsonSerializer <TValue> serializer, TValue value)
{
var document = new BsonDocument();
using (var writer = new BsonDocumentWriter(document))
{
var context = BsonSerializationContext.CreateRoot(writer);
writer.WriteStartDocument();
writer.WriteName("x");
serializer.Serialize(context, value);
writer.WriteEndDocument();
}
return(document[0]);
}
