private static BuildResultCompiledType GetThemeBuildResultType(string themeName) {

        string appThemeCacheKey, globalThemeCacheKey = null;

        // First, check if the application theme is cached
        appThemeCacheKey = "Theme_" + Util.MakeValidTypeNameFromString(themeName);
        BuildResultCompiledType result = (BuildResultCompiledType)
            BuildManager.GetBuildResultFromCache(appThemeCacheKey);

        if (result == null) {
            // Then, check if the global theme is cached
            globalThemeCacheKey = "GlobalTheme_" + themeName;
            result = (BuildResultCompiledType) BuildManager.GetBuildResultFromCache(
                globalThemeCacheKey);
        }

        // If we found a theme buildresulttype, return it
        if (result != null)
            return result;

        bool gotLock = false;

        try {
            // Grab the compilation mutex
            CompilationLock.GetLock(ref gotLock);

            // Check the cache again now that we have the mutex
            result = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(appThemeCacheKey);
            if (result == null) {
                result = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(
                    globalThemeCacheKey);
            }

            if (result != null)
                return result;

        // Theme was not found in the caches; check if the directory exists.
        VirtualPath appVirtualDir, globalVirtualDir = null;

        appVirtualDir = GetAppThemeVirtualDir(themeName);
        PageThemeBuildProvider themeBuildProvider = null;

        VirtualPath virtualDir = appVirtualDir;

        string cacheKey = appThemeCacheKey;
        // If the theme directories do not exist, simply throw
        if (appVirtualDir.DirectoryExists()) {
            themeBuildProvider = new PageThemeBuildProvider(appVirtualDir);
        }
        else {
            globalVirtualDir = GetGlobalThemeVirtualDir(themeName);

            if (!globalVirtualDir.DirectoryExists()) {
                throw new HttpException(SR.GetString(SR.Page_theme_not_found, themeName));
            }

            virtualDir = globalVirtualDir;
            cacheKey = globalThemeCacheKey;
            themeBuildProvider = new GlobalPageThemeBuildProvider(globalVirtualDir);
        }

        // The directory exists (either app or global), so compile it
        DateTime utcStart = DateTime.UtcNow;

        VirtualDirectory vdir = virtualDir.GetDirectory();

        // Add all the .skin files to it
        AddThemeFilesToBuildProvider(vdir, themeBuildProvider, true);

        // Use predictable fixed names for theme assemblies.
        BuildProvidersCompiler bpc = new BuildProvidersCompiler(virtualDir, 
            themeBuildProvider.AssemblyNamePrefix + BuildManager.GenerateRandomAssemblyName(themeName));

        // Add the single build provider to the BuildProvidersCompiler
        bpc.SetBuildProviders(new SingleObjectCollection(themeBuildProvider));

        // Compile it
        CompilerResults results = bpc.PerformBuild();

        // Get the Type we care about from the BuildProvider
        result = (BuildResultCompiledType) themeBuildProvider.GetBuildResult(results);

        // Cache it for next time
        BuildManager.CacheBuildResult(cacheKey, result, utcStart);

        }
        finally {
            // Always release the mutex if we had taken it
            if (gotLock) {
                CompilationLock.ReleaseLock();
            }
        }
        return result;
    }
