/// <summary> /// Resolves types for the specified expression. /// </summary> /// <param name="expression">The expression to resolve types for.</param> /// <returns>Expression with resolved types.</returns> public QueryExpression Visit(LinqNewInstanceExpression expression) { var constructorArguments = expression.ConstructorArguments.Select(this.ResolveTypes).ToList(); var members = expression.Members.Select(this.ResolveTypes).ToList(); return(LinqBuilder.NewInstance(constructorArguments, expression.MemberNames, members, expression.ExpressionType)); }
/// <summary> /// Evaluates the specified expression. /// </summary> /// <param name="expression">The expression to evaluate.</param> /// <returns>Value of the expression.</returns> public override QueryValue Visit(LinqNewInstanceExpression expression) { ExceptionUtilities.CheckArgumentNotNull(expression, "expression"); if (expression.ExpressionType is AstoriaQueryStreamType) { // Handle expressions like: new DataServiceStreamLink(c, "Photo") const int ExpectedArgumentCount = 2; int actualArgumentCount = expression.ConstructorArguments.Count; ExceptionUtilities.Assert( actualArgumentCount == ExpectedArgumentCount, "Expected {0} arguments in the constructor. Actual: {1}", ExpectedArgumentCount, actualArgumentCount); var source = (QueryStructuralValue)this.Evaluate(expression.ConstructorArguments[0]); string streamName = (string)((QueryScalarValue)this.Evaluate(expression.ConstructorArguments[1])).Value; return(source.GetValue(streamName)); } else { return(base.Visit(expression)); } }
/// <summary> /// Visits a QueryExpression tree whose root node is the LinqSelectExpression. /// </summary> /// <param name="expression">The root node of the expression tree being visited.</param> /// <returns>Uri query string representing the expression.</returns> public override string Visit(LinqSelectExpression expression) { string source = this.ComputeUriInternal(expression.Source); LinqNewExpression newExpression = expression.Lambda.Body as LinqNewExpression; LinqNewInstanceExpression newInstanceExpression = expression.Lambda.Body as LinqNewInstanceExpression; QueryPropertyExpression propertyExpression = expression.Lambda.Body as QueryPropertyExpression; string select = string.Empty; if (propertyExpression != null) { return(string.Format(CultureInfo.InvariantCulture, "{0}/{1}", source, propertyExpression.Name)); } else if (newExpression != null) { select = this.ExpressionConverter.Convert(newExpression); this.SetSelectQueryOption(select); this.hasQueryOption = true; return(string.Format(CultureInfo.InvariantCulture, "{0}{1}", source, string.Empty)); } else if (newInstanceExpression != null) { select = this.ExpressionConverter.Convert(newInstanceExpression); this.SetSelectQueryOption(select); this.hasQueryOption = true; return(string.Format(CultureInfo.InvariantCulture, "{0}{1}", source, string.Empty)); } return(source); }
/// <summary> /// Replaces the given expression. /// </summary> /// <param name="expression">The root node of the expression tree being visited.</param> /// <returns>Replaced expression.</returns> public virtual QueryExpression Visit(LinqNewInstanceExpression expression) { QueryExpression[] members = expression.Members.Select(this.ReplaceExpression).ToArray(); QueryExpression[] constructorArguments = expression.ConstructorArguments.Select(this.ReplaceExpression).ToArray(); if (HasChanged(expression.Members, members) || HasChanged(expression.ConstructorArguments, constructorArguments)) { return(LinqBuilder.NewInstance(constructorArguments, expression.MemberNames, members, expression.ExpressionType)); } return(expression); }
/// <summary> /// Generates System.CodeDom.CodeExpression from the given expression. /// </summary> /// <param name="expression">Expression from which System.CodeDom.CodeExpression is generated.</param> /// <returns>Generated System.CodeDom.CodeExpression.</returns> public virtual CodeExpression Visit(LinqNewInstanceExpression expression) { CodeCreateAndInitializeObjectExpression result = null; var constructorArguments = expression.ConstructorArguments.Select(this.GenerateCode); result = new CodeCreateAndInitializeObjectExpression(constructorArguments.ToArray()); var queryClrType = expression.ExpressionType as IQueryClrType; ExceptionUtilities.CheckObjectNotNull(queryClrType, "Type must implement " + typeof(IQueryClrType).Name + "interface: " + expression.ExpressionType + "."); CodeTypeReference entityTypeReference = Code.TypeRef(queryClrType.ClrType); result.ObjectType = entityTypeReference; for (int i = 0; i < expression.Members.Count; i++) { CodeExpression member = this.GenerateCode(expression.Members[i]); member = this.FixupPropertyForPropertyInitializer(expression, expression.MemberNames[i], expression.Members[i], member); result.PropertyInitializers.Add(new KeyValuePair <string, CodeExpression>(expression.MemberNames[i], member)); } return(result); }
/// <summary> /// Evaluates the specified expression. /// </summary> /// <param name="expression">The expression to evaluate.</param> /// <returns>Value of the expression.</returns> public virtual QueryValue Visit(LinqNewInstanceExpression expression) { if (expression.ExpressionType is QueryStructuralType) { QueryStructuralType queryType = (QueryStructuralType)expression.ExpressionType; QueryStructuralValue instance = queryType.CreateNewInstance(); foreach (var property in queryType.Properties.Where(p => !(p.PropertyType is QueryScalarType))) { instance.SetValue(property.Name, property.PropertyType.DefaultValue); } for (int i = 0; i < expression.Members.Count; ++i) { instance.SetValue(expression.MemberNames[i], this.Evaluate(expression.Members[i])); } return(instance); } else if (expression.ExpressionType is QueryCollectionType) { // for QueryCollectionTypes we only support constructor arguments, hence we will only be evaluating constructor arguments. QueryCollectionValue instance = ((QueryCollectionType)expression.ExpressionType).CreateCollectionWithValues(expression.ConstructorArguments.Select(arg => this.Evaluate(arg))); return(instance); } else { var scalarType = expression.ExpressionType as QueryScalarType; ExceptionUtilities.CheckObjectNotNull(scalarType, "QueryType is not a supported type"); ExceptionUtilities.Assert(expression.ConstructorArguments.Count == 1, "Cannot pass multiple arguments to PrimitiveType constructor"); var constructorArgument = expression.ConstructorArguments.Select(this.Evaluate).Single(); QueryScalarValue instance = scalarType.CreateValue(constructorArgument); return(instance); } }
/// <summary> /// Visits a QueryExpression tree whose root node is the LinqNewInstanceExpression. /// </summary> /// <param name="expression">The root node of the expression tree being visited.</param> /// <returns>Uri query string representing the expression.</returns> public override string Visit(LinqNewInstanceExpression expression) { return this.Convert(LinqBuilder.New(expression.MemberNames, expression.Members)); }
/// <summary> /// Visits a QueryExpression tree whose root node is the LinqNewInstanceExpression. /// </summary> /// <param name="expression">The root node of the expression tree being visited.</param> /// <returns>Uri query string representing the expression.</returns> public virtual string Visit(LinqNewInstanceExpression expression) { throw new TaupoNotSupportedException("Not supported"); }
/// <summary> /// Visits a QueryExpression tree whose root node is the LinqNewInstanceExpression. /// </summary> /// <param name="expression">The root node of the expression tree being visited.</param> /// <returns>Uri query string representing the expression.</returns> public override string Visit(LinqNewInstanceExpression expression) { return(this.Convert(LinqBuilder.New(expression.MemberNames, expression.Members))); }