// create a pre-compiled VBValueExpression, and also provides expressin type back to the caller.
//[SuppressMessage(FxCop.Category.Design, FxCop.Rule.AvoidOutParameters,
// Justification = "Design has been approved")]
public static Activity CreatePrecompiledVisualBasicValue(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)
{
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 });
returnType = targetType;
}
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.CreateVisualBasicValue(expressionText));
}
public static Activity CreatePrecompiledVisualBasicValue(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)
{
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 });
returnType = targetType;
}
catch (TargetInvocationException exception2)
{
SourceExpressionException innerException = exception2.InnerException as SourceExpressionException;
if (innerException == null)
{
throw FxTrace.Exception.AsError(exception2.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.CreateVisualBasicValue(expressionText));
}
