protected override IDataContextStack CreateDataContextTypeStack(ITypeDescriptor viewModelType, ITypeDescriptor wrapperType = null, IDataContextStack parentDataContextStack = null, IReadOnlyList <NamespaceImport> namespaceImports = null)
{
return(new DataContextStack(
ResolvedTypeDescriptor.ToSystemType(viewModelType),
parentDataContextStack as DataContextStack,
ResolvedTypeDescriptor.ToSystemType(wrapperType), namespaceImports));
}
protected override IDataContextStack CreateDataContextTypeStack(ITypeDescriptor viewModelType, IDataContextStack parentDataContextStack = null, IReadOnlyList <NamespaceImport> namespaceImports = null, IReadOnlyList <BindingExtensionParameter> extensionParameters = null)
{
return(DataContextStack.Create(
ResolvedTypeDescriptor.ToSystemType(viewModelType),
parentDataContextStack as DataContextStack,
namespaceImports, extensionParameters));
}
public override Expression GetServerEquivalent(Expression controlParameter)
{
var type = ResolvedTypeDescriptor.ToSystemType(this.ParameterType);
var expr = ExpressionUtils.Replace((DotvvmBindableObject c) => ResolveStaticCommandService(c, type), controlParameter);
return(Expression.Convert(expr, type));
}
static ParameterExpression CreateParameter(DataContextStack stackItem, string name, BindingExtensionParameter extensionParameter = null) =>
Expression.Parameter(
(extensionParameter == null
? stackItem.DataContextType
: ResolvedTypeDescriptor.ToSystemType(extensionParameter.ParameterType))
?? typeof(ExpressionHelper.UnknownTypeSentinel)
, name)
.AddParameterAnnotation(new BindingParameterAnnotation(stackItem, extensionParameter));
public static Type?GetEnumerableType(this Type collectionType)
{
var result = TypeDescriptorUtils.GetCollectionItemType(new ResolvedTypeDescriptor(collectionType));
if (result == null)
{
return(null);
}
return(ResolvedTypeDescriptor.ToSystemType(result));
}
public void ResolvedTree_SingleControl_HtmlAttributeWithBinding()
{
var root = ParseSource(@"@viewModel System.String, mscorlib
<dot:Button class='{value: Length}' />");
var control = root.Content.First();
var attribute = ((ResolvedPropertyBinding)control.GetHtmlAttribute("class"));
attribute.Binding.GetExpression();
Assert.AreEqual(typeof(int), ResolvedTypeDescriptor.ToSystemType(attribute.Binding.ResultType));
Assert.AreEqual(root, control.Parent);
Assert.AreEqual(attribute, attribute.Binding.Parent);
Assert.AreEqual(control, attribute.Parent);
}
public void ResolvedTree_SingleControlWithBinding_ValidBinding()
{
var root = ParseSource(@"@viewModel System.String, mscorlib
<dot:Button Text='{value: Length}' />");
var control = root.Content.First();
var textBinding = (ResolvedPropertyBinding)control.Properties[ButtonBase.TextProperty];
textBinding.Binding.GetExpression();
Assert.AreEqual(typeof(int), ResolvedTypeDescriptor.ToSystemType(textBinding.Binding.ResultType));
Assert.AreEqual(root, control.Parent);
Assert.AreEqual(control, textBinding.Parent);
Assert.AreEqual(textBinding, textBinding.Binding.Parent);
}
public override IDataContextStack ChangeStackForChildren(IDataContextStack original, IAbstractControl control, IPropertyDescriptor property, Func <IDataContextStack, ITypeDescriptor, IDataContextStack> createNewFrame)
{
return(DataContextStack.Create(ResolvedTypeDescriptor.ToSystemType(original.DataContextType), (DataContextStack)original.Parent,
bindingPropertyResolvers: new Delegate[] {
new Func <ParsedExpressionBindingProperty, ParsedExpressionBindingProperty>(e => {
if (e.Expression.NodeType == ExpressionType.Constant && (string)((ConstantExpression)e.Expression).Value == "abc")
{
return new ParsedExpressionBindingProperty(Expression.Constant("def"));
}
else
{
return e;
}
})
}));
}
public static void OnCompilation(ResolvedControl control, BindingCompilationService bindingService)
{
// ComboBoxed does not have to have the DataSource property and then they don't use the CurrentIndexBindingProperty
if (!control.HasProperty(DataSourceProperty))
{
return;
}
var dcChange = ControlTreeResolverBase.ApplyContextChange(control.DataContextTypeStack,
new DataContextChangeAttribute[] { new ControlPropertyBindingDataContextChangeAttribute(nameof(DataSource)), new CollectionElementDataContextChangeAttribute(0) },
control, null);
var dataContext = DataContextStack.Create(ResolvedTypeDescriptor.ToSystemType(dcChange.type), control.DataContextTypeStack, extenstionParameters: dcChange.extensionParameters);
control.SetProperty(new ResolvedPropertyBinding(Internal.CurrentIndexBindingProperty,
new ResolvedBinding(bindingService, new Compilation.BindingParserOptions(typeof(ValueBindingExpression)), dataContext,
parsedExpression: Expression.Parameter(typeof(int), "_index").AddParameterAnnotation(
new BindingParameterAnnotation(dataContext, new CurrentCollectionIndexExtensionParameter())))));
}
public override JsExpression GetJsTranslation(JsExpression dataContext)
{
return(dataContext.Member("$control").WithAnnotation(new ViewModelInfoAnnotation(ResolvedTypeDescriptor.ToSystemType(this.ParameterType), isControl: true)));
}
public override Expression GetServerEquivalent(Expression controlParameter)
{
return(Expression.Convert(ExpressionUtils.Replace((DotvvmBindableObject c) => c.GetClosestControlBindingTarget(), controlParameter), ResolvedTypeDescriptor.ToSystemType(ParameterType)));
}
protected override IControlType CreateControlType(ITypeDescriptor wrapperType, string virtualPath)
{
return(new ControlType(ResolvedTypeDescriptor.ToSystemType(wrapperType), virtualPath: virtualPath));
}
/// This is a strange conversion that wraps the entire expression into a Lambda
/// and makes an invokable delegate from a normal expression.
/// It also replaces special ExtensionParameters attached to the expression for lambda parameters
public static Expression MagicLambdaConversion(Expression expr, Type expectedType)
{
if (expectedType.IsDelegate())
{
var resultType = expectedType.GetMethod("Invoke").ReturnType;
var delegateArgs = expectedType
.GetMethod("Invoke")
.GetParameters()
.Select(p => Expression.Parameter(p.ParameterType, p.Name))
.ToArray();
var convertedToResult = TypeConversion.ImplicitConversion(expr, resultType) ?? TaskConversion(expr, resultType);
// TODO: convert delegates to another delegates
if (convertedToResult == null)
{
return(null);
}
else
{
var replacedArgs = convertedToResult.ReplaceAll(arg =>
arg?.GetParameterAnnotation()?.ExtensionParameter is MagicLambdaConversionExtensionParameter extensionParam ?
delegateArgs.Single(a => a.Name == extensionParam.Identifier)
.Assert(p => p.Type == ResolvedTypeDescriptor.ToSystemType(extensionParam.ParameterType)) :
arg
);
return(Expression.Lambda(
expectedType,
replacedArgs,
delegateArgs
));
}
}
else
{
return(null);
}
}
private (StaticCommandInvocationPlan plan, JsExpression[] clientArgs) CreateExecutionPlan(MethodCallExpression expression, DataContextStack dataContext)
{
var arguments = (expression.Object == null ? new Expression[0] : new[] { expression.Object }).Concat(expression.Arguments).ToArray();
var clientArgs = new List <JsExpression>();
var argPlans = arguments.Select((arg, index) => {
if (arg.GetParameterAnnotation() is BindingParameterAnnotation annotation && annotation.ExtensionParameter is InjectedServiceExtensionParameter service)
{
return(new StaticCommandParameterPlan(StaticCommandParameterType.Inject, ResolvedTypeDescriptor.ToSystemType(service.ParameterType)));
}