C# Expression.ToString方法代碼示例

 public static void CheckExpression(Expression<Func<Boolean>> expression)
 {
     if (!expression.Compile()())
     {
         throw new MalformedException(string.Concat("Bad file format, expecting ", expression.ToString().Replace("() => ", string.Empty)));
     }
 }

 public void Visit(TreeView tv, Expression ex)
 {
     this.tv = tv;
     root = tv.Nodes.Add(ex.ToString());
     nodeStack.Push(root);
     Visit(ex);
 }

		/// <summary>
		/// 式木の構造が一致してれば、少なくとも ToString の結果は一致するので、
		/// それで2つの式木の一致性を判定。
		/// </summary>
		static void SimpleCheck(Expression e1, Expression e2, bool verbose)
		{
			if (e1.ToString() != e2.ToString())
			{
				Console.Write("not match: {0}, {1}\n", e1, e2);
			}
		}

        internal static string ExtractRootObjectName(Expression e)
        {
            if (e.NodeType == ExpressionType.Lambda)
                return ((LambdaExpression)e).Parameters[0].Name;

            var path = e.ToString();
            return new string(path.TakeWhile(c => char.IsLetterOrDigit(c)).ToArray());
        }

        public override Expression Visit(Expression node)
        {
            // If we're not processed expression by special method
            // lets use base ToString implementation.
            if (node != null)
                _rep = node.ToString();

            return base.Visit(node);
        }

    protected override Expression VisitExtension (Expression expression)
    {
      ArgumentUtility.CheckNotNull ("expression", expression);

      if (expression.CanReduce)
        return base.VisitExtension (expression);

      return Expression.Parameter (expression.Type, expression.ToString());
    }

 public static void Assert(Expression<Func<bool>> assertion)
 {
     Func<bool> compiled = assertion.Compile();
     bool evaluatedValue = compiled();
     if (!evaluatedValue)
     {
         throw new InvalidOperationException(
             string.Format("'{0}' is not met.", Normalize(assertion.ToString())));
     }
 }

        internal static MemberExpression GetRightMostMember(Expression e)
        {
            if (e is MemberExpression)
                return (MemberExpression)e;

            if (e is MethodCallExpression)
                return GetRightMostMember(((MethodCallExpression)e).Object);

            throw new SisoDbException(ExceptionMessages.ExpressionUtils_GetRightMostMember_NoMemberFound
                .Inject(e.ToString()));
        }

        public void SetResult(Expression r)
        {
            if (r == null)
                throw new ArgumentNullException("Cannot set the result to be null");

            ResultValue = r;
            Debug.WriteLine("SetResult: {0}{1}", r.ToString(), "");

            if (r is IDeclaredParameter)
                ResultValueAsVaraible = r as IDeclaredParameter;
        }

		public CacheKey GetCacheKey(Expression expression)
		{
			// use the string representation of the expression for the cache key
			string key = expression.ToString();

			// the key is potentially very long, so use an md5 fingerprint
			// (fine if the query result data isn't critically sensitive)
			key = ToMd5Fingerprint(key);

			return CacheKey.Create(null, key); ;
		}

        internal static string ExpressionToString(DataServiceContext context, Expression e)
        {
            ExpressionWriter ew = new ExpressionWriter(context);
            string serialized = ew.Translate(e);
            if (ew.cantTranslateExpression)
            {
                throw new NotSupportedException(Strings.ALinq_CantTranslateExpression(e.ToString()));
            }

            return serialized;
        }

        public static string Parse(Expression expressionBody)
        {
            var body = expressionBody.ToString();

            var cut = body.IndexOf(").");

            var sentence = body.Substring(cut + 1, body.Length - cut - 1).Replace(")", " ").Replace(".", " ").Replace("(", " ").Replace("  ", " ").Trim().Replace("_", " ").Replace("\"", " ");

            while (sentence.Contains("  ")) sentence = sentence.Replace("  ", " ");

            return sentence.Trim();
        }

 public override Expression FindResolution(OperatorType op, Expression prop, Expression val)
 {
     if (op == OperatorType.Like)
     {
         string s = val.ToString().Trim('"').Replace('?', '_').Replace('*', '%');
         return Expression.GreaterThan(Expression.Call(typeof(SqlFunctions).GetMethod("PatIndex"), Expression.Constant(s, s.GetType()), prop), Expression.Constant(0, typeof(Nullable<int>)));
     }
     else
     {
         return base.FindResolution(op, prop, val);
     }
 }

        private static string DescribeExpression(Expression exp)
        {
            if (exp is MemberExpression || exp is MethodCallExpression)
            {
                return GetName(exp);
            }
            if (exp is ConstantExpression)
            {
                return ((ConstantExpression) exp).Value.ToString();
            }

            return exp.ToString();
        }

        public ExpressionVertex(Expression expression)
            : this()
        {
            FullName = expression.ToString();

            var fullTextFormatter = new FullTextFormatter();
            var shortTextFormatter = new ShortTextFormatter();

            FullName = fullTextFormatter.Format(expression);
            ShortName = shortTextFormatter.Format(expression);

            _expressionHashCode = expression.GetHashCode();
        }