Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / WF / Common / AuthoringOM / Compiler / XomlCompiler.cs / 1305376 / XomlCompiler.cs
namespace System.Workflow.ComponentModel.Compiler
{
#region Imports
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Collections.Generic;
using System.CodeDom;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.CodeDom.Compiler;
using System.Reflection;
using System.ComponentModel.Design.Serialization;
using System.Xml;
using System.Globalization;
using System.IO;
using System.Text;
using System.Diagnostics;
using System.Text.RegularExpressions;
using Microsoft.CSharp;
using Microsoft.VisualBasic;
using System.Workflow.ComponentModel.Design;
using System.Workflow.ComponentModel.Serialization;
using System.Security.Policy;
using System.Runtime.Versioning;
using System.Configuration;
using System.Collections.ObjectModel;
#endregion
#region WorkflowMarkupSourceAttribute Class
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
public sealed class WorkflowMarkupSourceAttribute : Attribute
{
private string fileName;
private string md5Digest;
public WorkflowMarkupSourceAttribute(string fileName, string md5Digest)
{
this.fileName = fileName;
this.md5Digest = md5Digest;
}
public string FileName
{
get
{
return this.fileName;
}
}
public string MD5Digest
{
get
{
return this.md5Digest;
}
}
}
#endregion
#region Interface IWorkflowCompilerOptionsService
public interface IWorkflowCompilerOptionsService
{
string RootNamespace { get; }
string Language { get; }
bool CheckTypes { get; }
}
public class WorkflowCompilerOptionsService : IWorkflowCompilerOptionsService
{
internal const string DefaultLanguage = "CSharp";
public virtual string RootNamespace
{
get
{
return string.Empty;
}
}
public virtual string Language
{
get
{
return WorkflowCompilerOptionsService.DefaultLanguage;
}
}
public virtual bool CheckTypes
{
get
{
return false;
}
}
public virtual string TargetFrameworkMoniker
{
get
{
return string.Empty;
}
}
}
#endregion
#region WorkflowCompilationContext
public sealed class WorkflowCompilationContext
{
[ThreadStatic]
static WorkflowCompilationContext current = null;
ContextScope scope;
ReadOnlyCollection authorizedTypes;
WorkflowCompilationContext(ContextScope scope)
{
this.scope = scope;
}
public static WorkflowCompilationContext Current
{
get
{
return WorkflowCompilationContext.current;
}
private set
{
WorkflowCompilationContext.current = value;
}
}
public string RootNamespace
{
get
{
return this.scope.RootNamespace;
}
}
public string Language
{
get
{
return this.scope.Language;
}
}
public bool CheckTypes
{
get
{
return this.scope.CheckTypes;
}
}
internal FrameworkName TargetFramework
{
get
{
return this.scope.TargetFramework;
}
}
internal Version TargetFrameworkVersion
{
get
{
FrameworkName fx = this.scope.TargetFramework;
if (fx != null)
{
return fx.Version;
}
else
{
return MultiTargetingInfo.DefaultTargetFramework;
}
}
}
internal IServiceProvider ServiceProvider
{
get
{
return this.scope;
}
}
public static IDisposable CreateScope(IServiceProvider serviceProvider)
{
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
IWorkflowCompilerOptionsService optionsService = serviceProvider.GetService(typeof(IWorkflowCompilerOptionsService)) as IWorkflowCompilerOptionsService;
if (optionsService != null)
{
return CreateScope(serviceProvider, optionsService);
}
else
{
return new DefaultContextScope(serviceProvider);
}
}
public IList GetAuthorizedTypes()
{
if (this.authorizedTypes == null)
{
try
{
IList authorizedTypes;
IDictionary> authorizedTypesDictionary =
ConfigurationManager.GetSection("System.Workflow.ComponentModel.WorkflowCompiler/authorizedTypes") as IDictionary>;
if (authorizedTypesDictionary.TryGetValue("v" + this.TargetFrameworkVersion.ToString(), out authorizedTypes))
{
this.authorizedTypes = new ReadOnlyCollection(authorizedTypes);
}
}
catch
{
}
}
return this.authorizedTypes;
}
internal static IDisposable CreateScope(IServiceProvider serviceProvider, WorkflowCompilerParameters parameters)
{
return new ParametersContextScope(serviceProvider, parameters);
}
static IDisposable CreateScope(IServiceProvider serviceProvider, IWorkflowCompilerOptionsService optionsService)
{
WorkflowCompilerOptionsService standardService = optionsService as WorkflowCompilerOptionsService;
if (standardService != null)
{
return new StandardContextScope(serviceProvider, standardService);
}
else
{
return new InterfaceContextScope(serviceProvider, optionsService);
}
}
abstract class ContextScope : IDisposable, IServiceProvider
{
IServiceProvider serviceProvider;
WorkflowCompilationContext currentContext;
bool disposed;
protected ContextScope(IServiceProvider serviceProvider)
{
this.serviceProvider = serviceProvider;
this.currentContext = WorkflowCompilationContext.Current;
WorkflowCompilationContext.Current = new WorkflowCompilationContext(this);
}
~ContextScope()
{
DisposeImpl();
}
public abstract string RootNamespace { get; }
public abstract string Language { get; }
public abstract bool CheckTypes { get; }
public abstract FrameworkName TargetFramework { get; }
public void Dispose()
{
DisposeImpl();
GC.SuppressFinalize(this);
}
public object GetService(Type serviceType)
{
return this.serviceProvider.GetService(serviceType);
}
void DisposeImpl()
{
if (!this.disposed)
{
WorkflowCompilationContext.Current = this.currentContext;
this.disposed = true;
}
}
}
class InterfaceContextScope : ContextScope
{
IWorkflowCompilerOptionsService service;
public InterfaceContextScope(IServiceProvider serviceProvider, IWorkflowCompilerOptionsService service)
: base(serviceProvider)
{
this.service = service;
}
public override string RootNamespace
{
get
{
return this.service.RootNamespace;
}
}
public override string Language
{
get
{
return this.service.Language;
}
}
public override bool CheckTypes
{
get
{
return this.service.CheckTypes;
}
}
public override FrameworkName TargetFramework
{
get
{
return null;
}
}
}
class StandardContextScope : ContextScope
{
WorkflowCompilerOptionsService service;
FrameworkName fxName;
public StandardContextScope(IServiceProvider serviceProvider, WorkflowCompilerOptionsService service)
: base(serviceProvider)
{
this.service = service;
}
public override string RootNamespace
{
get
{
return this.service.RootNamespace;
}
}
public override string Language
{
get
{
return this.service.Language;
}
}
public override bool CheckTypes
{
get
{
return this.service.CheckTypes;
}
}
public override FrameworkName TargetFramework
{
get
{
if (this.fxName == null)
{
string fxName = this.service.TargetFrameworkMoniker;
if (!string.IsNullOrEmpty(fxName))
{
this.fxName = new FrameworkName(fxName);
}
}
return this.fxName;
}
}
}
class ParametersContextScope : ContextScope
{
WorkflowCompilerParameters parameters;
public ParametersContextScope(IServiceProvider serviceProvider, WorkflowCompilerParameters parameters)
: base(serviceProvider)
{
this.parameters = parameters;
}
public override string RootNamespace
{
get
{
return WorkflowCompilerParameters.ExtractRootNamespace(this.parameters);
}
}
public override string Language
{
get
{
return this.parameters.LanguageToUse;
}
}
public override bool CheckTypes
{
get
{
return this.parameters.CheckTypes;
}
}
public override FrameworkName TargetFramework
{
get
{
if (this.parameters.MultiTargetingInformation != null)
{
return this.parameters.MultiTargetingInformation.TargetFramework;
}
else
{
return null;
}
}
}
}
class DefaultContextScope : ContextScope
{
public DefaultContextScope(IServiceProvider serviceProvider)
: base(serviceProvider)
{
}
public override string RootNamespace
{
get
{
return string.Empty;
}
}
public override string Language
{
get
{
return WorkflowCompilerOptionsService.DefaultLanguage;
}
}
public override bool CheckTypes
{
get
{
return false;
}
}
public override FrameworkName TargetFramework
{
get
{
return null;
}
}
}
}
#endregion
#region Class WorkflowCompiler
public sealed class WorkflowCompiler
{
public WorkflowCompilerResults Compile(WorkflowCompilerParameters parameters, params string[] files)
{
if (parameters == null)
throw new ArgumentNullException("parameters");
if (files == null)
throw new ArgumentNullException("files");
AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation;
setup.LoaderOptimization = LoaderOptimization.MultiDomainHost;
AppDomain compilerDomain = AppDomain.CreateDomain("CompilerDomain", null, setup);
bool generateInMemory = false;
string originalOutputAssembly = parameters.OutputAssembly;
try
{
if (parameters.GenerateInMemory)
{
generateInMemory = true;
parameters.GenerateInMemory = false;
if (string.IsNullOrEmpty(parameters.OutputAssembly))
parameters.OutputAssembly = Path.GetTempFileName() + ".dll";
else
{
while (true)
{
try
{
DirectoryInfo info = Directory.CreateDirectory(Path.GetTempPath() + "\\" + Guid.NewGuid());
parameters.OutputAssembly = info.FullName + "\\" + parameters.OutputAssembly;
break;
}
catch
{
}
}
}
}
WorkflowCompilerInternal compiler = (WorkflowCompilerInternal)compilerDomain.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, typeof(WorkflowCompilerInternal).FullName);
WorkflowCompilerResults results = compiler.Compile(parameters, files);
if (generateInMemory && !results.Errors.HasErrors)
{
results.CompiledAssembly = Assembly.Load(File.ReadAllBytes(results.PathToAssembly));
results.PathToAssembly = null;
// Delete the file and directory.
try
{
File.Delete(parameters.OutputAssembly);
Directory.Delete(Path.GetDirectoryName(parameters.OutputAssembly));
}
catch
{ }
}
return results;
}
finally
{
string outputAssembly = parameters.OutputAssembly;
if (generateInMemory)
{
parameters.GenerateInMemory = true;
parameters.OutputAssembly = originalOutputAssembly;
}
AppDomain.Unload(compilerDomain);
// The temp file must be deleted after the app domain is unloaded, or else it will
// be "busy", causing the delete to throw an access exception.
if (generateInMemory)
{
try
{
File.Delete(outputAssembly);
}
catch
{ }
}
}
}
}
#endregion
#region Class WorkflowCompilerInternal
internal sealed class WorkflowCompilerInternal : MarshalByRefObject
{
#region Lifetime service
public override object InitializeLifetimeService()
{
return null;
}
#endregion
#region File based compilation
public WorkflowCompilerResults Compile(WorkflowCompilerParameters parameters, string[] allFiles)
{
WorkflowCompilerResults results = new WorkflowCompilerResults(parameters.TempFiles);
// Split the xoml files from cs/vb files.
StringCollection xomlFiles = new StringCollection();
StringCollection userCodeFiles = new StringCollection();
foreach (string file in allFiles)
{
if (file.EndsWith(".xoml", StringComparison.OrdinalIgnoreCase))
xomlFiles.Add(file);
else
userCodeFiles.Add(file);
}
string[] files = new string[xomlFiles.Count];
xomlFiles.CopyTo(files, 0);
string[] codeFiles = new string[userCodeFiles.Count];
userCodeFiles.CopyTo(codeFiles, 0);
string mscorlibPath = typeof(object).Assembly.Location;
ServiceContainer serviceContainer = new ServiceContainer();
MultiTargetingInfo mtInfo = parameters.MultiTargetingInformation;
if (mtInfo == null)
{
XomlCompilerHelper.FixReferencedAssemblies(parameters, results, parameters.LibraryPaths);
}
string mscorlibName = Path.GetFileName(mscorlibPath);
// Add assembly resolver.
ReferencedAssemblyResolver resolver = new ReferencedAssemblyResolver(parameters.ReferencedAssemblies, parameters.LocalAssembly);
AppDomain.CurrentDomain.AssemblyResolve += resolver.ResolveEventHandler;
// prepare service container
TypeProvider typeProvider = new TypeProvider(new ServiceContainer());
int mscorlibIndex = -1;
if ((parameters.ReferencedAssemblies != null) && (parameters.ReferencedAssemblies.Count > 0))
{
for (int i = 0; i < parameters.ReferencedAssemblies.Count; i++)
{
string assemblyPath = parameters.ReferencedAssemblies[i];
if ((mscorlibIndex == -1) && (string.Compare(mscorlibName, Path.GetFileName(assemblyPath), StringComparison.OrdinalIgnoreCase) == 0))
{
mscorlibIndex = i;
mscorlibPath = assemblyPath;
}
typeProvider.AddAssemblyReference(assemblyPath);
}
}
// a note about references to mscorlib:
// If we found mscorlib in the list of reference assemblies, we should remove it prior to sending it to the CodeDOM compiler.
// The CodeDOM compiler would add the right mscorlib [based on the version of the provider we use] and the duplication would
// cause a compilation error.
// If we didn't found a reference to mscorlib we need to add it to the type-provider, though, so we will support exposing
// those known types.
if (mscorlibIndex != -1)
{
parameters.ReferencedAssemblies.RemoveAt(mscorlibIndex);
}
else
{
typeProvider.AddAssemblyReference(mscorlibPath);
}
serviceContainer.AddService(typeof(ITypeProvider), typeProvider);
TempFileCollection intermediateTempFiles = null;
string localAssemblyPath = string.Empty;
try
{
using (WorkflowCompilationContext.CreateScope(serviceContainer, parameters))
{
parameters.LocalAssembly = GenerateLocalAssembly(files, codeFiles, parameters, results, out intermediateTempFiles, out localAssemblyPath);
if (parameters.LocalAssembly != null)
{
// WinOE Bug 17591: we must set the local assembly here,
// otherwise, the resolver won't be able to resolve custom types correctly.
resolver.SetLocalAssembly(parameters.LocalAssembly);
// Work around HERE!!!
// prepare type provider
typeProvider.SetLocalAssembly(parameters.LocalAssembly);
typeProvider.AddAssembly(parameters.LocalAssembly);
results.Errors.Clear();
XomlCompilerHelper.InternalCompileFromDomBatch(files, codeFiles, parameters, results, localAssemblyPath);
}
}
}
catch (Exception e)
{
results.Errors.Add(new WorkflowCompilerError(String.Empty, -1, -1, ErrorNumbers.Error_UnknownCompilerException.ToString(CultureInfo.InvariantCulture), SR.GetString(SR.Error_CompilationFailed, e.Message)));
}
finally
{
// Delate the temp files.
if (intermediateTempFiles != null && parameters.TempFiles.KeepFiles == false)
{
string tempAssemblyDirectory = string.Empty;
if (File.Exists(localAssemblyPath))
tempAssemblyDirectory = Path.GetDirectoryName(localAssemblyPath);
foreach (string file in intermediateTempFiles)
{
try
{
System.IO.File.Delete(file);
}
catch
{
}
}
try
{
if (!string.IsNullOrEmpty(tempAssemblyDirectory))
Directory.Delete(tempAssemblyDirectory);
}
catch
{
}
}
}
return results;
}
#endregion
#region Code for Generating Local Assembly
private static ValidationErrorCollection ValidateIdentifiers(IServiceProvider serviceProvider, Activity activity)
{
ValidationErrorCollection validationErrors = new ValidationErrorCollection();
Dictionary names = new Dictionary();
Walker walker = new Walker();
walker.FoundActivity += delegate(Walker walker2, WalkerEventArgs e)
{
Activity currentActivity = e.CurrentActivity;
if (!currentActivity.Enabled)
{
e.Action = WalkerAction.Skip;
return;
}
ValidationError identifierError = null;
if (names.ContainsKey(currentActivity.QualifiedName))
{
if (names[currentActivity.QualifiedName] != 1)
{
identifierError = new ValidationError(SR.GetString(SR.Error_DuplicatedActivityID, currentActivity.QualifiedName), ErrorNumbers.Error_DuplicatedActivityID, false, "Name");
identifierError.UserData[typeof(Activity)] = currentActivity;
validationErrors.Add(identifierError);
names[currentActivity.QualifiedName] = 1;
}
return;
}
// Undone: AkashS - remove this check when we allow root activities to not have a name.
if (!string.IsNullOrEmpty(currentActivity.Name))
{
names[currentActivity.Name] = 0;
identifierError = ValidationHelpers.ValidateIdentifier("Name", serviceProvider, currentActivity.Name);
if (identifierError != null)
{
identifierError.UserData[typeof(Activity)] = currentActivity;
validationErrors.Add(identifierError);
}
}
};
walker.Walk(activity as Activity);
return validationErrors;
}
private Assembly GenerateLocalAssembly(string[] files, string[] codeFiles, WorkflowCompilerParameters parameters, WorkflowCompilerResults results, out TempFileCollection tempFiles2, out string localAssemblyPath)
{
localAssemblyPath = string.Empty;
tempFiles2 = null;
// Generate code for the markup files.
CodeCompileUnit markupCompileUnit = GenerateCodeFromFileBatch(files, parameters, results);
if (results.Errors.HasErrors)
return null;
SupportedLanguages language = CompilerHelpers.GetSupportedLanguage(parameters.LanguageToUse);
// Convert all compile units to source files.
CodeDomProvider codeDomProvider = CompilerHelpers.GetCodeDomProvider(language, parameters.CompilerVersion);
// Clone the parameters.
CompilerParameters clonedParams = XomlCompilerHelper.CloneCompilerParameters(parameters);
clonedParams.TempFiles.KeepFiles = true;
tempFiles2 = clonedParams.TempFiles;
clonedParams.GenerateInMemory = true;
if (string.IsNullOrEmpty(parameters.OutputAssembly))
localAssemblyPath = clonedParams.OutputAssembly = clonedParams.TempFiles.AddExtension("dll");
else
{
string tempAssemblyDirectory = clonedParams.TempFiles.BasePath;
int postfix = 0;
while (true)
{
try
{
Directory.CreateDirectory(tempAssemblyDirectory);
break;
}
catch
{
tempAssemblyDirectory = clonedParams.TempFiles.BasePath + postfix++;
}
}
localAssemblyPath = clonedParams.OutputAssembly = tempAssemblyDirectory + "\\" + Path.GetFileName(clonedParams.OutputAssembly);
clonedParams.TempFiles.AddFile(localAssemblyPath, true);
}
// Explictily ignore warnings (in case the user set this property in the project options).
clonedParams.TreatWarningsAsErrors = false;
if (clonedParams.CompilerOptions != null && clonedParams.CompilerOptions.Length > 0)
{
// Need to remove /delaysign option together with the /keyfile or /keycontainer
// the temp assembly should not be signed or we'll have problems loading it.
// Custom splitting: need to take strings like '"one two"' into account
// even though it has a space inside, it should not be split.
string source = clonedParams.CompilerOptions;
ArrayList optionsList = new ArrayList();
int begin = 0;
int end = 0;
bool insideString = false;
while (end < source.Length)
{
int currentLength = end - begin;
if (source[end] == '"')
{
insideString = !insideString;
}
else if (source[end] == ' ' && !insideString)
{
// Split only if not inside string like in "inside some string".
// Split here. Ignore multiple spaces.
if (begin == end)
{
begin++; // end will get incremented in the end of the loop.
}
else
{
string substring = source.Substring(begin, end - begin);
optionsList.Add(substring);
begin = end + 1; // end will get incremented in the end of the loop
}
}
end++;
}
// The remaining sub-string.
if (begin != end)
{
string substring = source.Substring(begin, end - begin);
optionsList.Add(substring);
}
string[] options = optionsList.ToArray(typeof(string)) as string[];
clonedParams.CompilerOptions = string.Empty;
foreach (string option in options)
{
if (option.Length > 0 &&
!option.StartsWith("/delaysign", StringComparison.OrdinalIgnoreCase) &&
!option.StartsWith("/keyfile", StringComparison.OrdinalIgnoreCase) &&
!option.StartsWith("/keycontainer", StringComparison.OrdinalIgnoreCase))
{
clonedParams.CompilerOptions += " " + option;
}
}
}
// Disable compiler optimizations, but include debug information.
clonedParams.CompilerOptions = (clonedParams.CompilerOptions == null) ? "/optimize-" : clonedParams.CompilerOptions + " /optimize-";
clonedParams.IncludeDebugInformation = true;
if (language == SupportedLanguages.CSharp)
clonedParams.CompilerOptions += " /unsafe";
// Add files.
ArrayList ccus = new ArrayList((ICollection)parameters.UserCodeCompileUnits);
ccus.Add(markupCompileUnit);
ArrayList userCodeFiles = new ArrayList();
userCodeFiles.AddRange(codeFiles);
userCodeFiles.AddRange(XomlCompilerHelper.GenerateFiles(codeDomProvider, clonedParams, (CodeCompileUnit[])ccus.ToArray(typeof(CodeCompileUnit))));
// Generate the temporary assembly.
CompilerResults results2 = codeDomProvider.CompileAssemblyFromFile(clonedParams, (string[])userCodeFiles.ToArray(typeof(string)));
if (results2.Errors.HasErrors)
{
results.AddCompilerErrorsFromCompilerResults(results2);
return null;
}
return results2.CompiledAssembly;
}
internal static CodeCompileUnit GenerateCodeFromFileBatch(string[] files, WorkflowCompilerParameters parameters, WorkflowCompilerResults results)
{
WorkflowCompilationContext context = WorkflowCompilationContext.Current;
if (context == null)
throw new Exception(SR.GetString(SR.Error_MissingCompilationContext));
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
foreach (string fileName in files)
{
Activity rootActivity = null;
try
{
DesignerSerializationManager manager = new DesignerSerializationManager(context.ServiceProvider);
using (manager.CreateSession())
{
WorkflowMarkupSerializationManager xomlSerializationManager = new WorkflowMarkupSerializationManager(manager);
xomlSerializationManager.WorkflowMarkupStack.Push(parameters);
xomlSerializationManager.LocalAssembly = parameters.LocalAssembly;
using (XmlReader reader = XmlReader.Create(fileName))
rootActivity = WorkflowMarkupSerializationHelpers.LoadXomlDocument(xomlSerializationManager, reader, fileName);
if (parameters.LocalAssembly != null)
{
foreach (object error in manager.Errors)
{
if (error is WorkflowMarkupSerializationException)
{
results.Errors.Add(new WorkflowCompilerError(fileName, (WorkflowMarkupSerializationException)error));
}
else
{
results.Errors.Add(new WorkflowCompilerError(fileName, -1, -1, ErrorNumbers.Error_SerializationError.ToString(CultureInfo.InvariantCulture), error.ToString()));
}
}
}
}
}
catch (WorkflowMarkupSerializationException xomlSerializationException)
{
results.Errors.Add(new WorkflowCompilerError(fileName, xomlSerializationException));
continue;
}
catch (Exception e)
{
results.Errors.Add(new WorkflowCompilerError(fileName, -1, -1, ErrorNumbers.Error_SerializationError.ToString(CultureInfo.InvariantCulture), SR.GetString(SR.Error_CompilationFailed, e.Message)));
continue;
}
if (rootActivity == null)
{
results.Errors.Add(new WorkflowCompilerError(fileName, 1, 1, ErrorNumbers.Error_SerializationError.ToString(CultureInfo.InvariantCulture), SR.GetString(SR.Error_RootActivityTypeInvalid)));
continue;
}
bool createNewClass = (!string.IsNullOrEmpty(rootActivity.GetValue(WorkflowMarkupSerializer.XClassProperty) as string));
if (!createNewClass)
{
results.Errors.Add(new WorkflowCompilerError(fileName, 1, 1, ErrorNumbers.Error_SerializationError.ToString(CultureInfo.InvariantCulture), SR.GetString(SR.Error_CannotCompile_No_XClass)));
continue;
}
//NOTE: CompileWithNoCode is meaningless now. It means no x:Code in a XOML file. It exists until the FP migration is done
//Ideally FP should just use XOML files w/o X:Class and run them w/o ever compiling them
if ((parameters.CompileWithNoCode) && XomlCompilerHelper.HasCodeWithin(rootActivity))
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_CodeWithinNotAllowed), ErrorNumbers.Error_CodeWithinNotAllowed);
error.UserData[typeof(Activity)] = rootActivity;
results.Errors.Add(XomlCompilerHelper.CreateXomlCompilerError(error, parameters));
}
ValidationErrorCollection errors = new ValidationErrorCollection();
errors = ValidateIdentifiers(context.ServiceProvider, rootActivity);
foreach (ValidationError error in errors)
results.Errors.Add(XomlCompilerHelper.CreateXomlCompilerError(error, parameters));
if (results.Errors.HasErrors)
continue;
codeCompileUnit.Namespaces.AddRange(WorkflowMarkupSerializationHelpers.GenerateCodeFromXomlDocument(rootActivity, fileName, context.RootNamespace, CompilerHelpers.GetSupportedLanguage(context.Language), context.ServiceProvider));
}
WorkflowMarkupSerializationHelpers.FixStandardNamespacesAndRootNamespace(codeCompileUnit.Namespaces, context.RootNamespace, CompilerHelpers.GetSupportedLanguage(context.Language));
return codeCompileUnit;
}
#endregion
}
#endregion
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
namespace System.Workflow.ComponentModel.Compiler
{
#region Imports
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Collections.Generic;
using System.CodeDom;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.CodeDom.Compiler;
using System.Reflection;
using System.ComponentModel.Design.Serialization;
using System.Xml;
using System.Globalization;
using System.IO;
using System.Text;
using System.Diagnostics;
using System.Text.RegularExpressions;
using Microsoft.CSharp;
using Microsoft.VisualBasic;
using System.Workflow.ComponentModel.Design;
using System.Workflow.ComponentModel.Serialization;
using System.Security.Policy;
using System.Runtime.Versioning;
using System.Configuration;
using System.Collections.ObjectModel;
#endregion
#region WorkflowMarkupSourceAttribute Class
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
public sealed class WorkflowMarkupSourceAttribute : Attribute
{
private string fileName;
private string md5Digest;
public WorkflowMarkupSourceAttribute(string fileName, string md5Digest)
{
this.fileName = fileName;
this.md5Digest = md5Digest;
}
public string FileName
{
get
{
return this.fileName;
}
}
public string MD5Digest
{
get
{
return this.md5Digest;
}
}
}
#endregion
#region Interface IWorkflowCompilerOptionsService
public interface IWorkflowCompilerOptionsService
{
string RootNamespace { get; }
string Language { get; }
bool CheckTypes { get; }
}
public class WorkflowCompilerOptionsService : IWorkflowCompilerOptionsService
{
internal const string DefaultLanguage = "CSharp";
public virtual string RootNamespace
{
get
{
return string.Empty;
}
}
public virtual string Language
{
get
{
return WorkflowCompilerOptionsService.DefaultLanguage;
}
}
public virtual bool CheckTypes
{
get
{
return false;
}
}
public virtual string TargetFrameworkMoniker
{
get
{
return string.Empty;
}
}
}
#endregion
#region WorkflowCompilationContext
public sealed class WorkflowCompilationContext
{
[ThreadStatic]
static WorkflowCompilationContext current = null;
ContextScope scope;
ReadOnlyCollection authorizedTypes;
WorkflowCompilationContext(ContextScope scope)
{
this.scope = scope;
}
public static WorkflowCompilationContext Current
{
get
{
return WorkflowCompilationContext.current;
}
private set
{
WorkflowCompilationContext.current = value;
}
}
public string RootNamespace
{
get
{
return this.scope.RootNamespace;
}
}
public string Language
{
get
{
return this.scope.Language;
}
}
public bool CheckTypes
{
get
{
return this.scope.CheckTypes;
}
}
internal FrameworkName TargetFramework
{
get
{
return this.scope.TargetFramework;
}
}
internal Version TargetFrameworkVersion
{
get
{
FrameworkName fx = this.scope.TargetFramework;
if (fx != null)
{
return fx.Version;
}
else
{
return MultiTargetingInfo.DefaultTargetFramework;
}
}
}
internal IServiceProvider ServiceProvider
{
get
{
return this.scope;
}
}
public static IDisposable CreateScope(IServiceProvider serviceProvider)
{
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
IWorkflowCompilerOptionsService optionsService = serviceProvider.GetService(typeof(IWorkflowCompilerOptionsService)) as IWorkflowCompilerOptionsService;
if (optionsService != null)
{
return CreateScope(serviceProvider, optionsService);
}
else
{
return new DefaultContextScope(serviceProvider);
}
}
public IList GetAuthorizedTypes()
{
if (this.authorizedTypes == null)
{
try
{
IList authorizedTypes;
IDictionary> authorizedTypesDictionary =
ConfigurationManager.GetSection("System.Workflow.ComponentModel.WorkflowCompiler/authorizedTypes") as IDictionary>;
if (authorizedTypesDictionary.TryGetValue("v" + this.TargetFrameworkVersion.ToString(), out authorizedTypes))
{
this.authorizedTypes = new ReadOnlyCollection(authorizedTypes);
}
}
catch
{
}
}
return this.authorizedTypes;
}
internal static IDisposable CreateScope(IServiceProvider serviceProvider, WorkflowCompilerParameters parameters)
{
return new ParametersContextScope(serviceProvider, parameters);
}
static IDisposable CreateScope(IServiceProvider serviceProvider, IWorkflowCompilerOptionsService optionsService)
{
WorkflowCompilerOptionsService standardService = optionsService as WorkflowCompilerOptionsService;
if (standardService != null)
{
return new StandardContextScope(serviceProvider, standardService);
}
else
{
return new InterfaceContextScope(serviceProvider, optionsService);
}
}
abstract class ContextScope : IDisposable, IServiceProvider
{
IServiceProvider serviceProvider;
WorkflowCompilationContext currentContext;
bool disposed;
protected ContextScope(IServiceProvider serviceProvider)
{
this.serviceProvider = serviceProvider;
this.currentContext = WorkflowCompilationContext.Current;
WorkflowCompilationContext.Current = new WorkflowCompilationContext(this);
}
~ContextScope()
{
DisposeImpl();
}
public abstract string RootNamespace { get; }
public abstract string Language { get; }
public abstract bool CheckTypes { get; }
public abstract FrameworkName TargetFramework { get; }
public void Dispose()
{
DisposeImpl();
GC.SuppressFinalize(this);
}
public object GetService(Type serviceType)
{
return this.serviceProvider.GetService(serviceType);
}
void DisposeImpl()
{
if (!this.disposed)
{
WorkflowCompilationContext.Current = this.currentContext;
this.disposed = true;
}
}
}
class InterfaceContextScope : ContextScope
{
IWorkflowCompilerOptionsService service;
public InterfaceContextScope(IServiceProvider serviceProvider, IWorkflowCompilerOptionsService service)
: base(serviceProvider)
{
this.service = service;
}
public override string RootNamespace
{
get
{
return this.service.RootNamespace;
}
}
public override string Language
{
get
{
return this.service.Language;
}
}
public override bool CheckTypes
{
get
{
return this.service.CheckTypes;
}
}
public override FrameworkName TargetFramework
{
get
{
return null;
}
}
}
class StandardContextScope : ContextScope
{
WorkflowCompilerOptionsService service;
FrameworkName fxName;
public StandardContextScope(IServiceProvider serviceProvider, WorkflowCompilerOptionsService service)
: base(serviceProvider)
{
this.service = service;
}
public override string RootNamespace
{
get
{
return this.service.RootNamespace;
}
}
public override string Language
{
get
{
return this.service.Language;
}
}
public override bool CheckTypes
{
get
{
return this.service.CheckTypes;
}
}
public override FrameworkName TargetFramework
{
get
{
if (this.fxName == null)
{
string fxName = this.service.TargetFrameworkMoniker;
if (!string.IsNullOrEmpty(fxName))
{
this.fxName = new FrameworkName(fxName);
}
}
return this.fxName;
}
}
}
class ParametersContextScope : ContextScope
{
WorkflowCompilerParameters parameters;
public ParametersContextScope(IServiceProvider serviceProvider, WorkflowCompilerParameters parameters)
: base(serviceProvider)
{
this.parameters = parameters;
}
public override string RootNamespace
{
get
{
return WorkflowCompilerParameters.ExtractRootNamespace(this.parameters);
}
}
public override string Language
{
get
{
return this.parameters.LanguageToUse;
}
}
public override bool CheckTypes
{
get
{
return this.parameters.CheckTypes;
}
}
public override FrameworkName TargetFramework
{
get
{
if (this.parameters.MultiTargetingInformation != null)
{
return this.parameters.MultiTargetingInformation.TargetFramework;
}
else
{
return null;
}
}
}
}
class DefaultContextScope : ContextScope
{
public DefaultContextScope(IServiceProvider serviceProvider)
: base(serviceProvider)
{
}
public override string RootNamespace
{
get
{
return string.Empty;
}
}
public override string Language
{
get
{
return WorkflowCompilerOptionsService.DefaultLanguage;
}
}
public override bool CheckTypes
{
get
{
return false;
}
}
public override FrameworkName TargetFramework
{
get
{
return null;
}
}
}
}
#endregion
#region Class WorkflowCompiler
public sealed class WorkflowCompiler
{
public WorkflowCompilerResults Compile(WorkflowCompilerParameters parameters, params string[] files)
{
if (parameters == null)
throw new ArgumentNullException("parameters");
if (files == null)
throw new ArgumentNullException("files");
AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation;
setup.LoaderOptimization = LoaderOptimization.MultiDomainHost;
AppDomain compilerDomain = AppDomain.CreateDomain("CompilerDomain", null, setup);
bool generateInMemory = false;
string originalOutputAssembly = parameters.OutputAssembly;
try
{
if (parameters.GenerateInMemory)
{
generateInMemory = true;
parameters.GenerateInMemory = false;
if (string.IsNullOrEmpty(parameters.OutputAssembly))
parameters.OutputAssembly = Path.GetTempFileName() + ".dll";
else
{
while (true)
{
try
{
DirectoryInfo info = Directory.CreateDirectory(Path.GetTempPath() + "\\" + Guid.NewGuid());
parameters.OutputAssembly = info.FullName + "\\" + parameters.OutputAssembly;
break;
}
catch
{
}
}
}
}
WorkflowCompilerInternal compiler = (WorkflowCompilerInternal)compilerDomain.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, typeof(WorkflowCompilerInternal).FullName);
WorkflowCompilerResults results = compiler.Compile(parameters, files);
if (generateInMemory && !results.Errors.HasErrors)
{
results.CompiledAssembly = Assembly.Load(File.ReadAllBytes(results.PathToAssembly));
results.PathToAssembly = null;
// Delete the file and directory.
try
{
File.Delete(parameters.OutputAssembly);
Directory.Delete(Path.GetDirectoryName(parameters.OutputAssembly));
}
catch
{ }
}
return results;
}
finally
{
string outputAssembly = parameters.OutputAssembly;
if (generateInMemory)
{
parameters.GenerateInMemory = true;
parameters.OutputAssembly = originalOutputAssembly;
}
AppDomain.Unload(compilerDomain);
// The temp file must be deleted after the app domain is unloaded, or else it will
// be "busy", causing the delete to throw an access exception.
if (generateInMemory)
{
try
{
File.Delete(outputAssembly);
}
catch
{ }
}
}
}
}
#endregion
#region Class WorkflowCompilerInternal
internal sealed class WorkflowCompilerInternal : MarshalByRefObject
{
#region Lifetime service
public override object InitializeLifetimeService()
{
return null;
}
#endregion
#region File based compilation
public WorkflowCompilerResults Compile(WorkflowCompilerParameters parameters, string[] allFiles)
{
WorkflowCompilerResults results = new WorkflowCompilerResults(parameters.TempFiles);
// Split the xoml files from cs/vb files.
StringCollection xomlFiles = new StringCollection();
StringCollection userCodeFiles = new StringCollection();
foreach (string file in allFiles)
{
if (file.EndsWith(".xoml", StringComparison.OrdinalIgnoreCase))
xomlFiles.Add(file);
else
userCodeFiles.Add(file);
}
string[] files = new string[xomlFiles.Count];
xomlFiles.CopyTo(files, 0);
string[] codeFiles = new string[userCodeFiles.Count];
userCodeFiles.CopyTo(codeFiles, 0);
string mscorlibPath = typeof(object).Assembly.Location;
ServiceContainer serviceContainer = new ServiceContainer();
MultiTargetingInfo mtInfo = parameters.MultiTargetingInformation;
if (mtInfo == null)
{
XomlCompilerHelper.FixReferencedAssemblies(parameters, results, parameters.LibraryPaths);
}
string mscorlibName = Path.GetFileName(mscorlibPath);
// Add assembly resolver.
ReferencedAssemblyResolver resolver = new ReferencedAssemblyResolver(parameters.ReferencedAssemblies, parameters.LocalAssembly);
AppDomain.CurrentDomain.AssemblyResolve += resolver.ResolveEventHandler;
// prepare service container
TypeProvider typeProvider = new TypeProvider(new ServiceContainer());
int mscorlibIndex = -1;
if ((parameters.ReferencedAssemblies != null) && (parameters.ReferencedAssemblies.Count > 0))
{
for (int i = 0; i < parameters.ReferencedAssemblies.Count; i++)
{
string assemblyPath = parameters.ReferencedAssemblies[i];
if ((mscorlibIndex == -1) && (string.Compare(mscorlibName, Path.GetFileName(assemblyPath), StringComparison.OrdinalIgnoreCase) == 0))
{
mscorlibIndex = i;
mscorlibPath = assemblyPath;
}
typeProvider.AddAssemblyReference(assemblyPath);
}
}
// a note about references to mscorlib:
// If we found mscorlib in the list of reference assemblies, we should remove it prior to sending it to the CodeDOM compiler.
// The CodeDOM compiler would add the right mscorlib [based on the version of the provider we use] and the duplication would
// cause a compilation error.
// If we didn't found a reference to mscorlib we need to add it to the type-provider, though, so we will support exposing
// those known types.
if (mscorlibIndex != -1)
{
parameters.ReferencedAssemblies.RemoveAt(mscorlibIndex);
}
else
{
typeProvider.AddAssemblyReference(mscorlibPath);
}
serviceContainer.AddService(typeof(ITypeProvider), typeProvider);
TempFileCollection intermediateTempFiles = null;
string localAssemblyPath = string.Empty;
try
{
using (WorkflowCompilationContext.CreateScope(serviceContainer, parameters))
{
parameters.LocalAssembly = GenerateLocalAssembly(files, codeFiles, parameters, results, out intermediateTempFiles, out localAssemblyPath);
if (parameters.LocalAssembly != null)
{
// WinOE Bug 17591: we must set the local assembly here,
// otherwise, the resolver won't be able to resolve custom types correctly.
resolver.SetLocalAssembly(parameters.LocalAssembly);
// Work around HERE!!!
// prepare type provider
typeProvider.SetLocalAssembly(parameters.LocalAssembly);
typeProvider.AddAssembly(parameters.LocalAssembly);
results.Errors.Clear();
XomlCompilerHelper.InternalCompileFromDomBatch(files, codeFiles, parameters, results, localAssemblyPath);
}
}
}
catch (Exception e)
{
results.Errors.Add(new WorkflowCompilerError(String.Empty, -1, -1, ErrorNumbers.Error_UnknownCompilerException.ToString(CultureInfo.InvariantCulture), SR.GetString(SR.Error_CompilationFailed, e.Message)));
}
finally
{
// Delate the temp files.
if (intermediateTempFiles != null && parameters.TempFiles.KeepFiles == false)
{
string tempAssemblyDirectory = string.Empty;
if (File.Exists(localAssemblyPath))
tempAssemblyDirectory = Path.GetDirectoryName(localAssemblyPath);
foreach (string file in intermediateTempFiles)
{
try
{
System.IO.File.Delete(file);
}
catch
{
}
}
try
{
if (!string.IsNullOrEmpty(tempAssemblyDirectory))
Directory.Delete(tempAssemblyDirectory);
}
catch
{
}
}
}
return results;
}
#endregion
#region Code for Generating Local Assembly
private static ValidationErrorCollection ValidateIdentifiers(IServiceProvider serviceProvider, Activity activity)
{
ValidationErrorCollection validationErrors = new ValidationErrorCollection();
Dictionary names = new Dictionary();
Walker walker = new Walker();
walker.FoundActivity += delegate(Walker walker2, WalkerEventArgs e)
{
Activity currentActivity = e.CurrentActivity;
if (!currentActivity.Enabled)
{
e.Action = WalkerAction.Skip;
return;
}
ValidationError identifierError = null;
if (names.ContainsKey(currentActivity.QualifiedName))
{
if (names[currentActivity.QualifiedName] != 1)
{
identifierError = new ValidationError(SR.GetString(SR.Error_DuplicatedActivityID, currentActivity.QualifiedName), ErrorNumbers.Error_DuplicatedActivityID, false, "Name");
identifierError.UserData[typeof(Activity)] = currentActivity;
validationErrors.Add(identifierError);
names[currentActivity.QualifiedName] = 1;
}
return;
}
// Undone: AkashS - remove this check when we allow root activities to not have a name.
if (!string.IsNullOrEmpty(currentActivity.Name))
{
names[currentActivity.Name] = 0;
identifierError = ValidationHelpers.ValidateIdentifier("Name", serviceProvider, currentActivity.Name);
if (identifierError != null)
{
identifierError.UserData[typeof(Activity)] = currentActivity;
validationErrors.Add(identifierError);
}
}
};
walker.Walk(activity as Activity);
return validationErrors;
}
private Assembly GenerateLocalAssembly(string[] files, string[] codeFiles, WorkflowCompilerParameters parameters, WorkflowCompilerResults results, out TempFileCollection tempFiles2, out string localAssemblyPath)
{
localAssemblyPath = string.Empty;
tempFiles2 = null;
// Generate code for the markup files.
CodeCompileUnit markupCompileUnit = GenerateCodeFromFileBatch(files, parameters, results);
if (results.Errors.HasErrors)
return null;
SupportedLanguages language = CompilerHelpers.GetSupportedLanguage(parameters.LanguageToUse);
// Convert all compile units to source files.
CodeDomProvider codeDomProvider = CompilerHelpers.GetCodeDomProvider(language, parameters.CompilerVersion);
// Clone the parameters.
CompilerParameters clonedParams = XomlCompilerHelper.CloneCompilerParameters(parameters);
clonedParams.TempFiles.KeepFiles = true;
tempFiles2 = clonedParams.TempFiles;
clonedParams.GenerateInMemory = true;
if (string.IsNullOrEmpty(parameters.OutputAssembly))
localAssemblyPath = clonedParams.OutputAssembly = clonedParams.TempFiles.AddExtension("dll");
else
{
string tempAssemblyDirectory = clonedParams.TempFiles.BasePath;
int postfix = 0;
while (true)
{
try
{
Directory.CreateDirectory(tempAssemblyDirectory);
break;
}
catch
{
tempAssemblyDirectory = clonedParams.TempFiles.BasePath + postfix++;
}
}
localAssemblyPath = clonedParams.OutputAssembly = tempAssemblyDirectory + "\\" + Path.GetFileName(clonedParams.OutputAssembly);
clonedParams.TempFiles.AddFile(localAssemblyPath, true);
}
// Explictily ignore warnings (in case the user set this property in the project options).
clonedParams.TreatWarningsAsErrors = false;
if (clonedParams.CompilerOptions != null && clonedParams.CompilerOptions.Length > 0)
{
// Need to remove /delaysign option together with the /keyfile or /keycontainer
// the temp assembly should not be signed or we'll have problems loading it.
// Custom splitting: need to take strings like '"one two"' into account
// even though it has a space inside, it should not be split.
string source = clonedParams.CompilerOptions;
ArrayList optionsList = new ArrayList();
int begin = 0;
int end = 0;
bool insideString = false;
while (end < source.Length)
{
int currentLength = end - begin;
if (source[end] == '"')
{
insideString = !insideString;
}
else if (source[end] == ' ' && !insideString)
{
// Split only if not inside string like in "inside some string".
// Split here. Ignore multiple spaces.
if (begin == end)
{
begin++; // end will get incremented in the end of the loop.
}
else
{
string substring = source.Substring(begin, end - begin);
optionsList.Add(substring);
begin = end + 1; // end will get incremented in the end of the loop
}
}
end++;
}
// The remaining sub-string.
if (begin != end)
{
string substring = source.Substring(begin, end - begin);
optionsList.Add(substring);
}
string[] options = optionsList.ToArray(typeof(string)) as string[];
clonedParams.CompilerOptions = string.Empty;
foreach (string option in options)
{
if (option.Length > 0 &&
!option.StartsWith("/delaysign", StringComparison.OrdinalIgnoreCase) &&
!option.StartsWith("/keyfile", StringComparison.OrdinalIgnoreCase) &&
!option.StartsWith("/keycontainer", StringComparison.OrdinalIgnoreCase))
{
clonedParams.CompilerOptions += " " + option;
}
}
}
// Disable compiler optimizations, but include debug information.
clonedParams.CompilerOptions = (clonedParams.CompilerOptions == null) ? "/optimize-" : clonedParams.CompilerOptions + " /optimize-";
clonedParams.IncludeDebugInformation = true;
if (language == SupportedLanguages.CSharp)
clonedParams.CompilerOptions += " /unsafe";
// Add files.
ArrayList ccus = new ArrayList((ICollection)parameters.UserCodeCompileUnits);
ccus.Add(markupCompileUnit);
ArrayList userCodeFiles = new ArrayList();
userCodeFiles.AddRange(codeFiles);
userCodeFiles.AddRange(XomlCompilerHelper.GenerateFiles(codeDomProvider, clonedParams, (CodeCompileUnit[])ccus.ToArray(typeof(CodeCompileUnit))));
// Generate the temporary assembly.
CompilerResults results2 = codeDomProvider.CompileAssemblyFromFile(clonedParams, (string[])userCodeFiles.ToArray(typeof(string)));
if (results2.Errors.HasErrors)
{
results.AddCompilerErrorsFromCompilerResults(results2);
return null;
}
return results2.CompiledAssembly;
}
internal static CodeCompileUnit GenerateCodeFromFileBatch(string[] files, WorkflowCompilerParameters parameters, WorkflowCompilerResults results)
{
WorkflowCompilationContext context = WorkflowCompilationContext.Current;
if (context == null)
throw new Exception(SR.GetString(SR.Error_MissingCompilationContext));
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
foreach (string fileName in files)
{
Activity rootActivity = null;
try
{
DesignerSerializationManager manager = new DesignerSerializationManager(context.ServiceProvider);
using (manager.CreateSession())
{
WorkflowMarkupSerializationManager xomlSerializationManager = new WorkflowMarkupSerializationManager(manager);
xomlSerializationManager.WorkflowMarkupStack.Push(parameters);
xomlSerializationManager.LocalAssembly = parameters.LocalAssembly;
using (XmlReader reader = XmlReader.Create(fileName))
rootActivity = WorkflowMarkupSerializationHelpers.LoadXomlDocument(xomlSerializationManager, reader, fileName);
if (parameters.LocalAssembly != null)
{
foreach (object error in manager.Errors)
{
if (error is WorkflowMarkupSerializationException)
{
results.Errors.Add(new WorkflowCompilerError(fileName, (WorkflowMarkupSerializationException)error));
}
else
{
results.Errors.Add(new WorkflowCompilerError(fileName, -1, -1, ErrorNumbers.Error_SerializationError.ToString(CultureInfo.InvariantCulture), error.ToString()));
}
}
}
}
}
catch (WorkflowMarkupSerializationException xomlSerializationException)
{
results.Errors.Add(new WorkflowCompilerError(fileName, xomlSerializationException));
continue;
}
catch (Exception e)
{
results.Errors.Add(new WorkflowCompilerError(fileName, -1, -1, ErrorNumbers.Error_SerializationError.ToString(CultureInfo.InvariantCulture), SR.GetString(SR.Error_CompilationFailed, e.Message)));
continue;
}
if (rootActivity == null)
{
results.Errors.Add(new WorkflowCompilerError(fileName, 1, 1, ErrorNumbers.Error_SerializationError.ToString(CultureInfo.InvariantCulture), SR.GetString(SR.Error_RootActivityTypeInvalid)));
continue;
}
bool createNewClass = (!string.IsNullOrEmpty(rootActivity.GetValue(WorkflowMarkupSerializer.XClassProperty) as string));
if (!createNewClass)
{
results.Errors.Add(new WorkflowCompilerError(fileName, 1, 1, ErrorNumbers.Error_SerializationError.ToString(CultureInfo.InvariantCulture), SR.GetString(SR.Error_CannotCompile_No_XClass)));
continue;
}
//NOTE: CompileWithNoCode is meaningless now. It means no x:Code in a XOML file. It exists until the FP migration is done
//Ideally FP should just use XOML files w/o X:Class and run them w/o ever compiling them
if ((parameters.CompileWithNoCode) && XomlCompilerHelper.HasCodeWithin(rootActivity))
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_CodeWithinNotAllowed), ErrorNumbers.Error_CodeWithinNotAllowed);
error.UserData[typeof(Activity)] = rootActivity;
results.Errors.Add(XomlCompilerHelper.CreateXomlCompilerError(error, parameters));
}
ValidationErrorCollection errors = new ValidationErrorCollection();
errors = ValidateIdentifiers(context.ServiceProvider, rootActivity);
foreach (ValidationError error in errors)
results.Errors.Add(XomlCompilerHelper.CreateXomlCompilerError(error, parameters));
if (results.Errors.HasErrors)
continue;
codeCompileUnit.Namespaces.AddRange(WorkflowMarkupSerializationHelpers.GenerateCodeFromXomlDocument(rootActivity, fileName, context.RootNamespace, CompilerHelpers.GetSupportedLanguage(context.Language), context.ServiceProvider));
}
WorkflowMarkupSerializationHelpers.FixStandardNamespacesAndRootNamespace(codeCompileUnit.Namespaces, context.RootNamespace, CompilerHelpers.GetSupportedLanguage(context.Language));
return codeCompileUnit;
}
#endregion
}
#endregion
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- XPathMessageFilterTable.cs
- RtfControlWordInfo.cs
- VectorValueSerializer.cs
- WSDualHttpBinding.cs
- SessionStateContainer.cs
- HebrewCalendar.cs
- SecurityRuntime.cs
- TypeUtils.cs
- ValidationHelper.cs
- DataShape.cs
- WhitespaceRule.cs
- XmlNodeComparer.cs
- DelegateInArgument.cs
- GiveFeedbackEvent.cs
- BindingNavigatorDesigner.cs
- InkCanvas.cs
- TemplateApplicationHelper.cs
- ProgressBarBrushConverter.cs
- ServiceHostFactory.cs
- Automation.cs
- assertwrapper.cs
- SerializationUtilities.cs
- QilExpression.cs
- AddressingProperty.cs
- StorageMappingItemCollection.cs
- AnnotationAdorner.cs
- __ComObject.cs
- HtmlForm.cs
- ToolboxComponentsCreatingEventArgs.cs
- RegionData.cs
- MetadataItemCollectionFactory.cs
- DynamicDiscoveryDocument.cs
- BitmapSource.cs
- AssemblyEvidenceFactory.cs
- OrderedDictionary.cs
- CodePrimitiveExpression.cs
- DeviceContexts.cs
- OletxCommittableTransaction.cs
- ChangeBlockUndoRecord.cs
- DSASignatureFormatter.cs
- OpCellTreeNode.cs
- XmlBinaryWriter.cs
- BmpBitmapDecoder.cs
- ProgressBarRenderer.cs
- TypeDescriptionProviderAttribute.cs
- CheckBox.cs
- BitSet.cs
- SynchronizationLockException.cs
- TransactionProxy.cs
- DockPatternIdentifiers.cs
- LexicalChunk.cs
- ParameterToken.cs
- SecurityElement.cs
- GPRECTF.cs
- RijndaelManagedTransform.cs
- TagPrefixCollection.cs
- AutomationEvent.cs
- GrammarBuilderWildcard.cs
- CodeBlockBuilder.cs
- WebRequestModulesSection.cs
- HtmlGenericControl.cs
- TaskbarItemInfo.cs
- LoadWorkflowAsyncResult.cs
- EntityViewGenerationAttribute.cs
- IndicCharClassifier.cs
- ToolStripDropDownMenu.cs
- RowType.cs
- cookiecollection.cs
- SimpleRecyclingCache.cs
- CustomBindingElement.cs
- SourceLocation.cs
- WinFormsUtils.cs
- DesignerCategoryAttribute.cs
- QilUnary.cs
- ISFClipboardData.cs
- XmlSerializerFormatAttribute.cs
- Transaction.cs
- WindowsSlider.cs
- MasterPage.cs
- Wrapper.cs
- ActivationArguments.cs
- IpcServerChannel.cs
- AsymmetricAlgorithm.cs
- NavigatorOutput.cs
- DataMember.cs
- DoWorkEventArgs.cs
- QuadraticBezierSegment.cs
- TypeCodeDomSerializer.cs
- TextEditorTyping.cs
- DataStorage.cs
- ToolStripRenderer.cs
- SqlConnectionFactory.cs
- DataGridViewDataConnection.cs
- WindowsListViewSubItem.cs
- DesignerTransactionCloseEvent.cs
- DisableDpiAwarenessAttribute.cs
- SecurityCapabilities.cs
- StorageEntityContainerMapping.cs
- CustomValidator.cs
- OleStrCAMarshaler.cs