MarkupCompilePass2.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / BuildTasks / Microsoft / Build / Tasks / Windows / MarkupCompilePass2.cs / 1305600 / MarkupCompilePass2.cs

                            //---------------------------------------------------------------------------- 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// Description: A MSBuild Task that can generate .baml file for some special 
//              xaml markup files that want to take some locally-defined types. 
//
// History: 
//  11/29/04: weibz   Created it.
//
//---------------------------------------------------------------------------
 
using System;
using System.IO; 
using System.Collections; 
using System.Security;
using System.Security.Permissions; 
using System.Text;

using System.Globalization;
using System.Diagnostics; 
using System.Reflection;
using System.Resources; 
using System.Runtime.InteropServices; 

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 MarkupCompilePass2 Task class 
 
    /// 
    /// Class of MarkupCompilePass2 Task 
    /// 
    public sealed class MarkupCompilePass2  : Task
    {
 
        //-----------------------------------------------------
        // 
        //  Constructors 
        //
        //----------------------------------------------------- 

        #region Constructors

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

            _outputType = SharedStrings.WinExe;
 
            _nErrors = 0;
 
        } 

        #endregion Constructors 

        //------------------------------------------------------
        //
        //  Public Methods 
        //
        //----------------------------------------------------- 
 
        #region Public Methods
 
        /// 
        /// Execute method in Task
        /// 
        ///  
        public override bool Execute()
        { 
            TaskHelper.DisplayLogo(Log, SR.Get(SRID.MarkupCompilePass2Task)); 

            // 
            // Create the TaskFileService instance here
            //
            _taskFileService = new TaskFileService(this) as ITaskFileService;
 
            try
            { 
                IsSupportedOutputType(OutputType); 

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

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

                    hasLocalXamlFiles = InitLocalXamlCache(); 

                    if (!hasLocalXamlFiles) 
                    { 
                        // There is no valid input xaml files.
                        // No need to do further work. 
                        // stop here.
                        return true;
                    }
 
                    // create output directory
                    if (!Directory.Exists(OutputPath)) 
                    { 
                        Directory.CreateDirectory(OutputPath);
                    } 

                    // Call the Markup Compiler to do the real compiling work

                    ArrayList referenceList; 
                    string localApplicationFile;
                    string[] localXamlPageFileList; 
 
                    // Prepare the appropriate file lists required by MarkupCompiler.
                    PrepareForMarkupCompilation(out localApplicationFile, out localXamlPageFileList, out referenceList); 

                    // Do the real Pass2 compilation work here.
                    DoLocalReferenceMarkupCompilation(localApplicationFile, localXamlPageFileList, referenceList);
 
                    // Generate the required output items.
                    GenerateOutputItems(); 
 
                    Log.LogMessageFromResources(MessageImportance.Low, SRID.CompilationDone);
                } 
            }
#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);
 
                _nErrors++; 
            }
