コード例 #1
0
        /// <summary>
        /// 访问 <see cref="T:System.Linq.Expressions.MemberExpression"/> 的子级。
        /// </summary>
        /// <returns>
        /// 如果修改了该表达式或任何子表达式,则为修改后的表达式;否则返回原始表达式。
        /// </returns>
        /// <param name="node">要访问的表达式。</param>
        protected override Expression VisitMember(MemberExpression node)
        {
            Check.NotNull(node, nameof(node));

            var translatedExpression = _memberTranslator.Translate(node);

            if (translatedExpression != null)
            {
                return(Visit(translatedExpression));
            }

            var expr = node.Expression;

            if (expr.NodeType == ExpressionType.Convert)
            {
                expr = expr.RemoveConvert();
            }
            switch (expr.NodeType)
            {
            case ExpressionType.Parameter:
                _builder.Append(Delimter(node.Member, expr.Type));
                break;

            case ExpressionType.MemberAccess:
            case ExpressionType.Constant:
                AppendInvoke(node);
                break;
            }
            return(node);
        }
コード例 #2
0
        protected override Expression VisitMember(MemberExpression expression)
        {
            Check.NotNull(expression, nameof(expression));

            if (!(expression.Expression is QuerySourceReferenceExpression) &&
                !(expression.Expression is SubQueryExpression))
            {
                var newExpression = Visit(expression.Expression);

                if (newExpression != null ||
                    expression.Expression == null)
                {
                    var newMemberExpression
                        = newExpression != expression.Expression
                            ? Expression.Property(newExpression, expression.Member.Name)
                            : expression;

                    var translatedExpression = _memberTranslator.Translate(newMemberExpression);

                    if (translatedExpression != null)
                    {
                        return(translatedExpression);
                    }
                }
            }

            var aliasExpression
                = _queryModelVisitor
                  .BindMemberExpression(expression, CreateAliasedColumnExpression);

            if (aliasExpression == null &&
                _bindParentQueries)
            {
                aliasExpression
                    = _queryModelVisitor?.ParentQueryModelVisitor
                      .BindMemberExpression(expression, CreateAliasedColumnExpressionCore);
            }

            if (aliasExpression == null)
            {
                var querySourceReferenceExpression
                    = expression.Expression as QuerySourceReferenceExpression;

                if (querySourceReferenceExpression != null)
                {
                    var selectExpression
                        = _queryModelVisitor.TryGetQuery(querySourceReferenceExpression.ReferencedQuerySource);

                    if (selectExpression != null)
                    {
                        aliasExpression
                            = selectExpression.Projection
                              .OfType <AliasExpression>()
                              .SingleOrDefault(ae => ae.SourceMember == expression.Member);
                    }
                }
            }

            return(aliasExpression);
        }
コード例 #3
0
        public MemberInfo TranslateMember(Type targetType, MemberInfo memberInfo)
        {
            if (memberInfo.DeclaringType.Namespace != FromNamespace)
            {
                return(memberInfo);
            }

            IMemberTranslator translator = memberInfo.GetCustomTranslator() ?? MemberTranslator;

            translator.Verifier   = StructureVerifier;
            translator.TargetType = targetType;

            return(translator.Translate(memberInfo));
        }