Example #1
0
 Encoder( EncodeOptions options )
 {
     this.options = options;
     builder = new StringBuilder();
     indent = 0;
 }
Example #2
0
 public static string Encode( object obj, EncodeOptions options )
 {
     var instance = new Encoder( options );
     instance.EncodeValue( obj, false );
     return instance.builder.ToString();
 }
        /// <summary>
        /// Encodes the lambda expression.
        /// </summary>
        /// <param name="expression">The expression to be encoded.</param>
        /// <param name="state">The current state of the encode operation.</param>
        /// <param name="options">The options for the encode operation.</param>
        /// <returns>An <see cref="EncodedExpression"/> object.</returns>
        internal static EncodedExpression EncodeLambdaExpression(Expression expression, EncodeState state, EncodeOptions options)
        {
            var lambdaExpression = ( LambdaExpression )expression;

            var expressions = new Dictionary <string, EncodedExpression>
            {
                { "Body", EncodeExpression(lambdaExpression.Body, state, options) }
            };

            for (int i = 0; i < lambdaExpression.Parameters.Count; i++)
            {
                expressions.Add($"p{i}", EncodeExpression(lambdaExpression.Parameters[i], state, options));
            }

            return(new EncodedExpression
            {
                NodeType = lambdaExpression.NodeType,
                Expressions = expressions,
                Values = new Dictionary <string, string>
                {
                    { "ParameterCount", lambdaExpression.Parameters.Count.ToString() }
                }
            });
        }
        /// <summary>
        /// Encodes the member expression.
        /// </summary>
        /// <param name="expression">The expression to be encoded.</param>
        /// <param name="state">The current state of the encode operation.</param>
        /// <param name="options">The options for the encode operation.</param>
        /// <returns>An <see cref="EncodedExpression"/> object.</returns>
        internal static EncodedExpression EncodeMemberExpression(Expression expression, EncodeState state, EncodeOptions options)
        {
            var memberExpression = ( MemberExpression )expression;

            if (IsAnonymousType(memberExpression.Member.ReflectedType))
            {
                throw new Exception("Encoding member access of anonymous types is not supported.");
            }

            return(new EncodedExpression
            {
                NodeType = memberExpression.NodeType,
                Expressions = new Dictionary <string, EncodedExpression>
                {
                    { "Expression", EncodeExpression(memberExpression.Expression, state, options) }
                },
                Values = new Dictionary <string, string>
                {
                    { "Type", state.SignatureHelper.GetSignatureFromType(memberExpression.Member.ReflectedType) },
                    { "Member", memberExpression.Member.Name },
                    { "IsProperty", (memberExpression.Member.MemberType == MemberTypes.Property).ToString() }
                }
            });
        }
        /// <summary>
        /// Decodes the binary expression.
        /// </summary>
        /// <param name="expression">The expression to be decoded.</param>
        /// <param name="state">The current state of the decode operation.</param>
        /// <param name="options">The options for the decode operation.</param>
        /// <returns>An <see cref="Expression"/> object.</returns>
        internal static EncodedExpression EncodeConstantExpression(Expression expression, EncodeState state, EncodeOptions options)
        {
            var constantExpression = ( ConstantExpression )expression;

            return(new EncodedExpression
            {
                NodeType = constantExpression.NodeType,
                Values = new Dictionary <string, string>
                {
                    { "Type", state.SignatureHelper.GetSignatureFromType(constantExpression.Type) },
                    { "Value", constantExpression.Value?.ToString() }
                }
            });
        }
        /// <summary>
        /// Encodes the unary expression.
        /// </summary>
        /// <param name="expression">The expression to be encoded.</param>
        /// <param name="state">The current state of the encode operation.</param>
        /// <param name="options">The options for the encode operation.</param>
        /// <returns>An <see cref="EncodedExpression"/> object.</returns>
        internal static EncodedExpression EncodeUnaryExpression(Expression expression, EncodeState state, EncodeOptions options)
        {
            var unaryExpression = ( UnaryExpression )expression;

            return(new EncodedExpression
            {
                NodeType = unaryExpression.NodeType,
                Expressions = new Dictionary <string, EncodedExpression>
                {
                    { "Operand", EncodeExpression(unaryExpression.Operand, state, options) }
                },
                Values = new Dictionary <string, string>
                {
                    { "Type", state.SignatureHelper.GetSignatureFromType(unaryExpression.Type) }
                }
            });
        }
        /// <summary>
        /// Encodes the binary expression.
        /// </summary>
        /// <param name="expression">The expression to be encoded.</param>
        /// <param name="state">The current state of the encode operation.</param>
        /// <param name="options">The options for the encode operation.</param>
        /// <returns>An <see cref="EncodedExpression"/> object.</returns>
        internal static EncodedExpression EncodeBinaryExpression(Expression expression, EncodeState state, EncodeOptions options)
        {
            var binaryExpression = ( BinaryExpression )expression;

            return(new EncodedExpression
            {
                NodeType = binaryExpression.NodeType,
                Expressions = new Dictionary <string, EncodedExpression>
                {
                    { "Left", EncodeExpression(binaryExpression.Left, state, options) },
                    { "Right", EncodeExpression(binaryExpression.Right, state, options) },
                    { "Conversion", binaryExpression.Conversion != null?EncodeExpression(binaryExpression.Conversion, state, options) : null }
                }
            });
        }
        /// <summary>
        /// Encodes a <see cref="Expression"/> into an object that can be
        /// serialized.
        /// </summary>
        /// <param name="expression">The expression to be encoded.</param>
        /// <param name="state">The state tracker for the encode operation.</param>
        /// <param name="options">The options that will be used during encoding.</param>
        /// <returns>An object that can be serialized.</returns>
        internal static EncodedExpression EncodeExpression(Expression expression, EncodeState state, EncodeOptions options)
        {
            if (!ExpressionTypeMapping.ContainsKey(expression.NodeType))
            {
                throw new ArgumentException($"Encountered unknown node type {expression.NodeType} when encoding expression.", nameof(expression));
            }

            return(ExpressionTypeMapping[expression.NodeType].Encode(expression, state, options));
        }
 /// <summary>
 /// Encodes a <see cref="Expression"/> into an object that can be
 /// serialized.
 /// </summary>
 /// <param name="expression">The expression to be encoded.</param>
 /// <param name="options">The options that will be used during encoding.</param>
 /// <returns>An object that can be serialized.</returns>
 public static EncodedExpression EncodeExpression(Expression expression, EncodeOptions options)
 {
     return(EncodeExpression(expression, new EncodeState(), options));
 }