public Expression GetConditionOrNull(
            IMemberMapperData mapperData,
            CallbackPosition position,
            QualifiedMember targetMember)
        {
            if (!HasCondition)
            {
                return(null);
            }

            var condition = _conditionLambda.GetBody(mapperData, position, targetMember);

            if (_negateCondition)
            {
                condition = Expression.Not(condition);
            }

            var targetCanBeNull = position.IsPriorToObjectCreation(targetMember);

            var conditionNestedAccessesChecks = mapperData
                                                .GetExpressionInfoFor(condition, targetCanBeNull)
                                                .NestedAccessChecks;

            if (conditionNestedAccessesChecks != null)
            {
                condition = Expression.AndAlso(conditionNestedAccessesChecks, condition);
            }

            return(condition);
        }
Beispiel #2
0
        private static void ProcessMemberAccesses(
            IMemberMapperData mapperData,
            ref Expression value,
            out Expression nestedAccessChecks,
            out IList <ParameterExpression> variables)
        {
            var valueInfo = mapperData.GetExpressionInfoFor(value, targetCanBeNull: false);

            nestedAccessChecks = valueInfo.NestedAccessChecks;

            if (valueInfo.MultiInvocations.None())
            {
                variables = Enumerable <ParameterExpression> .EmptyArray;
                return;
            }

            var numberOfInvocations = valueInfo.MultiInvocations.Count;

            variables = new ParameterExpression[numberOfInvocations];
            var cacheVariablesByValue = new Dictionary <Expression, Expression>(numberOfInvocations);
            var valueExpressions      = new Expression[numberOfInvocations + 1];

            for (var i = 0; i < numberOfInvocations; i++)
            {
                var invocation         = valueInfo.MultiInvocations[i];
                var valueVariableName  = invocation.Type.GetFriendlyName().ToCamelCase() + "Value";
                var valueVariable      = Expression.Variable(invocation.Type, valueVariableName);
                var valueVariableValue = invocation.Replace(cacheVariablesByValue);

                cacheVariablesByValue.Add(invocation, valueVariable);
                variables[i]        = valueVariable;
                valueExpressions[i] = valueVariable.AssignTo(valueVariableValue);
            }

            valueExpressions[numberOfInvocations] = value.Replace(cacheVariablesByValue);
            value = Expression.Block(valueExpressions);
        }