public static BsonArray SerializeValues(this ISerializationExpression field, Type itemType, IEnumerable values)
        {
            Ensure.IsNotNull(field, nameof(field));
            Ensure.IsNotNull(itemType, nameof(itemType));
            Ensure.IsNotNull(values, nameof(values));

            var itemSerializer = FieldValueSerializerHelper.GetSerializerForValueType(field.Serializer, BsonSerializer.SerializerRegistry, itemType);

            var tempDocument = new BsonDocument();

            using (var bsonWriter = new BsonDocumentWriter(tempDocument))
            {
                var context = BsonSerializationContext.CreateRoot(bsonWriter);
                bsonWriter.WriteStartDocument();
                bsonWriter.WriteName("values");
                bsonWriter.WriteStartArray();
                foreach (var value in values)
                {
                    itemSerializer.Serialize(context, value);
                }
                bsonWriter.WriteEndArray();
                bsonWriter.WriteEndDocument();

                return((BsonArray)tempDocument[0]);
            }
        }
        internal override RenderedFieldDefinition <TField> TranslateExpressionToField <TDocument, TField>(
            Expression <Func <TDocument, TField> > expression,
            IBsonSerializer <TDocument> documentSerializer,
            IBsonSerializerRegistry serializerRegistry,
            bool allowScalarValueForArrayField)
        {
            var lambda              = (LambdaExpression)PartialEvaluator.Evaluate(expression);
            var bindingContext      = new PipelineBindingContext(serializerRegistry);
            var parameterExpression = new DocumentExpression(documentSerializer);

            bindingContext.AddExpressionMapping(lambda.Parameters[0], parameterExpression);
            var bound = bindingContext.Bind(lambda.Body);

            bound = FieldExpressionFlattener.FlattenFields(bound);
            IFieldExpression field;

            if (!ExpressionHelper.TryGetExpression(bound, out field))
            {
                var message = string.Format("Unable to determine the serialization information for {0}.", expression);
                throw new InvalidOperationException(message);
            }

            var underlyingSerializer = field.Serializer;
            var fieldSerializer      = underlyingSerializer as IBsonSerializer <TField>;
            var valueSerializer      = (IBsonSerializer <TField>)FieldValueSerializerHelper.GetSerializerForValueType(underlyingSerializer, serializerRegistry, typeof(TField), allowScalarValueForArrayField);

            return(new RenderedFieldDefinition <TField>(field.FieldName, fieldSerializer, valueSerializer, underlyingSerializer));
        }
        public static BsonValue SerializeValue(this ISerializationExpression field, Type valueType, object value)
        {
            Ensure.IsNotNull(field, nameof(field));

            var valueSerializer = FieldValueSerializerHelper.GetSerializerForValueType(field.Serializer, BsonSerializer.SerializerRegistry, valueType, value);

            var tempDocument = new BsonDocument();

            using (var bsonWriter = new BsonDocumentWriter(tempDocument))
            {
                var context = BsonSerializationContext.CreateRoot(bsonWriter);
                bsonWriter.WriteStartDocument();
                bsonWriter.WriteName("value");
                valueSerializer.Serialize(context, value);
                bsonWriter.WriteEndDocument();
                return(tempDocument[0]);
            }
        }