//------------------------------------------------------------------------------
// <copyright file="WCFBuildProvider.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>                                                                
//------------------------------------------------------------------------------

namespace System.Web.Compilation
{

    using System;
    using System.Globalization;
    using System.CodeDom;
    using System.CodeDom.Compiler;
    using System.Collections.Specialized;
    using System.Collections;
    using System.Diagnostics.CodeAnalysis;
    using System.Net;
    using System.Xml.Serialization;
    using System.Web.Hosting;
    using System.Web.UI;
    using System.Diagnostics;
    using System.Threading;
    using System.Text;
    using System.Web.Compilation.WCFModel;
    using System.Collections.Generic;
    using System.Web.Configuration;
    using System.Web.Resources;
    using System.Security;
    using System.Security.Permissions;
    using System.Data.Services.Design;
    using System.IO;
    using System.Xml;
    using System.Reflection;


    /// <summary>
    /// A build provider for WCF service references in ASP.NET projects.
    ///   (Note: the ASMX version is called WebReferencesBuildProvider).
    /// Due to compatibility requirements, as few changes as possible were made
    ///   to System.Web.dll, which contains the build manager and WebReferencesBuildProvider.
    ///   WebReferencesBuildProvider will call into us for the App_WebReferences folder and
    ///   each of its subdirectories (recursively) if it finds our assembly and type on the
    ///   machine.
    /// Note: for a normal BuildProvider, the input file is represented by the protected VirtualPath
    ///   property of the base.  But for this build provider (same as for WebReferencesBuildProvider, the
    ///   asmx web references build provider), the input is an entire directory, which is still represented
    ///   by the protected VirtualPath property.
    /// TO DEBUG: The easiest way to debug is to debug the aspnet_compiler.exe command-line tool
    ///   while it compiles a website with a .svcmap file in it.
    ///   As an example, you could debug aspnet_compiler.exe with this command-line to debug
    ///   one of the suites:
    ///   
    ///     /v MiddleService -p {path}\ddsuites\src\vs\vb\IndigoTools\BuildProvider\WCFBuildProvider1\WebSite\MiddleService -c c:\temp\output
    ///     
    ///   Important: it will only call the build provider if the sources in the website have changed or if you delete
    ///   the deleted output folder's contents.
    ///   
    /// Data services (Astoria): in order to support Astoria "data services" we added code
    /// to scan for "datasvcmap" files in addition to the existing "svcmap" files. For data services
    /// we call into the Astoria code-gen library to do the work instead of the regular indigo path.
    ///     
    /// </summary>
    [
    SuppressMessage("Microsoft.Naming", "CA1705:LongAcronymsShouldBePascalCased",
                    Justification = "Too late to change in Orcas--the WCFBuildProvider is hard-coded in ASP.NET " +
                                   "build manager for app_webreferences folder. Build manager is part of redbits.")
    ]
    // Transparency
    [SecurityCritical]
    public class WCFBuildProvider : BuildProvider
    {
        internal const string WebRefDirectoryName = "App_WebReferences";
        internal const string SvcMapExtension = ".svcmap";
        internal const string DataSvcMapExtension = ".datasvcmap";
        private const string TOOL_CONFIG_ITEM_NAME = "Reference.config";

        /// <summary>
        /// version number for 3.5 framework
        /// </summary>
        private const int FRAMEWORK_VERSION_35 = 0x30005;

