MarkupCompilePass1.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Build / Microsoft / Build / Tasks / Windows / MarkupCompilePass1.cs / 2 / MarkupCompilePass1.cs

                            //---------------------------------------------------------------------------- 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// Description: An MSBuild Task that can generate .xaml markup file to specific 
//              Mangaged language code such as .cs, .js, .vb,etc, and /or binary 
//              token file .baml
// 
// Spec:        [....]/app/Compilation/Avalon-MSBUILD%20Targets.doc
//
// History:
//  06/20/03: [....]   rewrite and moved over to WCP tree 
//
//--------------------------------------------------------------------------- 
 
using System;
using System.IO; 
using System.Collections;
using System.Security;
using System.Security.Permissions;
 
using System.Globalization;
using System.Diagnostics; 
using System.Reflection; 
using System.Resources;
using System.Runtime.InteropServices; 

using System.CodeDom;
using System.CodeDom.Compiler;
 
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities; 
 
using MS.Utility;
using MS.Internal; 
using MS.Internal.Tasks;
using MS.Internal.Markup;

// Since we disable PreSharp warnings in this file, PreSharp warning is unknown to C# compiler. 
// We first need to disable warnings about unknown message numbers and unknown pragmas.
#pragma warning disable 1634, 1691 
 
namespace Microsoft.Build.Tasks.Windows
{ 

    #region MarkupCompilePass1 Task class

    ///  
    /// Class of MarkupCompilePass1 Task
    ///  
    public sealed class MarkupCompilePass1 : Task 
    {
        //  Security Concerns: [....] 04/13/05 
        //
        //  1) OutputPath property exposes the current dir and is publicly available.
        //  2) This class generates code files and copies them on the disk.
        // 
        //  The above two are already mitigated by the following facts:
        // 
        //  1) PresentationBuildTasks is not APTCA and thus partial trust assemblies 
        //     cannot call into it.
        //  2) There is a possibility that some APTCA assembly (eg. PF.dll) can create 
        //     this object and pass it on to partial trust code.  This is mitigated by
        //     FxCop rule against it.
        //
 
        //-----------------------------------------------------
        // 
        //  Constructors 
        //
        //----------------------------------------------------- 

        #region Constructors

        ///  
        /// Constructor
        ///  
        public MarkupCompilePass1( ) : base(SR.ResourceManager) 
        {
            // set the source directory 
            _sourceDir = Directory.GetCurrentDirectory() + "\\";

            _outputType = Shared.WinExe;
 
            // By default, no localization information is stripped out.
            _localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.None; 
 
            _nErrors = 0;
 
        }

        #endregion Constructors
 
        //------------------------------------------------------
        // 
        //  Public Methods 
        //
        //----------------------------------------------------- 

        #region Public Methods

        ///  
        /// Execute method in Task
        ///  
        ///  
        public override bool Execute()
        { 

            //CASRemoval:(new PermissionSet(PermissionState.Unrestricted)).Assert();

            TaskHelper.DisplayLogo(Log, SR.Get(SRID.MarkupCompilePass1Task)); 

            bool bSuccess = true; 
 
            try
            { 

                //
                // Create the TaskFileService instance here
                // 

                _taskFileService = new TaskFileService(this) as ITaskFileService; 
 
                _compilerState = new CompilerState(
                    OutputPath + AssemblyName + (TaskFileService.IsRealBuild? Shared.StateFile : Shared.IntellisenseStateFile), 
                    TaskFileService);

                _compilerLocalRefCache = new CompilerLocalReference(
                    OutputPath + AssemblyName + (TaskFileService.IsRealBuild? Shared.LocalTypeCacheFile : Shared.IntellisenseLocalTypeCacheFile), 
                    TaskFileService);
 
                if ((PageMarkup == null || PageMarkup.Length == 0) && 
                    (ApplicationMarkup == null || ApplicationMarkup.Length == 0))
                { 
                    // Don't need to do further work.
                    // stop here.
                    CleanupCacheFiles();
                    return true; 
                }
 
                VerifyInputs(); 

                Log.LogMessageFromResources(MessageImportance.Low, SRID.CurrentDirectory.String, SourceDir); 

                // If wrong files are set to some properties, the task
                // should stop here immediatelly.
 
                if (_nErrors > 0)
                { 
                    Log.LogErrorWithCodeFromResources(SRID.WrongPropertySetting.String); 
                }
                else 
                {

                    // create output directory
                    if (!Directory.Exists(OutputPath)) 
                    {
                        Directory.CreateDirectory(OutputPath); 
                    } 

                    // Analyze project inputs to detect which xaml files require to recompile. 
                    AnalyzeInputsAndSetting();

                    Log.LogMessageFromResources(MessageImportance.Low, SRID.AnalysisResult.String, CompilerAnalyzer.AnalyzeResult);
 
                    if (!SkipMarkupCompilation)
                    { 
 
                        if (CompilerAnalyzer.RecompileMarkupPages != null)
                        { 
                            for (int i = 0; i < CompilerAnalyzer.RecompileMarkupPages.Length; i++)
                            {

                                Log.LogMessageFromResources(MessageImportance.Low, SRID.RecompiledXaml.String, CompilerAnalyzer.RecompileMarkupPages[i]); 
                            }
                        } 
 
                        // If recompile is required, CompilerAnalyzer contains all the files which need to recompile.
 
                        // Cleanup baml files and code files generated in previous build.
                        CleanupGeneratedFiles();

                        // Call the Markup Compiler to do the real compiling work 
                        DoMarkupCompilation();
                    } 
 

                    // Generate the required output items. 
                    GenerateOutputItems();

                    Log.LogMessageFromResources(MessageImportance.Low, SRID.CompilationDone.String);
                } 

            } 
#pragma warning disable 6500 
            catch (Exception e)
            { 
                string message;
                string errorId;

                errorId = Log.ExtractMessageCode(e.Message, out message); 

                if (String.IsNullOrEmpty(errorId)) 
                { 
                    errorId = UnknownErrorID;
                    message = SR.Get(SRID.UnknownBuildError, message); 
                }

                Log.LogError(null, errorId, null, null, 0, 0, 0, 0, message, null);
 
                _nErrors++;
            } 
            catch // Non-CLS compliant errors 
            {
                Log.LogErrorWithCodeFromResources(SRID.NonClsError.String); 
                _nErrors++;
            }
#pragma warning restore 6500
 
            if (_nErrors > 0)
            { 
                // When error counter is changed, the appropriate error message should have 
                // been reported, simply return false here.
                bSuccess = false; 
                CleanupCacheFiles();
            }
            else
            { 
                Log.LogMessageFromResources(MessageImportance.Low, SRID.CompileSucceed_Pass1.String);
            } 
 
            return bSuccess;
        } 


        #endregion Public Methods
 
