/***************************************************/ /**** Interface Methods ****/ /***************************************************/ public Type GetActualType(IBsonReader 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) { var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); var actualType = nominalType; if (bsonReader.FindElement(ElementName)) { var context = BsonDeserializationContext.CreateRoot(bsonReader); var discriminator = BsonValueSerializer.Instance.Deserialize(context); actualType = BsonSerializer.LookupActualType(nominalType, discriminator); } else { actualType = typeof(CustomObject); } bsonReader.ReturnToBookmark(bookmark); return(actualType); } return(nominalType); }
/***************************************************/ /**** 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); }
// 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(IBsonReader 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); }
public Type GetActualType(IBsonReader bsonReader, Type nominalType) { if (!typeof(T).IsAssignableFrom(nominalType)) { throw new Exception($"Cannot use DiscriminatorConvention<{typeof(T).Name}> for type " + nominalType); } var ret = nominalType; var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); if (bsonReader.FindElement(ElementName)) { var value = bsonReader.ReadString(); ret = Type.GetType(value); if (ret == null) { throw new Exception("Could not find type from " + value); } if (!typeof(T).IsAssignableFrom(ret) && !ret.IsSubclassOf(typeof(T))) { throw new Exception("type is not an IRestriction"); } } bsonReader.ReturnToBookmark(bookmark); return(ret); }
public Type GetActualType(IBsonReader bsonReader, Type nominalType) { if (nominalType == typeof(OrderModel)) { var ret = nominalType; var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); if (bsonReader.FindElement(orderType)) { var value = bsonReader.ReadString(); ret = OrderTypeResolver.ResolveOrderType(value); if (ret == null) { throw new Exception("Could not find type " + value); } if (!ret.IsSubclassOf(typeof(OrderModel))) { throw new Exception("Database type does not inherit from OrderModel."); } } bsonReader.ReturnToBookmark(bookmark); return(ret); } else { return(nominalType); } }
public Type GetActualType(IBsonReader bsonReader, Type nominalType) { if (nominalType == typeof(JobTask)) { var ret = nominalType; var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); if (bsonReader.FindElement(ElementName)) { var value = bsonReader.ReadString(); ret = Type.GetType(value); if (ret == null) throw new Exception("Could not find type " + value); if (!ret.IsSubclassOf(typeof(JobTask))) throw new Exception("Database type does not inherit from JobTask."); } bsonReader.ReturnToBookmark(bookmark); return ret; } else { return nominalType; } }
public Type GetActualType(IBsonReader bsonReader, Type nominalType) { var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); string typeValue = string.Empty; if (bsonReader.FindElement(ElementName)) typeValue = bsonReader.ReadString(); else throw new NotSupportedException(); bsonReader.ReturnToBookmark(bookmark); var retr = Type.GetType(typeValue) ?? Type.GetType("ThreeOneThree.Proxima.Core.Entities." + typeValue); return retr; }
internal static Type FindDocumentType(this IBsonReader reader, Type nominalType) { var bookmark = reader.GetBookmark(); var actualType = nominalType; reader.ReadStartDocument(); if (reader.FindElement(Conventions.Type)) { actualType = ReadActualType(reader, nominalType); } reader.ReturnToBookmark(bookmark); reader.ReadStartDocument(); if (reader.FindElement(Conventions.TypeAlias)) { actualType = ReadActualType(reader, nominalType); } reader.ReturnToBookmark(bookmark); return(actualType); }
public Type GetActualType(IBsonReader bsonReader, Type nominalType) { var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); var t = nominalType; if (bsonReader.FindElement(ElementName)) { var raw = bsonReader.ReadString(); var discriminator = _discriminatorMapper.Discriminator(raw); t = _discriminatorMapper.ConcreteType(discriminator); } bsonReader.ReturnToBookmark(bookmark); return(t); }
public Type GetActualType(IBsonReader bsonReader, Type nominalType) { var ret = nominalType; var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); if (bsonReader.FindElement(ElementName)) { var value = bsonReader.ReadString(); ret = Type.GetType(value); } bsonReader.ReturnToBookmark(bookmark); return(ret); }
/***************************************************/ /**** Interface Methods ****/ /***************************************************/ public Type GetActualType(IBsonReader 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) { var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); var actualType = nominalType; if (bsonReader.FindElement(ElementName)) { var context = BsonDeserializationContext.CreateRoot(bsonReader); var discriminator = BsonValueSerializer.Instance.Deserialize(context); try { actualType = BsonSerializer.LookupActualType(nominalType, discriminator); } catch { BsonDocument doc = new BsonDocument { { "_t", "System.Type" }, { "Name", discriminator.ToString() } }; try { actualType = Convert.FromBson(doc) as Type; } catch { } } } else { actualType = typeof(CustomObject); } bsonReader.ReturnToBookmark(bookmark); return(actualType); } return(nominalType); }
public Type GetActualType(IBsonReader bsonReader, Type nominalType) { var ret = nominalType; var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); if (bsonReader.FindElement(ElementName)) { var value = bsonReader.ReadString(); ret = AppDomain.CurrentDomain.GetAssemblies() .SelectMany(a => a.GetTypes().Where(a => a.IsSubclassOf(typeof(Node)))) .FirstOrDefault(a => a.FullName == value); } bsonReader.ReturnToBookmark(bookmark); return(ret); }
public Type GetActualType(IBsonReader bsonReader, Type nominalType) { var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); string typeValue = string.Empty; if (bsonReader.FindElement(ElementName)) { typeValue = bsonReader.ReadString(); } else { throw new NotSupportedException(); } bsonReader.ReturnToBookmark(bookmark); var result = Type.GetType(typeValue); return(result); }
public Type GetActualType(IBsonReader bsonReader, Type nominalType) { var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); string typeValue = string.Empty; if (bsonReader.FindElement(ElementName)) { typeValue = bsonReader.ReadString(); } else { throw new NotSupportedException(); } bsonReader.ReturnToBookmark(bookmark); var retr = Type.GetType(typeValue) ?? Type.GetType("ThreeOneThree.Proxima.Core.Entities." + typeValue); return(retr); }
public Type GetActualType(IBsonReader bsonReader, Type nominalType) { Type type = null; var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); if (bsonReader.FindElement(ElementName)) { var value = bsonReader.ReadString(); if (typeMap.ContainsKey(value)) { type = typeMap[value]; } } bsonReader.ReturnToBookmark(bookmark); if (type == null) { throw new Exception($"Type mis-configuration can't find bson type for ${nominalType}"); } return(type); }
/***************************************************/ /**** 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); } else if (Reflection.Compute.UnqualifiedName(nominalType.FullName) != Reflection.Compute.UnqualifiedName(discriminator.ToString()) && Config.AllowUpgradeFromBson && !Config.TypesWithoutUpgrade.Contains(actualType)) { actualType = typeof(IDeprecated); } } bsonReader.ReturnToBookmark(bookmark); if (Config.AllowUpgradeFromBson && actualType.IsDeprecated() && !Config.TypesWithoutUpgrade.Contains(actualType)) { actualType = typeof(IDeprecated); } } return(actualType); }
public Type GetActualType(IBsonReader bsonReader, Type nominalType) { var ret = nominalType; var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); if (bsonReader.FindElement(ElementName)) { var value = bsonReader.ReadString(); ret = Type.GetType(value); if (ret == null) { throw new Exception("Could not find type " + value); } } bsonReader.ReturnToBookmark(bookmark); return(ret); }
public virtual Type GetActualType(IBsonReader bsonReader, Type nominalType) { var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); if (!bsonReader.FindElement(ElementName)) { bsonReader.ReturnToBookmark(bookmark); return(nominalType); } var typeValue = bsonReader.ReadString(); bsonReader.ReturnToBookmark(bookmark); var type = GetItemType(new Guid(typeValue)); if (type == null) { throw new MongoDerivedTypeResolutionException($"Cannot resolve derived type {typeValue}"); } return(type); }
// 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(IBsonReader bsonReader, Type nominalType) { // the BsonReader is sitting at the value whose actual type needs to be found var bsonType = bsonReader.GetCurrentBsonType(); if (bsonReader.State == BsonReaderState.Value) { Type primitiveType = null; switch (bsonType) { case BsonType.Boolean: primitiveType = typeof(bool); break; case BsonType.Binary: var bookmark = bsonReader.GetBookmark(); var binaryData = bsonReader.ReadBinaryData(); var subType = binaryData.SubType; if (subType == BsonBinarySubType.UuidStandard || subType == BsonBinarySubType.UuidLegacy) { primitiveType = typeof(Guid); } bsonReader.ReturnToBookmark(bookmark); break; case BsonType.DateTime: primitiveType = typeof(DateTime); break; case BsonType.Decimal128: primitiveType = typeof(Decimal128); break; case BsonType.Double: primitiveType = typeof(double); break; case BsonType.Int32: primitiveType = typeof(int); break; case BsonType.Int64: primitiveType = typeof(long); break; case BsonType.ObjectId: primitiveType = typeof(ObjectId); break; case BsonType.String: primitiveType = typeof(string); break; } // Type.IsAssignableFrom is extremely expensive, always perform a direct type check before calling Type.IsAssignableFrom if (primitiveType != null && (primitiveType == nominalType || nominalType.GetTypeInfo().IsAssignableFrom(primitiveType))) { return primitiveType; } } if (bsonType == BsonType.Document) { var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); var actualType = nominalType; 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 } actualType = BsonSerializer.LookupActualType(nominalType, discriminator); } bsonReader.ReturnToBookmark(bookmark); return actualType; } return nominalType; }
/// <inheritdoc /> public Type GetActualType( IBsonReader bsonReader, Type nominalType) { if (bsonReader == null) { throw new ArgumentNullException(nameof(bsonReader)); } if (nominalType == null) { throw new ArgumentNullException(nameof(nominalType)); } var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); Type result; if (bsonReader.FindElement(this.ElementName)) { var value = bsonReader.ReadString(); try { result = value.ResolveFromLoadedTypes(); if (result == null) { throw new InvalidOperationException(Invariant($"'{nameof(result)}' is null")); } } catch (ArgumentException) { bsonReader.ReturnToBookmark(bookmark); // previously persisted documents will have used Type.Name // in that case ToTypeRepresentationFromAssemblyQualifiedName will throw. // this is here for backward compatibility. result = HierarchicalDiscriminatorConvention.GetActualType(bsonReader, nominalType); if (result == null) { throw new InvalidOperationException(Invariant($"Found discriminator '{value}' when deserializing into {nameof(nominalType)} '{nominalType.ToStringReadable()}', but could not get the actual type using {nameof(TypeNameDiscriminator)}.{nameof(TypeNameDiscriminator.GetActualType)}(); it returned null.")); } } } else { // if _t is not in the payload then a discriminator wasn't needed result = nominalType; } bsonReader.ReturnToBookmark(bookmark); // See notes in ThrowOnUnregisteredTypeIfAppropriate for the need to make this call. // Note that this is a sub-par solution. Ideally this discriminator would know // which serializer (and hence which serialization configuration) is being used for deserializing, // because it is passed as a parameter to this method. Because that's not an option in Mongo, // we have to use ObcBsonSerializer.SerializationConfigurationInUseForDeserialization, which // tracks the thread being used for the deserialize operation and associates the serialization // configuration in-use with the thread. var serializationConfiguration = ObcBsonSerializer.GetSerializationConfigurationInUseForDeserialization(); // serializationConfiguration is only ever null if the consumer is NOT using the front-door for serialization // (i.e. a serializer), but using the Mongo driver directly to deserialize. In that case, we do not know // which serialization configuration is "in use". serializationConfiguration?.ThrowOnUnregisteredTypeIfAppropriate(result, SerializationDirection.Deserialize, null); return(result); }
// 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(IBsonReader 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(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; }
// 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(IBsonReader bsonReader, Type nominalType) { // the BsonReader is sitting at the value whose actual type needs to be found var bsonType = bsonReader.GetCurrentBsonType(); if (bsonReader.State == BsonReaderState.Value) { Type primitiveType = null; switch (bsonType) { case BsonType.Boolean: primitiveType = typeof(bool); break; case BsonType.Binary: var bookmark = bsonReader.GetBookmark(); var binaryData = bsonReader.ReadBinaryData(); var subType = binaryData.SubType; if (subType == BsonBinarySubType.UuidStandard || subType == BsonBinarySubType.UuidLegacy) { primitiveType = typeof(Guid); } bsonReader.ReturnToBookmark(bookmark); break; case BsonType.DateTime: primitiveType = typeof(DateTime); break; case BsonType.Decimal128: primitiveType = typeof(Decimal128); break; case BsonType.Double: primitiveType = typeof(double); break; case BsonType.Int32: primitiveType = typeof(int); break; case BsonType.Int64: primitiveType = typeof(long); break; case BsonType.ObjectId: primitiveType = typeof(ObjectId); break; case BsonType.String: primitiveType = typeof(string); break; } // Type.IsAssignableFrom is extremely expensive, always perform a direct type check before calling Type.IsAssignableFrom if (primitiveType != null && (primitiveType == nominalType || nominalType.GetTypeInfo().IsAssignableFrom(primitiveType))) { return(primitiveType); } } if (bsonType == BsonType.Document) { var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); var actualType = nominalType; 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 } actualType = BsonSerializer.LookupActualType(nominalType, discriminator); } bsonReader.ReturnToBookmark(bookmark); return(actualType); } return(nominalType); }