        /// <summary>
        /// Search through the folder represented by base.VirtualPath for .svcmap and .datasvcmap files.  
        /// If any .svcmap/.datasvcmap files are found, then generate proxy code for them into the 
        /// specified assemblyBuilder.
        /// </summary>
        /// <param name="assemblyBuilder">Where to generate the proxy code</param>
        /// <remarks>
        /// When this routine is called, it is expected that the protected VirtualPath property has
        ///   been set to the folder to scan for .svcmap/.datasvcmap files.
        /// </remarks>
        [SecuritySafeCritical]
        public override void GenerateCode(AssemblyBuilder assemblyBuilder)
        {

            // Go through all the svcmap files in the directory
            VirtualDirectory vdir = GetVirtualDirectory(VirtualPath);
            foreach (VirtualFile child in vdir.Files)
            {
                string extension = IO.Path.GetExtension(child.VirtualPath);
                if (extension.Equals(SvcMapExtension, StringComparison.OrdinalIgnoreCase))
                {
                    // .svcmap file found

                    // NOTE: the WebReferences code requires a physical path, so this feature
                    // cannot work with a non-file based VirtualPathProvider
                    string physicalPath = HostingEnvironment.MapPath(child.VirtualPath);

                    CodeCompileUnit codeUnit = GenerateCodeFromServiceMapFile(physicalPath);

                    // Add the CodeCompileUnit to the compilation
                    assemblyBuilder.AddCodeCompileUnit(this, codeUnit);
                }
                else if (extension.Equals(DataSvcMapExtension, StringComparison.OrdinalIgnoreCase))
                {
                    // In .NET FX 3.5, the ADO.NET Data Service build provider was included as part of the
                    // WCF build provider. In .NET FX 4.0, it is a separate build provider. However, under certain
                    // circumstances (i.e. design time/Visual Studio), we may call the 4.0 version of the build provider 
                    // when we actually want the web site to target .NET FX 3.5, and in that case, we have to emulate the 
                    // old behavior. 
                    if (BuildManager.TargetFramework.Version.Major < 4)
                    {

                        // NOTE: the WebReferences code requires a physical path, so this feature
                        // cannot work with a non-file based VirtualPathProvider
                        string physicalPath = HostingEnvironment.MapPath(child.VirtualPath);

                        GenerateCodeFromDataServiceMapFile(physicalPath, assemblyBuilder);
                    }
                }
            }
        }

        /// <summary>
        /// Generate code for one .datasvcmap file
        /// </summary>
        /// <param name="mapFilePath">The physical path to the data service map file</param>
        private void GenerateCodeFromDataServiceMapFile(string mapFilePath, AssemblyBuilder assemblyBuilder)
        {
            try
            {
                assemblyBuilder.AddAssemblyReference(typeof(System.Data.Services.Client.DataServiceContext).Assembly);

                DataSvcMapFileLoader loader = new DataSvcMapFileLoader(mapFilePath);
                DataSvcMapFile mapFile = loader.LoadMapFile() as DataSvcMapFile;

                if (mapFile.MetadataList[0].ErrorInLoading != null)
                {
                    throw mapFile.MetadataList[0].ErrorInLoading;
                }

                string edmxContent = mapFile.MetadataList[0].Content;

                System.Data.Services.Design.EntityClassGenerator generator = new System.Data.Services.Design.EntityClassGenerator(LanguageOption.GenerateCSharpCode);

                // the EntityClassGenerator works on streams/writers, does not return a CodeDom
                // object, so we use CreateCodeFile instead of compile units.
                using (TextWriter writer = assemblyBuilder.CreateCodeFile(this))
                {

                    // Note: currently GenerateCode never actually returns values
                    // for the error case (even though it returns an IList of error
                    // objects). Instead it throws on error. This may need some tweaking 
                    // later on.
#if DEBUG
                object errors = 
#endif
                    generator.GenerateCode(
                        XmlReader.Create(new StringReader(edmxContent)),
                        writer,
                        GetGeneratedNamespace());

#if DEBUG
                Debug.Assert(
                    errors == null ||
                    !(errors is ICollection) ||
                    ((ICollection)errors).Count == 0,
                    "Errors reported through the return value. Expected an exception");
#endif
                    writer.Flush();
                }
            }
            catch (Exception ex)
            {
                string errorMessage = ex.Message;
                errorMessage = String.Format(CultureInfo.CurrentCulture, "{0}: {1}", IO.Path.GetFileName(mapFilePath), errorMessage);
                throw new InvalidOperationException(errorMessage, ex);
            }
        }