        //------------------------------------------------------
        // 
        //  Public Properties 
        //
        //------------------------------------------------------ 

        #region Public Properties

        ///  
        /// The Language the managed compiler supports.
        /// the valid languages are C#, VB, Jscript, J#, C++ 
        ///  
        [Required]
        public string Language 
        {
            get { return _language; }
            set { _language = value;}
        } 

        ///  
        /// The valid source file extension for the passed language. 
        /// Normally a language supports more valid source file extensions.
        /// User could choose one of them in project file. 
        /// If this property is not set, we will take use of the default one for the language.
        /// 
        public string LanguageSourceExtension
        { 
            get { return _languageSourceExtension; }
            set { _languageSourceExtension = value; } 
        } 

        /// 
        /// OutputPath : Generated code files, Baml fles will be put in this directory.
        ///
        [Required]
        public string OutputPath 
        {
            get { return _outputDir; } 
            set 
            {
                string filePath = value; 

                // Get the relative path based on sourceDir
                _outputDir= TaskHelper.CreateFullFilePath(filePath, SourceDir);
 
                // Make sure OutputDir always ends with '\\'.
                if (!_outputDir.EndsWith("\\", StringComparison.Ordinal)) 
                { 
                    _outputDir += "\\";
                } 
            }
        }

        /// 
        /// OutputType
        ///       Valid types: winexe, exe, library, netmodule. 
        /// 
        [Required]
        public string OutputType 
        {
            get { return _outputType; }
            set { _outputType = TaskHelper.GetLowerString(value); }
        } 

        /// 
        /// AssemblyName 
        /// The short name of assembly which will be generated for this project.
        /// 
        [Required]
        public string AssemblyName
        {
            get { return _assemblyName; } 
            set { _assemblyName = value; }
        } 
 
        /// 
        /// The version of the assembly 
        /// 
        public string AssemblyVersion
        {
            get { return _assemblyVersion;  } 
            set { _assemblyVersion = value;  }
        } 
 
        /// 
        /// The public key token of the assembly 
        /// 
        public string AssemblyPublicKeyToken
        {
            get { return _assemblyPublicKeyToken; } 
            set { _assemblyPublicKeyToken = value;  }
        } 
 
        ///
        /// Root namespace for the classes inside the project. 
        /// It is also used as default CLR namespace of a generated code file
        /// when the corresponding markup page is not set x:Class attribute.
        ///
        public string RootNamespace 
        {
            get { return _rootNamespace; } 
            set { _rootNamespace = value; } 
        }
 
        /// 
        /// The UI Culture controls which culture satellite assembly will hold
        /// the generated baml files.
        /// If UICulture is not set,  the generated baml files will be embedded 
        /// into main assembly.
        ///  
        public string UICulture 
        {
            get { return _uiCulture; } 
            set { _uiCulture = value; }
        }

        ///  
        /// Source code file list for the current project.
        /// It doesnt include any generated code files. 
        ///  
        public ITaskItem[] SourceCodeFiles
        { 
            get { return _sourceCodeFiles; }
            set { _sourceCodeFiles = value; }
        }
 
        /// 
        /// DefineConstants 
        /// 
        /// Keep the current value of DefineConstants.
        /// 
        /// DefineConstants can affect the final assembly generation, if DefineConstants
        /// value is changed, the public API might be changed in the target assembly, which
        /// then has potential impacts on compilation for xaml files which contains local types.
        /// 
        /// 
        public string DefineConstants 
        { 
            get { return _defineConstants; }
            set { _defineConstants = value; } 
        }

        ///
        /// ApplicationMarkup 
        ///
        public ITaskItem [] ApplicationMarkup 
        { 
            get { return _applicationMarkup; }
            set { _applicationMarkup = value;} 
        }

        ///
        /// Description 
        ///
        public ITaskItem [] PageMarkup 
        { 
            get { return _pagemarkupFiles;  }
            set { _pagemarkupFiles = value; } 
        }

        /// 
        /// Loose file content list 
        /// 
        public ITaskItem[] ContentFiles 
        { 
            get { return _contentFiles; }
            set { _contentFiles = value; } 
        }

        /// 
        /// Assembly References. 
        /// 
        ///  
        public ITaskItem[] References 
        {
            get { return _references; } 
            set { _references = value; }
        }

        /// 
        ///
        public bool XamlDebuggingInformation 
        { 
            get { return _xamlDebuggingInformation; }
            set { _xamlDebuggingInformation = value; } 
        }

        /// 
        /// Keep a list of Build control files. 
        /// If one of them is changed since last build, it would trigger recompilation of all the xaml files.
        /// Such as WinFX target file change could require a rebuild etc. 
        ///  
        public ITaskItem [] ExtraBuildControlFiles
        { 
            get { return _extraBuildControlFiles; }
            set { _extraBuildControlFiles = value; }
        }
 
        ///
        ///If true code for supporting hosting in Browser is generated 
        /// 
        public string HostInBrowser
        { 
            get { return _hostInBrowser; }
            set { _hostInBrowser = TaskHelper.GetLowerString(value); }
        }
 
        /// 
        /// Controls how to generate localization information for each xaml file. 
        /// Valid values: None, CommentsOnly, All. 
        /// 
        public string LocalizationDirectivesToLocFile 
        {
            get
            {
                string localizationDirectives = Shared.Loc_None; 

                switch (_localizationDirectives) 
                { 
                    case MS.Internal.LocalizationDirectivesToLocFile.None :
 
                        localizationDirectives = Shared.Loc_None;
                        break;

                    case MS.Internal.LocalizationDirectivesToLocFile.CommentsOnly: 

                        localizationDirectives = Shared.Loc_CommentsOnly; 
                        break; 

                    case MS.Internal.LocalizationDirectivesToLocFile.All: 

                        localizationDirectives = Shared.Loc_All;

                        break; 

                } 
 
                return localizationDirectives;
 
            }

            set
            { 
                string localizationDirectives = value;
 
                if (localizationDirectives != null) 
                {
                    localizationDirectives = localizationDirectives.ToLower(CultureInfo.InvariantCulture); 
                }

                switch (localizationDirectives)
                { 
                    case Shared.Loc_None :
 
                        _localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.None; 
                        break;
 
                    case Shared.Loc_CommentsOnly :

                        _localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.CommentsOnly;
                        break; 

                    case Shared.Loc_All : 
 
                        _localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.All;
                        break; 

                    default:
                        _localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.Unknown;
                        break; 
                }
 
            } 
        }
 
        /// 
        /// Known reference paths hold referenced assemblies which are never changed during the build procedure.
        /// such as references in GAC, in framework directory or framework SDK directory etc.
        /// Users could add their own known reference paths in project files. 
        /// 
        public string[] KnownReferencePaths 
        { 
            get
            { 
                return _knownReferencePaths;
            }

            set 
            {
                _knownReferencePaths = value; 
            } 
        }
 
