/// <summary>
/// Generate client side code for calling service operations
/// </summary>
/// <param name="expression">The expression.</param>
/// <param name="rootExpression">The root code expression.</param>
/// <returns>The result of visiting this expression.</returns>
public static CodeExpression GenerateClientCode(this QueryCustomFunctionCallExpression expression, CodeExpression rootExpression)
{
// Generate this:
// return base.CreateQuery<entityType>("<Service Operation Name>").AddQueryOption("arg1", argValue1);
var entityType = expression.ExpressionType as QueryEntityType;
if (entityType == null)
{
var collectionType = expression.ExpressionType as QueryCollectionType;
if (collectionType != null)
{
entityType = collectionType.ElementType as QueryEntityType;
}
}
ExceptionUtilities.CheckObjectNotNull(entityType, "Non-entity service operations are not supported");
var codeExpression = rootExpression.Call("CreateQuery", new CodeTypeReference[] { Code.TypeRef(entityType.ClrType) }, Code.Primitive(expression.Function.Name));
for (int i = 0; i < expression.Arguments.Count; ++i)
{
var functionParameter = expression.Function.Parameters[i];
var argValue = (expression.Arguments[i] as QueryConstantExpression).ScalarValue;
if (argValue != null)
{
codeExpression = codeExpression.Call("AddQueryOption", Code.Primitive(functionParameter.Name), Code.Primitive(argValue.Value));
}
}
return(codeExpression);
}
public void EmitPropertyChanged(CodeStatementCollection stmt, CodeExpression storage)
{
if (Decorator.DefiningAsset.EmitPropertyChanged)
{
stmt.Add(storage.Call("PropertyChanged", "this.OffsetProperties + {0}".Expr(Decorator.OffsetProperties)));
}
}
/// <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 override CodeExpression Visit(LinqSelectExpression expression)
{
CodeExpression source = this.GenerateCode(expression.Source);
var lambda = this.GenerateCode(expression.Lambda) as CodeLambdaExpression;
return(source.Call("Select", lambda));
}
public void EmitInterpolationSettings(CodeExpression expr, CodeStatementCollection statements)
{
PropertyStateSettings s = Decorator.Definition.StateAssetSettings;
PropertyCommandSettings c = Decorator.Definition.CommandAssetSettings;
if (s != null)
{
if (s.SmoothingAlgorithm != SmoothingAlgorithms.None)
{
statements.Add(expr.Call("Settings_Interpolation", s.SnapMagnitude.Literal(), true.Literal()));
}
}
if (c != null)
{
if (c.SmoothCorrection)
{
statements.Add(expr.Call("Settings_Interpolation", c.SnapMagnitude.Literal(), false.Literal()));
}
}
}
internal static CodeVariableDeclarationStatement CreatePropertyInfoValueDeclaration(string name, CodeExpression propertyInfo, CodeExpression instance, params CodeExpression[] indexParameters)
{
List <CodeExpression> list = new List <CodeExpression> {
instance
};
if (indexParameters.Length == 0)
{
list.Add(nullEx);
}
else
{
list.Add(new CodeArrayCreateExpression(typeof(object), indexParameters));
}
return(new CodeVariableDeclarationStatement(typeof(object), name, propertyInfo.Call("GetValue", list.ToArray())));
}
/// <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 override CodeExpression Visit(LinqGroupByExpression expression)
{
CodeExpression source = this.GenerateCode(expression.Source);
var keySelector = (CodeLambdaExpression)this.GenerateCode(expression.KeySelector);
var arguments = new List <CodeLambdaExpression>(new[] { keySelector });
if (expression.ElementSelector != null)
{
var elementSelector = (CodeLambdaExpression)this.GenerateCode(expression.ElementSelector);
arguments.Add(elementSelector);
}
if (expression.ResultSelector != null)
{
var resultSelector = (CodeLambdaExpression)this.GenerateCode(expression.ResultSelector);
arguments.Add(resultSelector);
}
return(source.Call("GroupBy", arguments.ToArray()));
}
public static CodeExpression Call(
this CodeExpression targetObject,
String methodName,
params Type[] typeParameters
)
=> targetObject.Call(methodName, typeParameters, new CodeExpression[0]);
public static CodeExpression Call(
this CodeExpression targetObject,
String methodName,
params CodeExpression[] parameters
)
=> targetObject.Call(methodName, new Type[0], parameters);
public static CodeExpression Call(
this CodeExpression targetObject,
String methodName
)
=> targetObject.Call(methodName, new Type[0], new CodeExpression[0]);
internal static CodeExpressionStatement CallS(this CodeExpression callSite, string methodName, params CodeExpression[] parameters)
{
return(new CodeExpressionStatement(callSite.Call(methodName, parameters)));
}
internal static CodeVariableDeclarationStatement CreatePropertyInfoDeclaration(string name, CodeExpression target, string propertyName)
{
return(new CodeVariableDeclarationStatement(typeof(PropertyInfo), name, target.Call("GetType", new CodeExpression[0]).Call("GetProperty", new CodeExpression[] { propertyName.Prim() })));
}
private static CodeStatement GenerateTypeMismatchCheck(CodeExpression variable, string nameValue, CodeTypeReference typeReference, string typeValue, CodeStatement[] elseClause)
{
CodeStatement statement = GenerateReportTypeMismatch(nameValue, typeValue);
return(new CodeConditionStatement(new CodeTypeOfExpression(typeReference).Call("IsAssignableFrom", new CodeExpression[] { variable.Call("GetType", new CodeExpression[0]) }).UnaryNot(), new CodeStatement[] { statement }, elseClause));
}