public PipelineBindingContext(IBsonSerializerRegistry serializerRegistry) { _serializerRegistry = Ensure.IsNotNull(serializerRegistry, nameof(serializerRegistry)); _correlationMapping = new Dictionary<Expression, Guid>(); _expressionMapping = new Dictionary<Expression, Expression>(); _memberMapping = new Dictionary<MemberInfo, Expression>(); }
/// <inheritdoc/> public override IBsonSerializer GetSerializer(Type type, IBsonSerializerRegistry serializerRegistry) { if (type == null) { throw new ArgumentNullException("type"); } var typeInfo = type.GetTypeInfo(); if (typeInfo.IsGenericType && typeInfo.ContainsGenericParameters) { var message = string.Format("Generic type {0} has unassigned type parameters.", BsonUtils.GetFriendlyTypeName(type)); throw new ArgumentException(message, "type"); } #if NETSTANDARD1_6 var serializerAttributes = typeInfo.GetCustomAttributes(typeof(BsonSerializerAttribute), false).ToArray(); // don't inherit #else var serializerAttributes = typeInfo.GetCustomAttributes(typeof(BsonSerializerAttribute), false); // don't inherit #endif if (serializerAttributes.Length == 1) { var serializerAttribute = (BsonSerializerAttribute)serializerAttributes[0]; return serializerAttribute.CreateSerializer(type); } return null; }
/// <inheritdoc/> public override IBsonSerializer GetSerializer(Type type, IBsonSerializerRegistry serializerRegistry) { if (type == null) { throw new ArgumentNullException("type"); } var typeInfo = type.GetTypeInfo(); if (typeInfo.IsGenericType && typeInfo.ContainsGenericParameters) { var message = string.Format("Generic type {0} has unassigned type parameters.", BsonUtils.GetFriendlyTypeName(type)); throw new ArgumentException(message, "type"); } Type serializerType; if (__serializersTypes.TryGetValue(type, out serializerType)) { return CreateSerializer(serializerType, serializerRegistry); } if (typeInfo.IsGenericType && !typeInfo.ContainsGenericParameters) { Type serializerTypeDefinition; if (__serializersTypes.TryGetValue(type.GetGenericTypeDefinition(), out serializerTypeDefinition)) { return CreateGenericSerializer(serializerTypeDefinition, type.GetGenericArguments(), serializerRegistry); } } if (typeInfo.IsEnum) { return CreateGenericSerializer(typeof(EnumSerializer<>), new[] { type }, serializerRegistry); } return null; }
/// <inheritdoc/> public override IBsonSerializer GetSerializer(Type type, IBsonSerializerRegistry serializerRegistry) { if (type == null) { throw new ArgumentNullException("type"); } var typeInfo = type.GetTypeInfo(); if (typeInfo.IsGenericType && typeInfo.ContainsGenericParameters) { var message = string.Format("Generic type {0} has unassigned type parameters.", BsonUtils.GetFriendlyTypeName(type)); throw new ArgumentException(message, "type"); } if ((typeInfo.IsClass || (typeInfo.IsValueType && !typeInfo.IsPrimitive)) && !typeof(Array).IsAssignableFrom(type) && !typeof(Enum).IsAssignableFrom(type)) { var classMap = BsonClassMap.LookupClassMap(type); var classMapSerializerDefinition = typeof(BsonClassMapSerializer<>); var classMapSerializerType = classMapSerializerDefinition.MakeGenericType(type); return (IBsonSerializer)Activator.CreateInstance(classMapSerializerType, classMap); } return null; }
public static QueryableExecutionModel Build(Expression node, IBsonSerializerRegistry serializerRegistry) { var builder = new QueryableExecutionModelBuilder(serializerRegistry); builder.Visit(node); return (QueryableExecutionModel)Activator.CreateInstance( typeof(AggregateQueryableExecutionModel<>).MakeGenericType(builder._serializer.ValueType), builder._stages, builder._serializer); }
public static QueryableTranslation Translate(Expression node, IBsonSerializerRegistry serializerRegistry) { var translator = new QueryableTranslator(serializerRegistry); translator.Translate(node); var model = (QueryableExecutionModel)Activator.CreateInstance( typeof(AggregateQueryableExecutionModel<>).MakeGenericType(translator._outputSerializer.ValueType), BindingFlags.Instance | BindingFlags.NonPublic, null, new object[] { translator._stages, translator._outputSerializer }, null); return new QueryableTranslation(model, translator._resultTransformer); }
/// <inheritdoc/> public override IBsonSerializer GetSerializer(Type type, IBsonSerializerRegistry serializerRegistry) { if (type == null) { throw new ArgumentNullException("type"); } var typeInfo = type.GetTypeInfo(); if (typeInfo.IsGenericType && typeInfo.ContainsGenericParameters) { var message = string.Format("Generic type {0} has unassigned type parameters.", BsonUtils.GetFriendlyTypeName(type)); throw new ArgumentException(message, "type"); } Type serializerType; if (__serializerTypes.TryGetValue(type, out serializerType)) { return CreateSerializer(serializerType, serializerRegistry); } if (typeInfo.IsGenericType && !typeInfo.ContainsGenericParameters) { Type serializerTypeDefinition; if (__serializerTypes.TryGetValue(type.GetGenericTypeDefinition(), out serializerTypeDefinition)) { return CreateGenericSerializer(serializerTypeDefinition, type.GetGenericArguments(), serializerRegistry); } } if (type.IsArray) { var elementType = type.GetElementType(); switch (type.GetArrayRank()) { case 1: var arraySerializerDefinition = typeof(ArraySerializer<>); return CreateGenericSerializer(arraySerializerDefinition, new[] { elementType }, serializerRegistry); case 2: var twoDimensionalArraySerializerDefinition = typeof(TwoDimensionalArraySerializer<>); return CreateGenericSerializer(twoDimensionalArraySerializerDefinition, new[] { elementType }, serializerRegistry); case 3: var threeDimensionalArraySerializerDefinition = typeof(ThreeDimensionalArraySerializer<>); return CreateGenericSerializer(threeDimensionalArraySerializerDefinition, new[] { elementType }, serializerRegistry); default: var message = string.Format("No serializer found for array for rank {0}.", type.GetArrayRank()); throw new BsonSerializationException(message); } } return GetCollectionSerializer(type, serializerRegistry); }
public static QueryableTranslation Translate(Expression node, IBsonSerializerRegistry serializerRegistry) { var translator = new QueryableTranslator(serializerRegistry); translator.Translate(node); var outputType = translator._outputSerializer.ValueType; var modelType = typeof(AggregateQueryableExecutionModel<>).MakeGenericType(outputType); var modelTypeInfo = modelType.GetTypeInfo(); var outputSerializerInterfaceType = typeof(IBsonSerializer<>).MakeGenericType(new[] { outputType }); var constructorParameterTypes = new Type[] { typeof(IEnumerable<BsonDocument>), outputSerializerInterfaceType }; var constructorInfo = modelTypeInfo.GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic) .Where(c => c.GetParameters().Select(p => p.ParameterType).SequenceEqual(constructorParameterTypes)) .Single(); var constructorParameters = new object[] { translator._stages, translator._outputSerializer }; var model = (QueryableExecutionModel)constructorInfo.Invoke(constructorParameters); return new QueryableTranslation(model, translator._resultTransformer); }
/// <summary> /// Creates the serializer. /// </summary> /// <param name="serializerType">The serializer type.</param> /// <param name="serializerRegistry">The serializer registry.</param> /// <returns> /// A serializer. /// </returns> protected virtual IBsonSerializer CreateSerializer(Type serializerType, IBsonSerializerRegistry serializerRegistry) { var constructorInfo = serializerType.GetConstructor(new[] { typeof(IBsonSerializerRegistry) }); if (constructorInfo != null) { return (IBsonSerializer)constructorInfo.Invoke(new object[] { serializerRegistry }); } constructorInfo = serializerType.GetConstructor(new Type[0]); if (constructorInfo != null) { return (IBsonSerializer)constructorInfo.Invoke(new object[0]); } throw new MissingMethodException(string.Format( "No suitable constructor found for serializer type: '{0}'.", serializerType.FullName)); }
/// <inheritdoc/> public override IBsonSerializer GetSerializer(Type type, IBsonSerializerRegistry serializerRegistry) { if (type == null) { throw new ArgumentNullException("type"); } if (type.IsGenericType && type.ContainsGenericParameters) { var message = string.Format("Generic type {0} has unassigned type parameters.", BsonUtils.GetFriendlyTypeName(type)); throw new ArgumentException(message, "type"); } IBsonSerializer serializer; if (__serializers.TryGetValue(type, out serializer)) { return serializer; } return null; }
/// <inheritdoc/> public override IBsonSerializer GetSerializer(Type type, IBsonSerializerRegistry serializerRegistry) { if (type == null) { throw new ArgumentNullException("type"); } if (type.IsGenericType && type.ContainsGenericParameters) { var message = string.Format("Generic type {0} has unassigned type parameters.", BsonUtils.GetFriendlyTypeName(type)); throw new ArgumentException(message, "type"); } if (type.IsInterface) { var serializerTypeDefinition = typeof(DiscriminatedInterfaceSerializer<>); return CreateGenericSerializer(serializerTypeDefinition, new[] { type }, serializerRegistry); } return null; }
/// <inheritdoc /> public override BsonDocument Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry) { return(BsonDocument.Parse(_json)); }
public override BsonDocument Render(IBsonSerializer <TSource> sourceSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider linqProvider) { var renderedField = _field.Render(sourceSerializer, serializerRegistry, linqProvider); return(new BsonDocument(renderedField.FieldName, _value)); }
public static Expression Rewrite(Expression node, IBsonSerializerRegistry serializerRegistry) { var rewriter = new CorrelatedGroupRewriter(serializerRegistry); return rewriter.Visit(node); }
/// <inheritdoc/> public override RenderedProjectionDefinition <TProjection> Render(IBsonSerializer <TSource> sourceSerializer, IBsonSerializerRegistry serializerRegistry) { return(new RenderedProjectionDefinition <TProjection>( null, _projectionSerializer ?? (sourceSerializer as IBsonSerializer <TProjection>) ?? serializerRegistry.GetSerializer <TProjection>())); }
public override BsonDocument Render(IBsonSerializer <TSource> sourceSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider linqProvider) { var document = new BsonDocument(); foreach (var projection in _projections) { var renderedProjection = projection.Render(sourceSerializer, serializerRegistry, linqProvider); foreach (var element in renderedProjection.Elements) { // last one wins document.Remove(element.Name); document.Add(element); } } return(document); }
public static Expression BuildAsync(Expression node, Expression provider, Expression cancellationToken, IBsonSerializerRegistry serializerRegistry) { return new QueryableExecutionBuilder(provider, cancellationToken, serializerRegistry).Visit(node); }
/// <inheritdoc /> public override RenderedProjectionDefinition <TProjection> Render(IBsonSerializer <TSource> sourceSerializer, IBsonSerializerRegistry serializerRegistry) { return(FindProjectionTranslator.Translate <TSource, TProjection>(_expression, sourceSerializer, serializerRegistry)); }
/// <inheritdoc /> IRenderedPipelineStageDefinition IPipelineStageDefinition.Render(IBsonSerializer inputSerializer, IBsonSerializerRegistry serializerRegistry) { return(Render((IBsonSerializer <TInput>)inputSerializer, serializerRegistry)); }
/// <inheritdoc /> public override RenderedPipelineStageDefinition <TOutput> Render(IBsonSerializer <TInput> inputSerializer, IBsonSerializerRegistry serializerRegistry) { return(new RenderedPipelineStageDefinition <TOutput>( OperatorName, BsonDocument.Parse(_json), _outputSerializer ?? (inputSerializer as IBsonSerializer <TOutput>) ?? serializerRegistry.GetSerializer <TOutput>())); }
/// <summary> /// Creates the serializer from a serializer type definition and type arguments. /// </summary> /// <param name="serializerTypeDefinition">The serializer type definition.</param> /// <param name="typeArguments">The type arguments.</param> /// <param name="serializerRegistry">The serializer registry.</param> /// <returns> /// A serializer. /// </returns> protected virtual IBsonSerializer CreateGenericSerializer(Type serializerTypeDefinition, Type[] typeArguments, IBsonSerializerRegistry serializerRegistry) { var serializerType = serializerTypeDefinition.MakeGenericType(typeArguments); return CreateSerializer(serializerType, serializerRegistry); }
/// <summary> /// Renders the specified document serializer. /// </summary> /// <param name="inputSerializer">The input serializer.</param> /// <param name="serializerRegistry">The serializer registry.</param> /// <returns>A <see cref="RenderedPipelineStageDefinition{TOutput}" /></returns> public abstract RenderedPipelineStageDefinition <TOutput> Render(IBsonSerializer <TInput> inputSerializer, IBsonSerializerRegistry serializerRegistry);
/// <inheritdoc/> public abstract IBsonSerializer GetSerializer(Type type, IBsonSerializerRegistry serializerRegistry);
public AccumulatorBinder(IBsonSerializerRegistry serializerRegistry) : base(serializerRegistry) { _isPotentialAccumulatorMethod = true; }
private CorrelatedGroupRewriter(IBsonSerializerRegistry serializerRegistry) { _serializerRegistry = serializerRegistry; _map = new Dictionary<CorrelatedAccumulatorExpression, Expression>(); }
/// <summary> /// Renders the sort to a <see cref="BsonDocument"/>. /// </summary> /// <param name="documentSerializer">The document serializer.</param> /// <param name="serializerRegistry">The serializer registry.</param> /// <returns>A <see cref="BsonDocument"/>.</returns> public abstract BsonDocument Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry);
public override RenderedPipelineStageDefinition <TOutput> Render(IBsonSerializer <TInput> inputSerializer, IBsonSerializerRegistry serializerRegistry) { return(_renderer(inputSerializer, serializerRegistry)); }
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 GroupIdExpression(boundKeyExpression, ((ISerializationExpression)boundKeyExpression).SerializationInfo); var groupBinder = new AccumulatorBinder(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 = AggregateLanguageTranslator.Translate(boundGroupExpression).AsBsonDocument; // must have an "_id" in a group document if (!projection.Contains("_id")) { var idProjection = AggregateLanguageTranslator.Translate(boundKeyExpression); projection.InsertAt(0, new BsonElement("_id", idProjection)); } return(new RenderedProjectionDefinition <TResult>(projection, projectionSerializer)); }
/// <inheritdoc /> public override RenderedProjectionDefinition <TProjection> Render(IBsonSerializer <TSource> sourceSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider linqProvider) { return(linqProvider.GetAdapter().TranslateExpressionToFindProjection(_expression, sourceSerializer, serializerRegistry)); }
public QueryableTranslator(IBsonSerializerRegistry serializerRegistry, ExpressionTranslationOptions translationOptions) { _serializerRegistry = Ensure.IsNotNull(serializerRegistry, nameof(serializerRegistry)); _translationOptions = translationOptions; // can be null _stages = new List<BsonDocument>(); }
/// <inheritdoc /> public override BsonDocument Render(IBsonSerializer <TSource> sourceSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider linqProvider) { return(BsonDocument.Parse(_json)); }
public override RenderedProjectionDefinition <TProjection> Render(IBsonSerializer <TSource> sourceSerializer, IBsonSerializerRegistry serializerRegistry) { var document = _projection.Render(sourceSerializer, serializerRegistry); return(new RenderedProjectionDefinition <TProjection>( document, _projectionSerializer ?? (sourceSerializer as IBsonSerializer <TProjection>) ?? serializerRegistry.GetSerializer <TProjection>())); }
/// <inheritdoc /> public override BsonDocument Render(IBsonSerializer <TSource> sourceSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider linqProvider) { var serializer = serializerRegistry.GetSerializer(_obj.GetType()); return(new BsonDocumentWrapper(_obj, serializer)); }
/// <summary> /// Renders the projection to a <see cref="RenderedProjectionDefinition{TProjection}"/>. /// </summary> /// <param name="sourceSerializer">The source serializer.</param> /// <param name="serializerRegistry">The serializer registry.</param> /// <returns>A <see cref="BsonDocument"/>.</returns> public abstract BsonDocument Render(IBsonSerializer <TSource> sourceSerializer, IBsonSerializerRegistry serializerRegistry);
/// <summary> /// Renders the field to a <see cref="String"/>. /// </summary> /// <param name="documentSerializer">The document serializer.</param> /// <param name="serializerRegistry">The serializer registry.</param> /// <returns>A <see cref="String"/>.</returns> public abstract RenderedFieldDefinition Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry);
public override BsonDocument Render(IBsonSerializer <TSource> sourceSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider linqProvider) { var renderedField = _field.Render(sourceSerializer, serializerRegistry, linqProvider); IBsonSerializer <TItem> itemSerializer; if (renderedField.FieldSerializer != null) { var arraySerializer = renderedField.FieldSerializer as IBsonArraySerializer; BsonSerializationInfo itemSerializationInfo; if (arraySerializer == null || !arraySerializer.TryGetItemSerializationInfo(out itemSerializationInfo)) { var message = string.Format("The serializer for field '{0}' must implement IBsonArraySerializer and provide item serialization info.", renderedField.FieldName); throw new InvalidOperationException(message); } itemSerializer = (IBsonSerializer <TItem>)itemSerializationInfo.Serializer; } else { itemSerializer = serializerRegistry.GetSerializer <TItem>(); } var renderedFilter = _filter.Render(itemSerializer, serializerRegistry, linqProvider); return(new BsonDocument(renderedField.FieldName, new BsonDocument("$elemMatch", renderedFilter))); }
/// <inheritdoc /> public override RenderedFieldDefinition Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry) { string resolvedName; IBsonSerializer resolvedSerializer; StringFieldDefinitionHelper.Resolve <TDocument>(_fieldName, documentSerializer, out resolvedName, out resolvedSerializer); return(new RenderedFieldDefinition(resolvedName, resolvedSerializer)); }
public override RenderedProjectionDefinition <TNewResult> Render(IBsonSerializer <TResult> documentSerializer, IBsonSerializerRegistry serializerRegistry) { return(AggregateProjectionTranslator.TranslateGroup <TKey, TResult, TNewResult>(_idExpression, _groupExpression, documentSerializer, serializerRegistry)); }
public QueryableExecutionBuilder(Expression provider, Expression cancellationToken, IBsonSerializerRegistry serializerRegistry) { _provider = provider; _cancellationToken = cancellationToken; _serializerRegistry = serializerRegistry; }
/// <inheritdoc /> public override RenderedFieldDefinition Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry) { var binder = new SerializationInfoBinder(serializerRegistry); var parameterSerializationInfo = new BsonSerializationInfo(null, documentSerializer, documentSerializer.ValueType); var parameterExpression = new SerializationExpression(_expression.Parameters[0], parameterSerializationInfo); binder.RegisterParameterReplacement(_expression.Parameters[0], parameterExpression); var bound = binder.Bind(_expression.Body) as ISerializationExpression; if (bound == null) { var message = string.Format("Unable to determine the serialization information for {0}.", _expression); throw new InvalidOperationException(message); } return(new RenderedFieldDefinition(bound.SerializationInfo.ElementName, bound.SerializationInfo.Serializer)); }
public ProjectionBindingContext(IBsonSerializerRegistry serializerRegistry, IMethodCallBinder methodCallBinder) { _serializerRegistry = Ensure.IsNotNull(serializerRegistry, "serializerRegistry"); _methodCallBinder = Ensure.IsNotNull(methodCallBinder, "methodCallBinder"); _groupMap = new CorrelatedGroupMap(); }
/// <inheritdoc /> public override BsonDocument Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry) { return(_document); }
public AccumulatorBinder(CorrelatedGroupMap groupMap, IBsonSerializerRegistry serializerRegistry) : this(serializerRegistry) { _groupMap = groupMap; }
/// <inheritdoc /> public override BsonDocument Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry) { var serializer = serializerRegistry.GetSerializer(_obj.GetType()); return(new BsonDocumentWrapper(_obj, serializer)); }
public static IBsonSerializer Build(Expression node, IBsonSerializerRegistry serializerRegistry) { var builder = new SerializerBuilder(serializerRegistry); return builder.Build(node); }
public static RenderedProjectionDefinition <TResult> TranslateProject <TDocument, TResult>(Expression <Func <TDocument, TResult> > projector, IBsonSerializer <TDocument> parameterSerializer, IBsonSerializerRegistry serializerRegistry) { var binder = new SerializationInfoBinder(BsonSerializer.SerializerRegistry); var boundExpression = BindSerializationInfo(binder, projector, parameterSerializer); var projectionSerializer = (IBsonSerializer <TResult>)SerializerBuilder.Build(boundExpression, serializerRegistry); var projection = TranslateProject(boundExpression); return(new RenderedProjectionDefinition <TResult>(projection, projectionSerializer)); }
public static Expression Bind(Expression node, IBsonSerializer documentSerializer, IBsonSerializerRegistry serializerRegistry) { // bind var binder = new ProjectionBinder(documentSerializer, serializerRegistry, __methodCallBinder); var bound = binder.Bind(node); // post-process return CorrelatedGroupRewriter.Rewrite(bound, serializerRegistry); }
/// <summary> /// Renders the projection to a <see cref="RenderedProjectionDefinition{TProjection}"/>. /// </summary> /// <param name="sourceSerializer">The source serializer.</param> /// <param name="serializerRegistry">The serializer registry.</param> /// <returns>A <see cref="BsonDocument"/>.</returns> public virtual BsonDocument Render(IBsonSerializer <TSource> sourceSerializer, IBsonSerializerRegistry serializerRegistry) { return(Render(sourceSerializer, serializerRegistry, LinqProvider.V2)); }
public static Expression Build(Expression node, Expression provider, IBsonSerializerRegistry serializerRegistry) { return new QueryableExecutionBuilder(provider, null, serializerRegistry).Visit(node); }
private QueryableExecutionModelBuilder(IBsonSerializerRegistry serializerRegistry) { _serializerRegistry = serializerRegistry; _stages = new List<BsonDocument>(); }
/// <summary> /// Renders the projection to a <see cref="RenderedProjectionDefinition{TProjection}"/>. /// </summary> /// <param name="sourceSerializer">The source serializer.</param> /// <param name="serializerRegistry">The serializer registry.</param> /// <param name="linqProvider">The LINQ provider.</param> /// <returns>A <see cref="BsonDocument"/>.</returns> public abstract BsonDocument Render(IBsonSerializer <TSource> sourceSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider linqProvider);
private IBsonSerializer GetCollectionSerializer(Type type, IBsonSerializerRegistry serializerRegistry) { Type implementedGenericDictionaryInterface = null; Type implementedGenericEnumerableInterface = null; Type implementedGenericSetInterface = null; Type implementedDictionaryInterface = null; Type implementedEnumerableInterface = null; var implementedInterfaces = new List<Type>(type.GetInterfaces()); var typeInfo = type.GetTypeInfo(); if (typeInfo.IsInterface) { implementedInterfaces.Add(type); } foreach (var implementedInterface in implementedInterfaces) { var implementedInterfaceTypeInfo = implementedInterface.GetTypeInfo(); if (implementedInterfaceTypeInfo.IsGenericType) { var genericInterfaceDefinition = implementedInterface.GetGenericTypeDefinition(); if (genericInterfaceDefinition == typeof(IDictionary<,>)) { implementedGenericDictionaryInterface = implementedInterface; } if (genericInterfaceDefinition == typeof(IEnumerable<>)) { implementedGenericEnumerableInterface = implementedInterface; } if (genericInterfaceDefinition == typeof(ISet<>)) { implementedGenericSetInterface = implementedInterface; } } else { if (implementedInterface == typeof(IDictionary)) { implementedDictionaryInterface = implementedInterface; } if (implementedInterface == typeof(IEnumerable)) { implementedEnumerableInterface = implementedInterface; } } } // the order of the tests is important if (implementedGenericDictionaryInterface != null) { var keyType = implementedGenericDictionaryInterface.GetGenericArguments()[0]; var valueType = implementedGenericDictionaryInterface.GetGenericArguments()[1]; if (typeInfo.IsInterface) { var dictionaryDefinition = typeof(Dictionary<,>); var dictionaryType = dictionaryDefinition.MakeGenericType(keyType, valueType); var serializerDefinition = typeof(ImpliedImplementationInterfaceSerializer<,>); return CreateGenericSerializer(serializerDefinition, new[] { type, dictionaryType }, serializerRegistry); } else { var serializerDefinition = typeof(DictionaryInterfaceImplementerSerializer<,,>); return CreateGenericSerializer(serializerDefinition, new[] { type, keyType, valueType }, serializerRegistry); } } else if (implementedDictionaryInterface != null) { if (typeInfo.IsInterface) { var dictionaryType = typeof(Hashtable); var serializerDefinition = typeof(ImpliedImplementationInterfaceSerializer<,>); return CreateGenericSerializer(serializerDefinition, new[] { type, dictionaryType }, serializerRegistry); } else { var serializerDefinition = typeof(DictionaryInterfaceImplementerSerializer<>); return CreateGenericSerializer(serializerDefinition, new[] { type }, serializerRegistry); } } else if (implementedGenericSetInterface != null) { var itemType = implementedGenericSetInterface.GetGenericArguments()[0]; if (typeInfo.IsInterface) { var hashSetDefinition = typeof(HashSet<>); var hashSetType = hashSetDefinition.MakeGenericType(itemType); var serializerDefinition = typeof(ImpliedImplementationInterfaceSerializer<,>); return CreateGenericSerializer(serializerDefinition, new[] { type, hashSetType }, serializerRegistry); } else { var serializerDefinition = typeof(EnumerableInterfaceImplementerSerializer<,>); return CreateGenericSerializer(serializerDefinition, new[] { type, itemType }, serializerRegistry); } } else if (implementedGenericEnumerableInterface != null) { var itemType = implementedGenericEnumerableInterface.GetGenericArguments()[0]; var readOnlyCollectionType = typeof(ReadOnlyCollection<>).MakeGenericType(itemType); if (type == readOnlyCollectionType) { var serializerDefinition = typeof(ReadOnlyCollectionSerializer<>); return CreateGenericSerializer(serializerDefinition, new[] { itemType }, serializerRegistry); } else if (readOnlyCollectionType.IsAssignableFrom(type)) { var serializerDefinition = typeof(ReadOnlyCollectionSubclassSerializer<,>); return CreateGenericSerializer(serializerDefinition, new[] { type, itemType }, serializerRegistry); } else if (typeInfo.IsInterface) { var listDefinition = typeof(List<>); var listType = listDefinition.MakeGenericType(itemType); var serializerDefinition = typeof(ImpliedImplementationInterfaceSerializer<,>); return CreateGenericSerializer(serializerDefinition, new[] { type, listType }, serializerRegistry); } else { var serializerDefinition = typeof(EnumerableInterfaceImplementerSerializer<,>); return CreateGenericSerializer(serializerDefinition, new[] { type, itemType }, serializerRegistry); } } else if (implementedEnumerableInterface != null) { if (typeInfo.IsInterface) { var listType = typeof(ArrayList); var serializerDefinition = typeof(ImpliedImplementationInterfaceSerializer<,>); return CreateGenericSerializer(serializerDefinition, new[] { type, listType }, serializerRegistry); } else { var serializerDefinition = typeof(EnumerableInterfaceImplementerSerializer<>); return CreateGenericSerializer(serializerDefinition, new[] { type }, serializerRegistry); } } return null; }
public static IBsonSerializer GetSerializerForValueType(IBsonSerializer fieldSerializer, IBsonSerializerRegistry serializerRegistry, Type valueType, object value) { if (!valueType.GetTypeInfo().IsValueType&& value == null) { return(fieldSerializer); } else { return(GetSerializerForValueType(fieldSerializer, serializerRegistry, valueType, allowScalarValueForArrayField: false)); } }
public ConvertIfPossibleSerializer(IBsonSerializer <TTo> serializer, IBsonSerializerRegistry serializerRegistry) { _serializer = serializer; _serializerRegistry = serializerRegistry; }
public static IBsonSerializer GetSerializerForValueType(IBsonSerializer fieldSerializer, IBsonSerializerRegistry serializerRegistry, Type valueType) { return(GetSerializerForValueType(fieldSerializer, serializerRegistry, valueType, allowScalarValueForArrayField: false)); }
public QueryableTranslator(IBsonSerializerRegistry serializerRegistry) { _serializerRegistry = Ensure.IsNotNull(serializerRegistry, nameof(serializerRegistry)); _stages = new List<BsonDocument>(); }
public static IBsonSerializer GetSerializerForValueType(IBsonSerializer fieldSerializer, IBsonSerializerRegistry serializerRegistry, Type valueType, bool allowScalarValueForArrayField) { var fieldType = fieldSerializer.ValueType; // these will normally be equal unless we've removed some Convert(s) that the compiler put in if (fieldType == valueType) { return(fieldSerializer); } // serialize numeric values without converting them if (fieldType.IsNumeric() && valueType.IsNumeric()) { var valueSerializer = BsonSerializer.SerializerRegistry.GetSerializer(valueType); if (HasStringRepresentation(fieldSerializer)) { valueSerializer = WithStringRepresentation(valueSerializer); } return(valueSerializer); } var fieldTypeInfo = fieldType.GetTypeInfo(); var fieldSerializerInterfaceType = typeof(IBsonSerializer <>).MakeGenericType(fieldType); var valueTypeInfo = valueType.GetTypeInfo(); // synthesize a NullableSerializer using the field serializer if (valueType.IsNullable() && valueType.GetNullableUnderlyingType() == fieldType) { var nullableSerializerType = typeof(NullableSerializer <>).MakeGenericType(fieldType); var nullableSerializerConstructor = nullableSerializerType.GetTypeInfo().GetConstructor(new[] { fieldSerializerInterfaceType }); return((IBsonSerializer)nullableSerializerConstructor.Invoke(new object[] { fieldSerializer })); } // synthesize an EnumConvertingSerializer using the field serializer if (fieldTypeInfo.IsEnum) { if (valueType.IsConvertibleToEnum()) { var enumConvertingSerializerType = typeof(EnumConvertingSerializer <,>).MakeGenericType(valueType, fieldType); var enumConvertingSerializerConstructor = enumConvertingSerializerType.GetTypeInfo().GetConstructor(new[] { fieldSerializerInterfaceType }); return((IBsonSerializer)enumConvertingSerializerConstructor.Invoke(new object[] { fieldSerializer })); } if (valueType.IsNullable() && valueType.GetNullableUnderlyingType().IsConvertibleToEnum()) { var underlyingValueType = valueType.GetNullableUnderlyingType(); var underlyingValueSerializerInterfaceType = typeof(IBsonSerializer <>).MakeGenericType(underlyingValueType); var enumConvertingSerializerType = typeof(EnumConvertingSerializer <,>).MakeGenericType(underlyingValueType, fieldType); var enumConvertingSerializerConstructor = enumConvertingSerializerType.GetTypeInfo().GetConstructor(new[] { fieldSerializerInterfaceType }); var enumConvertingSerializer = enumConvertingSerializerConstructor.Invoke(new object[] { fieldSerializer }); var nullableSerializerType = typeof(NullableSerializer <>).MakeGenericType(underlyingValueType); var nullableSerializerConstructor = nullableSerializerType.GetTypeInfo().GetConstructor(new[] { underlyingValueSerializerInterfaceType }); return((IBsonSerializer)nullableSerializerConstructor.Invoke(new object[] { enumConvertingSerializer })); } } // synthesize a NullableEnumConvertingSerializer using the field serializer if (fieldType.IsNullableEnum() && valueType.IsNullable()) { var nonNullableFieldType = fieldType.GetNullableUnderlyingType(); var nonNullableValueType = valueType.GetNullableUnderlyingType(); var nonNullableFieldSerializer = ((IChildSerializerConfigurable)fieldSerializer).ChildSerializer; var nonNullableFieldSerializerInterfaceType = typeof(IBsonSerializer <>).MakeGenericType(nonNullableFieldType); var nullableEnumConvertingSerializerType = typeof(NullableEnumConvertingSerializer <,>).MakeGenericType(nonNullableValueType, nonNullableFieldType); var nullableEnumConvertingSerializerConstructor = nullableEnumConvertingSerializerType.GetTypeInfo().GetConstructor(new[] { nonNullableFieldSerializerInterfaceType }); return((IBsonSerializer)nullableEnumConvertingSerializerConstructor.Invoke(new object[] { nonNullableFieldSerializer })); } // synthesize an IEnumerableSerializer serializer using the item serializer from the field serializer Type fieldIEnumerableInterfaceType; Type valueIEnumerableInterfaceType; Type itemType; if ( (fieldIEnumerableInterfaceType = fieldType.FindIEnumerable()) != null && (valueIEnumerableInterfaceType = valueType.FindIEnumerable()) != null && (itemType = fieldIEnumerableInterfaceType.GetSequenceElementType()) == valueIEnumerableInterfaceType.GetSequenceElementType() && fieldSerializer is IChildSerializerConfigurable) { var itemSerializer = ((IChildSerializerConfigurable)fieldSerializer).ChildSerializer; var itemSerializerInterfaceType = typeof(IBsonSerializer <>).MakeGenericType(itemType); var ienumerableSerializerType = typeof(IEnumerableSerializer <>).MakeGenericType(itemType); var ienumerableSerializerConstructor = ienumerableSerializerType.GetTypeInfo().GetConstructor(new[] { itemSerializerInterfaceType }); return((IBsonSerializer)ienumerableSerializerConstructor.Invoke(new object[] { itemSerializer })); } if (allowScalarValueForArrayField) { // if the fieldSerializer is an array serializer try to adapt its itemSerializer for valueType IBsonArraySerializer arraySerializer; if ((arraySerializer = fieldSerializer as IBsonArraySerializer) != null) { BsonSerializationInfo itemSerializationInfo; if (arraySerializer.TryGetItemSerializationInfo(out itemSerializationInfo)) { var itemSerializer = itemSerializationInfo.Serializer; return(GetSerializerForValueType(itemSerializer, serializerRegistry, valueType, allowScalarValueForArrayField: false)); } } } // if we can't return a value serializer based on the field serializer return a converting serializer var convertIfPossibleSerializerType = typeof(ConvertIfPossibleSerializer <,>).MakeGenericType(valueType, fieldType); var convertIfPossibleSerializerConstructor = convertIfPossibleSerializerType.GetTypeInfo().GetConstructor(new[] { fieldSerializerInterfaceType, typeof(IBsonSerializerRegistry) }); return((IBsonSerializer)convertIfPossibleSerializerConstructor.Invoke(new object[] { fieldSerializer, serializerRegistry })); }
private SerializerBuilder(IBsonSerializerRegistry serializerRegistry) { _serializerRegistry = serializerRegistry; }
private ProjectionBinder(IBsonSerializer documentSerializer, IBsonSerializerRegistry serializerRegistry, IMethodCallBinder methodCallBinder) { _methodCallBinder = Ensure.IsNotNull(methodCallBinder, "methodCallBinder"); _documentSerializer = Ensure.IsNotNull(documentSerializer, "documentSerializer"); _context = new ProjectionBindingContext( Ensure.IsNotNull(serializerRegistry, "serializerRegistry"), _methodCallBinder); }