public static Activity RecompileVisualBasicReference(ActivityWithResult visualBasicReference, out Type returnType, out SourceExpressionException compileError, out VisualBasicSettings vbSettings) { ITextExpression textExpression = visualBasicReference as ITextExpression; if (textExpression == null || textExpression.Language != VisualBasicHelper.Language) { // the argument must be of type VisualBasicReference<> throw FxTrace.Exception.AsError(new ArgumentException()); } string expressionText = textExpression.ExpressionText; LocationReferenceEnvironment environment = visualBasicReference.GetParentEnvironment(); IList<string> namespaces; IList<string> referencedAssemblies; GetAllImportReferences(visualBasicReference, out namespaces, out referencedAssemblies); return CreatePrecompiledVisualBasicReference( null, expressionText, namespaces, referencedAssemblies, environment, out returnType, out compileError, out vbSettings); }
public static Activity CreatePrecompiledVisualBasicReference(Type targetType, string expressionText, IEnumerable<string> namespaces, IEnumerable<string> referencedAssemblies, LocationReferenceEnvironment environment, out Type returnType, out SourceExpressionException compileError, out VisualBasicSettings vbSettings) { LambdaExpression lambda = null; HashSet<string> namespacesSet = new HashSet<string>(); HashSet<AssemblyName> assembliesSet = new HashSet<AssemblyName>(); compileError = null; returnType = null; if (namespaces != null) { foreach (string ns in namespaces) { if (ns != null) { namespacesSet.Add(ns); } } } if (referencedAssemblies != null) { foreach (string assm in referencedAssemblies) { if (assm != null) { assembliesSet.Add(new AssemblyName(assm)); } } } VisualBasicHelper vbhelper = new VisualBasicHelper(expressionText, assembliesSet, namespacesSet); if (targetType == null) { try { lambda = vbhelper.CompileNonGeneric(environment); if (lambda != null) { // inspect the expressionTree to see if it is a valid location expression(L-value) string extraErrorMessage; if (!ExpressionUtilities.IsLocation(lambda, targetType, out extraErrorMessage)) { string errorMessage = SR.InvalidLValueExpression; if (extraErrorMessage != null) { errorMessage += ":" + extraErrorMessage; } throw FxTrace.Exception.AsError( new SourceExpressionException(SR.CompilerErrorSpecificExpression(expressionText, errorMessage))); } returnType = lambda.ReturnType; } } catch (SourceExpressionException e) { compileError = e; returnType = typeof(object); } targetType = returnType; } else { MethodInfo genericCompileMethod = typeof(VisualBasicHelper).GetMethod("Compile", new Type[] { typeof(LocationReferenceEnvironment) }); genericCompileMethod = genericCompileMethod.MakeGenericMethod(new Type[] { targetType }); try { lambda = (LambdaExpression)genericCompileMethod.Invoke(vbhelper, new object[] { environment }); // inspect the expressionTree to see if it is a valid location expression(L-value) string extraErrorMessage = null; if (!ExpressionUtilities.IsLocation(lambda, targetType, out extraErrorMessage)) { string errorMessage = SR.InvalidLValueExpression; if (extraErrorMessage != null) { errorMessage += ":" + extraErrorMessage; } throw FxTrace.Exception.AsError( new SourceExpressionException(SR.CompilerErrorSpecificExpression(expressionText, errorMessage))); } returnType = targetType; } catch (SourceExpressionException e) { compileError = e; returnType = typeof(object); } catch (TargetInvocationException e) { SourceExpressionException se = e.InnerException as SourceExpressionException; if (se != null) { compileError = se; returnType = typeof(object); } else { throw FxTrace.Exception.AsError(e.InnerException); } } } vbSettings = new VisualBasicSettings(); if (lambda != null) { HashSet<Type> typeReferences = new HashSet<Type>(); FindTypeReferences(lambda.Body, typeReferences); foreach (Type type in typeReferences) { Assembly tassembly = type.Assembly; if (tassembly.IsDynamic) { continue; } string assemblyName = VisualBasicHelper.GetFastAssemblyName(tassembly).Name; VisualBasicImportReference importReference = new VisualBasicImportReference { Assembly = assemblyName, Import = type.Namespace }; vbSettings.ImportReferences.Add(importReference); } } Type concreteHelperType = VisualBasicExpressionFactoryType.MakeGenericType(targetType); VisualBasicExpressionFactory expressionFactory = (VisualBasicExpressionFactory)Activator.CreateInstance(concreteHelperType); return expressionFactory.CreateVisualBasicReference(expressionText); }
public static Activity RecompileVisualBasicValue(ActivityWithResult visualBasicValue, out Type returnType, out SourceExpressionException compileError, out VisualBasicSettings vbSettings) { IVisualBasicExpression expression = visualBasicValue as IVisualBasicExpression; if (expression == null) { throw FxTrace.Exception.AsError(new ArgumentException()); } string expressionText = expression.ExpressionText; LocationReferenceEnvironment parentEnvironment = visualBasicValue.GetParentEnvironment(); HashSet<VisualBasicImportReference> allImportReferences = VisualBasicHelper.GetAllImportReferences((parentEnvironment != null) ? parentEnvironment.Root : null); HashSet<string> namespaces = new HashSet<string>(); HashSet<string> referencedAssemblies = new HashSet<string>(); foreach (VisualBasicImportReference reference in allImportReferences) { namespaces.Add(reference.Import); referencedAssemblies.Add(reference.Assembly); } return CreatePrecompiledVisualBasicValue(null, expressionText, namespaces, referencedAssemblies, parentEnvironment, out returnType, out compileError, out vbSettings); }
private static Activity CreateVBExpression(ExpressionValidationContext context, out string newExpressionText, out Type expReturnType, out SourceExpressionException compileErrorMessages, out VisualBasicSettings vbSettings) { expReturnType = null; newExpressionText = null; compileErrorMessages = null; vbSettings = null; //try easy way first - look if there is a type converter which supports conversion between expression type and string ActivityWithResult literal = null; try { if (!context.UseLocationExpression) { literal = ExpressionHelper.TryCreateLiteral(context.ExpressionType, context.ExpressionText, context.ParserContext); } if (literal != null) { //need to get new expression text - converter might have changed its format, and we want it to be up to date IValueSerializableExpression serializableExpression = literal as IValueSerializableExpression; Fx.Assert(serializableExpression != null, "the expression has to be a Literal<>, which should be IValueSerializableExpression"); if (serializableExpression.CanConvertToString(context.ParserContext)) { bool shouldBeQuoted = typeof(string) == context.ExpressionType || typeof(Uri) == context.ExpressionType; //whether string begins and ends with quotes '"'. also, if there are //more quotes within than those begining and ending ones, do not bother with literal - assume this is an expression. bool isQuotedString = shouldBeQuoted && context.ExpressionText.StartsWith("\"", StringComparison.CurrentCulture) && context.ExpressionText.EndsWith("\"", StringComparison.CurrentCulture) && context.ExpressionText.IndexOf("\"", 1, StringComparison.CurrentCulture) == context.ExpressionText.Length - 1; var formatString = isQuotedString ? "\"{0}\"" : "{0}"; newExpressionText = string.Format(CultureInfo.InvariantCulture, formatString, serializableExpression.ConvertToString(context.ParserContext)); } } } //conversion failed - do nothing, let VB compiler take care of the expression catch { } Activity valueExpression = literal; if (null == valueExpression) { if (!context.UseLocationExpression) { //Compile for validation. valueExpression = VisualBasicDesignerHelper.CreatePrecompiledVisualBasicValue(context.ExpressionType, context.ExpressionText, context.ParserContext.Namespaces, context.ReferencedAssemblies, context.ParserContext, out expReturnType, out compileErrorMessages, out vbSettings); } else { //Compile for validation. valueExpression = VisualBasicDesignerHelper.CreatePrecompiledVisualBasicReference(context.ExpressionType, context.ExpressionText, context.ParserContext.Namespaces, context.ReferencedAssemblies, context.ParserContext, out expReturnType, out compileErrorMessages, out vbSettings); } ////It's possible the inferred type of expression is a dynamic type (e.g. delegate type), in this case it will cause serialization failure. ////To prevent this, we'll always convert the expression type to be object if the inferred type is in dynamic assembly and user doesn't specify any ExpressionType property if ((expReturnType.Assembly.IsDynamic) && (context.ExpressionType == null)) { ActivityWithResult originalExpression = valueExpression as ActivityWithResult; ActivityWithResult morphedExpression; if (ExpressionHelper.TryMorphExpression(originalExpression, ExpressionHelper.IsGenericLocationExpressionType(originalExpression), typeof(object), context.EditingContext, out morphedExpression)) { valueExpression = morphedExpression; } } } return valueExpression; }
public static Activity CreatePrecompiledVisualBasicReference(Type targetType, string expressionText, IEnumerable<string> namespaces, IEnumerable<string> referencedAssemblies, LocationReferenceEnvironment environment, out Type returnType, out SourceExpressionException compileError, out VisualBasicSettings vbSettings) { LambdaExpression expression = null; HashSet<string> namespaceImportsNames = new HashSet<string>(); HashSet<AssemblyName> refAssemNames = new HashSet<AssemblyName>(); compileError = null; returnType = null; if (namespaces != null) { foreach (string str in namespaces) { if (str != null) { namespaceImportsNames.Add(str); } } } if (referencedAssemblies != null) { foreach (string str2 in referencedAssemblies) { if (str2 != null) { refAssemNames.Add(new AssemblyName(str2)); } } } VisualBasicHelper helper = new VisualBasicHelper(expressionText, refAssemNames, namespaceImportsNames); if (targetType == null) { try { expression = helper.CompileNonGeneric(environment); if (expression != null) { string str3; if (!ExpressionUtilities.IsLocation(expression, targetType, out str3)) { string invalidLValueExpression = System.Activities.SR.InvalidLValueExpression; if (str3 != null) { invalidLValueExpression = invalidLValueExpression + ":" + str3; } throw FxTrace.Exception.AsError(new SourceExpressionException(System.Activities.SR.CompilerErrorSpecificExpression(expressionText, invalidLValueExpression))); } returnType = expression.ReturnType; } } catch (SourceExpressionException exception) { compileError = exception; returnType = typeof(object); } targetType = returnType; } else { MethodInfo info = typeof(VisualBasicHelper).GetMethod("Compile", new Type[] { typeof(LocationReferenceEnvironment) }).MakeGenericMethod(new Type[] { targetType }); try { expression = (LambdaExpression) info.Invoke(helper, new object[] { environment }); string extraErrorMessage = null; if (!ExpressionUtilities.IsLocation(expression, targetType, out extraErrorMessage)) { string str6 = System.Activities.SR.InvalidLValueExpression; if (extraErrorMessage != null) { str6 = str6 + ":" + extraErrorMessage; } throw FxTrace.Exception.AsError(new SourceExpressionException(System.Activities.SR.CompilerErrorSpecificExpression(expressionText, str6))); } returnType = targetType; } catch (SourceExpressionException exception2) { compileError = exception2; returnType = typeof(object); } catch (TargetInvocationException exception3) { SourceExpressionException innerException = exception3.InnerException as SourceExpressionException; if (innerException == null) { throw FxTrace.Exception.AsError(exception3.InnerException); } compileError = innerException; returnType = typeof(object); } } vbSettings = new VisualBasicSettings(); if (expression != null) { HashSet<Type> typeReferences = new HashSet<Type>(); FindTypeReferences(expression.Body, typeReferences); foreach (Type type in typeReferences) { Assembly assembly = type.Assembly; if (!assembly.IsDynamic) { string name = VisualBasicHelper.GetFastAssemblyName(assembly).Name; VisualBasicImportReference item = new VisualBasicImportReference { Assembly = name, Import = type.Namespace }; vbSettings.ImportReferences.Add(item); } } } VisualBasicExpressionFactory factory = (VisualBasicExpressionFactory) Activator.CreateInstance(VisualBasicExpressionFactoryType.MakeGenericType(new Type[] { targetType })); return factory.CreateVisualBasicReference(expressionText); }