示例#1
0
        private SwitchCase BuildWriteBranch(object key, FieldDesc fieldDesc, Expression pWriter, Expression pItem, LabelTarget exit)
        {
            List <Expression> body = new List <Expression>();

            body.Add(SwitchField.BuildWriteOne(pWriter, key));

            if (fieldDesc != null)
            {
                body.Add(fieldDesc.BuildWrite(pWriter, pItem));
            }

            body.Add(Expression.Return(exit));
            return(Expression.SwitchCase(Expression.Block(body), Expression.Constant(key)));
        }
示例#2
0
        public Delegate BuildReader(Type targetType)
        {
            ParameterExpression pReader = Expression.Parameter(typeof(Reader));

            List <ParameterExpression> variables = new List <ParameterExpression>();
            List <Expression>          body      = new List <Expression>();

            ParameterExpression resultVar = Expression.Variable(targetType, "result");

            variables.Add(resultVar);

            BinaryExpression assign = Expression.Assign(resultVar, Expression.New(targetType));

            body.Add(assign);

            body.Add(SwitchField.BuildAssign(SwitchField.BuildReadOne(pReader), resultVar));

            LabelTarget exit = Expression.Label();

            List <SwitchCase> cases = new List <SwitchCase>();

            foreach (var branch in Branches)
            {
                cases.Add(BuildReadBranch(branch.Key, branch.Value, resultVar, pReader, exit));
            }

            body.Add(
                Expression.Switch(
                    Expression.PropertyOrField(resultVar, SwitchField.MInfo.Name),
                    Expression.Block(ThrowUnexpectedValue(Expression.PropertyOrField(resultVar, SwitchField.MInfo.Name))),
                    cases.ToArray())
                );

            body.Add(Expression.Label(exit));
            body.Add(resultVar);

            BlockExpression block = Expression.Block(variables, body);

            return(Expression
                   .Lambda(typeof(ReadOneDelegate <>).MakeGenericType(targetType), block, pReader)
                   .Compile());
        }
        public override object ReadJson(JsonReader reader,
                                        Type objectType, object existingValue,
                                        JsonSerializer serializer)
        {
            var jsonObject = JObject.Load(reader);
            var field      = default(IIntegrationSetupField);
            var fieldToken = jsonObject["FieldType"];

            if (fieldToken is null)
            {
                fieldToken = jsonObject["fieldType"];
            }
            switch (fieldToken.ToString())
            {
            case nameof(CheckboxField):
                field = new CheckboxField();
                break;

            case nameof(ShortTextField):
                field = new ShortTextField();
                break;

            case nameof(LongTextField):
                field = new LongTextField();
                break;

            case nameof(SsmlField):
                field = new SsmlField();
                break;

            case nameof(SelectField):
                field = new SelectField();
                break;

            case nameof(SwitchField):
                field = new SwitchField();
                break;
            }
            serializer.Populate(jsonObject.CreateReader(), field);
            return(field);
        }