public void Apply(BsonMemberMap memberMap) { if (memberMap.MemberType == typeof(Guid)) { memberMap.SetDefaultValue(Guid.Empty); } }
/// <summary> /// Applies the specified member map convention. /// </summary> /// <param name="memberMap">The member map convention.</param> public void Apply(BsonMemberMap memberMap) { Func<Type, IBsonSerializer> converter = t => { if (t == typeof(DateTime)) return new DateTimeSerializer(DateTimeKind.Local); else if (t == typeof(DateTime?)) return new NullableSerializer<DateTime>(new DateTimeSerializer(DateTimeKind.Local)); return null; }; IBsonSerializer serializer = null; switch (memberMap.MemberInfo.MemberType) { case MemberTypes.Property: PropertyInfo propertyInfo = (PropertyInfo)memberMap.MemberInfo; serializer = converter(propertyInfo.PropertyType); break; case MemberTypes.Field: FieldInfo fieldInfo = (FieldInfo)memberMap.MemberInfo; serializer = converter(fieldInfo.FieldType); break; default: break; } if (serializer != null) memberMap.SetSerializer(serializer); }
/// <summary> /// Initializes an instance of the MongoFieldExpression class. /// </summary> /// <param name="expression">The expression that references the field.</param> /// <param name="name">The name of the referenced field.</param> /// <param name="memberMap">The BsonMemberMap of the referenced field.</param> public MongoFieldExpression(Expression expression, string name, BsonMemberMap memberMap) : base(MongoExpressionType.Field, expression.Type) { _expression = expression; _name = name; _memberMap = memberMap; }
/// <summary> /// Changes the decimal representation if the member is a decimal /// </summary> /// <param name="memberMap"></param> public void Apply(BsonMemberMap memberMap) { if (memberMap.MemberType == typeof(string) && memberMap.ClassMap.IdMemberMap == memberMap) { memberMap.SetSerializer(new StringSerializer(BsonType.ObjectId)); } }
public FieldExpression(Expression expression, Alias alias, string name, BsonMemberMap memberMap) : base(MongoExpressionType.Field, expression.Type) { Alias = alias; Expression = expression; Name = name; MemberMap = memberMap; }
public void Apply(BsonMemberMap memberMap) { if (memberMap.MemberType.IsEnum) { var serializer = memberMap.GetSerializer(); var camelCaseValueSerializer = new CamelCaseValueSerializer(serializer); memberMap.SetSerializer(camelCaseValueSerializer); } }
internal BsonValue GetValue(BsonMemberMap memberMap, Expression expression) { _memberMap = memberMap; Visit(expression); if (_value == null) throw new NotSupportedException("No value result."); return _value; }
protected override void DeserializeExtraElement(BsonReader bsonReader, object obj, string elementName, BsonMemberMap extraElementsMemberMap) { if (elementName == VERSION_ELEMENT_NAME) { var extraElements = EnsureExtraElements(obj, extraElementsMemberMap); extraElements[VERSION_ELEMENT_NAME] = _versionSerializer.Deserialize(bsonReader, typeof (Version), null); } else { base.DeserializeExtraElement(bsonReader, obj, elementName, extraElementsMemberMap); } }
private object SerializeValue(object value, BsonMemberMap memberMap) { const string tmpField = "tmp"; var type = value.GetType(); var serializer = memberMap.GetSerializer(type); var document = new BsonDocument(); using (var writer = BsonWriter.Create(document)) { // serialize the value inside a document using the provided serializer writer.WriteStartDocument(); writer.WriteName(tmpField); serializer.Serialize(writer, type, value, memberMap.SerializationOptions); writer.WriteEndDocument(); } // extract the serialized value from the document return document[tmpField]; }
// public methods /// <summary> /// Applies a modification to the member map. /// </summary> /// <param name="memberMap">The member map.</param> public virtual void Apply(BsonMemberMap memberMap) { var memberSerializer = memberMap.GetSerializer(memberMap.MemberType); var memberSerializationOptions = memberMap.SerializationOptions; if (memberSerializationOptions == null) { var memberDefaultSerializationOptions = memberSerializer.GetDefaultSerializationOptions(); if (memberDefaultSerializationOptions == null) { var message = string.Format( "A serialization options attribute of type {0} cannot be used when the serializer is of type {1}.", BsonUtils.GetFriendlyTypeName(this.GetType()), BsonUtils.GetFriendlyTypeName(memberSerializer.GetType())); throw new NotSupportedException(message); } memberSerializationOptions = memberDefaultSerializationOptions.Clone(); memberMap.SetSerializationOptions(memberSerializationOptions); } memberSerializationOptions.ApplyAttribute(memberSerializer, this); }
private void DeserializeExtraElementMember( BsonDeserializationContext context, object obj, string elementName, BsonMemberMap extraElementsMemberMap) { var bsonReader = context.Reader; if (extraElementsMemberMap.MemberType == typeof(BsonDocument)) { var extraElements = (BsonDocument)extraElementsMemberMap.Getter(obj); if (extraElements == null) { extraElements = new BsonDocument(); extraElementsMemberMap.Setter(obj, extraElements); } var bsonValue = BsonValueSerializer.Instance.Deserialize(context); extraElements[elementName] = bsonValue; } else { var extraElements = (IDictionary <string, object>)extraElementsMemberMap.Getter(obj); if (extraElements == null) { if (extraElementsMemberMap.MemberType == typeof(IDictionary <string, object>)) { extraElements = new Dictionary <string, object>(); } else { extraElements = (IDictionary <string, object>)Activator.CreateInstance(extraElementsMemberMap.MemberType); } extraElementsMemberMap.Setter(obj, extraElements); } var bsonValue = BsonValueSerializer.Instance.Deserialize(context); extraElements[elementName] = BsonTypeMapper.MapToDotNetValue(bsonValue); } }
/// <summary> /// Applies the specified member map convention. /// </summary> /// <param name="memberMap">The member map convention.</param> public void Apply(BsonMemberMap memberMap) { IBsonSerializationOptions options = null; switch (memberMap.MemberInfo.MemberType) { case MemberTypes.Property: PropertyInfo propertyInfo = (PropertyInfo)memberMap.MemberInfo; if (propertyInfo.PropertyType == typeof(DateTime) || propertyInfo.PropertyType == typeof(DateTime?)) options = new DateTimeSerializationOptions(DateTimeKind.Local); break; case MemberTypes.Field: FieldInfo fieldInfo = (FieldInfo)memberMap.MemberInfo; if (fieldInfo.FieldType == typeof(DateTime) || fieldInfo.FieldType == typeof(DateTime?)) options = new DateTimeSerializationOptions(DateTimeKind.Local); break; default: break; } memberMap.SetSerializationOptions(options); }
private void DeserializeMember(BsonReader bsonReader, object obj, BsonMemberMap memberMap) { try { object value; var nominalType = memberMap.MemberType; var bsonType = bsonReader.GetCurrentBsonType(); if (bsonType == BsonType.Null && nominalType.IsInterface) { bsonReader.ReadNull(); value = null; } else { Type actualType; if (bsonType == BsonType.Null) { actualType = nominalType; } else { var discriminatorConvention = memberMap.GetDiscriminatorConvention(); actualType = discriminatorConvention.GetActualType(bsonReader, nominalType); // returns nominalType if no discriminator found } var serializer = memberMap.GetSerializer(actualType); value = serializer.Deserialize(bsonReader, nominalType, actualType, memberMap.SerializationOptions); } memberMap.Setter(obj, value); } catch (Exception ex) { var message = string.Format( "An error occurred while deserializing the {0} {1} of class {2}: {3}", // terminating period provided by nested message memberMap.MemberName, (memberMap.MemberInfo.MemberType == MemberTypes.Field) ? "field" : "property", obj.GetType().FullName, ex.Message); throw new FileFormatException(message, ex); } }
private void SerializeMember(BsonWriter bsonWriter, object obj, BsonMemberMap memberMap) { var value = memberMap.Getter(obj); if (!memberMap.ShouldSerialize(obj, value)) { return; // don't serialize member } bsonWriter.WriteName(memberMap.ElementName); var nominalType = memberMap.MemberType; if (value == null && nominalType.IsInterface) { bsonWriter.WriteNull(); } else { var actualType = (value == null) ? nominalType : value.GetType(); var serializer = memberMap.GetSerializer(actualType); serializer.Serialize(bsonWriter, nominalType, value, memberMap.SerializationOptions); } }
private void DeserializeMember( BsonReader bsonReader, object obj, BsonMemberMap memberMap ) { var nominalType = memberMap.MemberType; Type actualType; if (bsonReader.CurrentBsonType == BsonType.Null) { actualType = nominalType; } else { var discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(nominalType); actualType = discriminatorConvention.GetActualType(bsonReader, nominalType); // returns nominalType if no discriminator found } var serializer = memberMap.GetSerializer(actualType); var value = serializer.Deserialize(bsonReader, nominalType, actualType, memberMap.SerializationOptions); memberMap.Setter(obj, value); }
private void SerializeMember( BsonWriter bsonWriter, object obj, BsonMemberMap memberMap ) { var value = memberMap.Getter(obj); if (value == null && memberMap.IgnoreIfNull) { return; // don't serialize null value } if (memberMap.HasDefaultValue && !memberMap.SerializeDefaultValue && object.Equals(value, memberMap.DefaultValue)) { return; // don't serialize default value } bsonWriter.WriteName(memberMap.ElementName); var nominalType = memberMap.MemberType; var actualType = (value == null) ? nominalType : value.GetType(); var serializer = memberMap.GetSerializer(actualType); serializer.Serialize(bsonWriter, nominalType, value, memberMap.SerializationOptions); }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { bsonWriter.WriteNull(); } else { // Nullable types are weird because they get boxed as their underlying value type // we can best handle that by switching the nominalType to the underlying value type // (so VerifyNominalType doesn't fail and we don't get an unnecessary discriminator) if (nominalType.IsGenericType && nominalType.GetGenericTypeDefinition() == typeof(Nullable <>)) { nominalType = nominalType.GetGenericArguments()[0]; } VerifyNominalType(nominalType); var actualType = (value == null) ? nominalType : value.GetType(); if (actualType != _classMap.ClassType) { var message = string.Format("BsonClassMapSerializer.Serialize for type {0} was called with actualType {1}.", BsonUtils.GetFriendlyTypeName(_classMap.ClassType), BsonUtils.GetFriendlyTypeName(actualType)); throw new BsonSerializationException(message); } var documentSerializationOptions = (options ?? DocumentSerializationOptions.Defaults) as DocumentSerializationOptions; if (documentSerializationOptions == null) { var message = string.Format( "Serializer BsonClassMapSerializer expected serialization options of type {0}, not {1}.", BsonUtils.GetFriendlyTypeName(typeof(DocumentSerializationOptions)), BsonUtils.GetFriendlyTypeName(options.GetType())); throw new BsonSerializationException(message); } bsonWriter.WriteStartDocument(); BsonMemberMap idMemberMap = null; if (documentSerializationOptions.SerializeIdFirst) { idMemberMap = _classMap.IdMemberMap; if (idMemberMap != null) { SerializeMember(bsonWriter, value, idMemberMap); } } if (actualType != nominalType || _classMap.DiscriminatorIsRequired || _classMap.HasRootClass) { // never write out a discriminator for an anonymous class if (!_classMap.IsAnonymous) { var discriminatorConvention = _classMap.GetDiscriminatorConvention(); var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType); if (discriminator != null) { bsonWriter.WriteName(discriminatorConvention.ElementName); BsonValueSerializer.Instance.Serialize(bsonWriter, typeof(BsonValue), discriminator, null); } } } var allMemberMaps = _classMap.AllMemberMaps; var extraElementsMemberMapIndex = _classMap.ExtraElementsMemberMapIndex; for (var memberMapIndex = 0; memberMapIndex < allMemberMaps.Count; ++memberMapIndex) { var memberMap = allMemberMaps[memberMapIndex]; // note: if serializeIdFirst is false then idMemberMap will be null (so no property will be skipped) if (memberMap != idMemberMap) { if (memberMapIndex != extraElementsMemberMapIndex) { SerializeMember(bsonWriter, value, memberMap); } else { SerializeExtraElements(bsonWriter, value, memberMap); } } } bsonWriter.WriteEndDocument(); } }
public FindResult Find(Expression expression) { if (expression.NodeType == ExpressionType.Parameter) return null; _fieldParts = new Stack<string>(); _isBlocked = false; _bsonMemberMap = null; Visit(expression); var fieldName = string.Join(".", _fieldParts.ToArray()); if (_isBlocked) return null; return new FindResult { FieldName = fieldName, MemberMap = _bsonMemberMap }; }
// private methods private void DeserializeExtraElement(BsonReader bsonReader, object obj, string elementName, BsonMemberMap extraElementsMemberMap) { var extraElements = (BsonDocument)extraElementsMemberMap.Getter(obj); if (extraElements == null) { extraElements = new BsonDocument(); extraElementsMemberMap.Setter(obj, extraElements); } var value = BsonValue.ReadFrom(bsonReader); extraElements[elementName] = value; }
private void SerializeExtraElements(BsonSerializationContext context, object obj, BsonMemberMap extraElementsMemberMap) { var bsonWriter = context.Writer; var extraElements = extraElementsMemberMap.Getter(obj); if (extraElements != null) { if (extraElementsMemberMap.MemberType == typeof(BsonDocument)) { var bsonDocument = (BsonDocument)extraElements; foreach (var element in bsonDocument) { bsonWriter.WriteName(element.Name); BsonValueSerializer.Instance.Serialize(context, element.Value); } } else { var dictionary = (IDictionary <string, object>)extraElements; foreach (var key in dictionary.Keys) { bsonWriter.WriteName(key); var value = dictionary[key]; var bsonValue = BsonTypeMapper.MapToBsonValue(value); BsonValueSerializer.Instance.Serialize(context, bsonValue); } } } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options ) { if (value == null) { bsonWriter.WriteNull(); } else { // Nullable types are weird because they get boxed as their underlying value type // we can best handle that by switching the nominalType to the underlying value type // (so VerifyNominalType doesn't fail and we don't get an unnecessary discriminator) if (nominalType.IsGenericType && nominalType.GetGenericTypeDefinition() == typeof(Nullable <>)) { nominalType = nominalType.GetGenericArguments()[0]; } VerifyNominalType(nominalType); var actualType = (value == null) ? nominalType : value.GetType(); var classMap = BsonClassMap.LookupClassMap(actualType); bsonWriter.WriteStartDocument(); var documentOptions = (options == null) ? DocumentSerializationOptions.Defaults : (DocumentSerializationOptions)options; BsonMemberMap idMemberMap = null; if (documentOptions.SerializeIdFirst) { idMemberMap = classMap.IdMemberMap; if (idMemberMap != null) { SerializeMember(bsonWriter, value, idMemberMap); } } if (actualType != nominalType || classMap.DiscriminatorIsRequired || classMap.HasRootClass) { // never write out a discriminator for an anonymous class if (!classMap.IsAnonymous) { var discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(nominalType); var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType); if (discriminator != null) { bsonWriter.WriteName(discriminatorConvention.ElementName); discriminator.WriteTo(bsonWriter); } } } foreach (var memberMap in classMap.MemberMaps) { // note: if serializeIdFirst is false then idMemberMap will be null (so no property will be skipped) if (memberMap != idMemberMap) { if (memberMap == classMap.ExtraElementsMemberMap) { SerializeExtraElements(bsonWriter, value, memberMap); } else { SerializeMember(bsonWriter, value, memberMap); } } } bsonWriter.WriteEndDocument(); } }
private void SerializeExtraElements(BsonWriter bsonWriter, object obj, BsonMemberMap extraElementsMemberMap) { var extraElements = (BsonDocument)extraElementsMemberMap.Getter(obj); if (extraElements != null) { foreach (var element in extraElements) { element.WriteTo(bsonWriter); } } }
// private methods private void DeserializeExtraElement( BsonReader bsonReader, object obj, string elementName, BsonMemberMap extraElementsMemberMap) { if (extraElementsMemberMap.MemberType == typeof(BsonDocument)) { var extraElements = (BsonDocument)extraElementsMemberMap.Getter(obj); if (extraElements == null) { extraElements = new BsonDocument(); extraElementsMemberMap.Setter(obj, extraElements); } var bsonValue = (BsonValue)BsonValueSerializer.Instance.Deserialize(bsonReader, typeof(BsonValue), null); extraElements[elementName] = bsonValue; } else { var extraElements = (IDictionary<string, object>)extraElementsMemberMap.Getter(obj); if (extraElements == null) { if (extraElementsMemberMap.MemberType == typeof(IDictionary<string, object>)) { extraElements = new Dictionary<string, object>(); } else { extraElements = (IDictionary<string, object>)Activator.CreateInstance(extraElementsMemberMap.MemberType); } extraElementsMemberMap.Setter(obj, extraElements); } var bsonValue = (BsonValue)BsonValueSerializer.Instance.Deserialize(bsonReader, typeof(BsonValue), null); extraElements[elementName] = BsonTypeMapper.MapToDotNetValue(bsonValue); } }
private object DeserializeMemberValue(BsonReader bsonReader, BsonMemberMap memberMap) { try { var nominalType = memberMap.MemberType; var bsonType = bsonReader.GetCurrentBsonType(); if (bsonType == BsonType.Null && nominalType.IsInterface) { bsonReader.ReadNull(); return null; } Type actualType; if (bsonType == BsonType.Null) { actualType = nominalType; } else { var discriminatorConvention = memberMap.GetDiscriminatorConvention(); actualType = discriminatorConvention.GetActualType(bsonReader, nominalType); // returns nominalType if no discriminator found } var serializer = memberMap.GetSerializer(actualType); return serializer.Deserialize(bsonReader, nominalType, actualType, memberMap.SerializationOptions); } catch (Exception ex) { var message = string.Format( "An error occurred while deserializing the {0} {1} of class {2}: {3}", // terminating period provided by nested message memberMap.MemberName, (memberMap.MemberInfo.MemberType == MemberTypes.Field) ? "field" : "property", memberMap.ClassMap.ClassType.FullName, ex.Message); throw new Exception(message, ex); } }
private static bool IsReferencesManyRelation(BsonMemberMap memberMap) { return ReflectionUtility.IsListOfRawGeneric(typeof(Document<>), memberMap.MemberType); }
private static void ValidateVirtualRelation(BsonMemberMap memberMap) { if (!((PropertyInfo)memberMap.MemberInfo).GetGetMethod().IsVirtual) throw new Exception("Relational association properties must be declared as virtual, to support lazy loading"); }
private void SerializeMember( BsonWriter bsonWriter, object obj, BsonMemberMap memberMap ) { var value = memberMap.Getter(obj); if (value == null && memberMap.IgnoreIfNull) { return; // don't serialize null value } if (memberMap.HasDefaultValue && !memberMap.SerializeDefaultValue && object.Equals(value, memberMap.DefaultValue)) { return; // don't serialize default value } if (!memberMap.ShouldSerializeMethod(obj)) { return; // the ShouldSerializeMethod determined that the member shouldn't be serialized } bsonWriter.WriteName(memberMap.ElementName); var nominalType = memberMap.MemberType; var actualType = (value == null) ? nominalType : value.GetType(); var serializer = memberMap.GetSerializer(actualType); serializer.Serialize(bsonWriter, nominalType, value, memberMap.SerializationOptions); }
private static IDictionary<string, object> EnsureExtraElements(object obj, BsonMemberMap extraElementsMemberMap) { // TODO: make this method protected non-static and pull up? var extraElements = (IDictionary<string, object>) extraElementsMemberMap.Getter(obj); if (extraElements == null) { if (extraElementsMemberMap.MemberType == typeof (IDictionary<string, object>)) { extraElements = new Dictionary<string, object>(); } else { extraElements = (IDictionary<string, object>) Activator.CreateInstance(extraElementsMemberMap.MemberType); } extraElementsMemberMap.Setter(obj, extraElements); } return extraElements; }
// private methods private void DeserializeExtraElement( BsonReader bsonReader, object obj, string elementName, BsonMemberMap extraElementsMemberMap) { var extraElements = (BsonDocument)extraElementsMemberMap.Getter(obj); if (extraElements == null) { extraElements = new BsonDocument(); extraElementsMemberMap.Setter(obj, extraElements); } var value = BsonValue.ReadFrom(bsonReader); extraElements[elementName] = value; }
private void DeserializeMember(BsonReader bsonReader, object obj, BsonMemberMap memberMap) { try { var nominalType = memberMap.MemberType; Type actualType; if (bsonReader.CurrentBsonType == BsonType.Null) { actualType = nominalType; } else { var discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(nominalType); actualType = discriminatorConvention.GetActualType(bsonReader, nominalType); // returns nominalType if no discriminator found } var serializer = memberMap.GetSerializer(actualType); var value = serializer.Deserialize(bsonReader, nominalType, actualType, memberMap.SerializationOptions); memberMap.Setter(obj, value); } catch (Exception ex) { var message = string.Format( "An error occurred while deserializing the {0} {1} of class {2}: {3}", // terminating period provided by nested message memberMap.MemberName, (memberMap.MemberInfo.MemberType == MemberTypes.Field) ? "field" : "property", obj.GetType().FullName, ex.Message); throw new FileFormatException(message, ex); } }
private void DeserializeMember(BsonReader bsonReader, object obj, BsonMemberMap memberMap) { try { var nominalType = memberMap.MemberType; object value = null; var bsonType = bsonReader.GetCurrentBsonType(); if (bsonType == BsonType.Null && nominalType.IsInterface) { bsonReader.ReadNull(); goto setvalue; } else if (memberMap.MemberTypeIsBsonValue) { if (bsonType == BsonType.Document && IsCSharpNullRepresentation(bsonReader)) { // if IsCSharpNullRepresentation returns true it will have consumed the document representing C# null goto setvalue; } // handle BSON null for backward compatibility with existing data (new data would have _csharpnull) if (bsonType == BsonType.Null && (nominalType != typeof(BsonValue) && nominalType != typeof(BsonNull))) { bsonReader.ReadNull(); goto setvalue; } } Type actualType; if (bsonType == BsonType.Null) { actualType = nominalType; } else { var discriminatorConvention = memberMap.GetDiscriminatorConvention(); actualType = discriminatorConvention.GetActualType(bsonReader, nominalType); // returns nominalType if no discriminator found } var serializer = memberMap.GetSerializer(actualType); value = serializer.Deserialize(bsonReader, nominalType, actualType, memberMap.SerializationOptions); setvalue: memberMap.Setter(obj, value); } catch (Exception ex) { var message = string.Format( "An error occurred while deserializing the {0} {1} of class {2}: {3}", // terminating period provided by nested message memberMap.MemberName, (memberMap.MemberInfo.MemberType == MemberTypes.Field) ? "field" : "property", obj.GetType().FullName, ex.Message); throw new FileFormatException(message, ex); } }
private void SerializeMember(BsonWriter bsonWriter, object obj, BsonMemberMap memberMap) { var value = memberMap.Getter(obj); if (!memberMap.ShouldSerialize(obj, value)) { return; // don't serialize member } bsonWriter.WriteName(memberMap.ElementName); var nominalType = memberMap.MemberType; var actualType = (value == null) ? nominalType : value.GetType(); var serializer = memberMap.GetSerializer(actualType); serializer.Serialize(bsonWriter, nominalType, value, memberMap.SerializationOptions); }
private void SerializeExtraElements(BsonWriter bsonWriter, object obj, BsonMemberMap extraElementsMemberMap) { var extraElements = extraElementsMemberMap.Getter(obj); if (extraElements != null) { if (extraElementsMemberMap.MemberType == typeof(BsonDocument)) { var bsonDocument = (BsonDocument)extraElements; foreach (var element in bsonDocument) { bsonWriter.WriteName(element.Name); BsonValueSerializer.Instance.Serialize(bsonWriter, typeof(BsonValue), element.Value, null); } } else { var dictionary = (IDictionary<string, object>)extraElements; foreach (var key in dictionary.Keys) { bsonWriter.WriteName(key); var value = dictionary[key]; if (value == null) { bsonWriter.WriteNull(); } else { var bsonValue = BsonTypeMapper.MapToBsonValue(dictionary[key]); BsonValueSerializer.Instance.Serialize(bsonWriter, typeof(BsonValue), bsonValue, null); } } } } }
public void Apply(BsonMemberMap memberMap) { IsRun = true; RunCount++; RunTicks = _stopwatch.ElapsedTicks; }
private void SerializeMember(BsonWriter bsonWriter, object obj, BsonMemberMap memberMap) { var value = memberMap.Getter(obj); if (!memberMap.ShouldSerialize(obj, value)) { return; // don't serialize member } bsonWriter.WriteName(memberMap.ElementName); var nominalType = memberMap.MemberType; if (value == null && nominalType.IsInterface) { bsonWriter.WriteNull(); } else if (value == null && memberMap.MemberTypeIsBsonValue) { bsonWriter.WriteStartDocument(); bsonWriter.WriteBoolean("_csharpnull", true); bsonWriter.WriteEndDocument(); } else { var actualType = (value == null) ? nominalType : value.GetType(); var serializer = memberMap.GetSerializer(actualType); serializer.Serialize(bsonWriter, nominalType, value, memberMap.SerializationOptions); } }
private void SerializeMember(BsonWriter bsonWriter, object obj, BsonMemberMap memberMap) { object objA = memberMap.Getter(obj); if (objA == null && memberMap.IgnoreIfNull || (memberMap.HasDefaultValue && !memberMap.SerializeDefaultValue && object.Equals(objA, memberMap.DefaultValue) || !memberMap.ShouldSerializeMethod(obj))) return; bsonWriter.WriteName(memberMap.ElementName); Type memberType = memberMap.MemberType; Type actualType = objA == null ? memberType : objA.GetType(); if (IsRelation(memberMap)) ValidateVirtualRelation(memberMap); memberMap.GetSerializer(actualType).Serialize(bsonWriter, memberType, objA, memberMap.SerializationOptions); }
protected override Expression VisitMemberAccess(MemberExpression m) { var declaringType = m.Member.DeclaringType; if (!TypeHelper.IsNativeToMongo(declaringType) && !IsCollection(declaringType)) { Expression e; if (_determiner.IsGroupingKey(m)) { _fieldParts.Push(m.Member.Name); Visit(m.Expression); return m; } else if (_memberMap.TryGetValue(m.Member, out e) && e is FieldExpression) { var field = (FieldExpression)e; _fieldParts.Push(field.Name); if (_bsonMemberMap == null) _bsonMemberMap = field.MemberMap; Visit(m.Expression); return m; } else if(e == null) { var classMap = BsonClassMap.LookupClassMap(declaringType); var propMap = classMap.GetMemberMap(m.Member.Name); if (propMap != null) { _fieldParts.Push(propMap.ElementName); if (_bsonMemberMap == null) _bsonMemberMap = propMap; } else _fieldParts.Push(m.Member.Name); Visit(m.Expression); return m; } } _isBlocked = true; return m; }
private void SerializeNormalMember(BsonSerializationContext context, object obj, BsonMemberMap memberMap) { var bsonWriter = context.Writer; var value = memberMap.Getter(obj); if (!memberMap.ShouldSerialize(obj, value)) { return; // don't serialize member } bsonWriter.WriteName(memberMap.ElementName); memberMap.GetSerializer().Serialize(context, value); }
public void Apply(BsonMemberMap memberMap) { if (memberMap.MemberName.StartsWith("_")) memberMap.SetShouldSerializeMethod(o => false); }