BrowserCapabilitiesFactoryBase.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / FX-1434 / FX-1434 / 1.0 / untmp / whidbey / REDBITS / ndp / fx / src / xsp / System / Web / Configuration / BrowserCapabilitiesFactoryBase.cs / 1 / BrowserCapabilitiesFactoryBase.cs
                        

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

/* 
 * Base class for browser capabilities object: just a read-only dictionary 
 * holder that supports Init()
 * 
 *


*/ 

using System.Web.UI; 
using System.Collections; 
using System.Collections.Specialized;
using System.ComponentModel; 
using System.Globalization;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions; 
using System.Web.Util;
 
namespace System.Web.Configuration { 

    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)] 
    [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    public class BrowserCapabilitiesFactoryBase {

        private IDictionary _matchedHeaders; 
        private IDictionary _browserElements;
        private object _lock = new object(); 
 
        public BrowserCapabilitiesFactoryBase() {
        } 

        [EditorBrowsable(EditorBrowsableState.Advanced)]
        protected IDictionary BrowserElements {
            get { 
                if (_browserElements == null)
                    lock (_lock) { 
                        if (_browserElements == null) { 
                            _browserElements = Hashtable.Synchronized(new Hashtable(StringComparer.OrdinalIgnoreCase));
                            PopulateBrowserElements(_browserElements); 
                        }
                    }

                return _browserElements; 
            }
        } 
 
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        protected virtual void PopulateBrowserElements(IDictionary dictionary) { 
        }

        internal IDictionary InternalGetMatchedHeaders() {
            return MatchedHeaders; 
        }
 
        internal IDictionary InternalGetBrowserElements() { 
            return BrowserElements;
        } 

        [EditorBrowsable(EditorBrowsableState.Advanced)]
        protected IDictionary MatchedHeaders {
            get { 
                if (_matchedHeaders == null)
                    lock (_lock) { 
                        if (_matchedHeaders == null) { 
                            _matchedHeaders = Hashtable.Synchronized(new Hashtable(24, StringComparer.OrdinalIgnoreCase));
                            PopulateMatchedHeaders(_matchedHeaders); 
                        }
                    }

                return _matchedHeaders; 
            }
        } 
 
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        protected virtual void PopulateMatchedHeaders(IDictionary dictionary) { 
        }

        internal int CompareFilters(string filter1, string filter2) {
            bool isFilter1DefaultFilter = String.IsNullOrEmpty(filter1); 
            bool isFilter2DefaultFilter = String.IsNullOrEmpty(filter2);
 
            IDictionary browsers = BrowserElements; 
            bool filter1Exists = (browsers.Contains(filter1)) || isFilter1DefaultFilter;
            bool filter2Exists = (browsers.Contains(filter2)) || isFilter2DefaultFilter; 

            if (!filter1Exists) {
                if (!filter2Exists) {
                    return 0; 
                }
                else { 
                    return -1; 
                }
            } 
            else {
                if (!filter2Exists) {
                    return 1;
                } 
            }
 
            if (isFilter1DefaultFilter && !isFilter2DefaultFilter) { 
                return 1;
            } 

            if (isFilter2DefaultFilter && !isFilter1DefaultFilter) {
                return -1;
            } 

            if (isFilter1DefaultFilter && isFilter2DefaultFilter) { 
                return 0; 
            }
 
            int filter1Depth = (int)((Triplet)BrowserElements[filter1]).Third;
            int filter2Depth = (int)((Triplet)BrowserElements[filter2]).Third;

            return filter2Depth - filter1Depth; 
        }
 
        public virtual void ConfigureBrowserCapabilities(NameValueCollection headers, HttpBrowserCapabilities browserCaps) { 
        }
 
        internal static string GetBrowserCapKey(IDictionary headers, HttpRequest request) {
            StringBuilder sb = new StringBuilder();
            foreach(String key in headers.Keys) {
                if (key.Length == 0) { 
                    sb.Append(HttpCapabilitiesEvaluator.GetUserAgent(request));
                } 
                else { 
                    sb.Append(request.Headers[key]);
                } 

                sb.Append("\n");
            }
 
            return sb.ToString();
        } 
 
        internal HttpBrowserCapabilities GetHttpBrowserCapabilities(HttpRequest request) {
            if (request == null) 
                throw new ArgumentNullException("request");

            NameValueCollection headers = request.Headers;
            HttpBrowserCapabilities browserCaps = new HttpBrowserCapabilities(); 
            Hashtable values = new Hashtable(180, StringComparer.OrdinalIgnoreCase);
            values[String.Empty] = HttpCapabilitiesEvaluator.GetUserAgent(request); 
            browserCaps.Capabilities = values; 
            ConfigureBrowserCapabilities(headers, browserCaps);
 
            return browserCaps;
        }

        protected bool IsBrowserUnknown(HttpCapabilitiesBase browserCaps) { 
            // We want to ignore the "Default" node, which will also be matched.
            if(browserCaps.Browsers == null || browserCaps.Browsers.Count <= 1) { 
                return true; 
            }
 
            return false;
        }
    }
}

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