IResourceProvider.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 / ndp / fx / src / xsp / System / Web / Compilation / IResourceProvider.cs / 1305376 / IResourceProvider.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Web.Compilation { 
    using System; 
    using System.Collections;
    using System.Collections.Specialized; 
    using System.Reflection;
    using System.IO;
    using System.Security.Permissions;
    using System.CodeDom; 
    using System.Globalization;
    using System.Resources; 
    using System.Web.Compilation; 
    using System.Web.Util;
    using System.Web.UI; 


    /*
     * Basic interface to access and enumerate resources 
     */
    public interface IResourceProvider { 
 
        /*
         * Retrieve a resource object for the passed in key and culture 
         */
        object GetObject(string resourceKey, CultureInfo culture);

        /* 
         * Returns a reader that enumerates all the neutral resources for this provider
         */ 
        IResourceReader ResourceReader { get; } 
    }
 
    /*
     * Base class for resource providers based on a standard ResourceManager
     */
    internal abstract class BaseResXResourceProvider: IResourceProvider { 

        private ResourceManager _resourceManager; 
 
        ///// IResourceProvider implementation
 
        public virtual object GetObject(string resourceKey, CultureInfo culture) {

            // Attempt to get the resource manager
            EnsureResourceManager(); 

            // If we couldn't get a resource manager, return null 
            if (_resourceManager == null) 
                return null;
 
            if (culture == null)
                culture = CultureInfo.CurrentUICulture;

            return _resourceManager.GetObject(resourceKey, culture); 
        }
 
        public virtual IResourceReader ResourceReader { get { return null; } } 

        ///// End of IResourceProvider implementation 


        protected abstract ResourceManager CreateResourceManager();
 
        private void EnsureResourceManager() {
            if (_resourceManager != null) 
                return; 

            _resourceManager = CreateResourceManager(); 
        }
    }

    /* 
     * ResourceManager based provider for application resources.
     */ 
    internal class GlobalResXResourceProvider : BaseResXResourceProvider { 

        private string _classKey; 

        internal GlobalResXResourceProvider(string classKey) {
            _classKey = classKey;
        } 

        protected override ResourceManager CreateResourceManager() { 
 
            string fullClassName = BaseResourcesBuildProvider.DefaultResourcesNamespace +
                "." + _classKey; 

            // If there is no app resource assembly, return null
            if (BuildManager.AppResourcesAssembly == null)
                return null; 

            ResourceManager resourceManager = new ResourceManager(fullClassName, 
                BuildManager.AppResourcesAssembly); 
            resourceManager.IgnoreCase = true;
 
            return resourceManager;
        }

        public override IResourceReader ResourceReader { 
            get {
                // App resources don't support implicit resources, so the IResourceReader 
                // should never be needed 
                throw new NotSupportedException();
            } 
        }
    }

    /* 
     * ResourceManager based provider for page (local) resources.
     */ 
    internal class LocalResXResourceProvider : BaseResXResourceProvider { 

        private VirtualPath _virtualPath; 

        internal LocalResXResourceProvider(VirtualPath virtualPath) {
            _virtualPath = virtualPath;
        } 

        protected override ResourceManager CreateResourceManager() { 
 
            ResourceManager resourceManager = null;
 
            Assembly pageResAssembly = GetLocalResourceAssembly();

            if (pageResAssembly != null) {
                string fileName = _virtualPath.FileName; 

                resourceManager = new ResourceManager(fileName, pageResAssembly); 
                resourceManager.IgnoreCase = true; 
            }
            else { 
                throw new InvalidOperationException(SR.GetString(SR.ResourceExpresionBuilder_PageResourceNotFound));
            }

            return resourceManager; 
        }
 
        public override IResourceReader ResourceReader { 
            get {
                // Get the local resource assembly for this page 
                Assembly pageResAssembly = GetLocalResourceAssembly();

                if (pageResAssembly == null)
                    return null; 

                // Get the name of the embedded .resource file for this page 
                string resourceFileName = _virtualPath.FileName + ".resources"; 

                // Make it lower case, since GetManifestResourceStream is case sensitive 
                resourceFileName = resourceFileName.ToLower(CultureInfo.InvariantCulture);

                // Get the resource stream from the resource assembly
                Stream resourceStream = pageResAssembly.GetManifestResourceStream(resourceFileName); 

                // If this page has no resources, return null 
                if (resourceStream == null) 
                    return null;
 
                return new ResourceReader(resourceStream);
            }
        }
 
        // Need to Assert here in order to access the codegen dir (VSWhidbey 387312)
        [PermissionSet(SecurityAction.Assert, Unrestricted=true)] 
        private Assembly GetLocalResourceAssembly() { 
            // Remove the page file name to get its directory
            VirtualPath virtualDir = _virtualPath.Parent; 

            // Get the name of the local resource assembly
            string cacheKey = BuildManager.GetLocalResourcesAssemblyName(virtualDir);
            BuildResult result = BuildManager.GetBuildResultFromCache(cacheKey); 

            if (result != null) { 
                return ((BuildResultCompiledAssembly)result).ResultAssembly; 
            }
 
            return null;
        }
    }
 
}
 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

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