        /// 
        /// A list of reference assemblies that are to change for sure during the build cycle.
        ///
        /// Such as in VS.NET, if one project wants to reference another project's output, the 
        /// second project's output could be put in AssembliesGeneratedDuringBuild list.
        /// Note: Once this property is set, it must contain the complete list of generated 
        /// assemblies in this build solution. 
        /// 
        public string[] AssembliesGeneratedDuringBuild 
        {
            get
            {
                return _assembliesGeneratedDuringBuild; 
            }
 
            set 
            {
                _assembliesGeneratedDuringBuild = value; 
            }

        }
 
        /// 
        /// Control whether to run the compilation in second appdomain. 
        /// By default, it is set to true, but project can set this property 
        /// to false to make markup file compilation faster.
        ///  
        public bool AlwaysCompileMarkupFilesInSeparateDomain
        {
            get { return _alwaysCompileMarkupFilesInSeparateDomain;   }
            set { _alwaysCompileMarkupFilesInSeparateDomain = value;  } 
        }
 
        /// 
        /// Generated source code files for the given programing language.
        /// 
        [Output]
        public ITaskItem [] GeneratedCodeFiles
        {
            get 
            {
               if (_generatedCodeFiles == null) 
                   _generatedCodeFiles = new TaskItem[0]; 
               return _generatedCodeFiles;
            } 

            set
            {
                _generatedCodeFiles = value; 
            }
        } 
 
        ///
        /// Generated Baml files for the passed Markup files. 
        ///
        [Output]
        public ITaskItem [] GeneratedBamlFiles
        { 
            get
            { 
               if (_generatedBamlFiles == null) 
                   _generatedBamlFiles = new TaskItem[0];
               return _generatedBamlFiles; 
            }

            set
            { 
                _generatedBamlFiles = value;
            } 
        } 

        ///  
        /// The generated localization file for each localizable xaml file.
        /// 
        [Output]
        public ITaskItem[] GeneratedLocalizationFiles 
        {
            get 
            { 
                if (_generatedLocalizationFiles == null)
                    _generatedLocalizationFiles = new TaskItem[0]; 

                return _generatedLocalizationFiles;
            }
 
            set
            { 
                _generatedLocalizationFiles = value; 
            }
 
        }

        #region Local Reference Xaml markup files
 
        /// 
        /// Indicate whether the project contains xaml files which reference local types and 
        /// the corresponding baml file will be embedded into main assembly. 
        /// 
        [Output] 
        public bool RequirePass2ForMainAssembly
        {
            get { return _requirePass2ForMainAssembly; }
            set { _requirePass2ForMainAssembly = value; } 
        }
 
        ///  
        /// Indicate whether the project contains xaml files which reference local types and
        /// the corresponding baml file will be embedded into satellite assembly for current UICulture. 
        /// 
        [Output]
        public bool RequirePass2ForSatelliteAssembly
        { 
            get { return _requirePass2ForSatelliteAssembly; }
            set { _requirePass2ForSatelliteAssembly = value; } 
        } 

        #endregion Local Reference Xaml markup files 

        /// 
        /// A complete list of files which are generated by MarkupCompiler.
        ///  
        [Output]
        public ITaskItem[] AllGeneratedFiles 
        { 
            get { return _allGeneratedFiles; }
            set { _allGeneratedFiles = value; } 
        }

        #endregion Public Properties
 
        #region internal methods
 
        // 
        // Get the generated code file and baml file for a given xaml file
        // If the generated file doesn't exist, the output paramter is set to empty string. 
        //
        internal void GetGeneratedFiles(string xamlFile, out string codeFile, out string bamlFile)
        {
            string newSourceDir = SourceDir; 
            codeFile = String.Empty;
            bamlFile = String.Empty; 
 
            if (String.IsNullOrEmpty(xamlFile))
            { 
                // if xaml file is empty, return it now.
                return;
            }
 

            string relativeFilePath = GetResolvedFilePath(xamlFile, ref newSourceDir); 
            string langExt = 
                (TaskFileService.IsRealBuild? Shared.GeneratedExtension : Shared.IntellisenseGeneratedExtension)
                + LanguageSourceExtension; 

            // Replace the .xaml with corresponding generated file extensions.
            codeFile = OutputPath + Path.ChangeExtension(relativeFilePath, langExt);
            bamlFile = OutputPath + Path.ChangeExtension(relativeFilePath, Shared.BamlExtension); 

 
            // If the file doesn't exist, return empty string for the corresponding output parameter. 
            if (!TaskFileService.Exists(codeFile))
            { 
                codeFile = String.Empty;
            }

            // 
            // Baml file is not generated for intellisense build.
            // 
            if ((TaskFileService.IsRealBuild == false) || (!TaskFileService.Exists(bamlFile))) 
            {
                bamlFile = String.Empty; 
            }
        }

        #endregion internal methods 

 
        #region internal Properties 

        internal bool IsApplicationTarget 
        {
            get { return _isApplicationTarget; }
        }
 
        //
        // ApplicationFile 
        // 
        internal string ApplicationFile
        { 
            get { return _applicationFile; }
        }

        // 
        // PageMarkupCache
        // It is caculated from current PageMarkup list, will be saved in the 
        // cache file to support incremental compilation. 
        //
        internal string PageMarkupCache 
        {
            get { return _pageMarkupCache; }
        }
 
        //
        // ContentFilesCache 
        // It is caculated from current ContentFiles list, will be saved in the 
        // cache file to support incremental compilation.
        // 
        internal string ContentFilesCache
        {
            get { return _contentFilesCache; }
        } 

        // 
        // SourceCodeFilesCache 
        // It is caculated from current SourceCodeFiles list, will be saved in the
        // cache file to support incremental compilation. 
        //
        internal string SourceCodeFilesCache
        {
            get { return _sourceCodeFilesCache; } 
        }
 
        // 
        // ReferencesCache
        // It is caculated from current ReferencesCache list, will be saved in the 
        // cache file to support incremental compilation.
        //
        internal string ReferencesCache
        { 
            get { return _referencesCache; }
        } 
 
        //
        // Application File with Local Type 
        //
        internal LocalReferenceFile LocalApplicationFile
        {
            get { return _localApplicationFile; } 
        }
 
        // 
        // Markup Page files with local types
        // 
        internal LocalReferenceFile[] LocalMarkupPages
        {
            get { return _localMarkupPages; }
        } 

        // 
        // TaskFileService 
        //
        internal ITaskFileService TaskFileService 
        {
            get { return _taskFileService; }
        }
 
        //
        // CompilerState 
        // 
        internal CompilerState CompilerState
        { 
            get { return _compilerState; }
        }

