mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
382 lines
13 KiB
C#
382 lines
13 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="IndividualDeviceConfig.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
|
// Comment this out to get a version that doesn't need synchronized
|
|
// access. This can be used for profiling, to compare whether the lock
|
|
// or the late writing is more useful.
|
|
|
|
using System;
|
|
using System.Web.Configuration;
|
|
using System.Configuration;
|
|
using System.Xml;
|
|
using System.Collections;
|
|
using System.Diagnostics;
|
|
using System.Reflection;
|
|
using System.Reflection.Emit;
|
|
using System.Web;
|
|
using System.Web.Util;
|
|
using System.Threading;
|
|
using System.Web.Mobile;
|
|
|
|
namespace System.Web.UI.MobileControls
|
|
{
|
|
|
|
// Data structure for an individual device configuration.
|
|
// Included predicates, page adapter type, and a list of
|
|
// control/controlAdapter pairs.
|
|
[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 IndividualDeviceConfig
|
|
{
|
|
internal delegate bool DeviceQualifiesDelegate(HttpContext context);
|
|
|
|
private String _name;
|
|
private readonly ControlsConfig _controlsConfig;
|
|
private DeviceQualifiesDelegate _deviceQualifiesPredicate;
|
|
private Type _pageAdapterType;
|
|
private IWebObjectFactory _pageAdapterFactory;
|
|
|
|
// Parent device configuration.
|
|
|
|
private IndividualDeviceConfig _parentConfig;
|
|
private String _parentConfigName;
|
|
|
|
// ControlType --> ControlAdapterType mapping (one of these
|
|
// per individual device config)
|
|
private readonly Hashtable _controlAdapterTypes = new Hashtable();
|
|
|
|
// ControlType --> ControlAdapterType mapping cache, used to
|
|
// store mappings that are derived from a complex lookup (one of these
|
|
// per individual device config)
|
|
private readonly Hashtable _controlAdapterLookupCache = new Hashtable();
|
|
|
|
// Provide synchronized access to the hashtable, allowing
|
|
// multiple readers but just one writer. Here we have one per
|
|
// device config.
|
|
private readonly ReaderWriterLock _controlAdapterTypesLock = new ReaderWriterLock();
|
|
|
|
// The highest level to check.
|
|
|
|
private static readonly Type _baseControlType = typeof(System.Web.UI.Control);
|
|
|
|
|
|
// This constructor takes both a delegate that chooses this
|
|
// device, and a Type to instantiate the appropriate page
|
|
// adapter with.
|
|
internal IndividualDeviceConfig(ControlsConfig controlsConfig,
|
|
String name,
|
|
DeviceQualifiesDelegate deviceQualifiesDelegate,
|
|
Type pageAdapterType,
|
|
String parentConfigName)
|
|
{
|
|
_controlsConfig = controlsConfig;
|
|
_name = name;
|
|
_deviceQualifiesPredicate = deviceQualifiesDelegate;
|
|
_parentConfigName = parentConfigName;
|
|
_parentConfig = null;
|
|
PageAdapterType = pageAdapterType;
|
|
}
|
|
|
|
// This constructor takes just a page adapter for situations
|
|
// where device selection isn't necessary (e.g., the designer).
|
|
internal IndividualDeviceConfig(Type pageAdapterType) : this(null, null, null, pageAdapterType, null)
|
|
{
|
|
}
|
|
|
|
// Given a context, see if this device config should handle
|
|
// the given device. If there is no predicate, return true.
|
|
internal /*public*/ bool DeviceQualifies(HttpContext context)
|
|
{
|
|
return _deviceQualifiesPredicate == null ?
|
|
true :
|
|
_deviceQualifiesPredicate(context);
|
|
}
|
|
|
|
// Register an adapter with the given control.
|
|
internal /*public*/ void AddControl(Type controlType,
|
|
Type adapterType)
|
|
{
|
|
// Don't need to synchronize, as this is only being called
|
|
// from one thread -- the configuration section handler.
|
|
_controlAdapterTypes[controlType] = FactoryGenerator.StaticFactoryGenerator.GetFactory(adapterType);
|
|
}
|
|
|
|
private Type PageAdapterType
|
|
{
|
|
get
|
|
{
|
|
return _pageAdapterType;
|
|
}
|
|
set {
|
|
_pageAdapterType = value;
|
|
if (value != null) {
|
|
Debug.Assert(typeof(IPageAdapter).IsAssignableFrom(value));
|
|
_pageAdapterFactory =
|
|
(IWebObjectFactory)FactoryGenerator.StaticFactoryGenerator.GetFactory(_pageAdapterType);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal DeviceQualifiesDelegate DeviceQualifiesPredicate
|
|
{
|
|
get
|
|
{
|
|
return _deviceQualifiesPredicate;
|
|
}
|
|
set
|
|
{
|
|
_deviceQualifiesPredicate = value;
|
|
}
|
|
}
|
|
|
|
protected IWebObjectFactory LookupControl(Type controlType)
|
|
{
|
|
return LookupControl(controlType, false);
|
|
}
|
|
|
|
private IWebObjectFactory LookupControl(Type controlType, bool lookInTypeCache)
|
|
{
|
|
IWebObjectFactory factory;
|
|
|
|
factory = (IWebObjectFactory)_controlAdapterTypes[controlType];
|
|
if (factory == null && lookInTypeCache)
|
|
{
|
|
// Grab reader lock...
|
|
using (new ReaderWriterLockResource(_controlAdapterTypesLock,
|
|
false))
|
|
{
|
|
factory = (IWebObjectFactory)_controlAdapterLookupCache[controlType];
|
|
}
|
|
}
|
|
|
|
return factory;
|
|
}
|
|
|
|
// Create a new page adapter for the device.
|
|
internal /*public*/ IPageAdapter NewPageAdapter()
|
|
{
|
|
IPageAdapter a = _pageAdapterFactory.CreateInstance() as IPageAdapter;
|
|
|
|
if (a == null)
|
|
{
|
|
throw new Exception(
|
|
SR.GetString(SR.IndividualDeviceConfig_TypeMustSupportInterface,
|
|
_pageAdapterType.FullName, "IPageAdapter"));
|
|
}
|
|
|
|
return a;
|
|
}
|
|
|
|
// Given a control's type, create a control adapter for it.
|
|
|
|
internal virtual IControlAdapter NewControlAdapter(Type originalControlType)
|
|
{
|
|
IWebObjectFactory factory = GetAdapterFactory(originalControlType);
|
|
|
|
// Should return non-null, or throw an exception.
|
|
Debug.Assert(factory != null);
|
|
|
|
IControlAdapter a = (IControlAdapter) factory.CreateInstance();
|
|
return a;
|
|
}
|
|
|
|
// Given a control's type, returns the adapter type to be used.
|
|
// Note that it's legal to not register an adapter type for each
|
|
// control type.
|
|
//
|
|
// This lookup uses the following steps:
|
|
//
|
|
// (1) Look up the control type directly, to see if an adapter type
|
|
// has been registered for it.
|
|
// (2) Walk up the control inheritance chain, to see if an adapter type
|
|
// has been registered for the class. For example, if the passed
|
|
// control type is a validator, check BaseValidator, Label,
|
|
// TextControl, and finally MobileControl.
|
|
// (3) If no adapter type has still been found, call the parent configuration,
|
|
// if any, to look up the adapter type. For example, the CHTML device
|
|
// configuration would call the HTML device configuration.
|
|
// (4) If an adapter type is found, but is not explicitly registered for
|
|
// the passed control type, add an entry to the table, so that
|
|
// subsequent requests do not need to walk the hierarchy.
|
|
|
|
protected IWebObjectFactory GetAdapterFactory(Type originalControlType)
|
|
{
|
|
Debug.Assert(_parentConfigName == null);
|
|
|
|
Type controlType = originalControlType;
|
|
IWebObjectFactory factory = LookupControl(controlType, true); // Look in type cache
|
|
|
|
// Walk up hierarchy looking for registered adapters.
|
|
// Stop when we get to the base control.
|
|
|
|
while (factory == null && controlType != _baseControlType)
|
|
{
|
|
factory = LookupControl(controlType);
|
|
if (factory == null)
|
|
{
|
|
controlType = controlType.BaseType;
|
|
}
|
|
}
|
|
|
|
// Could not find one in the current hierarchy. So, look it up in
|
|
// the parent config if there is one.
|
|
|
|
if (factory == null && _parentConfig != null)
|
|
{
|
|
factory = _parentConfig.GetAdapterFactory(originalControlType);
|
|
}
|
|
|
|
if (factory == null)
|
|
{
|
|
throw new Exception(
|
|
SR.GetString(SR.IndividualDeviceConfig_ControlWithIncorrectPageAdapter,
|
|
controlType.FullName, _pageAdapterType.FullName));
|
|
|
|
}
|
|
|
|
if (controlType != originalControlType)
|
|
{
|
|
// Add to lookup cache, so the next lookup won't require
|
|
// traversing the hierarchy.
|
|
|
|
// Grab writer lock...
|
|
using (new ReaderWriterLockResource(_controlAdapterTypesLock,
|
|
true))
|
|
{
|
|
_controlAdapterLookupCache[originalControlType] = factory;
|
|
}
|
|
}
|
|
|
|
return factory;
|
|
}
|
|
|
|
internal /*public*/ String Name
|
|
{
|
|
get
|
|
{
|
|
return _name;
|
|
}
|
|
}
|
|
|
|
internal /*public*/ String ParentConfigName
|
|
{
|
|
get
|
|
{
|
|
return _parentConfigName;
|
|
}
|
|
set
|
|
{
|
|
_parentConfigName = null;
|
|
}
|
|
}
|
|
|
|
internal /*public*/ IndividualDeviceConfig ParentConfig
|
|
{
|
|
get
|
|
{
|
|
return _parentConfig;
|
|
}
|
|
set
|
|
{
|
|
_parentConfig = value;
|
|
}
|
|
}
|
|
|
|
private enum FixupState { NotFixedUp, FixingUp, FixedUp };
|
|
private FixupState _fixup = FixupState.NotFixedUp;
|
|
|
|
internal /*public*/ void FixupInheritance(IndividualDeviceConfig referrer, XmlNode configNode)
|
|
{
|
|
if (_fixup == FixupState.FixedUp)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (_fixup == FixupState.FixingUp)
|
|
{
|
|
Debug.Assert(referrer != null);
|
|
|
|
// Circular reference
|
|
throw new Exception(SR.GetString(SR.MobileControlsSectionHandler_CircularReference,
|
|
referrer.Name));
|
|
}
|
|
|
|
_fixup = FixupState.FixingUp;
|
|
|
|
if (ParentConfigName != null)
|
|
{
|
|
Debug.Assert(ParentConfigName.Length != 0 && ParentConfig == null);
|
|
|
|
ParentConfig = _controlsConfig.GetDeviceConfig(ParentConfigName);
|
|
|
|
if (ParentConfig == null)
|
|
{
|
|
throw new ConfigurationErrorsException(
|
|
SR.GetString(SR.MobileControlsSectionHandler_DeviceConfigNotFound,
|
|
ParentConfigName),
|
|
configNode);
|
|
}
|
|
|
|
// Make sure parent is fixed up.
|
|
|
|
ParentConfig.FixupInheritance(this, configNode);
|
|
|
|
if (PageAdapterType == null)
|
|
{
|
|
PageAdapterType = ParentConfig.PageAdapterType;
|
|
}
|
|
|
|
if (DeviceQualifiesPredicate == null)
|
|
{
|
|
DeviceQualifiesPredicate = ParentConfig.DeviceQualifiesPredicate;
|
|
}
|
|
|
|
Debug.Assert(PageAdapterType != null);
|
|
Debug.Assert(DeviceQualifiesPredicate != null);
|
|
|
|
// Reset this since we don't need it any longer.
|
|
ParentConfigName = null;
|
|
}
|
|
|
|
_fixup = FixupState.FixedUp;
|
|
}
|
|
}
|
|
|
|
[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 ReaderWriterLockResource : IDisposable
|
|
{
|
|
private ReaderWriterLock _lock;
|
|
private bool _writerLock;
|
|
|
|
internal /*public*/ ReaderWriterLockResource(ReaderWriterLock theLock, bool writerLock)
|
|
{
|
|
_lock = theLock;
|
|
_writerLock = writerLock;
|
|
if (_writerLock)
|
|
{
|
|
_lock.AcquireWriterLock(Timeout.Infinite);
|
|
}
|
|
else
|
|
{
|
|
_lock.AcquireReaderLock(Timeout.Infinite);
|
|
}
|
|
}
|
|
|
|
/*public*/ void IDisposable.Dispose()
|
|
{
|
|
if (_writerLock)
|
|
{
|
|
_lock.ReleaseWriterLock();
|
|
}
|
|
else
|
|
{
|
|
_lock.ReleaseReaderLock();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|