Exemplo n.º 2
0
        private static BuildResultCompiledType GetThemeBuildResultType(string themeName)
        {
            string appThemeCacheKey, globalThemeCacheKey = null;

            // First, check if the application theme is cached
            appThemeCacheKey = "Theme_" + Util.MakeValidTypeNameFromString(themeName);
            BuildResultCompiledType result = (BuildResultCompiledType)
                                             BuildManager.GetBuildResultFromCache(appThemeCacheKey);

            if (result == null)
            {
                // Then, check if the global theme is cached
                globalThemeCacheKey = "GlobalTheme_" + themeName;
                result = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(
                    globalThemeCacheKey);
            }

            // If we found a theme buildresulttype, return it
            if (result != null)
            {
                return(result);
            }

            bool gotLock = false;

            try {
                // Grab the compilation mutex
                CompilationLock.GetLock(ref gotLock);

                // Check the cache again now that we have the mutex
                result = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(appThemeCacheKey);
                if (result == null)
                {
                    result = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(
                        globalThemeCacheKey);
                }

                if (result != null)
                {
                    return(result);
                }

                // Theme was not found in the caches; check if the directory exists.
                VirtualPath appVirtualDir, globalVirtualDir = null;

                appVirtualDir = GetAppThemeVirtualDir(themeName);
                PageThemeBuildProvider themeBuildProvider = null;

                VirtualPath virtualDir = appVirtualDir;

                string cacheKey = appThemeCacheKey;
                // If the theme directories do not exist, simply throw
                if (appVirtualDir.DirectoryExists())
                {
                    themeBuildProvider = new PageThemeBuildProvider(appVirtualDir);
                }
                else
                {
                    globalVirtualDir = GetGlobalThemeVirtualDir(themeName);

                    if (!globalVirtualDir.DirectoryExists())
                    {
                        throw new HttpException(SR.GetString(SR.Page_theme_not_found, themeName));
                    }

                    virtualDir         = globalVirtualDir;
                    cacheKey           = globalThemeCacheKey;
                    themeBuildProvider = new GlobalPageThemeBuildProvider(globalVirtualDir);
                }

                // The directory exists (either app or global), so compile it
                DateTime utcStart = DateTime.UtcNow;

                VirtualDirectory vdir = virtualDir.GetDirectory();

                // Add all the .skin files to it
                AddThemeFilesToBuildProvider(vdir, themeBuildProvider, true);

                // Use predictable fixed names for theme assemblies.
                BuildProvidersCompiler bpc = new BuildProvidersCompiler(virtualDir,
                                                                        themeBuildProvider.AssemblyNamePrefix + BuildManager.GenerateRandomAssemblyName(themeName));

                // Add the single build provider to the BuildProvidersCompiler
                bpc.SetBuildProviders(new SingleObjectCollection(themeBuildProvider));

                // Compile it
                CompilerResults results = bpc.PerformBuild();

                // Get the Type we care about from the BuildProvider
                result = (BuildResultCompiledType)themeBuildProvider.GetBuildResult(results);

                // Cache it for next time
                BuildManager.CacheBuildResult(cacheKey, result, utcStart);
            }
            finally {
                // Always release the mutex if we had taken it
                if (gotLock)
                {
                    CompilationLock.ReleaseLock();
                }
            }
            return(result);
        }
 private static BuildResultCompiledType GetThemeBuildResultType(string themeName)
 {
     string cacheKey = null;
     string str = "Theme_" + Util.MakeValidTypeNameFromString(themeName);
     BuildResultCompiledType buildResultFromCache = (BuildResultCompiledType) BuildManager.GetBuildResultFromCache(str);
     if (buildResultFromCache == null)
     {
         cacheKey = "GlobalTheme_" + themeName;
         buildResultFromCache = (BuildResultCompiledType) BuildManager.GetBuildResultFromCache(cacheKey);
     }
     if (buildResultFromCache == null)
     {
         bool gotLock = false;
         try
         {
             CompilationLock.GetLock(ref gotLock);
             buildResultFromCache = (BuildResultCompiledType) BuildManager.GetBuildResultFromCache(str);
             if (buildResultFromCache == null)
             {
                 buildResultFromCache = (BuildResultCompiledType) BuildManager.GetBuildResultFromCache(cacheKey);
             }
             if (buildResultFromCache != null)
             {
                 return buildResultFromCache;
             }
             VirtualPath virtualDirPath = null;
             VirtualPath appThemeVirtualDir = GetAppThemeVirtualDir(themeName);
             PageThemeBuildProvider themeBuildProvider = null;
             VirtualPath configPath = appThemeVirtualDir;
             string str3 = str;
             if (appThemeVirtualDir.DirectoryExists())
             {
                 themeBuildProvider = new PageThemeBuildProvider(appThemeVirtualDir);
             }
             else
             {
                 virtualDirPath = GetGlobalThemeVirtualDir(themeName);
                 if (!virtualDirPath.DirectoryExists())
                 {
                     throw new HttpException(System.Web.SR.GetString("Page_theme_not_found", new object[] { themeName }));
                 }
                 configPath = virtualDirPath;
                 str3 = cacheKey;
                 themeBuildProvider = new GlobalPageThemeBuildProvider(virtualDirPath);
             }
             DateTime utcNow = DateTime.UtcNow;
             AddThemeFilesToBuildProvider(configPath.GetDirectory(), themeBuildProvider, true);
             BuildProvidersCompiler compiler = new BuildProvidersCompiler(configPath, themeBuildProvider.AssemblyNamePrefix + BuildManager.GenerateRandomAssemblyName(themeName));
             compiler.SetBuildProviders(new SingleObjectCollection(themeBuildProvider));
             CompilerResults results = compiler.PerformBuild();
             buildResultFromCache = (BuildResultCompiledType) themeBuildProvider.GetBuildResult(results);
             BuildManager.CacheBuildResult(str3, buildResultFromCache, utcNow);
         }
         finally
         {
             if (gotLock)
             {
                 CompilationLock.ReleaseLock();
             }
         }
     }
     return buildResultFromCache;
 }
