public void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
if (nominalType != typeof(Dictionary <TKey, TValue>))
{
throw new ArgumentException("Cannot serialize anything but self");
}
var dictionary = value as Dictionary <TKey, TValue>;
IEnumerable <MongoDictionaryValue <TKey, TValue> > databaseEntries;
if (dictionary != null)
{
databaseEntries = dictionary.Select(keyValuePair =>
new MongoDictionaryValue <TKey, TValue>
{
Key = keyValuePair.Key,
Value = keyValuePair.Value
});
}
else
{
databaseEntries = new MongoDictionaryValue <TKey, TValue>[] { };
}
var ser = new ArraySerializer <MongoDictionaryValue <TKey, TValue> >();
ser.Serialize(bsonWriter, typeof(MongoDictionaryValue <TKey, TValue>[]), databaseEntries.ToArray(), options);
}
public override AggregateResult Deserialize(BsonDeserializationContext context)
{
var reader = context.Reader;
AggregateResult result = null;
reader.ReadStartDocument();
while (reader.ReadBsonType() != 0)
{
var elementName = reader.ReadName();
if (elementName == "cursor")
{
var cursorDeserializer = new CursorDeserializer(_resultSerializer);
result = context.DeserializeWithChildContext(cursorDeserializer);
}
else if (elementName == "result")
{
var arraySerializer = new ArraySerializer <TResult>(_resultSerializer);
result = new AggregateResult();
result.Results = context.DeserializeWithChildContext(arraySerializer);
}
else
{
reader.SkipValue();
}
}
reader.ReadEndDocument();
return(result);
}
public static object FromJson(
JsonValue json,
Type deserializationType,
DeserializationContext context
)
{
// typical array format
if (json.IsJsonArray)
{
return(ArraySerializer.FromJson(
json, deserializationType, context
));
}
string encoded = json.AsString;
if (encoded == null || !encoded.StartsWith("base64:"))
{
throw new UnisaveSerializationException(
"Given JSON value is not a base64 encoded binary sequence."
);
}
try
{
return(Convert.FromBase64String(encoded.Substring(7)));
}
catch (FormatException e)
{
throw new UnisaveSerializationException(
"Given JSON value is not a base64 encoded binary sequence.",
e
);
}
}
public override AggregateResult Deserialize(BsonDeserializationContext context)
{
var reader = context.Reader;
var result = new AggregateResult();
reader.ReadStartDocument();
while (reader.ReadBsonType() != 0)
{
var elementName = reader.ReadName();
if (elementName == "id")
{
result.CursorId = context.DeserializeWithChildContext <long>(new Int64Serializer());
}
else if (elementName == "firstBatch")
{
var arraySerializer = new ArraySerializer <TResult>(_resultSerializer);
result.Results = context.DeserializeWithChildContext(arraySerializer);
}
else
{
reader.SkipValue();
}
}
reader.ReadEndDocument();
return(result);
}
public override object Deserialize(BsonReader bsonReader, Type nominalType, Type actualType, IBsonSerializationOptions options)
{
var ser = new ArraySerializer <Card>();
var cards = (Card[])ser.Deserialize(bsonReader, typeof(Card[]), options);
return(cards == null ? null : new Pack(cards));
}
public override AggregateResult Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var reader = context.Reader;
var result = new AggregateResult();
reader.ReadStartDocument();
while (reader.ReadBsonType() != 0)
{
var elementName = reader.ReadName();
switch (elementName)
{
case "id":
result.CursorId = new Int64Serializer().Deserialize(context);
break;
case "ns":
var ns = reader.ReadString();
result.CollectionNamespace = CollectionNamespace.FromFullName(ns);
break;
case "firstBatch":
var arraySerializer = new ArraySerializer <TResult>(_resultSerializer);
result.Results = arraySerializer.Deserialize(context);
break;
default:
reader.SkipValue();
break;
}
}
reader.ReadEndDocument();
return(result);
}
public static ProjectionInfo <TResult> TranslateGroup <TKey, TDocument, TResult>(Expression <Func <TDocument, TKey> > idProjector, Expression <Func <IGrouping <TKey, TDocument>, TResult> > groupProjector, IBsonSerializer <TDocument> parameterSerializer, IBsonSerializerRegistry serializerRegistry)
{
if (groupProjector.Body.NodeType != ExpressionType.New)
{
throw new NotSupportedException("Must use an anonymous type for constructing $group pipeline operators.");
}
var keyBinder = new SerializationInfoBinder(serializerRegistry);
var boundKeyExpression = BindSerializationInfo(keyBinder, idProjector, parameterSerializer);
var groupBinder = new GroupSerializationInfoBinder(BsonSerializer.SerializerRegistry);
groupBinder.RegisterMemberReplacement(typeof(IGrouping <TKey, TDocument>).GetProperty("Key"), boundKeyExpression);
var groupSerializer = new ArraySerializer <TDocument>(parameterSerializer);
var boundGroupExpression = BindSerializationInfo(groupBinder, groupProjector, groupSerializer);
var projectionSerializer = (IBsonSerializer <TResult>)SerializerBuilder.Build(boundGroupExpression, serializerRegistry);
var projection = ProjectionBuilder.Build(boundGroupExpression).AsBsonDocument;
// must have an "_id" in a group document
if (!projection.Contains("_id"))
{
var idProjection = ProjectionBuilder.Build(boundKeyExpression);
projection.InsertAt(0, new BsonElement("_id", idProjection));
}
return(new ProjectionInfo <TResult>(projection, projectionSerializer));
}
public static RenderedProjectionDefinition <TResult> TranslateGroup <TKey, TDocument, TResult>(Expression <Func <TDocument, TKey> > idProjector, Expression <Func <IGrouping <TKey, TDocument>, TResult> > groupProjector, IBsonSerializer <TDocument> parameterSerializer, IBsonSerializerRegistry serializerRegistry)
{
var keyBinder = new SerializationInfoBinder(serializerRegistry);
var boundKeyExpression = BindSerializationInfo(keyBinder, idProjector, parameterSerializer);
if (!(boundKeyExpression is ISerializationExpression))
{
var keySerializer = SerializerBuilder.Build(boundKeyExpression, serializerRegistry);
boundKeyExpression = new SerializationExpression(
boundKeyExpression,
new BsonSerializationInfo(null, keySerializer, typeof(TKey)));
}
var idExpression = new IdExpression(boundKeyExpression, ((ISerializationExpression)boundKeyExpression).SerializationInfo);
var groupBinder = new GroupSerializationInfoBinder(BsonSerializer.SerializerRegistry);
groupBinder.RegisterMemberReplacement(typeof(IGrouping <TKey, TDocument>).GetProperty("Key"), idExpression);
var groupSerializer = new ArraySerializer <TDocument>(parameterSerializer);
var boundGroupExpression = BindSerializationInfo(groupBinder, groupProjector, groupSerializer);
var projectionSerializer = (IBsonSerializer <TResult>)SerializerBuilder.Build(boundGroupExpression, serializerRegistry);
var projection = ProjectionBuilder.Build(boundGroupExpression).AsBsonDocument;
// must have an "_id" in a group document
if (!projection.Contains("_id"))
{
var idProjection = ProjectionBuilder.Build(boundKeyExpression);
projection.InsertAt(0, new BsonElement("_id", idProjection));
}
return(new RenderedProjectionDefinition <TResult>(projection, projectionSerializer));
}
public static void AvoidAOT()
{
ArraySerializer <int> aint = new ArraySerializer <int>();
ArraySerializer <string> astring = new ArraySerializer <string>();
ArraySerializer <long> along = new ArraySerializer <long>();
EnumerableInterfaceImplementerSerializer <List <int> > e = new EnumerableInterfaceImplementerSerializer <List <int> >();
EnumerableInterfaceImplementerSerializer <List <int>, int> elistint = new EnumerableInterfaceImplementerSerializer <List <int>, int>();
}
private ReadCommandOperation <TResult[]> CreateOperation(SemanticVersion serverVersion)
{
var command = CreateCommand(serverVersion);
var resultArraySerializer = new ArraySerializer <TResult>(_resultSerializer);
var resultSerializer = new ElementDeserializer <TResult[]>("results", resultArraySerializer);
return(new ReadCommandOperation <TResult[]>(CollectionNamespace.DatabaseNamespace, command, resultSerializer, MessageEncoderSettings));
}
private ReadCommandOperation <TResult[]> CreateOperation(ICoreSessionHandle session, ConnectionDescription connectionDescription)
{
var command = CreateCommand(session, connectionDescription);
var resultArraySerializer = new ArraySerializer <TResult>(_resultSerializer);
var resultSerializer = new ElementDeserializer <TResult[]>("results", resultArraySerializer);
return(new ReadCommandOperation <TResult[]>(CollectionNamespace.DatabaseNamespace, command, resultSerializer, MessageEncoderSettings));
}
private ReadCommandOperation <TValue[]> CreateOperation(SemanticVersion serverVersion)
{
var command = CreateCommand(serverVersion);
var valueArraySerializer = new ArraySerializer <TValue>(_valueSerializer);
var resultSerializer = new ElementDeserializer <TValue[]>("values", valueArraySerializer);
return(new ReadCommandOperation <TValue[]>(_collectionNamespace.DatabaseNamespace, command, resultSerializer, _messageEncoderSettings));
}
private ReadCommandOperation <TValue[]> CreateOperation(IChannel channel, IBinding binding)
{
var command = CreateCommand(channel.ConnectionDescription, binding.Session);
var valueArraySerializer = new ArraySerializer <TValue>(_valueSerializer);
var resultSerializer = new ElementDeserializer <TValue[]>("values", valueArraySerializer);
return(new ReadCommandOperation <TValue[]>(_collectionNamespace.DatabaseNamespace, command, resultSerializer, _messageEncoderSettings));
}
public override ValueSerializer BuildSerializer(Serializer serializer, Type type,
ConcurrentDictionary <Type, ValueSerializer> typeMapping)
{
ValueSerializer arraySerializer = new ArraySerializer(type);
typeMapping.TryAdd(type, arraySerializer);
return(arraySerializer);
}
private ReadCommandOperation <TResult[]> CreateOperation()
{
var command = CreateCommand();
var resultSerializer = _resultSerializer ?? BsonSerializer.LookupSerializer <TResult>();
var resultArraySerializer = new ArraySerializer <TResult>(resultSerializer);
var commandResultSerializer = new ElementDeserializer <TResult[]>("retval", resultArraySerializer);
return(new ReadCommandOperation <TResult[]>(_collectionNamespace.DatabaseNamespace, command, commandResultSerializer, _messageEncoderSettings));
}
public async Task <IReadOnlyList <TValue> > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, "binding");
var command = CreateCommand();
var valueArraySerializer = new ArraySerializer <TValue>(_valueSerializer);
var resultSerializer = new ElementDeserializer <TValue[]>("values", valueArraySerializer);
var operation = new ReadCommandOperation <TValue[]>(_collectionNamespace.DatabaseNamespace, command, resultSerializer, _messageEncoderSettings);
return(await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false));
}
public void WriteXml(XmlWriter writer)
{
foreach (IList <T> list in array)
{
if (list != null)
{
ArraySerializer.Serialize(writer, list, XmlUtil.DefaultNamespace);
}
}
}
/// <inheritdoc/>
public async Task <IEnumerable <TResult> > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
var command = CreateCommand();
var resultSerializer = _resultSerializer ?? BsonSerializer.LookupSerializer <TResult>();
var resultArraySerializer = new ArraySerializer <TResult>(resultSerializer);
var commandResultSerializer = new ElementDeserializer <TResult[]>("retval", resultArraySerializer);
var operation = new ReadCommandOperation <TResult[]>(_collectionNamespace.DatabaseNamespace, command, commandResultSerializer, _messageEncoderSettings);
return(await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false));
}
public void Serialize(BsonWriter bsonWriter, Type nominalType, IBsonSerializationOptions options)
{
if (nominalType != typeof(Location))
{
throw new ArgumentException("Cannot serialize anything but self");
}
var ser = new ArraySerializer <double>();
ser.Serialize(bsonWriter, typeof(double[]),
new[] { Longitude, Latitude }, options);
}
public object Deserialize(BsonReader bsonReader, Type nominalType, IBsonSerializationOptions options)
{
if (nominalType != typeof(Location))
{
throw new ArgumentException("Cannot deserialize anything but self");
}
var ser = new ArraySerializer <double>();
var arr = ((double[])ser.Deserialize(bsonReader, typeof(double[]), options));
return(new Location(arr[1], arr[0]));
}
/// <inheritdoc/>
public async Task <IAsyncCursor <TResult> > ExecuteAsync(IReadBinding binding, CancellationToken cancellationToken)
{
Ensure.IsNotNull(binding, nameof(binding));
var command = CreateCommand();
var resultArraySerializer = new ArraySerializer <TResult>(_resultSerializer);
var resultSerializer = new ElementDeserializer <TResult[]>("results", resultArraySerializer);
var operation = new ReadCommandOperation <TResult[]>(CollectionNamespace.DatabaseNamespace, command, resultSerializer, MessageEncoderSettings);
var result = await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false);
return(new SingleBatchAsyncCursor <TResult>(result));
}
public object Deserialize(BsonReader bsonReader, Type nominalType, IBsonSerializationOptions options)
{
if (nominalType != typeof(Dictionary <TKey, TValue>))
{
throw new ArgumentException("Cannot serialize anything but self");
}
var ser = new ArraySerializer <MongoDictionaryValue <TKey, TValue> >();
var nameEntries = (MongoDictionaryValue <TKey, TValue>[])ser.Deserialize(bsonReader, typeof(MongoDictionaryValue <TKey, TValue>[]), options) ?? new MongoDictionaryValue <TKey, TValue>[] { };
return(nameEntries.ToDictionary(nameLookupEntry => nameLookupEntry.Key, nameLookupEntry => nameLookupEntry.Value));
}
private ReadCommandOperation <TResult[]> CreateOperation(SemanticVersion serverVersion)
{
var command = CreateCommand(serverVersion);
var resultSerializer = _resultSerializer ?? BsonSerializer.LookupSerializer <TResult>();
var resultArraySerializer = new ArraySerializer <TResult>(resultSerializer);
var commandResultSerializer = new ElementDeserializer <TResult[]>("retval", resultArraySerializer);
return(new ReadCommandOperation <TResult[]>(_collectionNamespace.DatabaseNamespace, command, commandResultSerializer, _messageEncoderSettings)
{
RetryRequested = false
});
}
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
if (value == null)
{
bsonWriter.WriteNull();
}
else
{
var pack = (Pack)value;
var ser = new ArraySerializer <Card>();
ser.Serialize(bsonWriter, typeof(Card[]), pack.GetAllCards(), options);
}
}
public static JsonValue ToJson(
object subject,
Type typeScope,
SerializationContext context
)
{
// force typical array format
if (context.serializeBinaryAsByteArray)
{
return(ArraySerializer.ToJson(subject, typeScope, context));
}
byte[] data = (byte[])subject;
return("base64:" + Convert.ToBase64String(data));
}
private static Expression BindGroup <TKey, TDocument, TResult>(PipelineBindingContext bindingContext, Expression <Func <IGrouping <TKey, TDocument>, TResult> > groupProjector, IBsonSerializer <TDocument> parameterSerializer, Expression keySelector)
{
var groupSerializer = new ArraySerializer <TDocument>(parameterSerializer);
var groupExpression = new DocumentExpression(groupSerializer);
var correlationId = Guid.NewGuid();
bindingContext.AddCorrelatingId(groupExpression, correlationId);
bindingContext.AddExpressionMapping(groupProjector.Parameters[0], groupExpression);
bindingContext.AddMemberMapping(typeof(IGrouping <TKey, TDocument>).GetProperty("Key"), keySelector);
var node = PartialEvaluator.Evaluate(groupProjector.Body);
node = Transformer.Transform(node);
node = bindingContext.Bind(node);
return(CorrelatedAccumulatorRemover.Remove(node, correlationId));
}
/// <summary>
/// Serializes an object.
/// </summary>
/// <param name="value">The value to be serialized</param>
/// <returns>The serialized object</returns>
public static string Serialize(object value)
{
if (value == null)
{
return("");
}
var getTypeData = value as IGetTypeData;
if (getTypeData != null)
{
var info = new XunitSerializationInfo();
getTypeData.GetData(info);
return(info.ToSerializedString());
}
var stringData = value as string;
if (stringData != null)
{
return(ToBase64(stringData));
}
var nullableIntData = value as int?;
if (nullableIntData != null)
{
return(nullableIntData.GetValueOrDefault().ToString(CultureInfo.InvariantCulture));
}
var array = value as object[];
if (array != null)
{
var info = new XunitSerializationInfo();
var arraySer = new ArraySerializer(array);
arraySer.GetData(info);
return(info.ToSerializedString());
}
throw new ArgumentException("We don't know how to serialize type " + value.GetType().FullName, "value");
}
private Dictionary <Type, ISerializer> GetDefaultSerializers()
{
Dictionary <Type, ISerializer> tmp = new Dictionary <Type, ISerializer>();
tmp[typeof(byte)] = new ByteSerializer();
tmp[typeof(sbyte)] = new SByteSerializer();
tmp[typeof(bool)] = new BooleanSerializer();
tmp[typeof(short)] = new ShortSerializer();
tmp[typeof(ushort)] = new UShortSerializer();
tmp[typeof(int)] = new IntSerializer();
tmp[typeof(uint)] = new UIntSerializer();
tmp[typeof(long)] = new LongSerializer();
tmp[typeof(ulong)] = new ULongSerializer();
tmp[typeof(float)] = new FloatSerializer();
tmp[typeof(double)] = new DoubleSerializer();
tmp[typeof(string)] = new StringSerializer(this);
tmp[typeof(Array)] = new ArraySerializer(this);
return(tmp);
}
public void ReadXml(XmlReader reader)
{
if (reader.IsEmptyElement)
{
reader.Read();
}
else
{
List <T[]> collection = new List <T[]>();
reader.Read();
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.MoveToContent();
T[] value = (T[])ArraySerializer.Deserialize(reader);
if (value != null)
{
collection.Add(value);
}
}
reader.ReadEndElement();
array = collection.Select(r => r as IList <T>).ToArray();
}
}
/// <summary>
/// Serializes an object.
/// </summary>
/// <param name="value">The value to be serialized</param>
/// <returns>The serialized object</returns>
public static string Serialize(object value)
{
if (value == null)
{
return(null);
}
var serializable = value as IXunitSerializable;
if (serializable != null)
{
var info = new XunitSerializationInfo();
serializable.Serialize(info);
return(info.ToSerializedString());
}
var charData = value as char?;
if (charData != null)
{
return(((ushort)charData.GetValueOrDefault()).ToString(CultureInfo.InvariantCulture));
}
var stringData = value as string;
if (stringData != null)
{
return(ToBase64(stringData));
}
var byteData = value as byte?;
if (byteData != null)
{
return(byteData.GetValueOrDefault().ToString(CultureInfo.InvariantCulture));
}
var ushortData = value as ushort?;
if (ushortData != null)
{
return(ushortData.GetValueOrDefault().ToString(CultureInfo.InvariantCulture));
}
var shortData = value as short?;
if (shortData != null)
{
return(shortData.GetValueOrDefault().ToString(CultureInfo.InvariantCulture));
}
var uintData = value as uint?;
if (uintData != null)
{
return(uintData.GetValueOrDefault().ToString(CultureInfo.InvariantCulture));
}
var intData = value as int?;
if (intData != null)
{
return(intData.GetValueOrDefault().ToString(CultureInfo.InvariantCulture));
}
var ulongData = value as ulong?;
if (ulongData != null)
{
return(ulongData.GetValueOrDefault().ToString(CultureInfo.InvariantCulture));
}
var longData = value as long?;
if (longData != null)
{
return(longData.GetValueOrDefault().ToString(CultureInfo.InvariantCulture));
}
var floatData = value as float?;
if (floatData != null)
{
return(floatData.GetValueOrDefault().ToString(CultureInfo.InvariantCulture));
}
var doubleData = value as double?;
if (doubleData != null)
{
return(doubleData.GetValueOrDefault().ToString(CultureInfo.InvariantCulture));
}
var decimalData = value as decimal?;
if (decimalData != null)
{
return(decimalData.GetValueOrDefault().ToString(CultureInfo.InvariantCulture));
}
var booleanData = value as bool?;
if (booleanData != null)
{
return(booleanData.GetValueOrDefault().ToString());
}
var datetimeData = value as DateTime?;
if (datetimeData != null)
{
return(datetimeData.GetValueOrDefault().ToString("o", CultureInfo.InvariantCulture)); // Round-trippable format
}
var datetimeoffsetData = value as DateTimeOffset?;
if (datetimeoffsetData != null)
{
return(datetimeoffsetData.GetValueOrDefault().ToString("o", CultureInfo.InvariantCulture)); // Round-trippable format
}
var typeData = value as Type;
if (typeData != null)
{
if (!typeData.IsFromLocalAssembly())
{
throw new ArgumentException(String.Format("We cannot serialize type {0} because it lives in the GAC", typeData.FullName), "value");
}
return(SerializationHelper.GetTypeNameForSerialization(typeData));
}
var valueType = value.GetType();
if (valueType.IsEnum())
{
if (!valueType.IsFromLocalAssembly())
{
throw new ArgumentException(String.Format("We cannot serialize enum {0}.{1} because it lives in the GAC", valueType.FullName, value), "value");
}
return(value.ToString());
}
var arrayData = value as Array;
if (arrayData != null)
{
var info = new XunitSerializationInfo();
var arraySer = new ArraySerializer(arrayData);
arraySer.Serialize(info);
return(info.ToSerializedString());
}
throw new ArgumentException("We don't know how to serialize type " + valueType.FullName, "value");
}
/// <summary>
/// Serializes an object.
/// </summary>
/// <param name="value">The value to be serialized</param>
/// <returns>The serialized object</returns>
public static string Serialize(object value)
{
if (value == null)
return "";
var getTypeData = value as IGetTypeData;
if (getTypeData != null)
{
var info = new XunitSerializationInfo();
getTypeData.GetData(info);
return info.ToSerializedString();
}
var stringData = value as string;
if (stringData != null)
return ToBase64(stringData);
var nullableIntData = value as int?;
if (nullableIntData != null)
return nullableIntData.GetValueOrDefault().ToString(CultureInfo.InvariantCulture);
var array = value as object[];
if (array != null)
{
var info = new XunitSerializationInfo();
var arraySer = new ArraySerializer(array);
arraySer.GetData(info);
return info.ToSerializedString();
}
throw new ArgumentException("We don't know how to serialize type " + value.GetType().FullName, "value");
}