        /// <summary>
        /// Generate code for one .svcmap file
        /// </summary>
        /// <param name="mapFilePath">the path to the service map file</param>
        /// <return></return>
        /// <remarks></remarks>
        [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification="Violation is no longer relevant due to 4.0 CAS model")]
        private CodeCompileUnit GenerateCodeFromServiceMapFile(string mapFilePath)
        {
            try
            {
                string generatedNamespace = GetGeneratedNamespace();
                SvcMapFileLoader loader = new SvcMapFileLoader(mapFilePath);
                SvcMapFile mapFile = loader.LoadMapFile() as SvcMapFile;

                HandleProxyGenerationErrors(mapFile.LoadErrors);

                // We always use C# for the generated proxy
                CodeDomProvider provider = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("c#");

                //Note: with the current implementation of the generator, it does all of its
                //  work in the constructor.  This may change in the future.
                VSWCFServiceContractGenerator generator = VSWCFServiceContractGenerator.GenerateCodeAndConfiguration(
                    mapFile,
                    GetToolConfig(mapFile, mapFilePath),
                    provider,
                    generatedNamespace,
                    null, //targetConfiguration
                    null, //configurationNamespace
                    new ImportExtensionServiceProvider(),
                    new TypeResolver(),
                    FRAMEWORK_VERSION_35,
                    typeof (System.Data.Design.TypedDataSetSchemaImporterExtensionFx35) //Always we are above framework version 3.5
                );

                // Determine what "name" to display to users for the service if there are any exceptions
                // If generatedNamespace is empty, then we display the name of the .svcmap file.
                string referenceDisplayName = String.IsNullOrEmpty(generatedNamespace) ?
                    System.IO.Path.GetFileName(mapFilePath) : generatedNamespace;
                
                VerifyGeneratedCodeAndHandleErrors(referenceDisplayName, mapFile, generator.TargetCompileUnit, generator.ImportErrors, generator.ProxyGenerationErrors);
#if DEBUG
#if false
                IO.TextWriter writer = new IO.StringWriter();
                CodeGeneratorOptions options = new CodeGeneratorOptions();
                options.BlankLinesBetweenMembers=true;
                provider.GenerateCodeFromCompileUnit(generator.TargetCompileUnit, writer, options);
                Debug.WriteLine("Generated proxy code:\r\n" + writer.ToString());
#endif
#endif
                return generator.TargetCompileUnit;
            }
            catch (Exception ex)
            {
                string errorMessage = ex.Message;
                errorMessage = String.Format(CultureInfo.CurrentCulture, "{0}: {1}", IO.Path.GetFileName(mapFilePath), errorMessage);
                throw new InvalidOperationException(errorMessage, ex);
            }
        }

        /// <summary>
        /// If there are errors passed in, handle them by throwing an appropriate error
        /// </summary>
        /// <param name="errors">IEnumerable for easier unit test accessors</param>
        private static void HandleProxyGenerationErrors(System.Collections.IEnumerable /*<ProxyGenerationError>*/ errors)
        {
            foreach (ProxyGenerationError generationError in errors)
            {
                // NOTE: the ASP.Net framework does not handle an error list, so we only give them the first error message
                // all warning messages are ignored today
                //
                // We treat all error messages from WsdlImport and ProxyGenerator as warning messages
                //   The reason is that many of them are ignorable and doesn't block generating useful code.
                if (!generationError.IsWarning && 
                        generationError.ErrorGeneratorState != WCFModel.ProxyGenerationError.GeneratorState.GenerateCode)
                {
                    throw new InvalidOperationException(ConvertToBuildProviderErrorMessage(generationError));
                }
            }
        }

        /// <summary>
        /// Merge error message strings together
        /// </summary>
        /// <param name="errors"></param>
        /// <param name="collectedMessages"></param>
        /// <return></return>
        /// <remarks></remarks>
        private static void CollectErrorMessages(System.Collections.IEnumerable errors, StringBuilder collectedMessages)
        {
            foreach (ProxyGenerationError generationError in errors)
            {
                if (!generationError.IsWarning)
                {
                    if (collectedMessages.Length > 0)
                    {
                        collectedMessages.Append(Environment.NewLine);
                    }
                    collectedMessages.Append(ConvertToBuildProviderErrorMessage(generationError));
                }
            }
        }

        /// <summary>
        /// Format an error reported by the code generator to message string reported to the user.
        /// </summary>
        /// <param name="generationError"></param>
        /// <return></return>
        /// <remarks></remarks>
        private static string ConvertToBuildProviderErrorMessage(ProxyGenerationError generationError)
        {
            string errorMessage = generationError.Message;
            if (!String.IsNullOrEmpty(generationError.MetadataFile))
            {
                if (generationError.LineNumber < 0)
                {
                    errorMessage = String.Format(CultureInfo.CurrentCulture, "'{0}': {1}", generationError.MetadataFile, errorMessage);
                }
                else if (generationError.LinePosition < 0)
                {
                    errorMessage = String.Format(CultureInfo.CurrentCulture, "'{0}' ({1}): {2}", generationError.MetadataFile, generationError.LineNumber, errorMessage);
                }
                else
                {
                    errorMessage = String.Format(CultureInfo.CurrentCulture, "'{0}' ({1},{2}): {3}", generationError.MetadataFile, generationError.LineNumber, generationError.LinePosition, errorMessage);
                }
            }
            return errorMessage;
        }