#pragma warning restore 6500 

            CleanupReferenceAssemblyCacheForTargetAssembly();

            if (_nErrors > 0) 
            {
                // When error counter is changed, the appropriate error message should have 
                // been reported. 

                // 
                // The task should cleanup all the cache files so that all the xaml files will
                // get chance to recompile next time.
                //
 
                string stateFileName = OutputPath + AssemblyName +
                                      (TaskFileService.IsRealBuild? SharedStrings.StateFile : SharedStrings.IntellisenseStateFile); 
 
                string localTypeCacheFileName = OutputPath + AssemblyName +
                                      (TaskFileService.IsRealBuild? SharedStrings.LocalTypeCacheFile : SharedStrings.IntellisenseLocalTypeCacheFile); 

                if (TaskFileService.Exists(stateFileName))
                {
                    TaskFileService.Delete(stateFileName); 
                }
 
                if (TaskFileService.Exists(localTypeCacheFileName)) 
                {
                    TaskFileService.Delete(localTypeCacheFileName); 
                }

                return false;
            } 
            else
            { 
                // Mark Pass2 as completed in the cache 
                string stateFileName = OutputPath + AssemblyName +
                      (TaskFileService.IsRealBuild ? SharedStrings.StateFile : SharedStrings.IntellisenseStateFile); 
                if (TaskFileService.Exists(stateFileName))
                {
                    CompilerState compilerState = new CompilerState(stateFileName, TaskFileService);
                    compilerState.LoadStateInformation(); 
                    if (compilerState.Pass2Required)
                    { 
                        compilerState.Pass2Required = false; 
                        compilerState.SaveStateInformation();
                    } 
                }

                Log.LogMessageFromResources(SRID.CompileSucceed_Pass2);
                return true; 
            }
        } 
 

        #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; } 
        }

        ///
        /// OutputPath 
        /// Directory which will contain the generated baml files.
        /// 
        [Required] 
        public string OutputPath
        { 
            get { return _outputPath; }
            set
            {
                string filePath = value; 

                // Get the relative path based on sourceDir 
                _outputPath= TaskHelper.CreateFullFilePath(filePath, SourceDir); 

                // Make sure OutputDir always ends with '\\'. 
                if (!_outputPath.EndsWith("\\", StringComparison.Ordinal))
                {
                    _outputPath += "\\";
                } 
            }
        } 
 
        ///
        /// OutputType 
        /// Valid types: exe, winexe, 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; } 
        }

        ///
        /// Root namespace for the classes inside the project. 
        /// It is also used in the Root element record of the generated baml file
        /// when the corresponding markup page is not set x:Class attribute. 
        /// 
        public string RootNamespace
        { 
            get { return _rootNamespace; }
            set { _rootNamespace = 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; } 
        }
 
        ///  
        /// Assembly References.
        ///  
        /// 
        public ITaskItem[] References
        {
            get { return _references; } 
            set { _references = value; }
        } 
 
        ///
        /// 
        public bool XamlDebuggingInformation
        {
            get { return _xamlDebuggingInformation; }
            set { _xamlDebuggingInformation = value; } 
        }
 
        ///  
        /// 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; 
            } 

        } 

        ///
        /// Generated Baml files for the passed markup xaml files
        /// 
        [Output]
        public ITaskItem [] GeneratedBaml 
        { 
            get
            { 
               if (_generatedBaml == null)
                   _generatedBaml = new TaskItem[0];
               return _generatedBaml;
            } 

            set 
            { 
                _generatedBaml = value;
            } 
        }

        /// 
        /// Controls how to generate localization information for each xaml file. 
        /// Valid values: None, CommentsOnly, All.
        ///  
        public string LocalizationDirectivesToLocFile 
        {
            get 
            {
                string localizationDirectives = SharedStrings.Loc_None;

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

                    case MS.Internal.LocalizationDirectivesToLocFile.CommentsOnly:

                        localizationDirectives = SharedStrings.Loc_CommentsOnly; 
                        break;
 
                    case MS.Internal.LocalizationDirectivesToLocFile.All: 

                        localizationDirectives = SharedStrings.Loc_All; 

                        break;

                } 

                return localizationDirectives; 
            } 

            set 
            {
                string localizationDirectives = value;

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

                switch (localizationDirectives) 
                {
                    case SharedStrings.Loc_None:

                        _localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.None; 
                        break;
 
                    case SharedStrings.Loc_CommentsOnly: 

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

                    case SharedStrings.Loc_All:
 
                        _localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.All;
                        break; 
 
                    default:
                        _localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.Unknown; 
                        break;
                }

            } 
        }
 
 
        #endregion Public Properties
 
        //-----------------------------------------------------
        //
        // Private Properties
        // 
        //------------------------------------------------------
 
        // 
        // TaskFileService
        // 
        private ITaskFileService TaskFileService
        {
            get { return _taskFileService; }
        } 

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

        #region Private Methods 

        // 
        // Initialze the local xaml cache file. 
        //
        // return value: 
        //
        //    If cache doesn't exist, or both LocalAppDef and LocallXaml Pages do not exist, return false
        //    to indicate no further work required.
        //    otherwise, return true. 
        //
        private bool InitLocalXamlCache() 
        { 
            bool hasLocalFiles = false;
 
            _compilerLocalRefCache = new CompilerLocalReference(
                         OutputPath + AssemblyName + (TaskFileService.IsRealBuild? SharedStrings.LocalTypeCacheFile : SharedStrings.IntellisenseLocalTypeCacheFile),
                        _taskFileService);
 
            if (_compilerLocalRefCache.CacheFileExists())
            { 
                _compilerLocalRefCache.LoadCacheFile(); 

                _localApplicationFile = _compilerLocalRefCache.LocalApplicationFile; 
                _localMarkupPages = _compilerLocalRefCache.LocalMarkupPages;

                if (_localApplicationFile != null || (_localMarkupPages != null && _localMarkupPages.Length > 0))
                { 
                    hasLocalFiles = true;
 
                    // 
                    // Initialize InternalTypeHelper file from the cache file first.
                    // Further handling will be taken after the xaml file compilation is done. 
                    //
                    // If InternalTypeHelperFile is set in the Cache file, it means Pass1 cannot
                    // detect whether or not to keep the InternalTypeHelper File until the Pass2
                    // xaml file compilation is done. 
                    //
                    _internalTypeHelperFile = _compilerLocalRefCache.InternalTypeHelperFile; 
                } 
            }
 
            return hasLocalFiles;
        }

        // 
        // 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;
        }
 

        // 
        // Generate the necessary file lists and other information required by MarkupCompiler. 
        //
        // Output ArrayLists:  localApplicationFile, 
        //                     localXamlPageFileList
        //                     referenceList
        //
        private void PrepareForMarkupCompilation(out string localApplicationFile, out string [] localXamlPageFileList, out ArrayList referenceList) 
        {
            Log.LogMessageFromResources(MessageImportance.Low, SRID.PreparingCompile); 
            Log.LogMessageFromResources(MessageImportance.Low, SRID.OutputType, OutputType); 

            // Initialize the output parameters 
            localXamlPageFileList = new string[0];
            localApplicationFile = String.Empty;
            referenceList = new ArrayList();
 
            if (_localApplicationFile != null)
            { 
                // We don't want to support multiple application definition file per project. 
                localApplicationFile = _localApplicationFile.FilePath;
 
                Log.LogMessageFromResources(MessageImportance.Low, SRID.LocalRefAppDefFile, localApplicationFile);

            }
 
            // Generate the Xaml Markup file list
            if (_localMarkupPages != null && _localMarkupPages.Length > 0) 
            { 
                int localFileNum = _localMarkupPages.Length;
                localXamlPageFileList = new string[localFileNum]; 

                for (int i = 0; i < localFileNum; i++)
                {
                    string localPageFile = _localMarkupPages[i].FilePath; 

                    localXamlPageFileList[i] = localPageFile; 
                    Log.LogMessageFromResources(MessageImportance.Low, SRID.LocalRefMarkupPage, localPageFile); 
                }
            } 

            //
            // Generate the asmmebly reference list.
            // The temporay target assembly should have been added into Reference list from target file. 
            //
            if (References != null && References.Length > 0) 
            { 
                ReferenceAssembly asmReference;
                string refpath, asmname; 

                for (int i = 0; i < References.Length; i++)
                {
                    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);
                        } 
                    } 
                }
            } 

        }

        // 
        // Call MarkupCompiler to do the real compilation work.
        // 
        private void DoLocalReferenceMarkupCompilation(string localApplicationFile, string [] localXamlPageFileList, ArrayList referenceList) 
        {
            // When code goes here, the MarkupCompilation is really required, so don't need 
            // to do more further validation inside this private method.

            Log.LogMessageFromResources(MessageImportance.Low, SRID.DoCompilation);
 
            AppDomain appDomain = null;
            CompilerWrapper compilerWrapper = null; 
 
            try
            { 
                compilerWrapper = TaskHelper.CreateCompilerWrapper(AlwaysCompileMarkupFilesInSeparateDomain, ref appDomain);

                if (compilerWrapper != null)
                { 

                    compilerWrapper.OutputPath = OutputPath; 
 
                    compilerWrapper.TaskLogger = Log;
                    compilerWrapper.UnknownErrorID = UnknownErrorID; 
                    compilerWrapper.XamlDebuggingInformation = XamlDebuggingInformation;

                    compilerWrapper.TaskFileService = _taskFileService;
 
                    if (OutputType.Equals(SharedStrings.Exe) || OutputType.Equals(SharedStrings.WinExe))
                    { 
                        compilerWrapper.ApplicationMarkup = localApplicationFile; 
                    }
 
                    compilerWrapper.References = referenceList;

                    compilerWrapper.LocalizationDirectivesToLocFile = (int)_localizationDirectives;
 
                    // This is for Pass2 compilation
                    compilerWrapper.DoCompilation(AssemblyName, Language, RootNamespace, localXamlPageFileList, true); 
 
                    //
                    // If no any xaml file with local-types wants to reference an internal type from 
                    // current assembly and friend assembly, and InternalTypeHelperFile is set in the
                    // cache file, now it is the time to remove the content of InternalTypeHelper File.
                    //
                    // We still keep the empty file to make other parts of the build system happy. 
                    //
                    if (!String.IsNullOrEmpty(_internalTypeHelperFile) && !compilerWrapper.HasInternals) 
                    { 
                        if (TaskFileService.Exists(_internalTypeHelperFile))
                        { 
                            // Make empty content for this file.

                            MemoryStream memStream = new MemoryStream();
 
                            using (StreamWriter writer = new StreamWriter(memStream, new UTF8Encoding(false)))
                            { 
                                writer.WriteLine(String.Empty); 
                                writer.Flush();
                                TaskFileService.WriteFile(memStream.ToArray(), _internalTypeHelperFile); 
                            }

                            Log.LogMessageFromResources(MessageImportance.Low, SRID.InternalTypeHelperNotRequired, _internalTypeHelperFile);
                        } 
                    }
                } 
            } 
            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 Baml files.
            ArrayList bamlFileList = new ArrayList(); 
            string    newSourceDir = SourceDir;  // Just for calling GetResolvedFilePath
            string    relativeFile; 
 
            if (_localApplicationFile != null)
            { 
                TaskItem bamlItem;

                relativeFile = GetResolvedFilePath(_localApplicationFile.FilePath, ref newSourceDir);
 
                bamlItem = GenerateBamlItem(relativeFile, _localApplicationFile.Localizable);
 
                if (bamlItem != null) 
                {
                    bamlFileList.Add(bamlItem); 

                    Log.LogMessageFromResources(MessageImportance.Low, SRID.LocalRefGeneratedBamlFile, bamlItem.ItemSpec);
                }
            } 

            if (_localMarkupPages != null && _localMarkupPages.Length > 0) 
            { 

                for (int i = 0; i < _localMarkupPages.Length; i++) 
                {
                    // add the baml file
                    relativeFile = GetResolvedFilePath(_localMarkupPages[i].FilePath, ref newSourceDir);
 
                    TaskItem bamlItem = GenerateBamlItem(relativeFile, _localMarkupPages[i].Localizable);
 
                    if (bamlItem != null) 
                    {
                        bamlFileList.Add(bamlItem); 
                        Log.LogMessageFromResources(MessageImportance.Low, SRID.LocalRefGeneratedBamlFile, bamlItem.ItemSpec);
                    }
                }
            } 

            // Generate the  Baml Output Item 
            GeneratedBaml = (ITaskItem[])bamlFileList.ToArray(typeof(ITaskItem)); 

        } 

        //
        // 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 or a Markup Page
        // 
        // Note: the xaml file must be resolved by calling GetResolvedFilePath( ) or 
        // CreatFullFilePath( ) before calling this method.
        // 
        private TaskItem GenerateBamlItem(string resolvedXamlfile, bool localizable)
        {
            TaskItem bamlItem = null;
 
            //
            // For a given .xaml file (foo.xaml), there are below options for generated file: 
            // 
            //    1.  A baml file with the same xaml file base name. foo.baml (such as page)
            //    2.  No baml file generated. such as  logical component, 
            //                                      or some simple Application definition xaml.
            //

            string bamlFileName = Path.ChangeExtension(resolvedXamlfile, SharedStrings.BamlExtension); 

            string bamlFile = OutputPath + bamlFileName; 
 

            if (TaskFileService.Exists(bamlFile)) 
            {
                //
                // Baml file exists.
                // Generate a TaskItem for it. 
                //
 
                bamlItem = new TaskItem(); 
                bamlItem.ItemSpec = bamlFile;
 
                // Transfer the metadata value from source item to the generated baml item.
                bamlItem.SetMetadata(SharedStrings.Localizable, localizable ?  "True" : "False");
            }
 
            return bamlItem;
        } 
 

        // 
        // Don't support local reference xaml compilation for netmodule type.
        //
        private bool IsSupportedOutputType(string outputType)
        { 
            bool isSupported = false;
 
            switch (outputType) 
            {
                case SharedStrings.Exe : 
                case SharedStrings.WinExe:
                case SharedStrings.Library :
                    isSupported = true;
                    break; 
                default:
                    isSupported = false; 
                    break; 
            }
 
            if (isSupported == false)
            {
                Log.LogErrorWithCodeFromResources(SRID.TargetIsNotSupported, outputType);
 
                // Keep the error numbers so that the task can stop immediatelly
                // later when Execute( ) is called. 
                _nErrors++; 
            }
 
            return isSupported;
        }

 
        //
        // Clean up the loaded assembly cache entry for the temporary target assembly. 
        // 
        // The underneath Parser keeps a static hash table to cache information for
        // all the loaded assemblies. 
        //
        // If both MCPass1 and MCPass2 run in the same AppDomain, and they are executed in
        // Sparkle or VS.NET DEV environment to support multiple build runs, the referenced
        // cache information for the target assembly which is created in this build task might 
        // impact the next MCPass1 behavior for the next Build run. So we need to clean up
        // the cache information for this special assembly appropriatelly. 
        // 
        private void CleanupReferenceAssemblyCacheForTargetAssembly( )
        { 
            ReflectionHelper.ResetCacheForAssembly(AssemblyName);
        }

        #endregion Private Methods 

        //----------------------------------------------------- 
        // 
        //  Private Properties
        // 
        //------------------------------------------------------

        #region Private Properties
 
        // 
        // The root directory for the applicaiton project. 
        //  
        private string SourceDir
        { 
            get { return _sourceDir; }
        }

        #endregion Private Properties 

        //----------------------------------------------------- 
        // 
        //  Private Fields
        // 
        //------------------------------------------------------

        #region Private Fields
 
        private ITaskItem []               _references;
        private string                     _outputType; 
        private string                     _assemblyName; 
        private string[]                   _assembliesGeneratedDuringBuild;
        private string[]                   _knownReferencePaths; 
        private string                     _rootNamespace = String.Empty;
        private bool                       _xamlDebuggingInformation = false;

        private bool                       _alwaysCompileMarkupFilesInSeparateDomain = true; 

        private LocalizationDirectivesToLocFile _localizationDirectives = MS.Internal.LocalizationDirectivesToLocFile.None; 
 
        private string                     _sourceDir;
        private string                     _outputPath; 
        private string                     _language;

        private ITaskItem []               _generatedBaml;
 
        private int                        _nErrors;
 
        private CompilerLocalReference     _compilerLocalRefCache; 
        private LocalReferenceFile         _localApplicationFile = null;
        private LocalReferenceFile[]       _localMarkupPages = null; 
        private string                     _internalTypeHelperFile = String.Empty;

        private ITaskFileService           _taskFileService;
 

        private const string UnknownErrorID = "MC2000"; 
 
        #endregion Private Fields
 
    }

    #endregion MarkupCompilePass2 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