Code:
/ FXUpdate3074 / FXUpdate3074 / 1.1 / untmp / whidbey / QFE / ndp / fx / src / xsp / System / Web / UI / PageParser.cs / 8 / PageParser.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
* Implements the ASP.NET template parser
*
* Copyright (c) 1998 Microsoft Corporation
*/
namespace System.Web.UI {
using System.Runtime.Serialization.Formatters;
using System.Text;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System;
using System.IO;
using System.Collections;
using System.Collections.Specialized;
using System.Reflection;
using System.Globalization;
using System.CodeDom.Compiler;
using System.ComponentModel;
using System.Web.Hosting;
using System.Web.Caching;
using System.Web.Util;
using System.Web.Compilation;
using System.Web.Configuration;
using System.Web.Management;
using System.EnterpriseServices;
using HttpException = System.Web.HttpException;
using System.Text.RegularExpressions;
using System.Security.Permissions;
/*
* Parser for .aspx files
*/
///
/// [To be supplied.]
///
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
public sealed class PageParser : TemplateControlParser {
private int _transactionMode = 0 /*TransactionOption.Disabled*/;
internal int TransactionMode { get { return _transactionMode; } }
private TraceMode _traceMode = System.Web.TraceMode.Default;
internal TraceMode TraceMode { get { return _traceMode; } }
private TraceEnable _traceEnabled = TraceEnable.Default;
internal TraceEnable TraceEnabled { get { return _traceEnabled; } }
private int _codePage;
private string _responseEncoding;
private int _lcid;
private string _culture;
private int _mainDirectiveLineNumber = 1;
private bool _mainDirectiveMasterPageSet;
private OutputCacheLocation _outputCacheLocation;
internal bool FRequiresSessionState { get { return flags[requiresSessionState]; } }
internal bool FReadOnlySessionState { get { return flags[readOnlySessionState]; } }
private string _errorPage;
private string _styleSheetTheme;
internal String StyleSheetTheme { get { return _styleSheetTheme; } }
internal bool AspCompatMode { get { return flags[aspCompatMode]; } }
internal bool AsyncMode { get { return flags[asyncMode]; } }
internal bool ValidateRequest { get { return flags[validateRequest]; } }
private Type _previousPageType;
internal Type PreviousPageType { get { return _previousPageType; } }
private Type _masterPageType;
internal Type MasterPageType { get { return _masterPageType; } }
private string _configMasterPageFile;
public PageParser() {
flags[buffer] = Page.BufferDefault;
flags[requiresSessionState] = true;
flags[validateRequest] = true;
}
/*
* Compile an .aspx file into a Page object
*/
///
/// [To be supplied.]
///
private static object s_lock = new object();
// Only allowed in full trust (ASURT 123086)
[SecurityPermission(SecurityAction.Demand, Unrestricted=true)]
public static IHttpHandler GetCompiledPageInstance(string virtualPath,
string inputFile, HttpContext context) {
// Canonicalize the path to avoid failure caused by the CheckSuspiciousPhysicalPath
// security
if (!String.IsNullOrEmpty(inputFile)) {
inputFile = Path.GetFullPath(inputFile);
}
if (inputFile != null) {
// This call temporarily replaces _theHostingEnvironment._virtualPathProvider, and it can get
// corrupted if two threads do it at once. Use a lock to prevent this (
lock (s_lock) {
return GetCompiledPageInstance(VirtualPath.Create(virtualPath), inputFile, context);
}
}
else {
return GetCompiledPageInstance(VirtualPath.Create(virtualPath), inputFile, context);
}
}
private static IHttpHandler GetCompiledPageInstance(VirtualPath virtualPath,
string inputFile, HttpContext context) {
// This is a hacky API that only exists to support web service's
// DefaultWsdlHelpGenerator.aspx, which doesn't live under the app root.
// To make this work, we add an explicit mapping from the virtual path
// to the stream of the passed in file
// Make it relative to the current request if necessary
if (context != null)
virtualPath = context.Request.FilePathObject.Combine(virtualPath);
object virtualPathToFileMappingState = null;
try {
try {
// If there is a physical path, we need to connect the virtual path to it, so that
// the build system will use the right input file for the virtual path.
if (inputFile != null) {
virtualPathToFileMappingState = HostingEnvironment.AddVirtualPathToFileMapping(
virtualPath, inputFile);
}
BuildResultCompiledType result = (BuildResultCompiledType)BuildManager.GetVPathBuildResult(
context, virtualPath, false /*noBuild*/, true /*allowCrossApp*/, true /*allowBuildInPrecompile*/);
return (IHttpHandler)HttpRuntime.CreatePublicInstance(result.ResultType);
}
finally {
if (virtualPathToFileMappingState != null)
HostingEnvironment.ClearVirtualPathToFileMapping(virtualPathToFileMappingState);
}
}
catch {
throw;
}
}
internal override Type DefaultBaseType { get { return typeof(System.Web.UI.Page); } }
internal override Type DefaultFileLevelBuilderType {
get {
return typeof(FileLevelPageControlBuilder);
}
}
internal override RootBuilder CreateDefaultFileLevelBuilder() {
return new FileLevelPageControlBuilder();
}
private void EnsureMasterPageFileFromConfigApplied() {
// Skip if it's already applied.
if (_mainDirectiveMasterPageSet) {
return;
}
// If the masterPageFile is defined in the config
if (_configMasterPageFile != null) {
// Readjust the lineNumber to the location of maindirective
int prevLineNumber = _lineNumber;
_lineNumber = _mainDirectiveLineNumber;
try {
if (_configMasterPageFile.Length > 0) {
Type type = GetReferencedType(_configMasterPageFile);
// Make sure it has the correct base type
if (!typeof(MasterPage).IsAssignableFrom(type)) {
ProcessError(SR.GetString(SR.Invalid_master_base, _configMasterPageFile));
}
}
if (((FileLevelPageControlBuilder)RootBuilder).ContentBuilderEntries != null) {
RootBuilder.SetControlType(BaseType);
RootBuilder.PreprocessAttribute(String.Empty /*filter*/, "MasterPageFile", _configMasterPageFile, true /*mainDirectiveMode*/);
}
}
finally {
_lineNumber = prevLineNumber;
}
}
_mainDirectiveMasterPageSet = true;
}
internal override void HandlePostParse() {
base.HandlePostParse();
EnsureMasterPageFileFromConfigApplied();
}
// Get default settings from config
internal override void ProcessConfigSettings() {
base.ProcessConfigSettings();
if (PagesConfig != null) {
// Check config for various attributes, and if they have non-default values,
// set them in _mainDirectiveConfigSettings.
if (PagesConfig.Buffer != Page.BufferDefault)
_mainDirectiveConfigSettings["buffer"] = Util.GetStringFromBool(PagesConfig.Buffer);
if (PagesConfig.EnableViewStateMac != Page.EnableViewStateMacDefault)
_mainDirectiveConfigSettings["enableviewstatemac"] = Util.GetStringFromBool(PagesConfig.EnableViewStateMac);
if (PagesConfig.EnableEventValidation != Page.EnableEventValidationDefault)
_mainDirectiveConfigSettings["enableEventValidation"] = Util.GetStringFromBool(PagesConfig.EnableEventValidation);
if (PagesConfig.SmartNavigation != Page.SmartNavigationDefault)
_mainDirectiveConfigSettings["smartnavigation"] = Util.GetStringFromBool(PagesConfig.SmartNavigation);
if (PagesConfig.ThemeInternal != null && PagesConfig.Theme.Length != 0)
_mainDirectiveConfigSettings["theme"] = PagesConfig.Theme;
if (PagesConfig.StyleSheetThemeInternal != null && PagesConfig.StyleSheetThemeInternal.Length != 0)
_mainDirectiveConfigSettings["stylesheettheme"] = PagesConfig.StyleSheetThemeInternal;
if (PagesConfig.MasterPageFileInternal != null && PagesConfig.MasterPageFileInternal.Length != 0) {
_configMasterPageFile = PagesConfig.MasterPageFileInternal;
}
if (PagesConfig.ViewStateEncryptionMode != Page.EncryptionModeDefault) {
_mainDirectiveConfigSettings["viewStateEncryptionMode"] = Enum.Format(typeof(ViewStateEncryptionMode), PagesConfig.ViewStateEncryptionMode, "G");
}
if (PagesConfig.MaintainScrollPositionOnPostBack != Page.MaintainScrollPositionOnPostBackDefault) {
_mainDirectiveConfigSettings["maintainScrollPositionOnPostBack"] = Util.GetStringFromBool(PagesConfig.MaintainScrollPositionOnPostBack);
}
if (PagesConfig.MaxPageStateFieldLength != Page.DefaultMaxPageStateFieldLength) {
_mainDirectiveConfigSettings["maxPageStateFieldLength"] = PagesConfig.MaxPageStateFieldLength;
}
flags[requiresSessionState] = ((PagesConfig.EnableSessionState == PagesEnableSessionState.True) || (PagesConfig.EnableSessionState == PagesEnableSessionState.ReadOnly));
flags[readOnlySessionState] = (PagesConfig.EnableSessionState == PagesEnableSessionState.ReadOnly);
flags[validateRequest] = PagesConfig.ValidateRequest;
flags[aspCompatMode] = HttpRuntime.ApartmentThreading;
if (PagesConfig.PageBaseTypeInternal != null)
BaseType = PagesConfig.PageBaseTypeInternal;
}
}
internal override void ProcessDirective(string directiveName, IDictionary directive) {
if (StringUtil.EqualsIgnoreCase(directiveName, "previousPageType")) {
if (_previousPageType != null) {
ProcessError(SR.GetString(SR.Only_one_directive_allowed, directiveName));
return;
}
_previousPageType = GetDirectiveType(directive, directiveName);
Util.CheckAssignableType(typeof(Page), _previousPageType);
}
else if (StringUtil.EqualsIgnoreCase(directiveName, "masterType")) {
if (_masterPageType != null) {
ProcessError(SR.GetString(SR.Only_one_directive_allowed, directiveName));
return;
}
_masterPageType = GetDirectiveType(directive, directiveName);
Util.CheckAssignableType(typeof(MasterPage), _masterPageType);
}
else {
base.ProcessDirective(directiveName, directive);
}
}
// Override to get the location of maindirective.
internal override void ProcessMainDirective(IDictionary mainDirective) {
// Remember the location of the main directive.
_mainDirectiveLineNumber = _lineNumber;
base.ProcessMainDirective(mainDirective);
}
internal override bool ProcessMainDirectiveAttribute(string deviceName, string name,
string value, IDictionary parseData) {
switch (name) {
case "errorpage":
_errorPage = Util.GetNonEmptyAttribute(name, value);
// Return false to let the generic attribute processing continue
return false;
case "contenttype":
// Check validity
Util.GetNonEmptyAttribute(name, value);
// Return false to let the generic attribute processing continue
return false;
case "theme":
if (IsExpressionBuilderValue(value)) {
return false;
}
// Check validity
Util.CheckThemeAttribute(value);
// Return false to let the generic attribute processing continue
return false;
case "stylesheettheme":
// Make sure no device filter or expression builder was specified
ValidateBuiltInAttribute(deviceName, name, value);
// Check validity
Util.CheckThemeAttribute(value);
_styleSheetTheme = value;
return true;
case "enablesessionstate":
flags[requiresSessionState] = true;
flags[readOnlySessionState] = false;
if (Util.IsFalseString(value)) {
flags[requiresSessionState] = false;
}
else if (StringUtil.EqualsIgnoreCase(value, "readonly")) {
flags[readOnlySessionState] = true;
}
else if (!Util.IsTrueString(value)) {
ProcessError(SR.GetString(
SR.Enablesessionstate_must_be_true_false_or_readonly));
}
if (flags[requiresSessionState]) {
// Session state is only available for compiled pages
OnFoundAttributeRequiringCompilation(name);
}
break;
case "culture":
_culture = Util.GetNonEmptyAttribute(name, value);
// Setting culture requires medium permission
if (!HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Medium)) {
throw new HttpException(SR.GetString(SR.Insufficient_trust_for_attribute, "culture"));
}
//do not verify at parse time if potentially using browser AutoDetect
if(StringUtil.EqualsIgnoreCase(value, HttpApplication.AutoCulture)) {
return false;
}
// Create a CultureInfo just to verify validity
CultureInfo cultureInfo;
try {
if(StringUtil.StringStartsWithIgnoreCase(value, HttpApplication.AutoCulture)) {
//safe to trim leading "auto:", string used elsewhere for null
_culture = _culture.Substring(5);
}
cultureInfo = HttpServerUtility.CreateReadOnlyCultureInfo(_culture);
}
catch {
ProcessError(SR.GetString(SR.Invalid_attribute_value, _culture, "culture"));
return false;
}
// Don't allow neutral cultures (ASURT 77930)
if (cultureInfo.IsNeutralCulture) {
ProcessError(SR.GetString(SR.Invalid_culture_attribute,
Util.GetSpecificCulturesFormattedList(cultureInfo)));
}
// Return false to let the generic attribute processing continue
return false;
case "lcid":
// Skip validity
if (IsExpressionBuilderValue(value)) return false;
_lcid = Util.GetNonNegativeIntegerAttribute(name, value);
// Create a CultureInfo just to verify validity
try {
HttpServerUtility.CreateReadOnlyCultureInfo(_lcid);
}
catch {
ProcessError(SR.GetString(SR.Invalid_attribute_value,
_lcid.ToString(CultureInfo.InvariantCulture), "lcid"));
}
// Return false to let the generic attribute processing continue
return false;
case "uiculture":
// Check validity
Util.GetNonEmptyAttribute(name, value);
// Return false to let the generic attribute processing continue
return false;
case "responseencoding":
// Skip validity
if (IsExpressionBuilderValue(value)) return false;
_responseEncoding = Util.GetNonEmptyAttribute(name, value);
// Call Encoding.GetEncoding just to verify validity
Encoding.GetEncoding(_responseEncoding);
// Return false to let the generic attribute processing continue
return false;
case "codepage":
// Skip validity
if (IsExpressionBuilderValue(value)) return false;
_codePage = Util.GetNonNegativeIntegerAttribute(name, value);
// Call Encoding.GetEncoding just to verify validity
Encoding.GetEncoding(_codePage);
// Return false to let the generic attribute processing continue
return false;
case "transaction":
// This only makes sense for compiled pages
OnFoundAttributeRequiringCompilation(name);
ParseTransactionAttribute(name, value);
break;
case "aspcompat":
// This only makes sense for compiled pages
OnFoundAttributeRequiringCompilation(name);
flags[aspCompatMode] = Util.GetBooleanAttribute(name, value);
// Only allow the use of aspcompat when we have UnmanagedCode access (ASURT 76694)
if (flags[aspCompatMode] && !HttpRuntime.HasUnmanagedPermission()) {
throw new HttpException(SR.GetString(SR.Insufficient_trust_for_attribute, "AspCompat"));
}
break;
case "async":
// This only makes sense for compiled pages
OnFoundAttributeRequiringCompilation(name);
flags[asyncMode] = Util.GetBooleanAttribute(name, value);
// Async requires Medium trust
if (!HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Medium)) {
throw new HttpException(SR.GetString(SR.Insufficient_trust_for_attribute, "async"));
}
break;
case "tracemode":
// We use TraceModeInternal instead of TraceMode to disallow the 'default' value (ASURT 75783)
object tmpObj = Util.GetEnumAttribute(name, value, typeof(TraceModeInternal));
_traceMode = (TraceMode) tmpObj;
break;
case "trace":
bool traceEnabled = Util.GetBooleanAttribute(name, value);
if (traceEnabled)
_traceEnabled = TraceEnable.Enable;
else
_traceEnabled = TraceEnable.Disable;
break;
case "smartnavigation":
// Make sure no device filter or expression builder was specified, since it doesn't make much
// sense for smartnav (which only works on IE5.5+) (
ValidateBuiltInAttribute(deviceName, name, value);
// Ignore it if it has default value. Otherwise, let the generic
// attribute processing continue
bool smartNavigation = Util.GetBooleanAttribute(name, value);
return (smartNavigation == Page.SmartNavigationDefault);
case "maintainscrollpositiononpostback":
bool maintainScrollPosition = Util.GetBooleanAttribute(name, value);
return (maintainScrollPosition == Page.MaintainScrollPositionOnPostBackDefault);
case "validaterequest":
flags[validateRequest] = Util.GetBooleanAttribute(name, value);
break;
case "clienttarget":
// Skip validity
if (IsExpressionBuilderValue(value)) return false;
// Check validity
HttpCapabilitiesEvaluator.GetUserAgentFromClientTarget(CurrentVirtualPath, value);
// Return false to let the generic attribute processing continue
return false;
case "masterpagefile":
// Skip validity
if (IsExpressionBuilderValue(value)) return false;
if (value.Length > 0) {
// Add dependency on the Type by calling this method
Type type = GetReferencedType(value);
// Make sure it has the correct base type
if (!typeof(MasterPage).IsAssignableFrom(type)) {
ProcessError(SR.GetString(SR.Invalid_master_base, value));
}
if (deviceName.Length > 0) {
// Make sure the masterPageFile definition from config
// is applied before filtered masterPageFile attributes.
EnsureMasterPageFileFromConfigApplied();
}
}
//
_mainDirectiveMasterPageSet = true;
// Return false to let the generic attribute processing continue
return false;
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) {
// asynctimeout is in seconds while the corresponding public page property is a timespan
// this requires a patch-up
if (attribName == "asynctimeout") {
int timeoutInSeconds = Util.GetNonNegativeIntegerAttribute(attribName, value);
value = (new TimeSpan(0, 0, timeoutInSeconds)).ToString();
}
base.ProcessUnknownMainDirectiveAttribute(filter, attribName, value);
}
internal override void PostProcessMainDirectiveAttributes(IDictionary parseData) {
// Can't have an error page if buffering is off
if (!flags[buffer] && _errorPage != null) {
ProcessError(SR.GetString(
SR.Error_page_not_supported_when_buffering_off));
return;
}
if (_culture != null && _lcid > 0) {
ProcessError(SR.GetString(SR.Attributes_mutually_exclusive, "Culture", "LCID"));
return;
}
if (_responseEncoding != null && _codePage > 0) {
ProcessError(SR.GetString(SR.Attributes_mutually_exclusive, "ResponseEncoding", "CodePage"));
return;
}
// async can't be combined with aspcompat
if (AsyncMode && AspCompatMode) {
ProcessError(SR.GetString(SR.Async_and_aspcompat));
return;
}
// async can't be combined with transactions
if (AsyncMode && _transactionMode != 0) {
ProcessError(SR.GetString(SR.Async_and_transaction));
return;
}
// Let the base class do its post processing
base.PostProcessMainDirectiveAttributes(parseData);
}
private enum TraceModeInternal {
SortByTime = 0,
SortByCategory = 1
}
// This must be in its own method to avoid jitting System.EnterpriseServices.dll
// when it is not needed (ASURT 71868)
private void ParseTransactionAttribute(string name, string value) {
object tmpObj = Util.GetEnumAttribute(name, value, typeof(TransactionOption));
if (tmpObj != null) {
_transactionMode = (int) tmpObj;
// Add a reference to the transaction assembly only if needed
if (_transactionMode != 0 /*TransactionOption.Disabled*/) {
if (!HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Medium)) {
throw new HttpException(SR.GetString(SR.Insufficient_trust_for_attribute, "transaction"));
}
AddAssemblyDependency(typeof(TransactionOption).Assembly);
}
}
}
internal const string defaultDirectiveName = "page";
internal override string DefaultDirectiveName {
get { return defaultDirectiveName; }
}
/*
* Process the contents of the <%@ OutputCache ... %> directive
*/
internal override void ProcessOutputCacheDirective(string directiveName, IDictionary directive) {
string varyByContentEncoding;
string varyByHeader;
string sqlDependency;
bool noStoreValue = false;
varyByContentEncoding = Util.GetAndRemoveNonEmptyAttribute(directive, "varybycontentencoding");
if (varyByContentEncoding != null) {
OutputCacheParameters.VaryByContentEncoding = varyByContentEncoding;
}
varyByHeader = Util.GetAndRemoveNonEmptyAttribute(directive, "varybyheader");
if (varyByHeader != null) {
OutputCacheParameters.VaryByHeader = varyByHeader;
}
object tmpObj = Util.GetAndRemoveEnumAttribute(directive, typeof(OutputCacheLocation), "location");
if (tmpObj != null) {
_outputCacheLocation = (OutputCacheLocation) tmpObj;
OutputCacheParameters.Location = _outputCacheLocation;
}
sqlDependency = Util.GetAndRemoveNonEmptyAttribute(directive, "sqldependency");
if (sqlDependency != null) {
OutputCacheParameters.SqlDependency = sqlDependency;
// Validate the sqldependency attribute
SqlCacheDependency.ValidateOutputCacheDependencyString(sqlDependency, true);
}
// Get the "no store" bool value
if (Util.GetAndRemoveBooleanAttribute(directive, "nostore", ref noStoreValue)) {
OutputCacheParameters.NoStore = noStoreValue;
}
base.ProcessOutputCacheDirective(directiveName, directive);
}
internal override bool FDurationRequiredOnOutputCache {
get { return _outputCacheLocation != OutputCacheLocation.None; }
}
internal override bool FVaryByParamsRequiredOnOutputCache {
get { return _outputCacheLocation != OutputCacheLocation.None; }
}
internal override string UnknownOutputCacheAttributeError {
get { return SR.Attr_not_supported_in_pagedirective; }
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- TabItem.cs
- MenuItem.cs
- UserControlBuildProvider.cs
- ToolStripGripRenderEventArgs.cs
- ComEventsInfo.cs
- MediaPlayerState.cs
- WebPartRestoreVerb.cs
- CatalogPartCollection.cs
- KeyedCollection.cs
- JulianCalendar.cs
- SafeProcessHandle.cs
- CodeValidator.cs
- FixUp.cs
- SqlProviderManifest.cs
- CngKeyBlobFormat.cs
- PointAnimationClockResource.cs
- PriorityBindingExpression.cs
- InfoCardKeyedHashAlgorithm.cs
- _PooledStream.cs
- OptimizedTemplateContentHelper.cs
- LineServicesCallbacks.cs
- LogReserveAndAppendState.cs
- CombinedGeometry.cs
- OleDbParameterCollection.cs
- MappedMetaModel.cs
- XmlAtomicValue.cs
- NumberAction.cs
- MultiView.cs
- ServiceHostingEnvironment.cs
- DragStartedEventArgs.cs
- DataGridToolTip.cs
- CanonicalXml.cs
- AnonymousIdentificationModule.cs
- DateTimeSerializationSection.cs
- MessageBodyDescription.cs
- KeyboardEventArgs.cs
- IChannel.cs
- UiaCoreProviderApi.cs
- EdmType.cs
- InkCollectionBehavior.cs
- CombinedGeometry.cs
- Paragraph.cs
- EventLogException.cs
- AppDomainManager.cs
- PresentationTraceSources.cs
- ColorDialog.cs
- CheckPair.cs
- CurrencyManager.cs
- XmlCDATASection.cs
- FixedTextContainer.cs
- GiveFeedbackEventArgs.cs
- DataGridTable.cs
- precedingsibling.cs
- DeclarativeCatalogPart.cs
- TableStyle.cs
- SimpleApplicationHost.cs
- CodeAttributeDeclarationCollection.cs
- MethodResolver.cs
- Delegate.cs
- PartitionedStreamMerger.cs
- SoapBinding.cs
- FileSystemWatcher.cs
- TeredoHelper.cs
- TextStore.cs
- SqlErrorCollection.cs
- SchemaInfo.cs
- UnaryNode.cs
- documentsequencetextcontainer.cs
- FixedElement.cs
- MetabaseServerConfig.cs
- SqlDataSource.cs
- DataBinding.cs
- PieceNameHelper.cs
- Condition.cs
- TemplateBindingExpression.cs
- XmlSerializerAssemblyAttribute.cs
- MimeMultiPart.cs
- AsnEncodedData.cs
- DataConnectionHelper.cs
- RequiredAttributeAttribute.cs
- LineGeometry.cs
- PropertyTab.cs
- ServiceObjectContainer.cs
- StyleTypedPropertyAttribute.cs
- StandardBindingElement.cs
- LongValidator.cs
- ObjectDataSourceMethodEventArgs.cs
- SmtpNegotiateAuthenticationModule.cs
- WbmpConverter.cs
- ChannelServices.cs
- HandleValueEditor.cs
- Pen.cs
- SqlClientMetaDataCollectionNames.cs
- DataGridViewCellFormattingEventArgs.cs
- EntityDescriptor.cs
- HMACMD5.cs
- StreamResourceInfo.cs
- CodeSubDirectory.cs
- DecodeHelper.cs
- HtmlShim.cs