Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

385 lines
14 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="TemplateControlParser.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
/*
* Implements the ASP.NET template parser
*
* Copyright (c) 1998 Microsoft Corporation
*/
namespace System.Web.UI {
using System.Text;
using System;
using System.IO;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Reflection;
using System.Configuration;
using System.Web.Caching;
using System.Web.Util;
using System.Web.Compilation;
using HttpException = System.Web.HttpException;
using System.Text.RegularExpressions;
using System.Globalization;
using System.Security.Permissions;
/*
* Parser for TemplateControl's (UserControls and Pages)
*/
/// <internalonly/>
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public abstract class TemplateControlParser : BaseTemplateParser {
// Attributes in <%@ outputcache ... %> directive
private IDictionary _outputCacheDirective;
private OutputCacheParameters _outputCacheSettings;
internal OutputCacheParameters OutputCacheParameters { get { return _outputCacheSettings; } }
internal bool FAutoEventWireup { get { return !flags[noAutoEventWireup]; } }
internal override bool RequiresCompilation {
get { return flags[requiresCompilation] || CompilationMode == CompilationMode.Always; }
}
// Get default settings from config
internal override void ProcessConfigSettings() {
base.ProcessConfigSettings();
if (PagesConfig != null) {
flags[noAutoEventWireup] = !PagesConfig.AutoEventWireup;
// If config has a non-default EnableViewState value, set it in the main directive
if (PagesConfig.EnableViewState != Control.EnableViewStateDefault)
_mainDirectiveConfigSettings["enableviewstate"] = Util.GetStringFromBool(PagesConfig.EnableViewState);
CompilationMode = PagesConfig.CompilationMode;
}
// if there is a filter, ask it if it wants to use a different mode
if (_pageParserFilter != null)
CompilationMode = _pageParserFilter.GetCompilationMode(CompilationMode);
}
internal override void ProcessDirective(string directiveName, IDictionary directive) {
if (StringUtil.EqualsIgnoreCase(directiveName, "outputcache")) {
// Ignore the OutputCache directive in design mode (VSWhidbey 470314)
if (FInDesigner)
return;
if (_outputCacheSettings == null) {
_outputCacheSettings = new OutputCacheParameters();
}
// Make sure the outputcache directive was not already specified
if (_outputCacheDirective != null) {
throw new HttpException(
SR.GetString(SR.Only_one_directive_allowed, directiveName));
}
ProcessOutputCacheDirective(directiveName, directive);
_outputCacheDirective = directive;
}
else if (StringUtil.EqualsIgnoreCase(directiveName, "reference")) {
// Ignore the OutputCache directive in design mode (VSWhidbey 517783)
if (FInDesigner) {
return;
}
// Even though this only makes sense for compiled pages, Sharepoint needs us to
// ignore instead of throw when the page in non-compiled.
// For historical reasons, the virtual path can be specified by 3 different attributes:
// virtualpath, page and control. They all do the same, and virtualpath is the recommended
// one (the other two are deprecated).
// Make sure that no more than one is specified.
VirtualPath virtualPath = Util.GetAndRemoveVirtualPathAttribute(directive, "virtualpath");
bool enforcePage = false;
bool enforceControl = false;
VirtualPath tmp = Util.GetAndRemoveVirtualPathAttribute(directive, "page");
if (tmp != null) {
if (virtualPath != null) {
ProcessError(SR.GetString(SR.Invalid_reference_directive));
return;
}
virtualPath = tmp;
enforcePage = true;
}
tmp = Util.GetAndRemoveVirtualPathAttribute(directive, "control");
if (tmp != null) {
if (virtualPath != null) {
ProcessError(SR.GetString(SR.Invalid_reference_directive));
return;
}
virtualPath = tmp;
enforceControl = true;
}
// If we didn't get a virtual path, fail
if (virtualPath == null) {
ProcessError(SR.GetString(SR.Invalid_reference_directive));
return;
}
Type t = GetReferencedType(virtualPath);
if (t == null) {
ProcessError(SR.GetString(SR.Invalid_reference_directive_attrib, virtualPath));
}
// If the 'page' attribute was used, make sure it's indeed a Page
if (enforcePage && !typeof(Page).IsAssignableFrom(t)) {
ProcessError(SR.GetString(SR.Invalid_reference_directive_attrib, virtualPath));
}
// If the 'control' attribute was used, make sure it's indeed a UserControl
if (enforceControl && !typeof(UserControl).IsAssignableFrom(t)) {
ProcessError(SR.GetString(SR.Invalid_reference_directive_attrib, virtualPath));
}
// If there are some attributes left, fail
Util.CheckUnknownDirectiveAttributes(directiveName, directive);
}
else {
base.ProcessDirective(directiveName, directive);
}
}
internal override void ProcessMainDirective(IDictionary mainDirective) {
// We want to make sure that we process the compilationmode attribute before any
// of the other main directive attributes, since its presence can cause other
// attributes to be illegal. So we handle it instead of in ProcessMainDirectiveAttribute.
object tmpObj = null;
try {
tmpObj = Util.GetAndRemoveEnumAttribute(mainDirective,
typeof(CompilationMode), "compilationmode");
}
// catch the exception here so we can continue to process the rest of the main directive
// when called from CBM
catch (Exception ex) {
ProcessError(ex.Message);
}
if (tmpObj != null) {
CompilationMode = (CompilationMode) tmpObj;
// if there is a filter, ask it if it wants to use a different mode
if (_pageParserFilter != null)
CompilationMode = _pageParserFilter.GetCompilationMode(CompilationMode);
}
base.ProcessMainDirective(mainDirective);
}
internal override bool ProcessMainDirectiveAttribute(string deviceName, string name,
string value, IDictionary parseData) {
switch (name) {
// Ignore 'targetschema' attribute (ASURT 85670)
case "targetschema":
break;
case "autoeventwireup":
// This only makes sense for compiled pages
OnFoundAttributeRequiringCompilation(name);
flags[noAutoEventWireup] = !Util.GetBooleanAttribute(name, value);
break;
case "enabletheming":
// Return false to let the generic attribute processing continue
// which will cause the EnableTheming property to be set on the
// TemplateControl instance.
return false;
case CodeFileBaseClassAttributeName:
// Remember the base class for post processing
parseData[name] = Util.GetNonEmptyAttribute(name, value);
break;
default:
// We didn't handle the attribute. Try the base class
return base.ProcessMainDirectiveAttribute(deviceName, name, value, parseData);
}
// The attribute was handled
// Make sure no device filter or resource expression was specified
ValidateBuiltInAttribute(deviceName, name, value);
return true;
}
internal override void ProcessUnknownMainDirectiveAttribute(string filter, string attribName, string value) {
// Don't allow the id to be specified on the directive, even though it is
// a public member of the control class (VSWhidbey 85384)
if (attribName == "id") {
base.ProcessUnknownMainDirectiveAttribute(filter, attribName, value);
return;
}
// Process unknown attributes as regular control attribute, hence allowing
// arbitrary properties of the base class to be set.
// But turn off IAttributeAccessor support, otherwise any bad string on a
// user control's directive won't be caught.
try {
RootBuilder.PreprocessAttribute(filter, attribName, value, true /*mainDirectiveMode*/);
}
catch (Exception e) {
ProcessError(SR.GetString(SR.Attrib_parse_error, attribName, e.Message));
}
}
/*
* Add assembly dependencies for a collection of static objects
*/
private void AddStaticObjectAssemblyDependencies(HttpStaticObjectsCollection staticObjects) {
if (staticObjects == null || staticObjects.Objects == null) return;
IDictionaryEnumerator en = staticObjects.Objects.GetEnumerator();
while (en.MoveNext()) {
HttpStaticObjectsEntry entry = (HttpStaticObjectsEntry)en.Value;
AddTypeDependency(entry.ObjectType);
}
}
internal Type GetDirectiveType(IDictionary directive, string directiveName) {
string typeName = Util.GetAndRemoveNonEmptyNoSpaceAttribute(directive, "typeName");
VirtualPath virtualPath = Util.GetAndRemoveVirtualPathAttribute(directive, "virtualPath");
Type resultType = null;
// If neither or both are specified, fail
if ((typeName == null) == (virtualPath == null)) {
throw new HttpException(SR.GetString(SR.Invalid_typeNameOrVirtualPath_directive, directiveName));
}
if (typeName != null) {
resultType = GetType(typeName);
AddTypeDependency(resultType);
}
else {
resultType = GetReferencedType(virtualPath);
}
// If there are some attributes left, fail
Util.CheckUnknownDirectiveAttributes(directiveName, directive);
return resultType;
}
internal override void HandlePostParse() {
base.HandlePostParse();
if (!FInDesigner) {
// Omit AutoEventWireup if there can't possibly be any events defined (ASURT 97772)
if (ScriptList.Count == 0 && BaseType == DefaultBaseType && CodeFileVirtualPath == null)
flags[noAutoEventWireup] = true;
_applicationObjects = HttpApplicationFactory.ApplicationState.StaticObjects;
AddStaticObjectAssemblyDependencies(_applicationObjects);
_sessionObjects = HttpApplicationFactory.ApplicationState.SessionStaticObjects;
AddStaticObjectAssemblyDependencies(_sessionObjects);
}
}
/*
* Process the contents of the <%@ OutputCache ... %> directive
*/
internal virtual void ProcessOutputCacheDirective(string directiveName, IDictionary directive) {
int duration = 0; // Unit is second
string varyByParams;
string varyByCustom;
string outputCacheProfile = null;
string varyByControls;
bool fHasDuration = Util.GetAndRemovePositiveIntegerAttribute(directive, "duration", ref duration);
if (fHasDuration) {
OutputCacheParameters.Duration = duration;
}
//
if (this is PageParser) {
outputCacheProfile = Util.GetAndRemoveNonEmptyAttribute(directive, "cacheProfile");
if (outputCacheProfile != null) {
OutputCacheParameters.CacheProfile = outputCacheProfile;
}
}
if (!fHasDuration && (outputCacheProfile == null || outputCacheProfile.Length == 0) && FDurationRequiredOnOutputCache)
throw new HttpException(SR.GetString(SR.Missing_attr, "duration"));
varyByCustom = Util.GetAndRemoveNonEmptyAttribute(directive, "varybycustom");
if (varyByCustom != null) {
OutputCacheParameters.VaryByCustom = varyByCustom;
}
varyByControls = Util.GetAndRemoveNonEmptyAttribute(directive, "varybycontrol");
if (varyByControls != null) {
OutputCacheParameters.VaryByControl = varyByControls;
}
varyByParams = Util.GetAndRemoveNonEmptyAttribute(directive, "varybyparam");
if (varyByParams != null) {
OutputCacheParameters.VaryByParam = varyByParams;
}
// VaryByParams is required (ASURT 76763)
if (varyByParams == null &&
varyByControls == null &&
(outputCacheProfile == null || outputCacheProfile.Length == 0) &&
FVaryByParamsRequiredOnOutputCache)
throw new HttpException(SR.GetString(SR.Missing_varybyparam_attr));
// If it's "none", set it to null
if (StringUtil.EqualsIgnoreCase(varyByParams, "none"))
OutputCacheParameters.VaryByParam = null;
if (StringUtil.EqualsIgnoreCase(varyByControls, "none"))
OutputCacheParameters.VaryByControl = null;
// If there are some attributes left, fail
Util.CheckUnknownDirectiveAttributes(directiveName, directive, UnknownOutputCacheAttributeError);
}
internal virtual bool FDurationRequiredOnOutputCache {
get { return true; }
}
internal virtual bool FVaryByParamsRequiredOnOutputCache {
get { return true; }
}
internal abstract string UnknownOutputCacheAttributeError {
get;
}
}
}