/// <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)));
}