Exemplo n.º 4
0
        private static BuildResultCompiledType GetThemeBuildResultType(string themeName)
        {
            string cacheKey = null;
            string str      = "Theme_" + Util.MakeValidTypeNameFromString(themeName);
            BuildResultCompiledType buildResultFromCache = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(str);

            if (buildResultFromCache == null)
            {
                cacheKey             = "GlobalTheme_" + themeName;
                buildResultFromCache = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(cacheKey);
            }
            if (buildResultFromCache == null)
            {
                bool gotLock = false;
                try
                {
                    CompilationLock.GetLock(ref gotLock);
                    buildResultFromCache = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(str);
                    if (buildResultFromCache == null)
                    {
                        buildResultFromCache = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(cacheKey);
                    }
                    if (buildResultFromCache != null)
                    {
                        return(buildResultFromCache);
                    }
                    VirtualPath            virtualDirPath     = null;
                    VirtualPath            appThemeVirtualDir = GetAppThemeVirtualDir(themeName);
                    PageThemeBuildProvider themeBuildProvider = null;
                    VirtualPath            configPath         = appThemeVirtualDir;
                    string str3 = str;
                    if (appThemeVirtualDir.DirectoryExists())
                    {
                        themeBuildProvider = new PageThemeBuildProvider(appThemeVirtualDir);
                    }
                    else
                    {
                        virtualDirPath = GetGlobalThemeVirtualDir(themeName);
                        if (!virtualDirPath.DirectoryExists())
                        {
                            throw new HttpException(System.Web.SR.GetString("Page_theme_not_found", new object[] { themeName }));
                        }
                        configPath         = virtualDirPath;
                        str3               = cacheKey;
                        themeBuildProvider = new GlobalPageThemeBuildProvider(virtualDirPath);
                    }
                    DateTime utcNow = DateTime.UtcNow;
                    AddThemeFilesToBuildProvider(configPath.GetDirectory(), themeBuildProvider, true);
                    BuildProvidersCompiler compiler = new BuildProvidersCompiler(configPath, themeBuildProvider.AssemblyNamePrefix + BuildManager.GenerateRandomAssemblyName(themeName));
                    compiler.SetBuildProviders(new SingleObjectCollection(themeBuildProvider));
                    CompilerResults results = compiler.PerformBuild();
                    buildResultFromCache = (BuildResultCompiledType)themeBuildProvider.GetBuildResult(results);
                    BuildManager.CacheBuildResult(str3, buildResultFromCache, utcNow);
                }
                finally
                {
                    if (gotLock)
                    {
                        CompilationLock.ReleaseLock();
                    }
                }
            }
            return(buildResultFromCache);
        }