public ObjectConverter(JsonSerializerOptions options)
{
_objectMapping = options.GetObjectMappingRegistry().Lookup <T>();
_memberConverters = new Lazy <MemberConverters>(() => MemberConverters.Create(options, _objectMapping));
_isInterfaceOrAbstract = typeof(T).IsInterface || typeof(T).IsAbstract;
_isStruct = typeof(T).IsStruct();
if (!_isInterfaceOrAbstract && _objectMapping.CreatorMapping == null && !_isStruct)
{
ConstructorInfo defaultConstructorInfo = typeof(T).GetConstructor(
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
null,
Type.EmptyTypes,
null);
if (defaultConstructorInfo == null)
{
throw new JsonException($"Cannot find a default constructor on type {typeof(T)}");
}
_constructor = defaultConstructorInfo.CreateDelegate <T>();
}
_discriminatorConvention = options.GetDiscriminatorConventionRegistry().GetConvention(typeof(T));
_referenceHandling = _isStruct ? ReferenceHandling.Default : options.GetReferenceHandling();
}
/// <summary>
/// Initializes a new instance of the <see cref="ObjectSerializer"/> class.
/// </summary>
/// <param name="discriminatorConvention">The discriminator convention.</param>
/// <exception cref="System.ArgumentNullException">discriminatorConvention</exception>
public ObjectSerializer(IDiscriminatorConvention discriminatorConvention)
{
if (discriminatorConvention == null)
{
throw new ArgumentNullException("discriminatorConvention");
}
_discriminatorConvention = discriminatorConvention;
}
/// <summary>
/// Registers the convention.This behaves like a stack, so the
/// last convention registered is the first convention consulted.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="convention">The convention.</param>
public void RegisterConvention(IDiscriminatorConvention convention)
{
if (convention == null)
{
throw new ArgumentNullException(nameof(convention));
}
_conventions.Push(convention);
}
public IMemberConverter GenerateMemberConverter()
{
IDiscriminatorConvention discriminatorConvention = _discriminatorConventionRegistry.GetConvention(_objectMapping.ObjectType);
IMemberConverter memberConverter = new DiscriminatorMemberConverter <T>(
discriminatorConvention, _objectMapping.DiscriminatorPolicy);
return(memberConverter);
}
public void PostInitialize()
{
IDiscriminatorConvention discriminatorConvention = _discriminatorConventionRegistry.GetConvention(_objectMapping.ObjectType);
if (discriminatorConvention != null)
{
MemberName = Encoding.UTF8.GetString(discriminatorConvention.MemberName);
}
}
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>
/// Initializes a new instance of the <see cref="ObjectSerializer"/> class.
/// </summary>
/// <param name="discriminatorConvention">The discriminator convention.</param>
/// <param name="guidRepresentation">The Guid representation.</param>
public ObjectSerializer(IDiscriminatorConvention discriminatorConvention, GuidRepresentation guidRepresentation)
{
if (discriminatorConvention == null)
{
throw new ArgumentNullException("discriminatorConvention");
}
_discriminatorConvention = discriminatorConvention;
_guidRepresentation = guidRepresentation;
_guidSerializer = new GuidSerializer(_guidRepresentation);
}
/// <summary>
/// Initializes a new instance of the <see cref="DiscriminatedInterfaceSerializer{TInterface}" /> class.
/// </summary>
/// <param name="discriminatorConvention">The discriminator convention.</param>
/// <exception cref="System.ArgumentException">interfaceType</exception>
/// <exception cref="System.ArgumentNullException">interfaceType</exception>
public DiscriminatedInterfaceSerializer(IDiscriminatorConvention discriminatorConvention)
{
if (!typeof(TInterface).IsInterface)
{
var message = string.Format("{0} is not an interface.", typeof(TInterface).FullName);
throw new ArgumentException(message, "<TInterface>");
}
_interfaceType = typeof(TInterface);
_discriminatorConvention = discriminatorConvention;
}
public DiscriminatorMemberConverter(
IDiscriminatorConvention discriminatorConvention,
CborDiscriminatorPolicy discriminatorPolicy)
{
_discriminatorConvention = discriminatorConvention;
_discriminatorPolicy = discriminatorPolicy;
if (discriminatorConvention != null)
{
_memberName = discriminatorConvention.MemberName.ToArray();
}
}
/// <summary>
/// Gets the discriminator convention for values.
/// </summary>
/// <returns>The discriminator convention for the class.</returns>
private IDiscriminatorConvention GetValueDiscriminatorConvention()
{
// return a cached discriminator convention when possible
var discriminatorConvention = _cachedValueDiscriminatorConvention;
if (discriminatorConvention == null)
{
// it's possible but harmless for multiple threads to do the initial lookup at the same time
discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(TValue));
_cachedValueDiscriminatorConvention = discriminatorConvention;
}
return(discriminatorConvention);
}
// internal methods
/// <summary>
/// Gets the discriminator convention for the member type.
/// </summary>
/// <returns>The discriminator convention for the member type.</returns>
internal IDiscriminatorConvention GetDiscriminatorConvention()
{
// return a cached discriminator convention when possible
var discriminatorConvention = _cachedDiscriminatorConvention;
if (discriminatorConvention == null)
{
// it's possible but harmless for multiple threads to do the initial lookup at the same time
discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(_memberType);
_cachedDiscriminatorConvention = discriminatorConvention;
}
return(discriminatorConvention);
}
public static void Test_DiscriminatorConvention_01(BsonDocument document)
{
Trace.WriteLine("Test_DiscriminatorConvention_01");
BsonReader bsonReader = BsonReader.Create(document);
IDiscriminatorConvention discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(ZValue));
Trace.WriteLine("discriminatorConvention(ZValue) : {0}", discriminatorConvention);
Type actualType = discriminatorConvention.GetActualType(bsonReader, typeof(ZValue));
Trace.WriteLine("actualType : {0}", actualType);
//discriminatorConvention.GetDiscriminator()
Trace.WriteLine();
}
public MongoStore(
ILogger <MongoStore> logger,
IClientSessionHandle session,
IMongoCollection <Envelope> events,
IMongoCollection <Snapshot> snapshots
)
{
_logger = logger;
_session = session;
_events = events;
_snapshots = snapshots;
_discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(object));
}
public DiscriminatorMemberConverter(
IDiscriminatorConvention discriminatorConvention,
DiscriminatorPolicy discriminatorPolicy)
{
_discriminatorConvention = discriminatorConvention;
_discriminatorPolicy = discriminatorPolicy;
if (discriminatorConvention != null)
{
ReadOnlySpan <byte> discriminatorMemberName = discriminatorConvention.MemberName;
_memberName = discriminatorMemberName.ToArray();
MemberNameAsString = Encoding.UTF8.GetString(discriminatorMemberName);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DiscriminatedInterfaceSerializer{TInterface}" /> class.
/// </summary>
/// <param name="discriminatorConvention">The discriminator convention.</param>
/// <exception cref="System.ArgumentException">interfaceType</exception>
/// <exception cref="System.ArgumentNullException">interfaceType</exception>
public DiscriminatedInterfaceSerializer(IDiscriminatorConvention discriminatorConvention)
{
var interfaceTypeInfo = typeof(TInterface).GetTypeInfo();
if (!interfaceTypeInfo.IsInterface)
{
var message = string.Format("{0} is not an interface.", typeof(TInterface).FullName);
throw new ArgumentException(message, "<TInterface>");
}
_interfaceType = typeof(TInterface);
_discriminatorConvention = discriminatorConvention;
_objectSerializer = new ObjectSerializer(_discriminatorConvention);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConventionProfile"/> class.
/// </summary>
public ConventionProfile()
{
_aliasConvention = new DelegateAliasConvention(m => m.Name);
_collectionNameConvention = new DelegateCollectionNameConvention(t => t.Name);
_collectionAdapterConvention = DefaultCollectionAdapterConvention.Instance;
_defaultValueConvention = DefaultDefaultValueConvention.Instance;
_dictionaryAdapterConvention = DefaultDictionaryAdapterConvention.Instance;
_discriminatorConvention = new DelegateDiscriminatorConvention(t => t.Name);
_discriminatorAliasConvention = new DelegateDiscriminatorAliasConvention(t => "_t");
_extendedPropertiesConvention = new DelegateExtendedPropertiesConvention(m => m.Name == "ExtendedProperties");
_idConvention = new DelegateIdConvention(m => m.Name == "Id");
_idGeneratorConvention = DefaultIdGeneratorConvention.Instance;
_idUnsavedValueConvention = DefaultIdUnsavedValueConvention.Instance;
}
public object Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var bsonReader = context.Reader;
BsonType bsonType = bsonReader.CurrentBsonType;
object result;
if (bsonType == BsonType.Null)
{
bsonReader.ReadNull();
result = null;
}
else
{
if (bsonType == BsonType.Document)
{
var dictionary = new DynamicDictionary();
bsonReader.ReadStartDocument();
IDiscriminatorConvention valueDiscriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(object));
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
string key = bsonReader.ReadName();
Type valueType = valueDiscriminatorConvention.GetActualType(bsonReader, typeof(object));
IBsonSerializer valueSerializer = BsonSerializer.LookupSerializer(valueType);
object value = valueSerializer.Deserialize(context);
if (key != "_t")
{
dictionary.Add(key.Replace('\x03', '.'), value);
}
}
bsonReader.ReadEndDocument();
result = dictionary;
}
else
{
string message = string.Format("Can't deserialize a {0} from BsonType {1}.", context.Reader.CurrentBsonType, bsonType);
throw new BsonException(message);
}
}
return(result);
}
/// <summary>
/// Registers the discriminator convention for a type.
/// </summary>
/// <param name="type">Type type.</param>
/// <param name="convention">The discriminator convention.</param>
public static void RegisterDiscriminatorConvention(
Type type,
IDiscriminatorConvention convention
)
{
lock (BsonSerializer.ConfigLock) {
if (!discriminatorConventions.ContainsKey(type))
{
discriminatorConventions.Add(type, convention);
}
else
{
var message = string.Format("There is already a discriminator convention registered for type {0}.", type.FullName);
throw new BsonSerializationException(message);
}
}
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="DiscriminatedWrapperSerializer{TValue}" /> class.
/// </summary>
/// <param name="discriminatorConvention">The discriminator convention.</param>
/// <param name="wrappedSerializer">The wrapped serializer.</param>
public DiscriminatedWrapperSerializer(IDiscriminatorConvention discriminatorConvention, IBsonSerializer <TValue> wrappedSerializer)
{
_discriminatorConvention = discriminatorConvention;
_wrappedSerializer = wrappedSerializer;
_helper = new SerializerHelper
(
new SerializerHelper.Member(discriminatorConvention.ElementName, Flags.Discriminator),
new SerializerHelper.Member("_v", Flags.Value)
);
_isPositionedHelper = new SerializerHelper
(
new SerializerHelper.Member(discriminatorConvention.ElementName, Flags.Discriminator, isOptional: true),
new SerializerHelper.Member("_v", Flags.Value, isOptional: true),
new SerializerHelper.Member("*", Flags.Other, isOptional: true)
);
}
/// <summary>
/// Registers the discriminator convention for a type.
/// </summary>
/// <param name="type">Type type.</param>
/// <param name="convention">The discriminator convention.</param>
public static void RegisterDiscriminatorConvention(Type type, IDiscriminatorConvention convention)
{
__configLock.EnterWriteLock();
try
{
if (!__discriminatorConventions.ContainsKey(type))
{
__discriminatorConventions.Add(type, convention);
}
else
{
var message = string.Format("There is already a discriminator convention registered for type {0}.", type.FullName);
throw new BsonSerializationException(message);
}
}
finally
{
__configLock.ExitWriteLock();
}
}
private IDiscriminatorConvention InternalGetConvention(Type type)
{
IDiscriminatorConvention convention = _conventions.FirstOrDefault(c => c.TryRegisterType(type));
if (convention != null)
{
// setup discriminator for all base types
for (Type currentType = type.BaseType; currentType != null && currentType != typeof(object); currentType = currentType.BaseType)
{
_conventionsByType.TryAdd(currentType, convention);
}
// setup discriminator for all interfaces
foreach (Type @interface in type.GetInterfaces())
{
_conventionsByType.TryAdd(@interface, convention);
}
}
return(convention);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConventionProfile"/> class.
/// </summary>
public ConventionProfile()
{
_aliasConvention = new DelegateAliasConvention(m => m.Name);
_collectionNameConvention = new DelegateCollectionNameConvention(t => t.Name);
_collectionAdapterConvention = DefaultCollectionAdapterConvention.Instance;
_defaultValueConvention = DefaultDefaultValueConvention.Instance;
_dictionaryAdapterConvention = DefaultDictionaryAdapterConvention.Instance;
_discriminatorConvention = new DelegateDiscriminatorConvention(t => t.Name);
_discriminatorAliasConvention = new DelegateDiscriminatorAliasConvention(t => "_t");
_extendedPropertiesConvention = new DelegateExtendedPropertiesConvention(m => m.Name == "ExtendedProperties");
_idConvention = new DelegateIdConvention(m => m.Name == "Id");
_idGeneratorConvention = DefaultIdGeneratorConvention.Instance;
_idUnsavedValueConvention = DefaultIdUnsavedValueConvention.Instance;
}
/// <summary>
/// Initializes a new instance of the <see cref="ObjectSerializer"/> class.
/// </summary>
/// <param name="discriminatorConvention">The discriminator convention.</param>
/// <exception cref="System.ArgumentNullException">discriminatorConvention</exception>
public ObjectSerializer(IDiscriminatorConvention discriminatorConvention)
: this(discriminatorConvention, GuidRepresentation.Unspecified)
{
}
/// <summary>
/// Uses the discriminator convention.
/// </summary>
/// <param name="discriminatorConvention">The discriminator convention.</param>
/// <returns></returns>
public AutoMappingProfileBuilder UseDiscriminatorConvention(IDiscriminatorConvention discriminatorConvention)
{
_profile.Conventions.DiscriminatorConvention = discriminatorConvention;
return this;
}
public static void RegisterDiscriminatorConvention(
Type type,
IDiscriminatorConvention convention
)
{
lock (staticLock) {
if (!discriminatorConventions.ContainsKey(type)) {
discriminatorConventions.Add(type, convention);
} else {
var message = string.Format("There is already a discriminator convention registered for type: {0}", type.FullName);
throw new BsonSerializationException(message);
}
}
}
/// <summary>
/// Registers the discriminator convention for a type.
/// </summary>
/// <param name="type">Type type.</param>
/// <param name="convention">The discriminator convention.</param>
public static void RegisterDiscriminatorConvention(Type type, IDiscriminatorConvention convention)
{
BsonSerializer.ConfigLock.EnterWriteLock();
try
{
if (!__discriminatorConventions.ContainsKey(type))
{
__discriminatorConventions.Add(type, convention);
}
else
{
var message = string.Format("There is already a discriminator convention registered for type {0}.", type.FullName);
throw new BsonSerializationException(message);
}
}
finally
{
BsonSerializer.ConfigLock.ExitWriteLock();
}
}
/// <summary>
/// Uses the discriminator convention.
/// </summary>
/// <param name="discriminatorConvention">The discriminator convention.</param>
/// <returns></returns>
public AutoMappingProfileBuilder UseDiscriminatorConvention(IDiscriminatorConvention discriminatorConvention)
{
_profile.Conventions.DiscriminatorConvention = discriminatorConvention;
return(this);
}
// internal methods
/// <summary>
/// Gets the discriminator convention for the member type.
/// </summary>
/// <returns>The discriminator convention for the member type.</returns>
internal IDiscriminatorConvention GetDiscriminatorConvention()
{
// return a cached discriminator convention when possible
var discriminatorConvention = _cachedDiscriminatorConvention;
if (discriminatorConvention == null)
{
// it's possible but harmless for multiple threads to do the initial lookup at the same time
discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(_memberType);
_cachedDiscriminatorConvention = discriminatorConvention;
}
return discriminatorConvention;
}
public object Deserialize(BsonReader bsonReader, Type nominalType, Type actualType, IBsonSerializationOptions options)
{
this.VerifyNominalType(nominalType);
if (bsonReader.CurrentBsonType == BsonType.Null)
{
bsonReader.ReadNull();
return((object)null);
}
else
{
if (actualType.IsValueType)
{
throw new BsonSerializationException(string.Format("Value class {0} cannot be deserialized.", (object)actualType.FullName));
}
BsonClassMap bsonClassMap = BsonClassMap.LookupClassMap(actualType);
if (bsonClassMap.IsAnonymous)
{
throw new InvalidOperationException("An anonymous class cannot be deserialized.");
}
// Added
object instance = CreateInstance(bsonClassMap);
// Added
if (bsonReader.CurrentBsonType != BsonType.Document)
{
throw new FileFormatException(string.Format("Expected a nested document representing the serialized form of a {0} value, but found a value of type {1} instead.", (object)actualType.FullName, (object)bsonReader.CurrentBsonType));
}
bsonReader.ReadStartDocument();
HashSet <BsonMemberMap> hashSet = new HashSet <BsonMemberMap>(bsonClassMap.MemberMaps);
IDiscriminatorConvention discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(nominalType);
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
string elementName = bsonReader.ReadName();
if (elementName == discriminatorConvention.ElementName)
{
bsonReader.SkipValue();
}
else
{
BsonMemberMap memberMapForElement = bsonClassMap.GetMemberMapForElement(elementName);
if (memberMapForElement != null && memberMapForElement != bsonClassMap.ExtraElementsMemberMap)
{
this.DeserializeMember(bsonReader, instance, memberMapForElement);
hashSet.Remove(memberMapForElement);
}
else if (bsonClassMap.ExtraElementsMemberMap != null)
{
this.DeserializeExtraElement(bsonReader, instance, elementName, bsonClassMap.ExtraElementsMemberMap);
}
else
{
if (!bsonClassMap.IgnoreExtraElements)
{
throw new FileFormatException(string.Format("Element '{0}' does not match any field or property of class {1}.", (object)elementName, (object)bsonClassMap.ClassType.FullName));
}
bsonReader.SkipValue();
}
}
}
bsonReader.ReadEndDocument();
foreach (BsonMemberMap bsonMemberMap in hashSet)
{
if (bsonMemberMap.IsRequired)
{
string str = bsonMemberMap.MemberInfo.MemberType == MemberTypes.Field ? "field" : "property";
throw new FileFormatException(string.Format("Required element '{0}' for {1} '{2}' of class {3} is missing.", (object)bsonMemberMap.ElementName, (object)str, (object)bsonMemberMap.MemberName, (object)bsonClassMap.ClassType.FullName));
}
else if (bsonMemberMap.HasDefaultValue)
{
bsonMemberMap.ApplyDefaultValue(instance);
}
}
return(instance);
}
}