        // 
        // CompilerLocalReference
        // 
        internal CompilerLocalReference CompilerLocalReference 
        {
            get { return _compilerLocalRefCache; } 
        }

        //
        // Tell MarkupCompilePass2 whether it further handles InternalTypeHelper class. 
        //
        internal bool FurtherCheckInternalTypeHelper 
        { 
            get { return _furtherCheckInternalTypeHelper; }
            set { _furtherCheckInternalTypeHelper = value; } 
        }

        //
        // Get the file path for the generated InternalTypeHelper class. 
        //
        internal string InternalTypeHelperFile 
        { 
            get
            { 
                string fileName = Shared.GeneratedInternalTypeHelperFileName
                    + (TaskFileService.IsRealBuild? Shared.GeneratedExtension : Shared.IntellisenseGeneratedExtension)
                    + LanguageSourceExtension;
 
                return Path.Combine(OutputPath, fileName);
            } 
        } 

 
        #endregion  internal Properties

        //-----------------------------------------------------
        // 
        // Private Methods
        // 
        //------------------------------------------------------ 

        #region Private Methods 

        //
        // Check if all the input properties are set valid values
        // If any property contains an invalid value, Error counter _nErrors will 
        // be changed.
        // 
        private void VerifyInputs() 
        {
            // Check if the OutputType is valid type. 
            IsSupportedOutputType(OutputType);

            // Check if the Localization property is set correctly.
            IsValidLocalizationDirectives(); 

            VerifyApplicationFile(); 
 
            if (PageMarkup != null && PageMarkup.Length > 0)
            { 
                VerifyInputTaskItems(PageMarkup);
            }

        } 

        // 
        // Verify if the Application file is set correctly 
        // in project file.
        // 
        private void VerifyApplicationFile()
        {
            if (!IsApplicationTarget)
            { 
                //
                // For non Application target type. 
                // 
                if (ApplicationMarkup != null && ApplicationMarkup.Length > 0)
                { 
                    //
                    // For non-Application target type, Application definition should not be set.
                    //
                    Log.LogErrorWithCodeFromResources(SRID.AppDefIsNotRequired.String); 
                    _nErrors++;
 
                } 

            } 
            else
            {
                //
                // For Application Target type. 
                //
                if (ApplicationMarkup != null && ApplicationMarkup.Length > 0) 
                { 
                    if (ApplicationMarkup.Length > 1)
                    { 
                        Log.LogErrorWithCodeFromResources(SRID.MutlipleApplicationFiles.String);
                        _nErrors++;
                    }
 
                    _applicationFile = TaskHelper.CreateFullFilePath(ApplicationMarkup[0].ItemSpec, SourceDir);
                    Log.LogMessageFromResources(MessageImportance.Low, SRID.ApplicationDefinitionFile.String, ApplicationFile); 
 
                    if (!TaskFileService.Exists(ApplicationFile))
                    { 
                        Log.LogErrorWithCodeFromResources(SRID.FileNotFound.String, ApplicationFile);
                        _nErrors++;
                    }
 
                }
 
            } 
        }
 
        //
        // Don't support local reference xaml compilation for Container and netmodule type.
        //
        private bool IsSupportedOutputType(string outputType) 
        {
            bool isSupported = false; 
 
            switch (outputType)
            { 
                case Shared.Exe:
                case Shared.WinExe:
                    isSupported = true;
                    _isApplicationTarget = true; 
                    break;
                case Shared.Library: 
                case Shared.Module: 
                    isSupported = true;
                    break; 

                default:
                    isSupported = false;
                    break; 
            }
 
            if (isSupported == false) 
            {
                Log.LogErrorWithCodeFromResources(SRID.TargetIsNotSupported.String, outputType); 

                // Keep the error numbers so that the task can stop immediatelly
                // later when Execute( ) is called.
                _nErrors++; 
            }
 
            return isSupported; 
        }
 
        private bool IsValidLocalizationDirectives()
        {
            bool bValid = true;
 
            if (_localizationDirectives == MS.Internal.LocalizationDirectivesToLocFile.Unknown)
            { 
                bValid = false; 

                Log.LogErrorWithCodeFromResources(SRID.WrongLocalizationPropertySetting_Pass1.String); 

                // Keep the error numbers so that the task can stop immediatelly
                // later when Execute( ) is called.
                _nErrors++; 
            }
 
            return bValid; 
        }
 

        // 
        // Check if the passed TaskItems have valid ItemSpec
        //  
        // 
        //  
        private bool VerifyInputTaskItems(ITaskItem[] inputItems) 
        {
            bool bValid = true; 

            foreach (ITaskItem inputItem in inputItems)
            {
                bool bValidItem; 

                bValidItem = IsValidInputFile(inputItem.ItemSpec); 
 
                if (bValidItem == false)
                { 
                    bValid = false;
                }
            }
 
            return bValid;
        } 
 
        private bool IsValidInputFile(string filePath)
        { 
            bool bValid = true;

            if (!TaskFileService.Exists(TaskHelper.CreateFullFilePath(filePath, SourceDir)))
            { 
                bValid = false;
                Log.LogErrorWithCodeFromResources(SRID.FileNotFound.String, filePath); 
 
                // Keep the error numbers so that the task can stop immediatelly
                // later when Execute( ) is called. 
                _nErrors ++;

            }
 
            return bValid;
        } 
 
        //
        // Return a new sourceDir and relative filepath for a given filePath. 
        // This is for supporting of fullpath or ..\ in the original FilePath.
        //
        private string GetResolvedFilePath(string filePath, ref string newSourceDir)
        { 
            // Create a full path for the originalFilePath.
            string fullFilePath = TaskHelper.CreateFullFilePath(filePath, SourceDir); 
 
            // Get the relative path based on sourceDir
            string relPath = TaskHelper.GetRootRelativePath(SourceDir, fullFilePath); 
            string newRelativeFilePath;

            if (relPath.Length > 0)
            { 
                // the original file is relative to the SourceDir.
                newSourceDir = SourceDir; 
                newRelativeFilePath = relPath; 
            }
            else 
            {
                // the original file is not relative to the SourceDir.
                // it could have its own fullpath or contains "..\" etc.
                // 
                // In this case, we want to put the filename as relative filepath
                // and put the deepest directory that file is in as the new 
                // SourceDir. 
                //
                int pathEndIndex = fullFilePath.LastIndexOf("\\", StringComparison.Ordinal); 

                newSourceDir = fullFilePath.Substring(0, pathEndIndex + 1);
                newRelativeFilePath = TaskHelper.GetRootRelativePath(newSourceDir, fullFilePath);
            } 

            return newRelativeFilePath; 
        } 

