public TextExpressionCompiler(TextExpressionCompilerSettings settings)
        {
            if (settings == null)
            {
                throw FxTrace.Exception.ArgumentNull("settings");
            }

            if (settings.Activity == null)
            {
                throw FxTrace.Exception.Argument("settings", SR.TextExpressionCompilerActivityRequired);
            }

            if (settings.ActivityName == null)
            {
                throw FxTrace.Exception.Argument("settings", SR.TextExpressionCompilerActivityNameRequired);
            }

            if (settings.Language == null)
            {
                throw FxTrace.Exception.Argument("settings", SR.TextExpressionCompilerLanguageRequired);
            }

            this.expressionDescriptors = new List<CompiledExpressionDescriptor>();
            this.compiledDataContexts = new Stack<CompiledDataContextDescriptor>();
            this.nextContextId = 0;

            this.settings = settings;

            this.activityFullName = activityFullName = GetActivityFullName(settings);

            this.generateSource = this.settings.AlwaysGenerateSource;

            this.lineNumbersForNSes = new Dictionary<string, int>();
            this.lineNumbersForNSesForImpl = new Dictionary<string, int>();
        }        
        void GenerateSource(bool isSupportedVersion, string filePath, AssemblyBuilder assemblyBuilder, WorkflowService workflowService, out string codeFileName, out bool generatedSource, out string activityName)
        {
            // Get unique file and type name for the workflowservice
            codeFileName = assemblyBuilder.GetTempFilePhysicalPath(assemblyBuilder.CodeDomProvider.FileExtension);

            if (isSupportedVersion)
            {
                activityName = WorkflowServiceHostFactory.GetSupportedVersionGeneratedTypeName(filePath);
            }
            else
            {
                activityName = workflowService.Name.LocalName + "_" + Guid.NewGuid().ToString().Replace("-", "_");
            }            

            TextExpressionCompilerSettings settings = new TextExpressionCompilerSettings
            {
                Activity = workflowService.Body,
                ActivityName = activityName,
                ActivityNamespace = GeneratedNamespace,
                Language = CodeDomProvider.GetLanguageFromExtension(assemblyBuilder.CodeDomProvider.FileExtension),
                GenerateAsPartialClass = false,
                AlwaysGenerateSource = false,
                ForImplementation = false
            };

            TextExpressionCompiler compiler = new TextExpressionCompiler(settings);            

            generatedSource = false;
            using (StreamWriter fileStream = new StreamWriter(codeFileName))
            {
                try
                {
                    generatedSource = compiler.GenerateSource(fileStream);
                }
                catch (Exception ex)
                {
                    if (Fx.IsFatal(ex))
                    {
                        throw;
                    }

                    throw FxTrace.Exception.AsError(new HttpCompileException(SR.XamlBuildProviderExtensionException(ex.Message)));
                }
            }
        }             
        string GetActivityFullName(TextExpressionCompilerSettings settings)
        {
            string rootNamespacePrefix = null;
            string namespacePrefix = null;
            string activityFullName = "";
            if (this.IsVB && !String.IsNullOrWhiteSpace(this.settings.RootNamespace))
            {
                rootNamespacePrefix = this.settings.RootNamespace + ".";
            }

            if (!String.IsNullOrWhiteSpace(this.settings.ActivityNamespace))
            {
                namespacePrefix = this.settings.ActivityNamespace + ".";
            }

            if (rootNamespacePrefix != null)
            {
                if (namespacePrefix != null)
                {
                    activityFullName = rootNamespacePrefix + namespacePrefix + settings.ActivityName;
                }
                else
                {
                    activityFullName = rootNamespacePrefix + settings.ActivityName;
                }
            }
            else
            {
                if (namespacePrefix != null)
                {
                    activityFullName = namespacePrefix + settings.ActivityName;
                }
                else
                {
                    activityFullName = settings.ActivityName;
                }
            }

            return activityFullName;
        }