예제 #1
0
        public static WhenFormulaChangesBuilder <TProp> When <TProp>(this DependencyEngine engine, Expression <Func <TProp> > sourceFunction, string expressionId = null)
        {
            var parameterExpression = Expression.Parameter(typeof(TProp));
            var wrapped             = Expression.Lambda <Func <TProp, TProp> >(sourceFunction.Body, new[] { parameterExpression });

            return(new WhenFormulaChangesBuilder <TProp>(wrapped, expressionId, engine));
        }
예제 #2
0
        public AssignPropertyBuilder(DependencyEngine engine, Expression <Func <T> > targetMemberExpression, string nodeId)
        {
            var memberExpression = targetMemberExpression.Body as MemberExpression;

            if (memberExpression == null)
            {
                throw new ArgumentException("Expression must be a member (field/property) accessor, for example foo.Bar", "targetMemberExpression");
            }

            var propertyInfo = memberExpression.Member as PropertyInfo;
            var fieldInfo    = memberExpression.Member as FieldInfo;

            if (propertyInfo == null && fieldInfo == null)
            {
                throw new ArgumentException("Only fields and properties are supported", "targetMemberExpression");
            }
            if (propertyInfo != null && !propertyInfo.CanWrite)
            {
                throw new ArgumentException("Property must be writable", "targetMemberExpression");
            }
            if (fieldInfo != null && fieldInfo.IsInitOnly)
            {
                throw new ArgumentException("Field cannot be read-only", "targetMemberExpression");
            }

            this.engine            = engine;
            targetMemberDefinition = CreateMemberDefinition(targetMemberExpression, nodeId, true, true);
        }
예제 #3
0
 public WhenFormulaChangesBuilder(Expression <Func <T, T> > sourceFunction, string nodeId, DependencyEngine dependencyEngine)
 {
     this.dependencyEngine = dependencyEngine;
     if (sourceFunction.IsWritable())
     {
         sourceDefinition = CreateMemberDefinition(sourceFunction, nodeId, true, true);
     }
     else
     {
         sourceDefinition = CreateFormulaDefinition(sourceFunction, nodeId, true);
     }
 }
예제 #4
0
 public static AssignPropertyBuilder <TProp> Assign <TProp>(this DependencyEngine engine, Expression <Func <TProp> > targetMemberExpression, string expressionId = null)
 {
     return(new AssignPropertyBuilder <TProp>(engine, targetMemberExpression, expressionId));
 }