public SubObjectDirtyTrackerTemplate(object aggregate, BsonMemberMap map)
{
_map = map;
var currentSubObjectValue = aggregate == null ? null : _map.Getter(aggregate);
_originalValue = _map.GetSerializer().ToBsonValue(currentSubObjectValue);
_trackerTemplates = GetDirtyTrackerTemplates(_map.MemberType, currentSubObjectValue);
}
private void SerializeMember(BsonSerializationContext context, TClass document, BsonMemberMap memberMap)
{
IBsonWriter bsonWriter = context.Writer;
object value = memberMap.Getter(document);
if (memberMap.ShouldSerialize(document, value))
{
bsonWriter.WriteName(memberMap.ElementName);
memberMap.GetSerializer().Serialize(context, value);
}
}
/// <summary>
/// Applies the Ignore Empty Enumerables convention to the given <paramref name="memberMap"/>.
/// </summary>
/// <param name="memberMap">The <see cref="BsonMemberMap" /> to which the convention will be applied.</param>
public virtual void Apply(BsonMemberMap memberMap)
{
Check.NotNull(memberMap, nameof(memberMap));
if (memberMap.MemberType.TryGetSequenceType() != null)
{
memberMap.SetShouldSerializeMethod(@object =>
{
object value = memberMap.Getter(@object);
return((value as IEnumerable)?.GetEnumerator().MoveNext() ?? false);
});
}
}
private void DeserializeExtraElement(BsonReader bsonReader, object obj, string elementName, BsonMemberMap extraElementsMemberMap)
{
BsonDocument bsonDocument = (BsonDocument)extraElementsMemberMap.Getter(obj);
if (bsonDocument == (BsonDocument)null)
{
bsonDocument = new BsonDocument();
extraElementsMemberMap.Setter(obj, (object)bsonDocument);
}
BsonValue bsonValue = BsonValue.ReadFrom(bsonReader);
bsonDocument[elementName] = bsonValue;
}
public void Replace <T>(string collectionName, string criteria, T data, bool insertIfNotFound)
{
var flags = UpdateFlags.None;
if (insertIfNotFound)
{
flags |= UpdateFlags.Upsert;
}
BsonDocument deserialized;
var stringData = data as string;
if (stringData != null)
{
Exception exception;
if (!AttemptDeserialize(data as string, out deserialized, out exception))
{
throw new Exception("Invalid JSON format in 'Data'", exception);
}
Replace(collectionName, criteria, deserialized, insertIfNotFound);
return;
}
RegisterClassForBSONSerialisation <T>();
MongoCollection <T> collection = Database.GetCollection <T>(collectionName);
WriteConcernResult result;
if (String.IsNullOrEmpty(criteria) && typeof(T) != typeof(BsonDocument))
{
IEnumerable <BsonClassMap> maps = BsonClassMap.GetRegisteredClassMaps();
BsonMemberMap idMap = maps.First(v => v.ClassType == typeof(T)).IdMemberMap;
if (idMap == null)
{
throw new MongoException(
"Cannot perform mongo replace: no criteria specified and the object does not have an id field");
}
var id = (string)idMap.Getter(data);
if (String.IsNullOrEmpty(id))
{
throw new MongoException("Cannot perform mongo replace: no criteria specified and the object's id field is not set");
}
result = collection.Update(Query.EQ("_id", new ObjectId(id)), global::MongoDB.Driver.Builders.Update.Replace(data), flags);
}
else
{
result = collection.Update(new QueryDocument(ParseQuery(criteria)), global::MongoDB.Driver.Builders.Update.Replace(data),
flags);
}
Log(string.Format("{0} items {1}.", result.DocumentsAffected, (result.DocumentsAffected == 0) || (result.UpdatedExisting) ? "replaced" : "inserted"));
}
private void SerializeExtraElements(BsonWriter bsonWriter, object obj, BsonMemberMap extraElementsMemberMap)
{
BsonDocument bsonDocument = (BsonDocument)extraElementsMemberMap.Getter(obj);
if (!(bsonDocument != (BsonDocument)null))
{
return;
}
foreach (BsonElement bsonElement in bsonDocument)
{
bsonWriter.WriteName(bsonElement.Name);
bsonElement.Value.WriteTo(bsonWriter);
}
}
public void Apply(BsonMemberMap memberMap)
{
if (!typeof(IEnumerable).IsAssignableFrom(memberMap.MemberType) || //Allow IEnumerable
typeof(string) == memberMap.MemberType || //But not String
typeof(IDictionary).IsAssignableFrom(memberMap.MemberType)) //Or Dictionary (concrete classes only see below)
{
return;
}
//*NOTE Microsoft was too stupid to make the generic dictionary interfaces implement IDictonary even though every single concrete class does
// They were also too stupid to make generic IDictionary implement IReadOnlyDictionary even though every single concrete class does I believe this should catch all
if (memberMap.MemberType.IsGenericType && memberMap.MemberType.IsInterface)
{
var genericType = memberMap.MemberType.GetGenericTypeDefinition();
if (genericType == typeof(IDictionary <,>) || genericType == typeof(IReadOnlyDictionary <,>))
{
return;
}
}
if (memberMap.MemberType.IsArray) //Load Empty Array
{
memberMap.SetDefaultValue(() => Array.CreateInstance(memberMap.MemberType.GetElementType(), 0));
}
else if (!memberMap.MemberType.IsInterface) //Create ConcreteType directly
{
memberMap.SetDefaultValue(() => Activator.CreateInstance(memberMap.MemberType));
}
else if (memberMap.MemberType.IsGenericType) //Generic Interface type
{
var interfaceType = memberMap.MemberType.GetGenericTypeDefinition();
var concreteType = InterfaceToConcreteMap.ContainsKey(interfaceType)
? InterfaceToConcreteMap[interfaceType]
: DefaultType;
memberMap.SetDefaultValue(() => Activator.CreateInstance(concreteType.MakeGenericType(memberMap.MemberType.GetGenericArguments())));
}
else //This should just be the antique non generic interfaces like ICollection, IEnumerable, etc.
{
memberMap.SetDefaultValue(() => Activator.CreateInstance(typeof(List <object>)));
}
memberMap.SetShouldSerializeMethod(instance =>
{
var value = (IEnumerable)memberMap.Getter(instance);
return(value?.GetEnumerator().MoveNext() ?? false);
});
}
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);
}
public bool GetDocumentId(object document, out object id, out Type idNominalType, out IIdGenerator idGenerator)
{
BsonMemberMap idMemberMap = BsonClassMap.LookupClassMap(document.GetType()).IdMemberMap;
if (idMemberMap != null)
{
id = idMemberMap.Getter(document);
idNominalType = idMemberMap.MemberType;
idGenerator = idMemberMap.IdGenerator;
return(true);
}
else
{
id = (object)null;
idNominalType = (Type)null;
idGenerator = (IIdGenerator)null;
return(false);
}
}
private static void ShouldSerializeIfNotDefault(BsonMemberMap memberMap, string defaultString) => memberMap.SetShouldSerializeMethod(@object => !string.Equals(defaultString, memberMap.Getter(@object) as string));
private static void ShouldSerializeIfNotEmpty(BsonMemberMap memberMap) => memberMap.SetShouldSerializeMethod(@object => !string.IsNullOrEmpty(memberMap.Getter(@object) as string));
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 && value.Equals(memberMap.DefaultValue)) {
return; // don't serialize default value
}
var nominalType = memberMap.MemberType;
var actualType = (value == null) ? nominalType : value.GetType();
var serializer = memberMap.GetSerializerForActualType(actualType);
var elementName = memberMap.ElementName;
bsonWriter.WriteName(elementName);
serializer.Serialize(bsonWriter, nominalType, value, memberMap.SerializationOptions);
}
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 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;
}
public IMemberDirtyTracker ToDirtyTracker(object aggregate)
{
return(new SubObjectDirtyTracker(aggregate, _map, _originalValue, _trackerTemplates.ToTrackers(_map.Getter(aggregate)).ToList()));
}
private BsonValue GetBsonValue(object aggregate)
{
return(_memberMap.GetSerializer().ToBsonValue(_memberMap.Getter(aggregate)));
}
public MemberDirtyTrackerTemplate(object aggregate, BsonMemberMap map)
{
_map = map;
_originalValue = aggregate == null ? null : _map.GetSerializer().ToBsonValue(_map.Getter(aggregate));
}