        // 
        // Analyze the project setting and input files for incremental build support.
        private void AnalyzeInputsAndSetting()
        {
            // Initialize the cache file paths and related information. 

            _pageMarkupCache = CompilerState.GenerateCacheForFileList(PageMarkup); 
            _contentFilesCache = CompilerState.GenerateCacheForFileList(ContentFiles); 
            _sourceCodeFilesCache = CompilerState.GenerateCacheForFileList(SourceCodeFiles);
            _referencesCache = CompilerState.GenerateCacheForFileList(References); 

            _compilerAnalyzer = new IncrementalCompileAnalyzer(this);

            _compilerAnalyzer.AnalyzeInputFiles(); 

 
            _isCleanBuild = (CompilerAnalyzer.AnalyzeResult == RecompileCategory.All) ? true : false; 

        } 

        //
        // Specially handle Reference list to prepare for xaml file compilation.
        // 
        private ArrayList ProcessReferenceList( )
        { 
            ArrayList referenceList = new ArrayList(); 

            // Generate the asmmebly reference list. 
            if (References != null && References.Length > 0)
            {
                ReferenceAssembly asmReference;
                string refpath, asmname; 

                for (int i = 0; i < References.Length; i++) 
                { 
                    // The reference path must be full file path.
                    refpath = References[i].ItemSpec; 
                    refpath = TaskHelper.CreateFullFilePath(refpath, SourceDir);

                    asmname = Path.GetFileNameWithoutExtension(refpath);
 
                    asmReference = new ReferenceAssembly(refpath, asmname);
                    referenceList.Add(asmReference); 
 
                    //
                    // If always run the compilation in second appdomain, there is no need to specially 
                    // handle the referenced assemblies.
                    // Unload the appdomain can unload all the referenced assemblies.
                    //
                    if (AlwaysCompileMarkupFilesInSeparateDomain == false) 
                    {
                        bool bCouldbeChanged = TaskHelper.CouldReferenceAssemblyBeChanged(refpath, KnownReferencePaths, AssembliesGeneratedDuringBuild); 
 
                        if (bCouldbeChanged)
                        { 
                            MarkupCompiler.InitializeAssemblyState(asmname);
                        }
                    }
 
                    Log.LogMessageFromResources(MessageImportance.Low, SRID.ReferenceFile.String, refpath);
 
                } 
            }
 
            return referenceList;
        }

        // Cleanup baml files and code files generated in previous build. 
        private void CleanupGeneratedFiles( )
        { 
            string codeFile, bamlFile; 

            if (IsApplicationTarget && !String.IsNullOrEmpty(CompilerAnalyzer.RecompileApplicationFile)) 
            {
                GetGeneratedFiles(CompilerAnalyzer.RecompileApplicationFile, out codeFile, out bamlFile);

                if (!String.IsNullOrEmpty(codeFile)) 
                {
                    TaskFileService.Delete(codeFile); 
                } 

                if (!String.IsNullOrEmpty(bamlFile)) 
                {
                    TaskFileService.Delete(bamlFile);
                }
            } 

            if (CompilerAnalyzer.RecompileMarkupPages != null) 
            { 
                for (int i = 0; i < CompilerAnalyzer.RecompileMarkupPages.Length; i++)
                { 
                    GetGeneratedFiles(CompilerAnalyzer.RecompileMarkupPages[i], out codeFile, out bamlFile);

                    if (!String.IsNullOrEmpty(codeFile))
                    { 
                        TaskFileService.Delete(codeFile);
                    } 
 
                    if (!String.IsNullOrEmpty(bamlFile))
                    { 
                        TaskFileService.Delete(bamlFile);
                    }
                }
            } 

            // If the content file setting is changed, the generated content.g.cs code file should be updated later, 
            // so delete the file here first. 
            //
            // This includes the scenario that all the previous content files are removed from the content item list in 
            // this build run.
            if ((CompilerAnalyzer.AnalyzeResult & RecompileCategory.ContentFiles) == RecompileCategory.ContentFiles)
            {
                if (TaskFileService.Exists(ContentCodeFile)) 
                {
                    TaskFileService.Delete(ContentCodeFile); 
                } 
            }
 
            // If this is for CleanBuild, and the InternalTypeHelper file exists, delete it first.
            if (IsCleanBuild && TaskFileService.Exists(InternalTypeHelperFile))
            {
                TaskFileService.Delete(InternalTypeHelperFile); 
            }
        } 
 
        //
        // Call MarkupCompiler to do the real compilation work. 
        //
        private void DoMarkupCompilation()
        {
            Log.LogMessageFromResources(MessageImportance.Low, SRID.DoCompilation.String); 
            Log.LogMessageFromResources(MessageImportance.Low, SRID.OutputType.String, OutputType);
 
 
            // When code goes here, the MarkupCompilation is really required, so don't need
            // to do more further validation inside this private method. 

            AppDomain appDomain = null;
            CompilerWrapper compilerWrapper = null;
 
            try
            { 
                compilerWrapper = TaskHelper.CreateCompilerWrapper(AlwaysCompileMarkupFilesInSeparateDomain, ref appDomain); 

                if (compilerWrapper != null) 
                {
                    compilerWrapper.OutputPath = OutputPath;
                    compilerWrapper.AssemblyVersion = AssemblyVersion;
                    compilerWrapper.AssemblyPublicKeyToken = AssemblyPublicKeyToken; 
                    compilerWrapper.LanguageSourceExtension = LanguageSourceExtension;
                    compilerWrapper.HostInBrowser = TaskHelper.BooleanStringValue(HostInBrowser); 
 
                    compilerWrapper.TaskLogger = Log;
                    compilerWrapper.UnknownErrorID = UnknownErrorID; 
                    compilerWrapper.XamlDebuggingInformation = XamlDebuggingInformation;

                    compilerWrapper.TaskFileService = TaskFileService;
 
                    if (IsApplicationTarget)
                    { 
                        compilerWrapper.ApplicationMarkup = CompilerAnalyzer.RecompileApplicationFile; 
                    }
 
                    compilerWrapper.ContentFiles = CompilerAnalyzer.ContentFiles;

                    // Process Reference list here.
                    ArrayList referenceList = ProcessReferenceList(); 

                    compilerWrapper.References = referenceList; 
 
                    compilerWrapper.LocalizationDirectivesToLocFile = (int)_localizationDirectives;
 
                    compilerWrapper.DoCompilation(AssemblyName, Language, RootNamespace, CompilerAnalyzer.RecompileMarkupPages, false);

                    // Keep the Local-Type-Ref file lists
 
                    _localXamlPages = compilerWrapper.LocalXamlPages;
                    _localXamlApplication = compilerWrapper.LocalXamlApplication; 
 
                    _hasInternals = compilerWrapper.HasInternals;
                } 
            }
            finally
            {
 
                if (compilerWrapper != null && compilerWrapper.ErrorTimes > 0)
                { 
                    _nErrors += compilerWrapper.ErrorTimes; 
                }
 
                if (appDomain != null)
                {
                    AppDomain.Unload(appDomain);
                    compilerWrapper = null; 
                }
 
            } 
        }
 

