HttpHandlerAction.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 / HttpHandlerAction.cs / 3 / HttpHandlerAction.cs
                        

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

namespace System.Web.Configuration { 
    using System; 
    using System.Xml;
    using System.Configuration; 
    using System.Collections.Specialized;
    using System.Collections;
    using System.IO;
    using System.Text; 
    using System.Web.Util;
    using System.Web.Compilation; 
    using System.Globalization; 
    using System.Security.Permissions;
 
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    public sealed class HttpHandlerAction : ConfigurationElement {
        private static ConfigurationPropertyCollection _properties;
        private static readonly ConfigurationProperty _propPath = 
            new ConfigurationProperty("path",
                                      typeof(string), 
                                      null, 
                                      null,
                                      StdValidatorsAndConverters.NonEmptyStringValidator, 
                                      ConfigurationPropertyOptions.IsRequired | ConfigurationPropertyOptions.IsKey);
        private static readonly ConfigurationProperty _propVerb =
            new ConfigurationProperty("verb",
                                      typeof(string), 
                                      null,
                                      null, 
                                      StdValidatorsAndConverters.NonEmptyStringValidator, 
                                      ConfigurationPropertyOptions.IsRequired | ConfigurationPropertyOptions.IsKey);
        private static readonly ConfigurationProperty _propType = 
            new ConfigurationProperty("type",
                                      typeof(string),
                                      null,
                                      null, 
                                      StdValidatorsAndConverters.NonEmptyStringValidator,
                                      ConfigurationPropertyOptions.IsRequired); 
        private static readonly ConfigurationProperty _propValidate = 
            new ConfigurationProperty("validate",
                                      typeof(bool), 
                                      true,
                                      ConfigurationPropertyOptions.None);

        private Wildcard _requestType; 
        private WildcardUrl _path;
        private Type _type; 
        private string typeCache = null; 

        static HttpHandlerAction() { 
            _properties = new ConfigurationPropertyCollection();
            _properties.Add(_propPath);
            _properties.Add(_propVerb);
            _properties.Add(_propType); 
            _properties.Add(_propValidate);
        } 
 
        public HttpHandlerAction(String path, String type, String verb)
            : this(path, type, verb, true) { 
        }

        public HttpHandlerAction(String path, String type, String verb, bool validate) {
            Path = path; 
            Type = type;
            Verb = verb; 
            Validate = validate; 
        }
 
        internal HttpHandlerAction() {
        }

        internal string Key { 
            get {
                return "verb=" + Verb + " | path=" + Path; 
            } 
        }
 
        protected override ConfigurationPropertyCollection Properties {
            get {
                return _properties;
            } 
        }
 
        [ConfigurationProperty("path", IsRequired = true, IsKey = true)] 
        public string Path {
            get { 
                return (string)base[_propPath];
            }
            set {
                base[_propPath] = value; 
            }
        } 
 
        [ConfigurationProperty("verb", IsRequired = true, IsKey = true)]
        public string Verb { 
            get {
                return (string)base[_propVerb];
            }
            set { 
                base[_propVerb] = value;
            } 
        } 

        [ConfigurationProperty("type", IsRequired = true)] 
        public string Type {
            get {
                if (typeCache == null)
                    typeCache = (string)base[_propType]; 
                return typeCache;
            } 
            set { 
                base[_propType] = value;
                typeCache = value; 
            }
        }

        internal Type TypeInternal { 
            get {
                return _type; 
            } 
        }
 
        [ConfigurationProperty("validate", DefaultValue = true)]
        public bool Validate {
            get {
                return (bool)base[_propValidate]; 
            }
            set { 
                base[_propValidate] = value; 
            }
        } 

        internal void InitValidateInternal() {
            string verb = Verb;
 
            // Remove all spaces from verbs before wildcard parsing.
            //   - We don't want get in "POST, GET" to be parsed into " GET". 
            verb = verb.Replace(" ", String.Empty); // replace all " " with String.Empty in requestType 

            _requestType = new Wildcard(verb, false);    // case-sensitive wildcard 
            _path = new WildcardUrl(Path, true);         // case-insensitive URL wildcard

            // if validate="false" is marked on a handler, then the type isn't created until a request
            // is actually made that requires the handler. This (1) allows us to list handlers that 
            // aren't present without throwing errors at init time and (2) speeds up init by avoiding
            // loading types until they are needed. 
 
            if (!Validate) {
                _type = null; 
            }
            else {
                _type = ConfigUtil.GetType(Type, "type", this);
 
                if (!ConfigUtil.IsTypeHandlerOrFactory(_type)) {
                    throw new ConfigurationErrorsException( 
                        SR.GetString(SR.Type_not_factory_or_handler, Type), 
                        ElementInformation.Source, ElementInformation.LineNumber);
                } 
            }
        }

        internal bool IsMatch(String verb, VirtualPath path) { 
            return (_path.IsSuffix(path.VirtualPathString) && _requestType.IsMatch(verb));
        } 
 
        internal Object Create() {
            // HACKHACK: for now, let uncreatable types through and error later (for .soap factory) 
            // This design should change - developers will want to know immediately
            // when they misspell a type

            if (_type == null) { 
                Type t = ConfigUtil.GetType(Type, "type", this);
 
                // throw for bad types in deferred case 
                if (!ConfigUtil.IsTypeHandlerOrFactory(t)) {
                    throw new ConfigurationErrorsException( 
                        SR.GetString(SR.Type_not_factory_or_handler, Type),
                        ElementInformation.Source, ElementInformation.LineNumber);
                }
 
                _type = t;
            } 
 
            return HttpRuntime.CreateNonPublicInstance(_type);
        } 
    }
}

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