        /// <summary>
        /// Check the result from the code generator.
        /// By default we treat all error messages from WsdlImporter as warnings,
        /// and they will be ignored if valid code has been generated.
        /// We may hit other errors when we parse the metadata files.
        /// Those errors (which are usually because of a bad file) will not be ignored, because the user can fix them.
        /// If the WsdlImporter hasn't generated any code as we expect, we have to consider some of the error messages are fatal.
        /// We collect those messages and report to the user.
        /// </summary>
        /// <param name="referenceDisplayName">The name of the generated reference</param>
        /// <param name="mapFile">Original Map File</param>
        /// <param name="generatedCode">generated code compile unit</param>
        /// <param name="importErrors"></param>
        /// <param name="generatorErrors"></param>
        /// <remarks></remarks>
        private static void VerifyGeneratedCodeAndHandleErrors(
                                            string referenceDisplayName,
                                            SvcMapFile mapFile,
                                            CodeCompileUnit generatedCode,
                                            System.Collections.IEnumerable importErrors,
                                            System.Collections.IEnumerable generatorErrors)
        {
            // Check and report fatal error first...
            HandleProxyGenerationErrors(importErrors);
            HandleProxyGenerationErrors(generatorErrors);

            // if there is no fatal error, we expect valid type generated from the process
            //   unless there is no metadata files, or there is a service contract type sharing
            if (mapFile.MetadataList.Count > 0 && mapFile.ClientOptions.ServiceContractMappingList.Count == 0)
            {
                if (!IsAnyTypeGenerated(generatedCode))
                {
                    StringBuilder collectedMessages = new StringBuilder();

                    // merge error messages
                    CollectErrorMessages(importErrors, collectedMessages);
                    CollectErrorMessages(generatorErrors, collectedMessages);

                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, WCFModelStrings.ReferenceGroup_FailedToGenerateCode, referenceDisplayName, collectedMessages.ToString()));
                }
            }
        }

        /// <summary>
        /// Check whether we have generated any types
        /// </summary>
        /// <param name="CompileUnit"></param>
        /// <return></return>
        /// <remarks></remarks>
        private static bool IsAnyTypeGenerated(CodeCompileUnit compileUnit)
        {
            if (compileUnit != null)
            {
                foreach (System.CodeDom.CodeNamespace codeNamespace in compileUnit.Namespaces)
                {
                    if (codeNamespace.Types.Count > 0)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        /// <summary>
        ///  Retrieve a VirtualDirectory for the given virtual path
        /// </summary>
        /// <param name="virtualPath"></param>
        /// <returns></returns>
        private VirtualDirectory GetVirtualDirectory(string virtualPath)
        {
            return HostingEnvironment.VirtualPathProvider.GetDirectory(VirtualPath);
        }

        /// <summary>
        ///  Caculate our namespace for current VirtualPath...
        /// </summary>
        /// <return></return>
        /// <remarks></remarks>
        private string GetGeneratedNamespace()
        {
            // First, determine the namespace to use for code generation.  This is based on the
            //   relative path of the reference from its base App_WebReferences directory

            // ... Get the virtual path to the App_WebReferences folder, e.g "/MyApp/App_WebReferences"
            string rootWebRefDirVirtualPath = GetWebRefDirectoryVirtualPath();

            // ... Get the folder's directory path, e.g "/MyApp/Application_WebReferences/Foo/Bar",
            //     where we'll look for .svcmap files
            string currentSubfolderUnderWebReferences = this.VirtualPath;
            if (currentSubfolderUnderWebReferences == null)
            {
                Debug.Fail("Shouldn't be given a null virtual path");
                throw new InvalidOperationException();
            }

            return CalculateGeneratedNamespace(rootWebRefDirVirtualPath, currentSubfolderUnderWebReferences);
        }

        /// <summary>
        /// Determine the namespace to use for the proxy generation
        /// </summary>
        /// <param name="webReferencesRootVirtualPath">The path to the App_WebReferences folder</param>
        /// <param name="virtualPath">The path to the current folder</param>
        /// <returns></returns>
        private static string CalculateGeneratedNamespace(string webReferencesRootVirtualPath, string virtualPath)
        {
            // ... Ensure both folders have trailing slashes
            webReferencesRootVirtualPath = VirtualPathUtility.AppendTrailingSlash(webReferencesRootVirtualPath);
            virtualPath = VirtualPathUtility.AppendTrailingSlash(virtualPath);

            Debug.Assert(virtualPath.StartsWith(webReferencesRootVirtualPath, StringComparison.OrdinalIgnoreCase),
                "We expected to be inside the App_WebReferences folder");

            // ... Determine the namespace to use, based on the directory structure where the .svcmap file
            //     is found.
            if (webReferencesRootVirtualPath.Length == virtualPath.Length)
            {
                Debug.Assert(string.Equals(webReferencesRootVirtualPath, virtualPath, StringComparison.OrdinalIgnoreCase),
                    "We expected to be in the App_WebReferences directory");

                // If it's the root WebReferences dir, use the empty namespace
                return String.Empty;
            }
            else
            {
                // We're in a subdirectory of App_WebReferences.
                // Get the directory's relative path from App_WebReferences, e.g. "Foo/Bar"

                virtualPath = VirtualPathUtility.RemoveTrailingSlash(virtualPath).Substring(webReferencesRootVirtualPath.Length);

                // Split it into chunks separated by '/'
                string[] chunks = virtualPath.Split('/');

                // Turn all the relevant chunks into valid namespace chunks
                for (int i = 0; i < chunks.Length; i++)
                {
                    chunks[i] = MakeValidTypeNameFromString(chunks[i]);
                }

                // Put the relevant chunks back together to form the namespace
                return String.Join(".", chunks);
            }
        }

        /// <summary>
        /// Returns the app domain's application virtual path [from HttpRuntime.AppDomainAppVPath].
        /// Includes trailing slash, e.g. "/MyApp/"
        /// </summary>
        private static string GetAppDomainAppVirtualPath()
        {
            string appVirtualPath = HttpRuntime.AppDomainAppVirtualPath;
            if (appVirtualPath == null)
            {
                Debug.Fail("Shouldn't get a null app virtual path from the app domain");
                throw new InvalidOperationException();
            }

            return VirtualPathUtility.AppendTrailingSlash(VirtualPathUtility.ToAbsolute(appVirtualPath));
        }

        /// <summary>
        /// Gets the virtual path to the application's App_WebReferences directory, e.g. "/MyApp/App_WebReferences/"
        /// </summary>
        private static string GetWebRefDirectoryVirtualPath()
        {
            return VirtualPathUtility.Combine(GetAppDomainAppVirtualPath(), WebRefDirectoryName + @"\");
        }

        /// <summary>
        /// Return a valid type name from a string by changing any character
        ///   that's not a letter or a digit to an '_'.
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        internal static string MakeValidTypeNameFromString(string typeName)
        {
            if (String.IsNullOrEmpty(typeName))
                throw new ArgumentNullException("typeName");

            StringBuilder sb = new StringBuilder();

            for (int i = 0; i < typeName.Length; i++)
            {
                // Make sure it doesn't start with a digit (ASURT 31134)
                if (i == 0 && Char.IsDigit(typeName[0]))
                    sb.Append('_');

                if (Char.IsLetterOrDigit(typeName[i]))
                    sb.Append(typeName[i]);
                else
                    sb.Append('_');
            }

            // Identifier can't be a single underscore character
            string validTypeName = sb.ToString();
            if (validTypeName.Equals("_", StringComparison.Ordinal))
            {
                validTypeName = "__";
            }

            return validTypeName;
        }

        /// <summary>
        /// Get the appropriate tool configuration for this service reference.
        /// 
        /// If a reference.config file is present, the configuration object returned 
        /// will be the merged view of:
        /// 
        ///    Machine Config
        ///       ReferenceConfig
        ///       
        /// If not reference.config file is present, the configuration object returned
        /// will be a merged view of:
        ///     
        ///     Machine.config
        ///         web.config in application's physical path...
        ///         
        /// </summary>
        /// <param name="mapFile">SvcMapFile representing the service</param>
        /// <returns></returns>
        private System.Configuration.Configuration GetToolConfig(SvcMapFile mapFile, string mapFilePath)
        {
            string toolConfigFile = null;

            if (mapFile != null && mapFilePath != null)
            {
                foreach (ExtensionFile extensionFile in mapFile.Extensions)
                {
                    if (String.Equals(extensionFile.Name, TOOL_CONFIG_ITEM_NAME, StringComparison.Ordinal))
                    {
                        toolConfigFile = extensionFile.FileName;
                    }
                }
            }

            System.Web.Configuration.WebConfigurationFileMap fileMap;
            fileMap = new System.Web.Configuration.WebConfigurationFileMap();

            System.Web.Configuration.VirtualDirectoryMapping mapping;
            if (toolConfigFile != null)
            {
                //
                // If we've got a specific tool configuration to use, we better load that...
                //
                mapping = new System.Web.Configuration.VirtualDirectoryMapping(System.IO.Path.GetDirectoryName(mapFilePath), true, toolConfigFile);
            }
            else
            {
                //
                // Otherwise we fall back to the default web.config file...
                //
                mapping = new System.Web.Configuration.VirtualDirectoryMapping(HostingEnvironment.ApplicationPhysicalPath, true);
            }
            fileMap.VirtualDirectories.Add("/", mapping);

            return System.Web.Configuration.WebConfigurationManager.OpenMappedWebConfiguration(fileMap, "/", System.Web.Hosting.HostingEnvironment.SiteName);

        }


        /// <summary>
        /// Helper class to implement type resolution for the generator
        /// </summary>
        private class TypeResolver : IContractGeneratorReferenceTypeLoader
        {
            private System.Reflection.Assembly[] _referencedAssemblies;

            private IEnumerable<System.Reflection.Assembly> ReferencedAssemblies
            {
                get
                {
                    if (_referencedAssemblies == null)
                    {
                        System.Collections.ICollection referencedAssemblyCollection = BuildManager.GetReferencedAssemblies();
                        _referencedAssemblies = new System.Reflection.Assembly[referencedAssemblyCollection.Count];
                        referencedAssemblyCollection.CopyTo(_referencedAssemblies, 0);
                    }
                    return _referencedAssemblies;
                }
            }

            [SecuritySafeCritical]
            System.Type IContractGeneratorReferenceTypeLoader.LoadType(string typeName)
            {
                // If the type can't be resolved, we need an exception thrown (thus the true argument)
                //   so it can be reported as a build error.
                return BuildManager.GetType(typeName, true);
            }

            [SecuritySafeCritical]
            System.Reflection.Assembly IContractGeneratorReferenceTypeLoader.LoadAssembly(string assemblyName)
            {
                System.Reflection.AssemblyName assemblyToLookFor = new System.Reflection.AssemblyName(assemblyName);

                foreach (System.Reflection.Assembly assembly in ReferencedAssemblies)
                {
                    if (System.Reflection.AssemblyName.ReferenceMatchesDefinition(assemblyToLookFor, assembly.GetName()))
                    {
                        return assembly;
                    }
                }

                throw new System.IO.FileNotFoundException(String.Format(CultureInfo.CurrentCulture, WCFModelStrings.ReferenceGroup_FailedToLoadAssembly, assemblyName));
            }

            [SecuritySafeCritical]
            void IContractGeneratorReferenceTypeLoader.LoadAllAssemblies(out IEnumerable<System.Reflection.Assembly> loadedAssemblies, out IEnumerable<Exception> loadingErrors)
            {
                loadedAssemblies = ReferencedAssemblies;
                loadingErrors = new System.Exception[] {};   
            }

        }

        [SuppressMessage("Microsoft.Usage", "CA2302:FlagServiceProviders", Justification = "IServiceProvider implementation does not return anything.")]
        private class ImportExtensionServiceProvider : IServiceProvider
        {

            #region IServiceProvider Members

            [SecuritySafeCritical]
            public object GetService(Type serviceType)
            {
                // We don't currently provide any services to import extensions in the build provider context
                return null;
            }

            #endregion
        }

    }

}