        // 
        // Generate the required Output Items.
        //  
        private void GenerateOutputItems( )
        { 
            // For the rest target types, 
            // Create the output lists for CS and Baml files.
 
            ArrayList bamlFileList = new ArrayList();
            ArrayList csFileList = new ArrayList();
            ArrayList localRefPageList = new ArrayList();
            ArrayList localRefAppdefList = new ArrayList(); 

            // Generate Output Items for PageMarkup 
            if (PageMarkup != null && PageMarkup.Length > 0) 
            {
                GenerateOutputItemsForCompiledXamlFiles(PageMarkup, 
                                                        _localXamlPages,
                                                        ref bamlFileList,
                                                        ref csFileList,
                                                        ref localRefPageList); 
            }
 
            // 
            // Generate output items for ApplicationDefinition if it is set in the project file.
            // 
            if (ApplicationFile != null && ApplicationFile.Length > 0)
            {
                string[] appdefLocalList = null;
 
                if (!String.IsNullOrEmpty(_localXamlApplication))
                { 
                    appdefLocalList = new string[1] { _localXamlApplication }; 
                }
 
                GenerateOutputItemsForCompiledXamlFiles(ApplicationMarkup,
                                          appdefLocalList,
                                          ref bamlFileList,
                                          ref csFileList, 
                                          ref localRefAppdefList);
            } 
 
            if (TaskFileService.Exists(ContentCodeFile))
            { 
                csFileList.Add(new TaskItem(ContentCodeFile));
            }

            // Generate the Baml, code and /or locally-defined type related output items. 
            GeneratedBamlFiles = (ITaskItem[])bamlFileList.ToArray(typeof(ITaskItem));
 
            if (!SkipMarkupCompilation) 
            {
                if (localRefAppdefList.Count > 0) 
                {
                    _localApplicationFile = (LocalReferenceFile)localRefAppdefList[0];
                }
 
                if (localRefPageList.Count > 0)
                { 
                    _localMarkupPages = (LocalReferenceFile[])localRefPageList.ToArray(typeof(LocalReferenceFile)); 
                }
 
                //
                // If MarkupCompilePass2 is required for Main assembly, there is no need to invoke MarkupCompilePass2
                // for satellite assembly again.
                // 
                if (_requirePass2ForMainAssembly)
                { 
                    _requirePass2ForSatelliteAssembly = false; 
                }
            } 

            //
            // Detect whether or not to ask Pass2 to do further handding for the InternalTypeHelper class.
            // 
            // Only when all of below conditions are true, it requires Pass2 to further handling this wrapper class:
            // 
            //    1.    InternalTypeHelper file exists. 
            //    2.    It is a CleanBuild.
            //    3.    No any xaml files which don't contain local types contains internal types from friend assembly. 
            //    4.    _requirePass2ForMainAssembly is true.
            //
            // If InternalTypeHelper File exists, Pass1 would always add it to the code file list, so that consequent task
            // can take it.  If Pass2 determines that this wrapper class is not required, it can simply make an empty file. 
            // But we still keep the list of generated code files.
 
            bool existsInternalTypeHelper = TaskFileService.Exists(InternalTypeHelperFile); 

            if (IsCleanBuild && existsInternalTypeHelper && _requirePass2ForMainAssembly && !_hasInternals) 
            {
                FurtherCheckInternalTypeHelper = true;
            }
            else 
            {
                FurtherCheckInternalTypeHelper = false; 
            } 

            if (existsInternalTypeHelper) 
            {
                csFileList.Add(new TaskItem(InternalTypeHelperFile));
            }
 
            GeneratedCodeFiles = (ITaskItem[])csFileList.ToArray(typeof(ITaskItem));
 
            // Generate the Localization Output files 
            if (_localizationDirectives != MS.Internal.LocalizationDirectivesToLocFile.None)
            { 
                GenerateOutputItemsForLocFiles();
            }

            HandleCacheFiles(); 

            // 
            // Put all the generated files into one output Item so that it can be set to 
            // FileWrites item in target file, this list of files will be cleaned up for
            // next clean build by msbuild. 
            // The generated files should include Baml files, code files, localization files
            // and the cache files.
            //
 
            ArrayList allGeneratedFiles = new ArrayList( );
 
            for (int i = 0; i < GeneratedBamlFiles.Length; i++) 
            {
                allGeneratedFiles.Add(GeneratedBamlFiles[i]); 
            }

            for (int i = 0; i < GeneratedCodeFiles.Length; i++)
            { 
                allGeneratedFiles.Add(GeneratedCodeFiles[i]);
            } 
 
            for (int i = 0; i < GeneratedLocalizationFiles.Length; i++)
            { 
                allGeneratedFiles.Add(GeneratedLocalizationFiles[i]);
            }

            // Add the CompilerState cache file into the list 

            allGeneratedFiles.Add(new TaskItem(CompilerState.CacheFilePath)); 
 
            if (CompilerLocalReference.CacheFileExists())
            { 
                allGeneratedFiles.Add(new TaskItem(CompilerLocalReference.CacheFilePath));
            }

            AllGeneratedFiles = (ITaskItem[])allGeneratedFiles.ToArray(typeof(ITaskItem)); 

        } 
 

