private void Assert <TDocument>(Expression <Func <TDocument, bool> > expression, int expectedCount, string expectedFilter) { expression = (Expression <Func <TDocument, bool> >)PartialEvaluator.EvaluatePartially(expression); var parameter = expression.Parameters.Single(); var serializer = BsonSerializer.LookupSerializer <TDocument>(); var context = TranslationContext.Create(expression, serializer); var symbol = context.CreateSymbol(parameter, serializer, isCurrent: true); context = context.WithSymbol(symbol); var filterAst = ExpressionToFilterTranslator.Translate(context, expression.Body); var renderedFilter = (BsonDocument)filterAst.Render(); renderedFilter.Should().Be(expectedFilter); var filter = new BsonDocumentFilterDefinition <C>(renderedFilter); var list = __collection.FindSync <TDocument>(filter).ToList(); list.Count.Should().Be(expectedCount); }
public List <TDocument> Assert <TDocument>(IMongoCollection <TDocument> collection, Expression <Func <TDocument, bool> > filter, int expectedCount, BsonDocument expectedFilter) { filter = (Expression <Func <TDocument, bool> >)PartialEvaluator.EvaluatePartially(filter); var serializer = BsonSerializer.SerializerRegistry.GetSerializer <TDocument>(); var parameter = filter.Parameters.Single(); var context = TranslationContext.Create(filter, serializer); var symbol = context.CreateSymbol(parameter, serializer, isCurrent: true); context = context.WithSymbol(symbol); var filterAst = ExpressionToFilterTranslator.Translate(context, filter.Body); var filterDocument = (BsonDocument)filterAst.Render(); filterDocument.Should().Be(expectedFilter); var list = collection.FindSync(filterDocument).ToList(); list.Count.Should().Be(expectedCount); return(list); }
/// <inheritdoc /> public override RenderedFieldDefinition Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry) { var bindingContext = new PipelineBindingContext(serializerRegistry); var lambda = ExpressionHelper.GetLambda(PartialEvaluator.Evaluate(_expression)); 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); } return(new RenderedFieldDefinition(field.FieldName, field.Serializer)); }
public TranslateResult Translate(Expression expression) { expression = PartialEvaluator.Eval(expression); ProjectionExpression project = expression as ProjectionExpression; if (project == null) { expression = new QueryBinder().Bind(expression); expression = OrderByRewriter.Rewrite(expression); project = expression as ProjectionExpression; } string commandText = new QueryFormatter().FormatExpression(project.Source); LambdaExpression projector = new ProjectionBuilder().Build(project.Projector); return(new TranslateResult() { CommandText = commandText, Projector = projector }); }
private LambdaExpression Parameterize(Expression query, out object[] arguments) { IQueryProvider provider = this.FindProvider(query); if (provider == null) { throw new ArgumentException(Res.ArgumentQuery); } var ep = provider as IDbContext; // turn all relatively constant expression into actual constants Func <Expression, bool> fnCanBeEvaluated = e => ep != null?ExpressionHelper.CanBeEvaluatedLocally(e) : true; var body = PartialEvaluator.Eval(query, fnCanBeEvaluated); // convert all constants into parameters List <ParameterExpression> parameters; List <object> values; body = Parameterizer.Parameterize(body, out parameters, out values); // make sure the body will return a value typed as 'object'. if (body.Type != typeof(object)) { body = Expression.Convert(body, typeof(object)); } // make a lambda expression with these parameters arguments = values.ToArray(); if (arguments.Length < 5) { return(Expression.Lambda(body, parameters.ToArray())); } else { // too many parameters, use an object array instead. arguments = new object[] { arguments }; return(ExplicitToObjectArray.Rewrite(body, parameters)); } }
/// <summary> /// 对表达式进行解析,并返回限制值字典。 /// </summary> /// <param name="expression">查询表达式。</param> /// <param name="dicRestrMbrs"></param> /// <returns></returns> public static RestrictionDictionary GetRestrictions <T>(Expression expression, Dictionary <Type, List <MemberInfo> > dicRestrMbrs) { if (expression == null) { return(RestrictionDictionary.Empty); } var translator = new SchemaQueryTranslator { _metadataType = typeof(T) }; if (!dicRestrMbrs.TryGetValue(typeof(T), out List <MemberInfo> properties)) { throw new SchemaQueryTranslateException(typeof(T)); } translator._members = properties; expression = PartialEvaluator.Eval(expression); translator.Visit(expression); return(translator._restrDict); }
/// <summary> /// 通过一个 <see cref="MemberInitExpression"/> 表达式将属性值绑定到实体对象中。 /// </summary> /// <param name="entity"></param> /// <param name="factory"></param> /// <returns></returns> public static IEntity InitByExpression(this IEntity entity, LambdaExpression factory) { if (factory.Body is MemberInitExpression initExp) { foreach (var bind in initExp.Bindings) { if (bind as MemberAssignment == null) { continue; } var exp = PartialEvaluator.Eval((bind as MemberAssignment).Expression); if (exp is ConstantExpression constExp) { entity.SetValue((bind as MemberAssignment).Member.Name, PropertyValue.NewValue(constExp.Value, (bind as MemberAssignment).Member.GetMemberType())); } } } return(entity); }
public static RenderedProjectionDefinition <TProjection> Translate <TDocument, TProjection>(Expression <Func <TDocument, TProjection> > projector, IBsonSerializer <TDocument> parameterSerializer) { var parameterSerializationInfo = new BsonSerializationInfo(null, parameterSerializer, parameterSerializer.ValueType); var parameterExpression = new SerializationExpression(projector.Parameters[0], parameterSerializationInfo); var binder = new SerializationInfoBinder(BsonSerializer.SerializerRegistry); binder.RegisterParameterReplacement(projector.Parameters[0], parameterExpression); var normalizedBody = Normalizer.Normalize(projector.Body); var evaluatedBody = PartialEvaluator.Evaluate(normalizedBody); var boundExpression = binder.Bind(evaluatedBody); var candidateFields = FieldGatherer.Gather(boundExpression); var fields = GetUniqueFieldsByHierarchy(candidateFields); var serializationInfo = fields.Select(x => x.SerializationInfo).ToList(); var replacementParameter = Expression.Parameter(typeof(ProjectedObject), "document"); var translator = new FindProjectionTranslator(projector.Parameters[0], replacementParameter, fields); var newProjector = Expression.Lambda <Func <ProjectedObject, TProjection> >( translator.Visit(boundExpression), replacementParameter); BsonDocument projectionDocument; IBsonSerializer <TProjection> serializer; if (translator._fullDocument) { projectionDocument = null; serializer = new ProjectingDeserializer <TDocument, TProjection>(parameterSerializer, projector.Compile()); } else { projectionDocument = GetProjectionDocument(serializationInfo); var projectedObjectSerializer = new ProjectedObjectDeserializer(serializationInfo); serializer = new ProjectingDeserializer <ProjectedObject, TProjection>(projectedObjectSerializer, newProjector.Compile()); } return(new RenderedProjectionDefinition <TProjection>(projectionDocument, serializer)); }
protected override Expression VisitSelect(SelectExpression select) { // select * from table order by x skip s take t // => // select * from (select top s * from (select top s + t from table order by x) order by -x) order by x select = (SelectExpression)base.VisitSelect(select); if (select.Skip != null && select.Take != null && select.OrderBy.Count > 0) { var skip = select.Skip; var take = select.Take; var skipPlusTake = PartialEvaluator.Eval(Expression.Add(skip, take)); select = select.SetTake(skipPlusTake).SetSkip(null); select = select.AddRedundantSelect(this.language, new TableAlias()); select = select.SetTake(take); // propogate order-bys to new layer select = (SelectExpression)OrderByRewriter.Rewrite(this.language, select); var inverted = select.OrderBy.Select(ob => new OrderExpression( ob.OrderType == OrderType.Ascending ? OrderType.Descending : OrderType.Ascending, ob.Expression )); select = select.SetOrderBy(inverted); select = select.AddRedundantSelect(this.language, new TableAlias()); select = select.SetTake(Expression.Constant(0)); // temporary select = (SelectExpression)OrderByRewriter.Rewrite(this.language, select); var reverted = select.OrderBy.Select(ob => new OrderExpression( ob.OrderType == OrderType.Ascending ? OrderType.Descending : OrderType.Ascending, ob.Expression )); select = select.SetOrderBy(reverted); select = select.SetTake(null); } return(select); }
//重写projectrow 中的ExecuteSubQuery 方法 public override IEnumerable <E> ExcuteSubQuery <E>(LambdaExpression query) { //干什么用的?? // 将查询主体 替换为 查询参数 // // Replace 参数 在query.Body 中搜索 query.parameter ,并用 Expression.Constant(this) 替换 ProjectionExpression projection = (ProjectionExpression) new DbExpressionReplacer(). Replace(query.Body, query.Parameters[0], Expression.Constant(this)); //计算 本地表达式,去除本地引用 projection = PartialEvaluator.Eval(projection, CanEvaluateLocally) as ProjectionExpression; //执行查询 IEnumerable <E> result = (IEnumerable <E>) this.provider.Execute(projection); List <E> list = new List <E>(result); // 如果是 IQueryable 类型,直接返回 if (typeof(IQueryable <E>).IsAssignableFrom(query.Body.Type)) { return(list.AsQueryable()); } return(list); }
protected override Expression VisitProjection(DbProjectionExpression proj) { // select * from table order by x skip s take t // => // select * from (select top s * from (select top s + t from table order by x) order by -x) order by x if (proj.Select.Skip != null && proj.Select.Take != null && proj.Select.OrderBy.Count > 0) { var skip = proj.Select.Skip; var take = proj.Select.Take; var select = proj.Select; var skipPlusTake = PartialEvaluator.Eval(Expression.Add(skip, take)); select = proj.Select.SetTake(skipPlusTake).SetSkip(null); select = select.AddRedundantSelect(new DbTableAlias()); select = select.SetTake(take); // propogate order-bys to new layer select = (DbSelectExpression)OrderByRewriter.Rewrite(select); var inverted = select.OrderBy.Select(ob => new DbOrderExpression( ob.OrderType == DbOrderType.Ascending ? DbOrderType.Descending : DbOrderType.Ascending, ob.Expression )); select = select.SetOrderBy(inverted); select = select.AddRedundantSelect(new DbTableAlias()); select = select.SetTake(Expression.Constant(0)); // temporary select = (DbSelectExpression)OrderByRewriter.Rewrite(select); var reverted = select.OrderBy.Select(ob => new DbOrderExpression( ob.OrderType == DbOrderType.Ascending ? DbOrderType.Descending : DbOrderType.Ascending, ob.Expression )); select = select.SetOrderBy(reverted); select = select.SetTake(null); return(new DbProjectionExpression(select, proj.Projector, proj.Aggregator)); } return(proj); }
public override Expression ApplyPolicy(Expression expression, MemberInfo member) { List <LambdaExpression> ops; if (this.policy.operations.TryGetValue(member, out ops)) { var result = expression; foreach (var fnOp in ops) { var pop = PartialEvaluator.Eval(fnOp, this.Translator.Mapper.Mapping.CanBeEvaluatedLocally); result = this.Translator.Mapper.ApplyMapping(Expression.Invoke(pop, result)); } var projection = (ProjectionExpression)result; if (projection.Type != expression.Type) { var fnAgg = Aggregator.GetAggregator(expression.Type, projection.Type); projection = new ProjectionExpression(projection.Select, projection.Projector, fnAgg); } return(projection); } return(expression); }
internal Expression ApplyPolicy(Expression expression, MemberInfo member) { List <LambdaExpression> ops; if (Operations.TryGetValue(member, out ops)) { var result = expression; foreach (var fnOp in ops) { var pop = PartialEvaluator.Eval(fnOp, ExpressionHelper.CanBeEvaluatedLocally); result = QueryBinder.Bind(ExpressionBuilder, this, Expression.Invoke(pop, result)); } var projection = (ProjectionExpression)result; if (projection.Type != expression.Type) { var fnAgg = Aggregator.GetAggregator(expression.Type, projection.Type); projection = new ProjectionExpression(projection.Select, projection.Projector, fnAgg); } return(projection); } return(expression); }
public void Setup() { Func <int, Expression <Func <int, int, int> > > builder; switch (ExpressionType) { case ExpressionTypes.Simple: builder = buildSimpleExpression; break; case ExpressionTypes.Complex: builder = buildComplexExpression; break; default: throw new NotSupportedException(ExpressionType.ToString()); } expression = PartialEvaluator.PartialEvalBody(builder(5), ExpressionInterpreter.Instance); similarExpression = PartialEvaluator.PartialEvalBody(builder(5), ExpressionInterpreter.Instance); nonSimilarExpression = PartialEvaluator.PartialEvalBody(builder(42), ExpressionInterpreter.Instance); }
internal void Compile(params object[] args) { if (this.fnQuery == null) { // first identify the query provider being used Expression replaced = null; Expression body = this.query.Body; ConstantExpression root = RootQueryableFinder.Find(body) as ConstantExpression; if (root == null && args != null && args.Length > 0) { replaced = ExpressionReplacer.ReplaceAll( this.query, this.query.Parameters.ToArray(), args.Select((a, i) => Expression.Constant(a, this.query.Parameters[i].Type)).ToArray() ); body = PartialEvaluator.Eval(replaced); root = RootQueryableFinder.Find(body) as ConstantExpression; } if (root == null) { throw new InvalidOperationException("Could not find query provider"); } // ask the query provider to compile the query by 'executing' the lambda expression IQueryProvider provider = ((IQueryable)root.Value).Provider; Delegate result = null; if (replaced != null) { result = (Delegate)provider.Execute(replaced); } else { result = (Delegate)provider.Execute(this.query); } System.Threading.Interlocked.CompareExchange(ref this.fnQuery, result, null); } }
protected override Expression VisitSelect(SelectExpression selectExpression) { selectExpression = (SelectExpression)base.VisitSelect(selectExpression); if (((selectExpression.Skip != null) && (selectExpression.Take != null)) && (selectExpression.OrderBy.Count > 0)) { Expression skip = selectExpression.Skip; Expression take = selectExpression.Take; Expression expression3 = PartialEvaluator.Eval(Expression.Add(skip, take)); selectExpression = selectExpression.SetTake(expression3).SetSkip(null); selectExpression = selectExpression.AddRedundantSelect(this.language, new TableAlias()); selectExpression = selectExpression.SetTake(take); selectExpression = (SelectExpression)OrderByRewriter.Rewrite(this.language, selectExpression); IEnumerable <OrderExpression> orderBy = from ob in selectExpression.OrderBy select new OrderExpression((ob.OrderType == OrderType.Ascending) ? OrderType.Descending : OrderType.Ascending, ob.Expression); selectExpression = selectExpression.SetOrderBy(orderBy); selectExpression = selectExpression.AddRedundantSelect(this.language, new TableAlias()); selectExpression = selectExpression.SetTake(Expression.Constant(0)); selectExpression = (SelectExpression)OrderByRewriter.Rewrite(this.language, selectExpression); IEnumerable <OrderExpression> enumerable2 = from ob in selectExpression.OrderBy select new OrderExpression((ob.OrderType == OrderType.Ascending) ? OrderType.Descending : OrderType.Ascending, ob.Expression); selectExpression = selectExpression.SetOrderBy(enumerable2); selectExpression = selectExpression.SetTake(null); } return(selectExpression); }
/// <summary> /// 通过表达式计算出对应的缓存键。 /// </summary> /// <param name="expression">作为 Key 的 Lambda 表达式。</param> /// <param name="prefix">用于区分缓存的前缀。</param> /// <returns></returns> public string Generate(Expression expression, params string[] prefix) { var evalExp = PartialEvaluator.Eval(expression, TranslateProviderBase.EvaluatedLocallyFunc); var cacheKey = ExpressionWriter.WriteToString(evalExp); //使用md5进行hash编码 var md5 = new MD5CryptoServiceProvider(); var data = md5.ComputeHash(Encoding.Unicode.GetBytes(cacheKey)); var sb = new StringBuilder(); foreach (var p in prefix) { if (!string.IsNullOrEmpty(p)) { sb.AppendFormat("{0}:", p); } } sb.Append(data.ToHex(true)); return(sb.ToString()); }
public override Expression ApplyPolicy(Expression expression, MemberInfo member) { List <LambdaExpression> list; if (this.policy.operations.TryGetValue(member, out list)) { Expression expression2 = expression; foreach (LambdaExpression expression3 in list) { QueryMapping mapping = base.Translator.Mapper.Mapping; Expression expression4 = PartialEvaluator.Eval(expression3, new Func <Expression, bool>(mapping.CanBeEvaluatedLocally)); expression2 = base.Translator.Mapper.ApplyMapping(Expression.Invoke(expression4, new Expression[] { expression2 })); } ProjectionExpression expression5 = (ProjectionExpression)expression2; if (expression5.Type != expression.Type) { LambdaExpression aggregator = Aggregator.GetAggregator(expression.Type, expression5.Type); expression5 = new ProjectionExpression(expression5.Select, expression5.Projector, aggregator); } return(expression5); } return(expression); }
internal IQueryProvider FindProvider(Expression expression, object[] args) { Expression root = this.FindProviderInExpression(expression) as ConstantExpression; if (root == null && args != null && args.Length > 0) { Expression replaced = ExpressionReplacer.ReplaceAll( expression, this.query.Parameters.ToArray(), args.Select((a, i) => Expression.Constant(a, this.query.Parameters[i].Type)).ToArray() ); root = this.FindProviderInExpression(replaced); } if (root != null) { ConstantExpression cex = root as ConstantExpression; if (cex == null) { cex = PartialEvaluator.Eval(root) as ConstantExpression; } if (cex != null) { IQueryProvider provider = cex.Value as IQueryProvider; if (provider == null) { IQueryable query = cex.Value as IQueryable; if (query != null) { provider = query.Provider; } } return(provider); } } return(null); }
public Expression ApplyPolicy(Expression expression, MemberInfo member, Func <Expression, Expression> builder) { if (_operations.TryGetValue(member, out List <LambdaExpression> ops)) { var syntax = _provider.GetService <ISyntaxProvider>(); var result = expression; foreach (var fnOp in ops) { var pop = PartialEvaluator.Eval(fnOp); result = builder(Expression.Invoke(pop, result)); } var projection = (ProjectionExpression)result; if (projection.Type != expression.Type) { var fnAgg = QueryUtility.GetAggregator(expression.Type, projection.Type); projection = new ProjectionExpression(projection.Select, projection.Projector, fnAgg, projection.IsAsync, projection.IsNoTracking); } return(projection); } return(expression); }
protected override MemberBinding VisitBinding(MemberBinding binding) { var assign = binding as MemberAssignment; if (assign == null) { return(binding); } var propertyName = assign.Member.Name; var property = PropertyUnity.GetProperty(typeof(TEntity), propertyName); if (property != null) { if (condition.Length > 0) { condition.Append(" AND "); } var constExp = PartialEvaluator.Eval(assign.Expression) as ConstantExpression; if (constExp.Type.IsStringOrDateTime()) { condition.AppendFormat("{0} = '{1}'", property.Info.FieldName, constExp.Value); } else if (constExp.Type.IsEnum) { condition.AppendFormat("{0} = {1}", property.Info.FieldName, (int)constExp.Value); } else { condition.AppendFormat("{0} = {1}", property.Info.FieldName, constExp.Value); } } return(binding); }
Expression IQueryPolicy.ApplyPolicy(Expression expression, MemberInfo member) { if (operations.TryGetValue(member, out List <LambdaExpression> ops)) { var syntax = Database.Provider.GetService <ISyntaxProvider>(); var result = expression; foreach (var fnOp in ops) { var pop = PartialEvaluator.Eval(fnOp); result = QueryBinder.Bind(Expression.Invoke(pop, result), syntax); } var projection = (ProjectionExpression)result; if (projection.Type != expression.Type) { var fnAgg = QueryUtility.GetAggregator(expression.Type, projection.Type); projection = new ProjectionExpression(projection.Select, projection.Projector, fnAgg); } return(projection); } return(expression); }
/// <summary> /// 对 ELinq 表达式进行翻译,并返回翻译的结果。 /// </summary> /// <param name="expression">一个 ELinq 表达式。</param> /// <param name="options">翻译的选项。</param> /// <returns></returns> public virtual Expression Translate(Expression expression, TranslateOptions options = null) { expression = PartialEvaluator.Eval(expression, CanBeEvaluatedLocally); return(TranslateInternal(expression, options)); }
/// <summary> /// 对 ELinq 表达式进行翻译,并返回翻译的结果。 /// </summary> /// <param name="expression">一个 ELinq 表达式。</param> /// <returns></returns> public virtual Expression Translate(Expression expression) { expression = PartialEvaluator.Eval(expression, CanBeEvaluatedLocally); return(TranslateInternal(expression)); }
public void InterpreterToCompiler() { var r = PartialEvaluator.PartialEvaluate <Expression <Func <int, int> >, int, int>((f, i) => f.Compile()(i), i => i * 100); Assert.That(r.Compile()(20), Is.EqualTo(2000)); }
// public methods /// <summary> /// Gets the serialization info for the given expression. /// </summary> /// <param name="node">The expression.</param> /// <returns>The serialization info.</returns> public BsonSerializationInfo GetSerializationInfo(Expression node) { var evaluatedNode = PartialEvaluator.Evaluate(node); return(BsonSerializationInfoFinder.GetSerializationInfo(evaluatedNode, _serializationInfoCache)); }
public object Execute(Expression expression) { var visitor = new SalesforceVisitor(NamingConvention, SelectType); var cmd = visitor.Translate(PartialEvaluator.Eval(expression)); switch (visitor.QueryType) { case QueryTypeEnum.FirstOrDefault: return(ProduceAsyncEnumerable(cmd).FirstOrDefault()); case QueryTypeEnum.First: return(ProduceAsyncEnumerable(cmd).First()); case QueryTypeEnum.Single: return(ProduceAsyncEnumerable(cmd).Single()); case QueryTypeEnum.SingleOrDefault: return(ProduceAsyncEnumerable(cmd).SingleOrDefault()); case QueryTypeEnum.Count: return(ProduceCountAsync(cmd)); case QueryTypeEnum.Any: return(ProduceCountAsync(cmd).ContinueWith(task => task.Result > 0)); case QueryTypeEnum.List: return(ProduceAsyncEnumerable(cmd).ToList()); // var argument = typeof(TResult).GetGenericArguments()[0]; // // var method = GetType().GetMethod("ProduceAsyncEnumerable", BindingFlags.Instance | BindingFlags.NonPublic).MakeGenericMethod(argument); // var asyncEnumerable = method.Invoke(this, new object[]{cmd}); // // // var enumerabletype = typeof(IAsyncEnumerable<>).MakeGenericType(argument); // var toList = GetGenericMethod(typeof(AsyncEnumerable), "ToList", typeof(IAsyncEnumerable<>)).MakeGenericMethod(argument); // // var result = (Task<TResult>) toList.Invoke(null, new [] {asyncEnumerable}); // // MethodInfo GetGenericMethod(Type type, string name, params Type[] argumentTypes) // { // var methods = type.GetTypeInfo().GetMember("ToList").OfType<MethodInfo>().ToList(); // // return methods.FirstOrDefault(m => // { // var parameters = m.GetParameters(); // // if (parameters.Length != argumentTypes.Length) // return false; // // for (var i = 0; i < parameters.Length; i++) // { // var parameterType = parameters[i].ParameterType; // // if (parameterType.IsGenericType) // parameterType = parameterType.GetGenericTypeDefinition(); // // if (parameterType != argumentTypes[i]) // return false; // } // // return true; // }); // } case QueryTypeEnum.Enumerator: default: return(Task.FromResult(ProduceAsyncEnumerator(cmd))); } }
public string ToString(Expression expression) { var visitor = new SalesforceVisitor(NamingConvention, SelectType); return(visitor.Translate(PartialEvaluator.Eval(expression))); }
public void StaticReadonlyClosurePartialEvaluation() { PartialEvaluator.PartialEvalBody(staticReadonlyClosureExpression, MiaPlaza.ExpressionUtils.Evaluating.ExpressionInterpreter.Instance); }
/// <summary> /// Tries the get serialization information. /// </summary> /// <param name="node">The node.</param> /// <param name="serializationInfo">The serialization information.</param> /// <returns></returns> public bool TryGetSerializationInfo(Expression node, out BsonSerializationInfo serializationInfo) { var evaluatedNode = PartialEvaluator.Evaluate(node); return(BsonSerializationInfoFinder.TryGetSerializationInfo(evaluatedNode, _serializationInfoCache, out serializationInfo)); }