private void SerializeDiscriminatedValue(BsonSerializationContext context, BsonSerializationArgs args, object value, Type actualType) { var serializer = BsonSerializer.LookupSerializer(actualType); var polymorphicSerializer = serializer as IBsonPolymorphicSerializer; if (polymorphicSerializer != null && polymorphicSerializer.IsDiscriminatorCompatibleWithObjectSerializer) { serializer.Serialize(context, args, value); } else { if (context.IsDynamicType != null && context.IsDynamicType(value.GetType())) { args.NominalType = actualType; serializer.Serialize(context, args, value); } else { var bsonWriter = context.Writer; var discriminator = _discriminatorConvention.GetDiscriminator(typeof(object), actualType); bsonWriter.WriteStartDocument(); bsonWriter.WriteName(_discriminatorConvention.ElementName); BsonValueSerializer.Instance.Serialize(context, discriminator); bsonWriter.WriteName("_v"); serializer.Serialize(context, value); bsonWriter.WriteEndDocument(); } } }
public async Task <Snapshot> Load <TSnap>( string invariantId, string causationId ) { if (null != causationId) { if (await _events .AsQueryable() .Where(e => e.InvariantType == typeof(TSnap).Name) .Where(e => e.InvariantId == invariantId) .AnyAsync(e => e.CausationId == causationId)) { throw new IdempotencyException(causationId); } } var snapshot = await _snapshots.AsQueryable() .Where(d => d.Snap is TSnap) .Where(d => d.Identity == invariantId) .FirstOrDefaultAsync(); return(snapshot ?? BsonSerializer.Deserialize <Snapshot>(new BsonDocument { { "Sequence", -1 }, { "Identity", invariantId }, { "Snap", new BsonDocument { { "_t", _discriminatorConvention.GetDiscriminator(typeof(object), typeof(TSnap)) } } } })); }
public void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { bsonWriter.WriteNull(); } else { if (nominalType.IsGenericType && nominalType.GetGenericTypeDefinition() == typeof(Nullable <>)) { nominalType = nominalType.GetGenericArguments()[0]; } this.VerifyNominalType(nominalType); // Added Type type = value == null ? nominalType : ProxyManager.GetUnderlyingType(value); // Added BsonClassMap bsonClassMap = BsonClassMap.LookupClassMap(type); bsonWriter.WriteStartDocument(); DocumentSerializationOptions serializationOptions = options == null ? DocumentSerializationOptions.Defaults : (DocumentSerializationOptions)options; BsonMemberMap memberMap = (BsonMemberMap)null; if (serializationOptions.SerializeIdFirst) { memberMap = bsonClassMap.IdMemberMap; if (memberMap != null) { this.SerializeMember(bsonWriter, value, memberMap); } } if ((type != nominalType || bsonClassMap.DiscriminatorIsRequired || bsonClassMap.HasRootClass) && !bsonClassMap.IsAnonymous) { IDiscriminatorConvention discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(nominalType); BsonValue discriminator = discriminatorConvention.GetDiscriminator(nominalType, type); if (discriminator != (BsonValue)null) { bsonWriter.WriteName(discriminatorConvention.ElementName); discriminator.WriteTo(bsonWriter); } } foreach (BsonMemberMap bsonMemberMap in bsonClassMap.MemberMaps) { if (bsonMemberMap != memberMap) { if (bsonMemberMap == bsonClassMap.ExtraElementsMemberMap) { this.SerializeExtraElements(bsonWriter, value, bsonMemberMap); } else { this.SerializeMember(bsonWriter, value, bsonMemberMap); } } } bsonWriter.WriteEndDocument(); } }
private void SerializeDiscriminator(BsonSerializationContext context, Type nominalType, object obj) { IDiscriminatorConvention discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(_classMap.ClassType); BsonValue discriminator = discriminatorConvention?.GetDiscriminator(nominalType, obj.GetType()); if (discriminator != null) { context.Writer.WriteName(discriminatorConvention.ElementName); BsonValueSerializer.Instance.Serialize(context, discriminator); } }
/// <summary> /// Serializes a value. /// </summary> /// <param name="context">The serialization context.</param> /// <param name="value">The value.</param> public override void Serialize(BsonSerializationContext context, TValue value) { var bsonWriter = context.Writer; var nominalType = context.NominalType; var actualType = value.GetType(); var discriminator = _discriminatorConvention.GetDiscriminator(nominalType, actualType); bsonWriter.WriteStartDocument(); bsonWriter.WriteName(_discriminatorConvention.ElementName); context.SerializeWithChildContext(BsonValueSerializer.Instance, discriminator); bsonWriter.WriteName("_v"); _wrappedSerializer.Serialize(context.CreateChild(actualType), value); bsonWriter.WriteEndDocument(); }
/// <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> public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, TValue value) { var bsonWriter = context.Writer; var nominalType = args.NominalType; var actualType = value.GetType(); var discriminator = _discriminatorConvention.GetDiscriminator(nominalType, actualType); bsonWriter.WriteStartDocument(); bsonWriter.WriteName(_discriminatorConvention.ElementName); BsonValueSerializer.Instance.Serialize(context, discriminator); bsonWriter.WriteName("_v"); args.NominalType = actualType; _wrappedSerializer.Serialize(context, args, value); bsonWriter.WriteEndDocument(); }
/// <summary> /// If the type is not registered, attach it to our discriminator /// </summary> /// <param name="actualType">the type to examine</param> protected void RegisterNewTypesToDiscriminator(Type actualType) { // we've detected a new concrete type that isn't registered in MongoDB's serializer if (actualType != typeof(object) && !actualType.GetTypeInfo().IsInterface&& !BsonSerializer.IsTypeDiscriminated(actualType)) { try { BsonSerializer.RegisterDiscriminatorConvention(actualType, DiscriminatorConvention); BsonSerializer.RegisterDiscriminator(actualType, DiscriminatorConvention.GetDiscriminator(typeof(object), actualType)); } catch (BsonSerializationException) { // the MongoDB driver library has no nice mechanism for checking if a discriminator convention is registerd. // The "Lookup" logic tends to define a default if it doesn't exist. // So we're forced to eat the "duplicate registration" exception. } } }