ControlsConfig.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 / MIT / System / Web / UI / MobileControls / ControlsConfig.cs / 1305376 / ControlsConfig.cs

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

 
using System; 
using System.Xml;
using System.Diagnostics; 
using System.Configuration;
using System.Globalization;
using System.Web;
using System.Web.Configuration; 
using System.Collections.Specialized;
using System.Security.Permissions; 
 
namespace System.Web.UI.MobileControls
{ 
    // Mobile Controls Configuration class.
    // Includes Mobile Web Forms-specific settings, including a set
    // of device configurations, that can be used to decide what set of
    // adapters to use for a given device. 

    [Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")] 
    internal class ControlsConfig 
    {
        private readonly ControlsConfig _parent; 

        private readonly StringDictionary _settings = new StringDictionary();
        private readonly ListDictionary _deviceConfigs = new ListDictionary();
 
        [ConfigurationPermission(SecurityAction.Assert, Unrestricted=true)]
        internal static ControlsConfig GetFromContext(HttpContext context) 
        { 
            // VSWhidbey 372365: Use MobileControlsSection if it is being returned
            Object config = context.GetSection("system.web/mobileControls"); 
            MobileControlsSection controlSection = config as MobileControlsSection;
            if (controlSection != null)
            {
                return controlSection.GetControlsConfig(); 
            }
            return (ControlsConfig)config; 
        } 

        internal ControlsConfig(ControlsConfig parent) 
        {
            _parent = parent;
        }
 
        // Return false if a device of the same name has already been added.
        internal /*public*/ bool AddDeviceConfig(String configName, IndividualDeviceConfig deviceConfig) 
        { 
            // Note that GetDeviceConfig also walks the parents configs
            if (GetDeviceConfig(configName) != null) 
            {
                return false;
            }
            else 
            {
                _deviceConfigs[configName] = deviceConfig; 
                return true; 
            }
        } 

        internal /*public*/ IndividualDeviceConfig GetDeviceConfig(HttpContext context)
        {
            IndividualDeviceConfig deviceConfig = null; 

            #if DEBUG 
            if (context.Session != null) 
            {
                String var = "AdapterOverride"; 
                bool saveInSession = true;
                String adapterOverride = (String)context.Session[var];
                if (adapterOverride == null)
                { 
                    saveInSession = false;
                    adapterOverride = (String)context.Request.QueryString[var]; 
                } 
                if (adapterOverride != null &&
                    (deviceConfig = GetDeviceConfig(adapterOverride)) != null) 
                {
                    if (saveInSession)
                    {
                        context.Session[var] = adapterOverride; 
                    }
                    return deviceConfig; 
                } 
            }
            #endif 

            foreach (IndividualDeviceConfig candidate in _deviceConfigs.Values)
            {
                if (candidate.DeviceQualifies(context)) 
                {
                    deviceConfig = candidate; 
                    break; 
                }
            } 

            if (deviceConfig == null && _parent != null)
            {
                deviceConfig = _parent.GetDeviceConfig (context); 
            }
 
            if (deviceConfig == null) 
            {
                throw new Exception( 
                    SR.GetString(SR.ControlsConfig_NoDeviceConfigRegistered,
                                 context.Request.UserAgent));
            }
 
            return deviceConfig;
        } 
 
        internal /*public*/ IndividualDeviceConfig GetDeviceConfig(String configName)
        { 
            IndividualDeviceConfig deviceConfig = (IndividualDeviceConfig)_deviceConfigs[configName];
            if (deviceConfig == null && _parent != null)
            {
                deviceConfig = _parent.GetDeviceConfig (configName); 
            }
            return deviceConfig; 
        } 

        // Call this after all the device configs have been entered.  This will 
        // resolve the names of the parent classes to inherit from actual
        // classes, and flag an error if there isn't one.  This is done as a
        // second-pass because devices earlier in web.config may inherit from
        // items later in the web.config.  That flexibility is required to get 
        // the right behavior for device predicates being evaluated in the order
        // they appear. 
        internal void FixupDeviceConfigInheritance(XmlNode configNode) 
        {
            foreach (IndividualDeviceConfig config in _deviceConfigs.Values) 
            {
                config.FixupInheritance(null, configNode);
            }
        } 

        internal /*public*/ String this[String key] 
        { 
            get
            { 
                String s = _settings[key];
                if (s == null && _parent != null)
                {
                    s = _parent[key]; 
                }
                return s; 
            } 

            set 
            {
                _settings[key] = value;
            }
        } 

        internal /*public*/ int SessionStateHistorySize 
        { 
            get
            { 
                String sizeString = this["sessionStateHistorySize"];
                int size = Constants.DefaultSessionsStateHistorySize;

                if (sizeString != null) 
                {
                    // Enclose in case a numerical value wasn't provided.  In 
                    // which case just return the default. 
                    try
                    { 
                        size = Int32.Parse(sizeString, CultureInfo.InvariantCulture);
                    }
                    catch
                    { 
                    }
                } 
 
                return size;
            } 
        }

        internal /*public*/ Type CookielessDataDictionaryType
        { 
            get
            { 
                Type cookielessDataType = null; 
                String typeString = this["cookielessDataDictionaryType"];
                if (!String.IsNullOrEmpty(typeString)) { 
                    cookielessDataType = Type.GetType(typeString);
                }
                return cookielessDataType;
            } 
        }
 
        internal /*public*/ bool AllowCustomAttributes 
        {
            get 
            {
                String allow = this["allowCustomAttributes"];
                return String.Compare(allow, "true", StringComparison.OrdinalIgnoreCase) == 0;
            } 
        }
    } 
} 

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