        // 
        // Both MarkupPage and MarkupResource have the similar code to generate
        // output baml, code file and /or locallyDefined xaml files.
        // so put all the common code in this private method.
        // 
        // Inputs :
        //            Xaml file items:  PageMarkup or MarkupResource 
        //            LocallyDefined Xaml List (Generated by MarkupCompiler) 
        //
        // Outputs:   BamlFile List, 
        //            CodeFile List,
        //            LocallyDefined Xaml List
        //
        private void GenerateOutputItemsForCompiledXamlFiles(ITaskItem[] inputXamlItemList, 
                                                             string[]   inputLocalRefXamlFileList,
                                                             ref ArrayList outputBamlFileList, 
                                                             ref ArrayList outputCodeFileList, 
                                                             ref ArrayList outputLocalRefXamlList)
        { 

            //
            // For each input xaml file, check if the code and baml file are generated or not.
            // If baml or code files are generated, put them into the appropriate output file item list. 
            //
            for (int i = 0; i < inputXamlItemList.Length; i++) 
            { 
                string genLangFilePath, bamlFile;
 
                GetGeneratedFiles(inputXamlItemList[i].ItemSpec, out genLangFilePath, out bamlFile);

                if (!String.IsNullOrEmpty(genLangFilePath) && outputCodeFileList != null)
                { 
                    TaskItem codeItem;
 
                    codeItem = new TaskItem(); 
                    codeItem.ItemSpec = genLangFilePath;
 
                    outputCodeFileList.Add(codeItem);

                    Log.LogMessageFromResources(MessageImportance.Low, SRID.GeneratedCodeFile.String, codeItem.ItemSpec);
                } 

                if (!String.IsNullOrEmpty(bamlFile)) 
                { 
                    TaskItem bamlItem = GenerateBamlItem(bamlFile, inputXamlItemList[i]);
 
                    // Add bamlItem to the output Baml List
                    outputBamlFileList.Add(bamlItem);
                    Log.LogMessageFromResources(MessageImportance.Low, SRID.GeneratedBamlFile.String, bamlItem.ItemSpec);
                } 

            }  // End of for {  } loop. 
 

            // 
            // If the project contains local-type xaml files, put them into the right output item list here.
            //

            // 
            // If MarkupCompilation is skipped, there is no need to check local-type xaml files.
            // 
            if (!SkipMarkupCompilation && inputLocalRefXamlFileList != null && inputLocalRefXamlFileList.Length > 0) 
            {
                for (int i = 0; i < inputLocalRefXamlFileList.Length; i++) 
                {
                    string fullLocalXamlFile = TaskHelper.CreateFullFilePath(inputLocalRefXamlFileList[i], SourceDir);

                    LocalReferenceFile localFile = GenerateLocalTypeItem(fullLocalXamlFile, inputXamlItemList); 

                    if (localFile != null && outputLocalRefXamlList != null) 
                    { 
                        outputLocalRefXamlList.Add(localFile);
                    } 
                }
            }
        }
 

        // 
        // Generate appropriate output file list for local-type xaml file. This information will be saved 
        // into the .lref cache file so that the MarkupCompilePass2 can take it.
        // 
        private LocalReferenceFile GenerateLocalTypeItem(string localTypeXamlFile, ITaskItem[] inputXamlItemList)
        {
            LocalReferenceFile localFile = null;
            bool isLocalizable = false; 

            // 
            // Check if the local-type xaml file is localizable or not. 
            //
            for (int i = 0; i < inputXamlItemList.Length; i++) 
            {
                ITaskItem inputXamlItem = inputXamlItemList[i];

                string xamlInputFullPath = TaskHelper.CreateFullFilePath(inputXamlItem.ItemSpec, SourceDir); 

                if (String.Compare(localTypeXamlFile, xamlInputFullPath, StringComparison.OrdinalIgnoreCase) == 0) 
                { 
                    //
                    // Got this file from the original XamlFile TaskItem list. 
                    // Check if this item is localizable or not and stop the search here.
                    //
                    isLocalizable = IsItemLocalizable(inputXamlItem);
                    break; 
                }
            } 
 
            //
            // Generate the instance of LocalReferenceFile for this local-type xaml file. 
            //
            localFile = new LocalReferenceFile(localTypeXamlFile, isLocalizable);

            if (isLocalizable) 
            {
                _requirePass2ForSatelliteAssembly = true; 
            } 
            else
            { 
                _requirePass2ForMainAssembly = true;
            }

            return localFile; 
        }
 
 

        // 
        // Generate a baml TaskItem for the given xmal file, and transfer the appropriate
        // source task item's custom attributes to the generated baml item if necessary.
        // The xaml file could be an application definition file, a Markup Page.
        // The bamlFile must exist before this method is called. 
        private TaskItem GenerateBamlItem(string bamlFile, ITaskItem SourceItem)
        { 
            TaskItem bamlItem; 

            bamlItem =  new TaskItem(); 
            bamlItem.ItemSpec = bamlFile;

            //
            // Transfer some special custom attributes from source task item 
            // to output item.
            // Such as transfer the Localizable attribute from a given .xaml file item 
            // to the generated .baml file item. 
            //
            // Normally MarkupPage and MarkupResource need to transfer their attributes. 
            // But Application definition doesn't require this.
            if (SourceItem != null)
            {
                string[] listCarryOverAttribute = new string[] { 
                    "Localizable"
                }; 
 
                for (int j = 0; j < listCarryOverAttribute.Length; j++)
                { 
                    string attributeValue;

                    attributeValue = SourceItem.GetMetadata(listCarryOverAttribute[j]);
                    if (attributeValue != null) 
                    {
                        bamlItem.SetMetadata(listCarryOverAttribute[j], attributeValue); 
                    } 
                }
            } 

            return bamlItem;
        }
 
        //
        // Generate output item list for localization files. 
        // 
        private void GenerateOutputItemsForLocFiles()
        { 

            ArrayList locFileItemList = new ArrayList();
            TaskItem  tiLoc;
            ITaskItem xamlItem; 

            if (ApplicationMarkup != null && ApplicationMarkup.Length > 0 && ApplicationMarkup[0] != null) 
            { 

                tiLoc = ProcessLocFileForXamlItem(ApplicationMarkup[0]); 

                if (tiLoc != null)
                {
                    // Add this LocItem to the locFileItemList 
                    locFileItemList.Add(tiLoc);
                } 
            } 

            if (PageMarkup != null) 
            {
                for (int i = 0; i < PageMarkup.Length; i++)
                {
                    xamlItem = PageMarkup[i]; 

                    tiLoc = ProcessLocFileForXamlItem(xamlItem); 
 
                    if (tiLoc != null)
                    { 
                        // Add this LocItem to the locFileItemList
                        locFileItemList.Add(tiLoc);
                    }
                } 
            }
 
            // Generate the Output TaskItem List 
            GeneratedLocalizationFiles = (ITaskItem[])locFileItemList.ToArray(typeof(ITaskItem));
 
        }

        //
        // General method to handle an input xaml file item for Localization. 
        //
        // If the XamlFile is localizable, generate a TaskItem for LocFile. 
        // If the XamlFile is not localizable, and if the .loc file is generated, delelet it 
        // so that it won't affec the incremental build next time.
        // 
        private TaskItem ProcessLocFileForXamlItem(ITaskItem xamlItem)
        {
            TaskItem tiLoc = null;
 
            string   tempDir = SourceDir;  // Just for calling GetResolvedFilePath, the value is not used here.
 
            // Get a relative file path for the passed .xaml file 
            string xamlRelativeFilePath = GetResolvedFilePath(xamlItem.ItemSpec, ref tempDir);
            string locFile; 

            // Change the extension from .xaml to .loc
            locFile = Path.ChangeExtension(xamlRelativeFilePath, Shared.LocExtension);
 
            // the .loc file is at OutputPath + relative Path.
            locFile = OutputPath + locFile; 
 
            if (TaskFileService.Exists(locFile))
            { 
               //
               // Per discussion with Globalization team:
               //
               //   Globalization requests to collect .loc file for a baml file 
               //   no matter the baml is in main assembly or satelliate assembly.
               // 
               //   The localization tool can localize the baml from the main assembly as well. 
               //
 
                // Generate a TaskItem to include .loc file
                // The item is going to add to the output LocFile list
                tiLoc = new TaskItem(locFile);
            } 

            return tiLoc; 
        } 

