Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / HttpContext.cs / 1477467 / HttpContext.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
* HttpContext class
*
* Copyright (c) 1999 Microsoft Corporation
*/
namespace System.Web {
using System.Collections;
using System.ComponentModel;
using System.Configuration;
using System.Configuration.Internal;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Reflection;
using System.Runtime.Serialization.Formatters;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Security.Principal;
using System.Threading;
using System.Web.Security;
using System.Web.SessionState;
using System.Web.Configuration;
using System.Web.Caching;
using System.Web.Hosting;
using System.Web.Util;
using System.Web.UI;
using System.Runtime.Remoting.Messaging;
using System.Security.Permissions;
using System.Web.Profile;
using System.EnterpriseServices;
using System.Web.Management;
using System.Web.Compilation;
using System.Web.Routing;
///
/// Encapsulates
/// all HTTP-specific
/// context used by the HTTP server to process Web requests.
/// System.Web.IHttpModules and System.Web.IHttpHandler instances are provided a
/// reference to an appropriate HttpContext object. For example
/// the Request and Response
/// objects.
///
public sealed class HttpContext : IServiceProvider {
internal static readonly Assembly SystemWebAssembly = typeof(HttpContext).Assembly;
private static volatile bool s_eurlSet;
private static string s_eurl;
private IHttpAsyncHandler _asyncAppHandler; // application as handler (not always HttpApplication)
private HttpApplication _appInstance;
private IHttpHandler _handler;
private HttpRequest _request;
private HttpResponse _response;
private HttpServerUtility _server;
private Stack _traceContextStack;
private TraceContext _topTraceContext;
private Hashtable _items;
private ArrayList _errors;
private Exception _tempError;
private bool _errorCleared;
private IPrincipal _user;
private IntPtr _pManagedPrincipal;
internal ProfileBase _Profile;
private DateTime _utcTimestamp;
private HttpWorkerRequest _wr;
private GCHandle _root;
private IntPtr _ctxPtr;
private VirtualPath _configurationPath;
internal bool _skipAuthorization;
private CultureInfo _dynamicCulture;
private CultureInfo _dynamicUICulture;
private int _serverExecuteDepth;
private Stack _handlerStack;
private bool _preventPostback;
private bool _runtimeErrorReported;
// timeout support
private DateTime _timeoutStartTime = DateTime.MinValue;
private bool _timeoutSet;
private TimeSpan _timeout;
private int _timeoutState; // 0=non-cancelable, 1=cancelable, -1=canceled
private DoubleLink _timeoutLink; // link in the timeout's manager list
private Thread _thread;
// cached configuration
private CachedPathData _configurationPathData; // Cached data if _configurationPath != null
private CachedPathData _filePathData; // Cached data of the file being requested
// Sql Cache Dependency
private string _sqlDependencyCookie;
// Delayed session state item
SessionStateModule _sessionStateModule; // if non-null, it means we have a delayed session state item
// non-compiled pages
private TemplateControl _templateControl;
// integrated pipeline state
// keep synchronized with mgdhandler.hxx
private const int FLAG_NONE = 0x0;
private const int FLAG_CHANGE_IN_SERVER_VARIABLES = 0x1;
private const int FLAG_CHANGE_IN_REQUEST_HEADERS = 0x2;
private const int FLAG_CHANGE_IN_RESPONSE_HEADERS = 0x4;
private const int FLAG_CHANGE_IN_USER_OBJECT = 0x8;
private const int FLAG_SEND_RESPONSE_HEADERS = 0x10;
private const int FLAG_RESPONSE_HEADERS_SENT = 0x20;
internal const int FLAG_ETW_PROVIDER_ENABLED = 0x40;
private const int FLAG_CHANGE_IN_RESPONSE_STATUS = 0x80;
private NotificationContext _notificationContext;
private bool _isAppInitialized;
private bool _isIntegratedPipeline;
private bool _finishPipelineRequestCalled;
private bool _impersonationEnabled;
internal bool HideRequestResponse;
internal volatile bool InIndicateCompletion;
internal volatile HttpApplication.ThreadContext IndicateCompletionContext = null;
// synchronization context (for the newasync pattern)
private AspNetSynchronizationContext _syncContext;
// session state support
private bool _requiresSessionStateFromHandler;
internal bool RequiresSessionState {
get {
switch (SessionStateBehavior) {
case SessionStateBehavior.Required:
case SessionStateBehavior.ReadOnly:
return true;
case SessionStateBehavior.Disabled:
return false;
case SessionStateBehavior.Default:
default:
return _requiresSessionStateFromHandler;
}
}
}
private bool _readOnlySessionStateFromHandler;
internal bool ReadOnlySessionState {
get {
switch (SessionStateBehavior) {
case SessionStateBehavior.ReadOnly:
return true;
case SessionStateBehavior.Required:
case SessionStateBehavior.Disabled:
return false;
case SessionStateBehavior.Default:
default:
return _readOnlySessionStateFromHandler;
}
}
}
internal bool InAspCompatMode;
private IHttpHandler _remapHandler = null;
///
///
/// Initializes a new instance of the HttpContext class.
///
///
public HttpContext(HttpRequest request, HttpResponse response) {
Init(request, response);
request.Context = this;
response.Context = this;
}
///
///
/// Initializes a new instance of the HttpContext class.
///
///
public HttpContext(HttpWorkerRequest wr) {
_wr = wr;
Init(new HttpRequest(wr, this), new HttpResponse(wr, this));
_response.InitResponseWriter();
}
// ctor used in HttpRuntime
internal HttpContext(HttpWorkerRequest wr, bool initResponseWriter) {
_wr = wr;
Init(new HttpRequest(wr, this), new HttpResponse(wr, this));
if (initResponseWriter)
_response.InitResponseWriter();
PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_EXECUTING);
}
private void Init(HttpRequest request, HttpResponse response) {
_request = request;
_response = response;
_utcTimestamp = DateTime.UtcNow;
if (_wr is IIS7WorkerRequest) {
_isIntegratedPipeline = true;
}
if (!(_wr is System.Web.SessionState.StateHttpWorkerRequest))
CookielessHelper.RemoveCookielessValuesFromPath(); // This ensures that the cookieless-helper is initialized and
// rewrites the path if the URI contains cookieless form-auth ticket, session-id, etc.
Profiler p = HttpRuntime.Profile;
if (p != null && p.IsEnabled)
_topTraceContext = new TraceContext(this);
// rewrite path in order to remove "/eurl.axd/guid", if it was
// added to the URL by aspnet_filter.dll.
string eurl = GetEurl();
if (!String.IsNullOrEmpty(eurl)) {
string path = request.Path;
int idxStartEurl = path.Length - eurl.Length;
bool hasTrailingSlash = (path[path.Length - 1] == '/');
if (hasTrailingSlash) {
idxStartEurl--;
}
if (idxStartEurl >= 0
&& StringUtil.Equals(path, idxStartEurl, eurl, 0, eurl.Length)) {
// restore original URL
int originalUrlLen = idxStartEurl;
if (hasTrailingSlash) {
originalUrlLen++;
}
string originalUrl = path.Substring(0, originalUrlLen);
// Dev10 835901: We don't call HttpContext.RewritePath(path) because the
// original path may contain '?' encoded as %3F, and RewritePath
// would interpret what follows as the query string. So instead, we
// clear ConfigurationPath and call InternalRewritePath directly.
ConfigurationPath = null;
Request.InternalRewritePath(VirtualPath.Create(originalUrl), null, true);
}
}
}
// We have a feature that directs extensionless URLs
// into managed code by appending "/eurl.axd/guid" to the path. On IIS 6.0,
// we restore the URL as soon as we get into managed code. Here we get the
// actual value of "/eurl.axd/guid" and remember it.
private string GetEurl() {
// only used on IIS 6.0
if (!(_wr is ISAPIWorkerRequestInProcForIIS6)
|| (_wr is ISAPIWorkerRequestInProcForIIS7)) {
return null;
}
string eurl = s_eurl;
if (eurl == null && !s_eurlSet) {
try {
IntPtr pBuffer = UnsafeNativeMethods.GetExtensionlessUrlAppendage();
if (pBuffer != IntPtr.Zero) {
eurl = StringUtil.StringFromWCharPtr(pBuffer, UnsafeNativeMethods.lstrlenW(pBuffer));
}
}
catch {} // ignore all exceptions
s_eurl = eurl;
s_eurlSet = true;
}
return eurl;
}
// Current HttpContext off the call context
#if DBG
internal static void SetDebugAssertOnAccessToCurrent(bool doAssert) {
if (doAssert) {
CallContext.SetData("__ContextAssert", String.Empty);
}
else {
CallContext.SetData("__ContextAssert", null);
}
}
private static bool NeedDebugAssertOnAccessToCurrent {
get {
return (CallContext.GetData("__ContextAssert") != null);
}
}
#endif
///
/// Returns the current HttpContext object.
///
public static HttpContext Current {
get {
#if DBG
if (NeedDebugAssertOnAccessToCurrent) {
Debug.Assert(ContextBase.Current != null);
}
#endif
return ContextBase.Current as HttpContext;
}
set {
ContextBase.Current = value;
}
}
//
// Root / unroot for the duration of async operation
//
internal void Root() {
_root = GCHandle.Alloc(this);
_ctxPtr = GCHandle.ToIntPtr(_root);
}
internal void Unroot() {
if(_root.IsAllocated) {
_root.Free();
_ctxPtr = IntPtr.Zero;
}
}
internal void FinishPipelineRequest() {
if (!_finishPipelineRequestCalled) {
_finishPipelineRequestCalled = true;
HttpRuntime.FinishPipelineRequest(this);
}
}
internal IntPtr ContextPtr { get { return _ctxPtr; } }
internal void ValidatePath() {
CachedPathData pathData = GetConfigurationPathData();
pathData.ValidatePath(_request.PhysicalPathInternal);
}
// IServiceProvider implementation
///
/// Retrieves a reference to the application object for the current Http request.
///
public HttpApplication ApplicationInstance {
get { return _appInstance;}
set {
// For integrated pipeline, once this is set to a non-null value, it can only be set to null.
// The setter should never have been made public. It probably happened in 1.0, before it was possible
// to have getter and setter with different accessibility.
if (_isIntegratedPipeline && _appInstance != null && value != null) {
throw new InvalidOperationException(SR.GetString(SR.Application_instance_cannot_be_changed));
}
else {
_appInstance = value;
}
}
}
///
///
/// Retrieves a reference to the application object for the current
/// Http request.
///
///
public HttpApplicationState Application {
get { return HttpApplicationFactory.ApplicationState; }
}
///
///
/// Retrieves or assigns a reference to the
///
public IHttpHandler Handler {
get { return _handler;}
set {
_handler = value;
_requiresSessionStateFromHandler = false;
_readOnlySessionStateFromHandler = false;
InAspCompatMode = false;
if (_handler != null) {
if (_handler is IRequiresSessionState) {
_requiresSessionStateFromHandler = true;
}
if (_handler is IReadOnlySessionState) {
_readOnlySessionStateFromHandler = true;
}
Page page = _handler as Page;
if (page != null && page.IsInAspCompatMode) {
InAspCompatMode = true;
}
}
}
}
///
///
/// Retrieves or assigns a reference to the
///
public IHttpHandler PreviousHandler {
get {
if (_handlerStack == null || _handlerStack.Count == 0)
return null;
return (IHttpHandler)_handlerStack.Peek();
}
}
///
///
/// Retrieves or assigns a reference to the
///
private IHttpHandler _currentHandler = null;
public IHttpHandler CurrentHandler {
get {
if (_currentHandler == null)
_currentHandler = _handler;
return _currentHandler;
}
}
internal void RestoreCurrentHandler() {
_currentHandler = (IHttpHandler)_handlerStack.Pop();
}
internal void SetCurrentHandler(IHttpHandler newtHandler) {
if (_handlerStack == null) {
_handlerStack = new Stack();
}
_handlerStack.Push(CurrentHandler);
_currentHandler = newtHandler;
}
///
///
/// Set custom mapping handler processing the request
///
public void RemapHandler(IHttpHandler handler) {
IIS7WorkerRequest wr = _wr as IIS7WorkerRequest;
if (wr != null) {
// Remap handler not allowed after ResolveRequestCache notification
if (_notificationContext.CurrentNotification >= RequestNotification.MapRequestHandler) {
throw new InvalidOperationException(SR.GetString(SR.Invoke_before_pipeline_event, "HttpContext.RemapHandler", "HttpApplication.MapRequestHandler"));
}
string handlerTypeName = null;
string handlerName = null;
if (handler != null) {
Type handlerType = handler.GetType();
handlerTypeName = handlerType.AssemblyQualifiedName;
handlerName = handlerType.FullName;
}
wr.SetRemapHandler(handlerTypeName, handlerName);
}
_remapHandler = handler;
}
internal IHttpHandler RemapHandlerInstance {
get {
return _remapHandler;
}
}
///
///
/// Retrieves a reference to the target
///
public HttpRequest Request {
[System.Runtime.TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
get {
if (HideRequestResponse)
throw new HttpException(SR.GetString(SR.Request_not_available));
return _request;
}
}
///
///
/// Retrieves a reference to the
///
public HttpResponse Response {
[System.Runtime.TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
get {
if (HideRequestResponse)
throw new HttpException(SR.GetString(SR.Response_not_available));
return _response;
}
}
internal IHttpHandler TopHandler {
get {
if (_handlerStack == null) {
return _handler;
}
object[] handlers = _handlerStack.ToArray();
if (handlers == null || handlers.Length == 0) {
return _handler;
}
return (IHttpHandler)handlers[handlers.Length - 1];
}
}
///
/// Retrieves a reference to the
///
public TraceContext Trace {
get {
if (_topTraceContext == null)
_topTraceContext = new TraceContext(this);
return _topTraceContext;
}
}
internal bool TraceIsEnabled {
get {
if (_topTraceContext == null)
return false;
return _topTraceContext.IsEnabled;
}
set {
if (value)
_topTraceContext = new TraceContext(this);
}
}
///
///
/// Retrieves a key-value collection that can be used to
/// build up and share data between an
///
public IDictionary Items {
get {
if (_items == null)
_items = new Hashtable();
return _items;
}
}
///
///
/// Gets a reference to the
///
public HttpSessionState Session {
get {
if (_sessionStateModule != null) {
lock (this) {
if (_sessionStateModule != null) {
// If it's not null, it means we have a delayed session state item
_sessionStateModule.InitStateStoreItem(true);
_sessionStateModule = null;
}
}
}
return(HttpSessionState)Items[SessionStateUtility.SESSION_KEY];
}
}
internal void AddDelayedHttpSessionState(SessionStateModule module) {
if (_sessionStateModule != null) {
throw new HttpException(SR.GetString(SR.Cant_have_multiple_session_module));
}
_sessionStateModule = module;
}
internal void RemoveDelayedHttpSessionState() {
Debug.Assert(_sessionStateModule != null, "_sessionStateModule != null");
_sessionStateModule = null;
}
///
///
/// Gets a reference to the
///
public HttpServerUtility Server {
get {
// create only on demand
if (_server == null)
_server = new HttpServerUtility(this);
return _server;
}
}
// if the context has an error, report it, but only one time
internal void ReportRuntimeErrorIfExists(ref RequestNotificationStatus status) {
Exception e = Error;
if (e == null || _runtimeErrorReported) {
return;
}
// WOS 1921799: custom errors don't work in integrated mode if there's an initialization exception
if (_notificationContext != null && CurrentModuleIndex == -1) {
try {
IIS7WorkerRequest wr = _wr as IIS7WorkerRequest;
if (Request.QueryString["aspxerrorpath"] != null
&& wr != null
&& String.IsNullOrEmpty(wr.GetManagedHandlerType())
&& wr.GetCurrentModuleName() == PipelineRuntime.InitExceptionModuleName) {
status = RequestNotificationStatus.Continue; // allow non-managed handler to execute request
return;
}
}
catch {
}
}
_runtimeErrorReported = true;
if (HttpRuntime.AppOfflineMessage != null) {
try {
// report app offline error
Response.TrySkipIisCustomErrors = true;
HttpRuntime.ReportAppOfflineErrorMessage(Response, HttpRuntime.AppOfflineMessage);
}
catch {
}
}
else {
// report error exception
using (new DisposableHttpContextWrapper(this)) {
// if the custom encoder throws, it might interfere with returning error information
// to the client, so we force use of the default encoder
Response.DisableCustomHttpEncoder = true;
// when application is on UNC share the code below must
// be run while impersonating the token given by IIS
using (new ApplicationImpersonationContext()) {
try {
try {
// try to report error in a way that could possibly throw (a config exception)
Response.ReportRuntimeError(e, true /*canThrow*/, false);
}
catch (Exception eReport) {
// report the config error in a way that would not throw
Response.ReportRuntimeError(eReport, false /*canThrow*/, false);
}
}
catch (Exception) {
}
}
}
}
status = RequestNotificationStatus.FinishRequest;
return;
}
///
///
/// Gets the
/// first error (if any) accumulated during request processing.
///
///
public Exception Error {
get {
if (_tempError != null)
return _tempError;
if (_errors == null || _errors.Count == 0 || _errorCleared)
return null;
return (Exception)_errors[0];
}
}
//
// Temp error (yet to be caught on app level)
// to be reported as Server.GetLastError() but could be cleared later
//
internal Exception TempError {
get { return _tempError; }
set { _tempError = value; }
}
///
///
/// An array (collection) of errors accumulated while processing a
/// request.
///
///
public Exception[] AllErrors {
get {
int n = (_errors != null) ? _errors.Count : 0;
if (n == 0)
return null;
Exception[] errors = new Exception[n];
_errors.CopyTo(0, errors, 0, n);
return errors;
}
}
///
///
/// Registers an error for the current request.
///
///
public void AddError(Exception errorInfo) {
if (_errors == null)
_errors = new ArrayList();
_errors.Add(errorInfo);
if (_isIntegratedPipeline && _notificationContext != null) {
// set the error on the current notification context
_notificationContext.Error = errorInfo;
}
}
///
///
/// Clears all errors for the current request.
///
///
public void ClearError() {
if (_tempError != null)
_tempError = null;
else
_errorCleared = true;
if (_isIntegratedPipeline && _notificationContext != null) {
// clear the error on the current notification context
_notificationContext.Error = null;
}
}
///
///
/// IPrincipal security information.
///
///
public IPrincipal User {
get { return _user; }
[SecurityPermission(SecurityAction.Demand, ControlPrincipal=true)]
set {
SetPrincipalNoDemand(value);
}
}
// route all internals call to the principal (that don't have luring attacks)
// through this method so we can centralize reporting
// Before this, some auth modules were assigning directly to _user
internal void SetPrincipalNoDemand(IPrincipal principal, bool needToSetNativePrincipal) {
_user = principal;
// push changes through to native side
if (needToSetNativePrincipal
&& _isIntegratedPipeline
&& _notificationContext.CurrentNotification == RequestNotification.AuthenticateRequest) {
IntPtr pManagedPrincipal = IntPtr.Zero;
try {
IIS7WorkerRequest wr = _wr as IIS7WorkerRequest;
if (principal != null) {
GCHandle h = GCHandle.Alloc(principal);
try {
pManagedPrincipal = GCHandle.ToIntPtr(h);
wr.SetPrincipal(principal, pManagedPrincipal);
}
catch {
pManagedPrincipal = IntPtr.Zero;
if (h.IsAllocated) {
h.Free();
}
throw;
}
}
else {
wr.SetPrincipal(null, IntPtr.Zero);
}
}
finally {
if (_pManagedPrincipal != IntPtr.Zero) {
GCHandle h = GCHandle.FromIntPtr(_pManagedPrincipal);
if (h.IsAllocated) {
h.Free();
}
}
_pManagedPrincipal = pManagedPrincipal;
}
}
}
internal void SetPrincipalNoDemand(IPrincipal principal) {
SetPrincipalNoDemand(principal, true /*needToSetNativePrincipal*/);
}
internal bool _ProfileDelayLoad = false;
public ProfileBase Profile {
get {
if (_Profile == null && _ProfileDelayLoad)
_Profile = ProfileBase.Create(Request.IsAuthenticated ? User.Identity.Name : Request.AnonymousID, Request.IsAuthenticated);
return _Profile;
}
}
internal SessionStateBehavior SessionStateBehavior { get; set; }
[SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate",
Justification = "An internal property already exists. This method does additional work.")]
public void SetSessionStateBehavior(SessionStateBehavior sessionStateBehavior) {
if (_notificationContext != null && _notificationContext.CurrentNotification >= RequestNotification.AcquireRequestState) {
throw new InvalidOperationException(SR.GetString(SR.Invoke_before_pipeline_event, "HttpContext.SetSessionStateBehavior", "HttpApplication.AcquireRequestState"));
}
SessionStateBehavior = sessionStateBehavior;
}
public bool SkipAuthorization {
get { return _skipAuthorization;}
[SecurityPermission(SecurityAction.Demand, ControlPrincipal=true)]
set {
SetSkipAuthorizationNoDemand(value, false);
}
}
internal void SetSkipAuthorizationNoDemand(bool value, bool managedOnly)
{
if (HttpRuntime.UseIntegratedPipeline
&& !managedOnly
&& value != _skipAuthorization) {
// For integrated mode, persist changes to SkipAuthorization
// in the IS_LOGIN_PAGE server variable. When this server variable exists
// and the value is not "0", IIS skips authorization.
_request.SetSkipAuthorization(value);
}
_skipAuthorization = value;
}
///
///
/// Is this request in debug mode?
///
///
public bool IsDebuggingEnabled {
get {
try {
return CompilationUtil.IsDebuggingEnabled(this);
}
catch {
// in case of config errors don't throw
return false;
}
}
}
///
///
/// Is this custom error enabled for this request?
///
///
public bool IsCustomErrorEnabled {
get {
return CustomErrorsSection.GetSettings(this).CustomErrorsEnabled(_request);
}
}
internal TemplateControl TemplateControl {
get {
return _templateControl;
}
set {
_templateControl = value;
}
}
///
/// Gets the initial timestamp of the current request.
///
public DateTime Timestamp {
get { return _utcTimestamp.ToLocalTime();}
}
internal DateTime UtcTimestamp {
get { return _utcTimestamp;}
}
internal HttpWorkerRequest WorkerRequest {
get { return _wr;}
}
///
///
/// Gets a reference to the System.Web.Cache.Cache object for the current request.
///
///
public Cache Cache {
get { return HttpRuntime.Cache;}
}
/*
* The virtual path used to get config settings. This allows the user
* to specify a non default config path, without having to pass it to every
* configuration call.
*/
internal VirtualPath ConfigurationPath {
get {
if (_configurationPath == null)
_configurationPath = _request.FilePathObject;
return _configurationPath;
}
set {
_configurationPath = value;
_configurationPathData = null;
_filePathData = null;
}
}
internal CachedPathData GetFilePathData() {
if (_filePathData == null) {
_filePathData = CachedPathData.GetVirtualPathData(_request.FilePathObject, false);
}
return _filePathData;
}
internal CachedPathData GetConfigurationPathData() {
if (_configurationPath == null) {
return GetFilePathData();
}
//
if (_configurationPathData == null) {
_configurationPathData = CachedPathData.GetVirtualPathData(_configurationPath, true);
}
return _configurationPathData;
}
internal CachedPathData GetPathData(VirtualPath path) {
if (path != null) {
if (path.Equals(_request.FilePathObject)) {
return GetFilePathData();
}
if (_configurationPath != null && path.Equals(_configurationPath)) {
return GetConfigurationPathData();
}
}
return CachedPathData.GetVirtualPathData(path, false);
}
internal void FinishRequestForCachedPathData(int statusCode) {
// Remove the cached path data for a file path if the first request for it
// does not succeed due to a bad request. Otherwise we could be vulnerable
// to a DOS attack.
if (_filePathData != null && !_filePathData.CompletedFirstRequest) {
if (400 <= statusCode && statusCode < 500) {
CachedPathData.RemoveBadPathData(_filePathData);
}
else {
CachedPathData.MarkCompleted(_filePathData);
}
}
}
/*
* Uses the Config system to get the specified configuraiton
*/
[Obsolete("The recommended alternative is System.Web.Configuration.WebConfigurationManager.GetWebApplicationSection in System.Web.dll. http://go.microsoft.com/fwlink/?linkid=14202")]
public static object GetAppConfig(String name) {
return WebConfigurationManager.GetWebApplicationSection(name);
}
[Obsolete("The recommended alternative is System.Web.HttpContext.GetSection in System.Web.dll. http://go.microsoft.com/fwlink/?linkid=14202")]
public object GetConfig(String name) {
return GetSection(name);
}
public object GetSection(String sectionName) {
if (HttpConfigurationSystem.UseHttpConfigurationSystem) {
return GetConfigurationPathData().ConfigRecord.GetSection(sectionName);
}
else {
return ConfigurationManager.GetSection(sectionName);
}
}
internal RuntimeConfig GetRuntimeConfig() {
return GetConfigurationPathData().RuntimeConfig;
}
internal RuntimeConfig GetRuntimeConfig(VirtualPath path) {
return GetPathData(path).RuntimeConfig;
}
public void RewritePath(String path) {
RewritePath(path, true);
}
/*
* Called by the URL rewrite module to modify the path for downstream modules
*/
///
/// [To be supplied.]
///
public void RewritePath(String path, bool rebaseClientPath) {
if (path == null)
throw new ArgumentNullException("path");
// extract query string
String qs = null;
int iqs = path.IndexOf('?');
if (iqs >= 0) {
qs = (iqs < path.Length-1) ? path.Substring(iqs+1) : String.Empty;
path = path.Substring(0, iqs);
}
// resolve relative path
VirtualPath virtualPath = VirtualPath.Create(path);
virtualPath = Request.FilePathObject.Combine(virtualPath);
// disallow paths outside of app
virtualPath.FailIfNotWithinAppRoot();
// clear things that depend on path
ConfigurationPath = null;
// rewrite path on request
Request.InternalRewritePath(virtualPath, qs, rebaseClientPath);
}
///
/// [To be supplied.]
///
public void RewritePath(String filePath, String pathInfo, String queryString) {
RewritePath(VirtualPath.CreateAllowNull(filePath), VirtualPath.CreateAllowNull(pathInfo),
queryString, false /*setClientFilePath*/);
}
public void RewritePath(string filePath, string pathInfo, String queryString, bool setClientFilePath)
{
RewritePath(VirtualPath.CreateAllowNull(filePath), VirtualPath.CreateAllowNull(pathInfo), queryString, setClientFilePath);
}
internal void RewritePath(VirtualPath filePath, VirtualPath pathInfo, String queryString, bool setClientFilePath) {
if (filePath == null)
throw new ArgumentNullException("filePath");
// resolve relative path
filePath = Request.FilePathObject.Combine(filePath);
// disallow paths outside of app
filePath.FailIfNotWithinAppRoot();
// clear things that depend on path
ConfigurationPath = null;
// rewrite path on request
Request.InternalRewritePath(filePath, pathInfo, queryString, setClientFilePath);
}
internal CultureInfo DynamicCulture {
get { return _dynamicCulture; }
set { _dynamicCulture = value; }
}
internal CultureInfo DynamicUICulture {
get { return _dynamicUICulture; }
set { _dynamicUICulture = value; }
}
public static object GetGlobalResourceObject(string classKey, string resourceKey) {
return GetGlobalResourceObject(classKey, resourceKey, null);
}
public static object GetGlobalResourceObject(string classKey, string resourceKey, CultureInfo culture) {
return ResourceExpressionBuilder.GetGlobalResourceObject(classKey, resourceKey, null, null, culture);
}
public static object GetLocalResourceObject(string virtualPath, string resourceKey) {
return GetLocalResourceObject(virtualPath, resourceKey, null);
}
public static object GetLocalResourceObject(string virtualPath, string resourceKey, CultureInfo culture) {
IResourceProvider pageProvider = ResourceExpressionBuilder.GetLocalResourceProvider(
VirtualPath.Create(virtualPath));
return ResourceExpressionBuilder.GetResourceObject(pageProvider, resourceKey, culture);
}
internal int ServerExecuteDepth {
get { return _serverExecuteDepth; }
set { _serverExecuteDepth = value; }
}
internal bool PreventPostback {
get { return _preventPostback; }
set { _preventPostback = value; }
}
//
// Timeout support
//
internal Thread CurrentThread {
get {
return _thread;
}
set {
_thread = value;
}
}
internal TimeSpan Timeout {
get {
EnsureTimeout();
return _timeout;
}
set {
_timeout = value;
_timeoutSet = true;
}
}
internal void EnsureTimeout() {
// Ensure that calls to Timeout property will not go to config after this call
if (!_timeoutSet) {
HttpRuntimeSection cfg = RuntimeConfig.GetConfig(this).HttpRuntime;
int s = (int) cfg.ExecutionTimeout.TotalSeconds;
_timeout = new TimeSpan(0, 0, s);
_timeoutSet = true;
}
}
internal DoubleLink TimeoutLink {
get { return _timeoutLink;}
set { _timeoutLink = value;}
}
/*
Notes on the following 5 functions:
Execution can be cancelled only during certain periods, when inside the catch
block for ThreadAbortException. These periods are marked with the value of
_timeoutState of 1.
There is potential [rare] race condition when the timeout thread would call
thread.abort but the execution logic in the meantime escapes the catch block.
To avoid such race conditions _timeoutState of -1 (cancelled) is introduced.
The timeout thread sets _timeoutState to -1 before thread abort and the
unwinding logic just waits for the exception in this case. The wait cannot
be done in EndCancellablePeriod because the function is call from inside of
a finally block and thus would wait indefinetely. That's why another function
WaitForExceptionIfCancelled had been added.
Originally _timeoutStartTime was set in BeginCancellablePeriod. However, that means
we'll call UtcNow everytime we call ExecuteStep, which is too expensive. So to save
CPU time we created a new method SetStartTime() which is called by the caller of
ExecuteStep.
*/
[System.Runtime.TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
internal void BeginCancellablePeriod() {
// It could be caused by an exception in OnThreadStart
if (_timeoutStartTime == DateTime.MinValue) {
SetStartTime();
}
_timeoutState = 1;
}
internal void SetStartTime() {
_timeoutStartTime = DateTime.UtcNow;
}
internal void EndCancellablePeriod() {
Interlocked.CompareExchange(ref _timeoutState, 0, 1);
}
[System.Runtime.TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
internal void WaitForExceptionIfCancelled() {
while (_timeoutState == -1)
Thread.Sleep(100);
}
internal bool IsInCancellablePeriod {
get { return (_timeoutState == 1); }
}
internal Thread MustTimeout(DateTime utcNow) {
if (_timeoutState == 1) { // fast check
if (TimeSpan.Compare(utcNow.Subtract(_timeoutStartTime), Timeout) >= 0) {
// don't abort in debug mode
try {
if (CompilationUtil.IsDebuggingEnabled(this) || System.Diagnostics.Debugger.IsAttached)
return null;
}
catch {
// ignore config errors
return null;
}
// abort the thread only if in cancelable state, avoiding race conditions
// the caller MUST timeout if the return is true
if (Interlocked.CompareExchange(ref _timeoutState, -1, 1) == 1)
return _thread;
}
}
return null;
}
// call a delegate within cancellable period (possibly throwing timeout exception)
internal void InvokeCancellableCallback(WaitCallback callback, Object state) {
if (IsInCancellablePeriod) {
// call directly
callback(state);
return;
}
try {
BeginCancellablePeriod(); // request can be cancelled from this point
try {
callback(state);
}
finally {
EndCancellablePeriod(); // request can be cancelled until this point
}
WaitForExceptionIfCancelled(); // wait outside of finally
}
catch (ThreadAbortException e) {
if (e.ExceptionState != null &&
e.ExceptionState is HttpApplication.CancelModuleException &&
((HttpApplication.CancelModuleException)e.ExceptionState).Timeout) {
Thread.ResetAbort();
PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_TIMED_OUT);
throw new HttpException(SR.GetString(SR.Request_timed_out),
null, WebEventCodes.RuntimeErrorRequestAbort);
}
}
}
internal void PushTraceContext() {
if (_traceContextStack == null) {
_traceContextStack = new Stack();
}
// push current TraceContext on stack
_traceContextStack.Push(_topTraceContext);
// now make a new one for the top if necessary
if (_topTraceContext != null) {
TraceContext tc = new TraceContext(this);
_topTraceContext.CopySettingsTo(tc);
_topTraceContext = tc;
}
}
internal void PopTraceContext() {
Debug.Assert(_traceContextStack != null);
_topTraceContext = (TraceContext) _traceContextStack.Pop();
}
internal bool RequestRequiresAuthorization() {
#if !FEATURE_PAL // FEATURE_PAL does not enable IIS-based hosting features
// if current user is anonymous, then trivially, this page does not require authorization
if (!User.Identity.IsAuthenticated)
return false;
// Ask each of the authorization modules
return
( FileAuthorizationModule.RequestRequiresAuthorization(this) ||
UrlAuthorizationModule.RequestRequiresAuthorization(this) );
#else // !FEATURE_PAL
return false; // ROTORTODO
#endif // !FEATURE_PAL
}
internal int CallISAPI(UnsafeNativeMethods.CallISAPIFunc iFunction, byte [] bufIn, byte [] bufOut) {
if (_wr == null || !(_wr is System.Web.Hosting.ISAPIWorkerRequest))
throw new HttpException(SR.GetString(SR.Cannot_call_ISAPI_functions));
#if !FEATURE_PAL // FEATURE_PAL does not enable IIS-based hosting features
return ((System.Web.Hosting.ISAPIWorkerRequest) _wr).CallISAPI(iFunction, bufIn, bufOut);
#else // !FEATURE_PAL
throw new NotImplementedException ("ROTORTODO");
#endif // !FEATURE_PAL
}
internal void SendEmptyResponse() {
#if !FEATURE_PAL // FEATURE_PAL does not enable IIS-based hosting features
if (_wr != null && (_wr is System.Web.Hosting.ISAPIWorkerRequest))
((System.Web.Hosting.ISAPIWorkerRequest) _wr).SendEmptyResponse();
#endif // !FEATURE_PAL
}
private CookielessHelperClass _CookielessHelper;
internal CookielessHelperClass CookielessHelper {
get {
if (_CookielessHelper == null)
_CookielessHelper = new CookielessHelperClass(this);
return _CookielessHelper;
}
}
// When a thread enters the pipeline, we may need to set the cookie in the CallContext.
internal void ResetSqlDependencyCookie() {
if (_sqlDependencyCookie != null) {
System.Runtime.Remoting.Messaging.CallContext.LogicalSetData(SqlCacheDependency.SQL9_OUTPUT_CACHE_DEPENDENCY_COOKIE, _sqlDependencyCookie);
}
}
// When a thread leaves the pipeline, we may need to remove the cookie from the CallContext.
internal void RemoveSqlDependencyCookie() {
if (_sqlDependencyCookie != null) {
System.Runtime.Remoting.Messaging.CallContext.LogicalSetData(SqlCacheDependency.SQL9_OUTPUT_CACHE_DEPENDENCY_COOKIE, null);
}
}
internal string SqlDependencyCookie {
get {
return _sqlDependencyCookie;
}
set {
_sqlDependencyCookie = value;
System.Runtime.Remoting.Messaging.CallContext.LogicalSetData(SqlCacheDependency.SQL9_OUTPUT_CACHE_DEPENDENCY_COOKIE, value);
}
}
//
// integrated pipeline related
//
internal NotificationContext NotificationContext {
get { return _notificationContext; }
set { _notificationContext = value; }
}
public RequestNotification CurrentNotification {
get {
if (!HttpRuntime.UseIntegratedPipeline) {
throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
}
return _notificationContext.CurrentNotification;
}
internal set {
if (!HttpRuntime.UseIntegratedPipeline) {
throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
}
_notificationContext.CurrentNotification = value;
}
}
internal bool IsChangeInServerVars {
get { return (_notificationContext.CurrentNotificationFlags & FLAG_CHANGE_IN_SERVER_VARIABLES) == FLAG_CHANGE_IN_SERVER_VARIABLES; }
}
internal bool IsChangeInRequestHeaders {
get { return (_notificationContext.CurrentNotificationFlags & FLAG_CHANGE_IN_REQUEST_HEADERS) == FLAG_CHANGE_IN_REQUEST_HEADERS; }
}
internal bool IsChangeInResponseHeaders {
get { return (_notificationContext.CurrentNotificationFlags & FLAG_CHANGE_IN_RESPONSE_HEADERS) == FLAG_CHANGE_IN_RESPONSE_HEADERS; }
}
internal bool IsChangeInResponseStatus {
get { return (_notificationContext.CurrentNotificationFlags & FLAG_CHANGE_IN_RESPONSE_STATUS) == FLAG_CHANGE_IN_RESPONSE_STATUS; }
}
internal bool IsChangeInUserPrincipal {
get { return (_notificationContext.CurrentNotificationFlags & FLAG_CHANGE_IN_USER_OBJECT) == FLAG_CHANGE_IN_USER_OBJECT; }
}
internal bool IsSendResponseHeaders {
get { return (_notificationContext.CurrentNotificationFlags & FLAG_SEND_RESPONSE_HEADERS) == FLAG_SEND_RESPONSE_HEADERS; }
}
internal void SetImpersonationEnabled() {
IdentitySection c = RuntimeConfig.GetConfig(this).Identity;
_impersonationEnabled = (c != null && c.Impersonate);
}
internal bool UsesImpersonation {
get {
// if we're on a UNC share and we have a UNC token, then use impersonation for all notifications
if (HttpRuntime.IsOnUNCShareInternal && HostingEnvironment.ApplicationIdentityToken != IntPtr.Zero) {
return true;
}
// if is false, then don't use impersonation
if (!_impersonationEnabled) {
return false;
}
// if this notification is after AuthenticateRequest and not a SendResponse notification, use impersonation
return ( ( (_notificationContext.CurrentNotification == RequestNotification.AuthenticateRequest && _notificationContext.IsPostNotification)
|| _notificationContext.CurrentNotification > RequestNotification.AuthenticateRequest )
&& _notificationContext.CurrentNotification != RequestNotification.SendResponse );
}
}
internal bool AreResponseHeadersSent {
get { return (_notificationContext.CurrentNotificationFlags & FLAG_RESPONSE_HEADERS_SENT) == FLAG_RESPONSE_HEADERS_SENT; }
}
internal bool NeedToInitializeApp() {
bool needToInit = !_isAppInitialized;
if (needToInit) {
_isAppInitialized = true;
}
return needToInit;
}
// flags passed in on the call to PipelineRuntime::ProcessRequestNotification
internal int CurrentNotificationFlags {
get {
return _notificationContext.CurrentNotificationFlags;
}
set {
_notificationContext.CurrentNotificationFlags = value;
}
}
// index of the current "module" running the request
// into the application module array
internal int CurrentModuleIndex {
get {
return _notificationContext.CurrentModuleIndex;
}
set {
_notificationContext.CurrentModuleIndex = value;
}
}
// Each module has a PipelineModuleStepContainer
// which stores/manages a list of event handlers
// that correspond to each RequestNotification.
// CurrentModuleEventIndex is the index (for the current
// module) of the current event handler.
// This will be greater than one when a single
// module registers multiple delegates for a single event.
// e.g.
// app.BeginRequest += Foo;
// app.BeginRequest += Bar;
internal int CurrentModuleEventIndex {
get {
return _notificationContext.CurrentModuleEventIndex;
}
set {
_notificationContext.CurrentModuleEventIndex = value;
}
}
internal void DisableNotifications(RequestNotification notifications, RequestNotification postNotifications) {
IIS7WorkerRequest wr = _wr as IIS7WorkerRequest;
if (null != wr) {
wr.DisableNotifications(notifications, postNotifications);
}
}
// if the principal is derived from WindowsIdentity
// there may be a dup'ed token here that we should dispose
// of as quickly as possible
internal void DisposePrincipal() {
if (_pManagedPrincipal == IntPtr.Zero
&& _user != null
&& _user != WindowsAuthenticationModule.AnonymousPrincipal) {
WindowsIdentity id = _user.Identity as WindowsIdentity;
if (id != null) {
_user = null;
id.Dispose();
}
}
}
public bool IsPostNotification {
get {
if (!HttpRuntime.UseIntegratedPipeline) {
throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
}
return _notificationContext.IsPostNotification;
}
internal set {
if (!HttpRuntime.UseIntegratedPipeline) {
throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
}
_notificationContext.IsPostNotification = value;
}
}
// user token for the request
internal IntPtr ClientIdentityToken {
get {
if (_wr != null) {
return _wr.GetUserToken();
}
else {
return IntPtr.Zero;
}
}
}
// is configured to impersonate client?
internal bool IsClientImpersonationConfigured {
get {
try {
IdentitySection c = RuntimeConfig.GetConfig(this).Identity;
return (c != null && c.Impersonate && c.ImpersonateToken == IntPtr.Zero);
}
catch {
// this property should not throw as it is used in the error reporting pass
// config errors will be reported elsewhere
return false;
}
}
}
internal IntPtr ImpersonationToken {
get {
// by default use app identity
IntPtr token = HostingEnvironment.ApplicationIdentityToken;
IdentitySection c = RuntimeConfig.GetConfig(this).Identity;
if (c != null) {
if (c.Impersonate) {
token = (c.ImpersonateToken != IntPtr.Zero) ? c.ImpersonateToken : ClientIdentityToken;
}
else {
// for non-UNC case impersonate="false" means "don't impersonate",
// but there is a special case for UNC shares - even if
// impersonate="false" we still impersonate the UNC identity
// (hosting identity). and this is how v1.x works as well
if (!HttpRuntime.IsOnUNCShareInternal) {
token = IntPtr.Zero;
}
}
}
return token;
}
}
internal AspNetSynchronizationContext SyncContext {
[System.Runtime.TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
get {
if (_syncContext == null) {
_syncContext = new AspNetSynchronizationContext(ApplicationInstance);
}
return _syncContext;
}
}
internal AspNetSynchronizationContext InstallNewAspNetSynchronizationContext() {
AspNetSynchronizationContext syncContext = _syncContext;
if (syncContext != null && syncContext == AsyncOperationManager.SynchronizationContext) {
// using current ASP.NET synchronization context - switch it
_syncContext = new AspNetSynchronizationContext(ApplicationInstance);
AsyncOperationManager.SynchronizationContext = _syncContext;
return syncContext;
}
return null;
}
internal void RestoreSavedAspNetSynchronizationContext(AspNetSynchronizationContext syncContext) {
AsyncOperationManager.SynchronizationContext = syncContext;
_syncContext = syncContext;
}
internal string UserLanguageFromContext() {
if(Request != null && Request.UserLanguages != null) {
string userLanguageEntry = Request.UserLanguages[0];
if(userLanguageEntry != null) {
int loc = userLanguageEntry.IndexOf(';');
if(loc != -1) {
return userLanguageEntry.Substring(0, loc);
}
else {
return userLanguageEntry;
}
}
}
return null;
}
// References should be nulled a.s.a.p. to reduce working set
internal void ClearReferences() {
_appInstance = null;
_handler = null;
_handlerStack = null;
_currentHandler = null;
if (_isIntegratedPipeline) {
_items = null;
_syncContext = null;
}
}
internal CultureInfo CultureFromConfig(string configString, bool requireSpecific) {
//auto
if(StringUtil.EqualsIgnoreCase(configString, HttpApplication.AutoCulture)) {
string userLanguage = UserLanguageFromContext();
if (userLanguage != null) {
try {
if (requireSpecific) {
return HttpServerUtility.CreateReadOnlySpecificCultureInfo(userLanguage);
}
else {
return HttpServerUtility.CreateReadOnlyCultureInfo(userLanguage);
}
}
catch {
return null;
}
}
else {
return null;
}
}
else if(StringUtil.StringStartsWithIgnoreCase(configString, "auto:")) {
string userLanguage = UserLanguageFromContext();
if(userLanguage != null) {
try {
if(requireSpecific) {
return HttpServerUtility.CreateReadOnlySpecificCultureInfo(userLanguage);
}
else {
return HttpServerUtility.CreateReadOnlyCultureInfo(userLanguage);
}
}
catch {
if(requireSpecific) {
return HttpServerUtility.CreateReadOnlySpecificCultureInfo(HttpApplication.GetFallbackCulture(configString));
}
else {
return HttpServerUtility.CreateReadOnlyCultureInfo(HttpApplication.GetFallbackCulture(configString));
}
}
}
else {
if(requireSpecific) {
return HttpServerUtility.CreateReadOnlySpecificCultureInfo(configString.Substring(5));
}
else {
return HttpServerUtility.CreateReadOnlyCultureInfo(configString.Substring(5));
}
}
}
if(requireSpecific) {
return HttpServerUtility.CreateReadOnlySpecificCultureInfo(configString);
}
else {
return HttpServerUtility.CreateReadOnlyCultureInfo(configString);
}
}
}
//
// Helper class to add/remove HttpContext to/from CallContext
//
// using (new DisposableHttpContextWrapper(context)) {
// // this code will have HttpContext.Current working
// }
//
internal class DisposableHttpContextWrapper : IDisposable {
private bool _needToUndo;
private HttpContext _savedContext;
internal static HttpContext SwitchContext(HttpContext context) {
return ContextBase.SwitchContext(context) as HttpContext;
}
internal DisposableHttpContextWrapper(HttpContext context) {
if (context != null) {
_savedContext = SwitchContext(context);
_needToUndo = (_savedContext != context);
}
}
void IDisposable.Dispose() {
if (_needToUndo) {
SwitchContext(_savedContext);
_savedContext = null;
_needToUndo = false;
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- ItemMap.cs
- TransformerTypeCollection.cs
- ExpandedWrapper.cs
- BasicExpandProvider.cs
- RemotingSurrogateSelector.cs
- SQLDoubleStorage.cs
- PageVisual.cs
- ThemeDictionaryExtension.cs
- MsmqIntegrationSecurity.cs
- X509SecurityToken.cs
- XsltContext.cs
- TextParagraph.cs
- DetailsViewRowCollection.cs
- StylusDevice.cs
- IISMapPath.cs
- webproxy.cs
- loginstatus.cs
- ProcessModelSection.cs
- Label.cs
- StrokeCollection.cs
- TemplatedAdorner.cs
- SynchronizedPool.cs
- MsmqTransportReceiveParameters.cs
- TypeDescriptorFilterService.cs
- XmlWriter.cs
- LocalizabilityAttribute.cs
- NavigationFailedEventArgs.cs
- BitmapSourceSafeMILHandle.cs
- WebPartDisplayModeEventArgs.cs
- ChangeTracker.cs
- webclient.cs
- CustomValidator.cs
- ManagementQuery.cs
- WebReferencesBuildProvider.cs
- InternalTransaction.cs
- VideoDrawing.cs
- HttpListenerResponse.cs
- ColorEditor.cs
- PropertyTabChangedEvent.cs
- ItemsPanelTemplate.cs
- XNodeValidator.cs
- TrackingRecord.cs
- ParseChildrenAsPropertiesAttribute.cs
- CustomValidator.cs
- login.cs
- Selection.cs
- Encoder.cs
- WebPartHelpVerb.cs
- Rotation3D.cs
- AlternationConverter.cs
- QilLiteral.cs
- Thickness.cs
- ConstraintStruct.cs
- TypeConverterAttribute.cs
- StaticFileHandler.cs
- MouseEventArgs.cs
- WebAdminConfigurationHelper.cs
- ChangeInterceptorAttribute.cs
- InternalBufferOverflowException.cs
- FixedSOMLineCollection.cs
- WinFormsSpinner.cs
- NumericUpDownAcceleration.cs
- DocumentOrderQuery.cs
- UserMapPath.cs
- EtwTrackingBehaviorElement.cs
- XPathPatternBuilder.cs
- DuplicateWaitObjectException.cs
- StackBuilderSink.cs
- DesignConnection.cs
- UpdatePanelTriggerCollection.cs
- DbProviderManifest.cs
- AppendHelper.cs
- ProviderConnectionPoint.cs
- PageRequestManager.cs
- PropertyInformationCollection.cs
- DataControlPagerLinkButton.cs
- DataServices.cs
- TextRangeEdit.cs
- SqlDataSourceConfigureFilterForm.cs
- RsaSecurityTokenParameters.cs
- PointKeyFrameCollection.cs
- TextDpi.cs
- Signature.cs
- CoreSwitches.cs
- HttpResponse.cs
- SystemIPv4InterfaceProperties.cs
- WindowsToolbarAsMenu.cs
- SolidColorBrush.cs
- DelegatedStream.cs
- SeverityFilter.cs
- ToolStripItemCollection.cs
- Missing.cs
- TextClipboardData.cs
- TextContainerHelper.cs
- GridPatternIdentifiers.cs
- ViewStateException.cs
- TextServicesCompartment.cs
- ProofTokenCryptoHandle.cs
- XslAstAnalyzer.cs
- TextContainer.cs