        // 
        // Check if the given TaskItem localizable.
        //
        private bool IsItemLocalizable(ITaskItem ti)
        { 
            bool bIsLocalizable;
 
            if (String.IsNullOrEmpty(UICulture)) 
            {
                // if UICulture is not set, all baml files are not localizable. 
                // The Localizable metadate value is ignored for this case.
                bIsLocalizable = false;
            }
            else 
            {
                string strLocalizable; 
 
                // if UICulture is set, by default all the baml files are localizable unless
                // an explicit value "false" is set to Localizable metadata. 
                bIsLocalizable = true;

                strLocalizable = ti.GetMetadata(Shared.Localizable);
 
                if (strLocalizable != null && String.Compare(strLocalizable, "false", StringComparison.OrdinalIgnoreCase) == 0)
                { 
                    bIsLocalizable = false; 
                }
            } 

            return bIsLocalizable;
        }
 
        //
        // Cleanup the cache files. 
        // It could happen if build error occurs. 
        //
        private void CleanupCacheFiles() 
        {
            CompilerState.CleanupCache();
            CompilerLocalReference.CleanupCache();
        } 

 
        // 
        // A central place to update cache files based on current build status MarkupCompiler result.
        // 
        // This method should be called after the markupcompiler is done or skipped.
        //
        private void HandleCacheFiles()
        { 
            // Update the CompilerState file based on new project setting, no matter MarkupCompiler is skipped or not.
            CompilerState.SaveStateInformation(this); 
 
            if ( (CompilerAnalyzer.AnalyzeResult & ( RecompileCategory.PagesWithLocalType |  RecompileCategory.ModifiedPages )) != RecompileCategory.NoRecompile)
            { 
                // The modified xaml files and all the local-type xaml files should be recompiled, depends on the
                // MarkupCompiler return, it will keep or delete the cache file for local type xaml files.

                if (_requirePass2ForMainAssembly || _requirePass2ForSatelliteAssembly) 
                {
                    CompilerLocalReference.SaveCacheInformation(this); 
                } 
                else
                { 
                    CompilerLocalReference.CleanupCache();
                }
            }
 
            // if build doesn't handle the local-ref xaml files, (it implies not handling the modified xaml files either),
            // such as the build handles only for Application (HIB change) and Content files changes, or the markup compilation 
            // is skipped, ( NoRecompile). 
            //
            // For this scenario, if .lref file exists, it should still be kept. 
            //

        }
 
        #endregion Private Methods
 
        //----------------------------------------------------- 
        //
        //  Private Properties 
        //
        //-----------------------------------------------------

        #region Private Properties 

        //  
        // The root directory for the applicaiton project. 
        // 
        private string SourceDir 
        {
            get { return _sourceDir; }
        }
 
        private IncrementalCompileAnalyzer CompilerAnalyzer
        { 
            get { return _compilerAnalyzer; } 
        }
 

        //
        // If no input file is modified, Markup compilation will be skipped.
        // But the code still generates the correct output item lists. 
        //
        private bool SkipMarkupCompilation 
        { 
            get { return CompilerAnalyzer.AnalyzeResult == RecompileCategory.NoRecompile; }
        } 

        private string ContentCodeFile
        {
            get 
            {
                return OutputPath + AssemblyName + Shared.ContentFile 
                    + (TaskFileService.IsRealBuild? Shared.GeneratedExtension : Shared.IntellisenseGeneratedExtension) 
                    + LanguageSourceExtension;
            } 
        }

        //
        // Whether this is a clean build or not 
        //
        private bool IsCleanBuild 
        { 
            get { return _isCleanBuild; }
        } 

        #endregion Private Properties

        //----------------------------------------------------- 
        //
        //  Private Fields 
        // 
        //------------------------------------------------------
 
        #region Private Fields

        private string                     _language;
        private string                     _languageSourceExtension = string.Empty; 
        private ITaskItem []               _pagemarkupFiles;
        private ITaskItem []               _contentFiles; 
        private ITaskItem []               _references; 
        private bool                       _xamlDebuggingInformation = false;
        private string                     _outputType; 
        private string                     _assemblyName;
        private string                     _assemblyVersion;
        private string                     _assemblyPublicKeyToken;
        private string                     _rootNamespace = String.Empty; 
        private ITaskItem []               _applicationMarkup;
        private bool                       _alwaysCompileMarkupFilesInSeparateDomain = true; 
 
        private string[]                   _assembliesGeneratedDuringBuild;
        private string[]                   _knownReferencePaths; 

        private string                     _sourceDir;
        private string                     _outputDir;
 
        private ITaskItem[]                _extraBuildControlFiles;
        private string                     _uiCulture = String.Empty; 
 
        private string                     _applicationFile = String.Empty;
        private bool                       _isApplicationTarget = false; 
        private string                     _hostInBrowser = String.Empty;

        private LocalizationDirectivesToLocFile _localizationDirectives;
 
        private ITaskItem []               _generatedCodeFiles;
        private ITaskItem []               _generatedBamlFiles; 
        private ITaskItem []               _generatedLocalizationFiles; 
        private ITaskItem []               _allGeneratedFiles = null;
 
        private string                     _localXamlApplication;
        private string[]                   _localXamlPages;
        private bool                       _hasInternals = false;
 
        private int                        _nErrors;
 
        private string                     _defineConstants = String.Empty; 
        private ITaskItem[]                _sourceCodeFiles;
 
        private string                     _pageMarkupCache = String.Empty;
        private string                     _contentFilesCache = String.Empty;
        private string                     _sourceCodeFilesCache = String.Empty;
        private string                     _referencesCache = String.Empty; 
        private LocalReferenceFile         _localApplicationFile = null;
        private LocalReferenceFile[]       _localMarkupPages = null; 
 
        private bool                       _requirePass2ForMainAssembly = false;
        private bool                       _requirePass2ForSatelliteAssembly = false; 

        private bool                       _furtherCheckInternalTypeHelper = false;

        private CompilerState              _compilerState; 
        private CompilerLocalReference     _compilerLocalRefCache;
        private IncrementalCompileAnalyzer _compilerAnalyzer; 
 
        private ITaskFileService           _taskFileService;
 
        private bool                       _isCleanBuild = true;   // Indicates whether this is a cleanbuild or incremental build.

        #region const string
 
        private const string UnknownErrorID = "MC1000";
 
        #endregion const string 

        #endregion Private Fields 

    }

    #endregion MarkupCompilePass1 Task class 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK