Code:
/ FXUpdate3074 / FXUpdate3074 / 1.1 / DEVDIV / depot / DevDiv / releases / whidbey / QFE / ndp / fx / src / xsp / System / Web / Hosting / MapPathBasedVirtualPathProvider.cs / 4 / MapPathBasedVirtualPathProvider.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
* Implementation of VirtualPathProvider based on the metabase and the standard
* file system. This is what ASP.NET uses by default.
*/
namespace System.Web.Hosting {
using System;
using System.IO;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.Configuration;
using System.Web.Util;
using System.Web.Configuration;
using System.Web.Caching;
using System.Web.Compilation;
using Util=System.Web.UI.Util;
using System.Security.Permissions;
internal class MapPathBasedVirtualPathProvider: VirtualPathProvider {
public override string GetFileHash(string virtualPath, IEnumerable virtualPathDependencies) {
HashCodeCombiner hashCodeCombiner = new HashCodeCombiner();
// Calculate the hash based on the time stamps of all the virtual paths
foreach (string virtualDependency in virtualPathDependencies) {
string physicalDependency = HostingEnvironment.MapPathInternal(virtualDependency);
hashCodeCombiner.AddFile(physicalDependency);
}
return hashCodeCombiner.CombinedHashString;
}
public override CacheDependency GetCacheDependency(string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart) {
if (virtualPathDependencies == null)
return null;
StringCollection physicalDependencies = null;
// Get the list of physical dependencies
foreach (string virtualDependency in virtualPathDependencies) {
string physicalDependency = HostingEnvironment.MapPathInternal(virtualDependency);
if (physicalDependencies == null)
physicalDependencies = new StringCollection();
physicalDependencies.Add(physicalDependency);
}
if (physicalDependencies == null)
return null;
// Copy the list of physical dependencies into an array
string[] physicalDependenciesArray = new string[physicalDependencies.Count];
physicalDependencies.CopyTo(physicalDependenciesArray, 0);
return new CacheDependency(0, physicalDependenciesArray, utcStart);
}
public override bool FileExists(string virtualPath) {
string physicalPath = HostingEnvironment.MapPathInternal(virtualPath);
return File.Exists(physicalPath);
}
public override bool DirectoryExists(string virtualDir) {
string physicalDir = HostingEnvironment.MapPathInternal(virtualDir);
return Directory.Exists(physicalDir);
}
public override VirtualFile GetFile(string virtualPath) {
return new MapPathBasedVirtualFile(virtualPath);
}
public override VirtualDirectory GetDirectory(string virtualDir) {
return new MapPathBasedVirtualDirectory(virtualDir);
}
}
internal class MapPathBasedVirtualFile: VirtualFile {
private string _physicalPath;
private FindFileData _ffd;
internal MapPathBasedVirtualFile(string virtualPath) : base(virtualPath) { }
internal MapPathBasedVirtualFile(string virtualPath, string physicalPath,
FindFileData ffd) : base(virtualPath) {
_physicalPath = physicalPath;
_ffd = ffd;
}
private void EnsureFileInfoObtained() {
// Get the physical path and FindFileData on demand
if (_physicalPath == null) {
Debug.Assert(_ffd == null);
_physicalPath = HostingEnvironment.MapPathInternal(VirtualPath);
FindFileData.FindFile(_physicalPath, out _ffd);
}
}
public override string Name {
get {
EnsureFileInfoObtained();
// If for whatever reason we couldn't get the FindFileData, just call the base (
if (_ffd == null)
return base.Name;
return _ffd.FileNameLong;
}
}
public override Stream Open() {
EnsureFileInfoObtained();
TimeStampChecker.AddFile(VirtualPath, _physicalPath);
return new FileStream(_physicalPath, FileMode.Open, FileAccess.Read, FileShare.Read);
}
internal string PhysicalPath {
get {
EnsureFileInfoObtained();
return _physicalPath;
}
}
}
internal class MapPathBasedVirtualDirectory: VirtualDirectory {
public MapPathBasedVirtualDirectory(string virtualPath) : base(virtualPath) { }
public override IEnumerable Directories {
get {
return new MapPathBasedVirtualPathCollection(
System.Web.VirtualPath.CreateNonRelative(VirtualPath), RequestedEntryType.Directories);
}
}
public override IEnumerable Files {
get {
return new MapPathBasedVirtualPathCollection(
System.Web.VirtualPath.CreateNonRelative(VirtualPath), RequestedEntryType.Files);
}
}
public override IEnumerable Children {
get {
return new MapPathBasedVirtualPathCollection(
System.Web.VirtualPath.CreateNonRelative(VirtualPath), RequestedEntryType.All);
}
}
}
internal enum RequestedEntryType {
Files,
Directories,
All
}
internal class MapPathBasedVirtualPathCollection: MarshalByRefObject, IEnumerable {
private VirtualPath _virtualPath;
private RequestedEntryType _requestedEntryType;
internal MapPathBasedVirtualPathCollection(VirtualPath virtualPath, RequestedEntryType requestedEntryType) {
_virtualPath = virtualPath;
_requestedEntryType = requestedEntryType;
}
public override Object InitializeLifetimeService(){
return null; // never expire lease
}
IEnumerator IEnumerable.GetEnumerator() {
return new MapPathBasedVirtualPathEnumerator(_virtualPath, _requestedEntryType);
}
}
internal class MapPathBasedVirtualPathEnumerator : MarshalByRefObject, IEnumerator, IDisposable {
VirtualPath _virtualPath; // virtual path we are enumerating
Hashtable _exclude; // names of files and dirs to exclude
Hashtable _virtualPaths; // names of virtual directories to include
IEnumerator _fileEnumerator; // the physical file enumerator
IEnumerator _virtualEnumerator; // the virtual file enumerator
bool _useFileEnumerator; // use the file enumerator
RequestedEntryType _requestedEntryType;
ProcessHostServerConfig _processHostServerConfig; // only used with ProcessHostServerConfig
internal MapPathBasedVirtualPathEnumerator(VirtualPath virtualPath, RequestedEntryType requestedEntryType) {
if (virtualPath.IsRelative) {
throw new ArgumentException(SR.GetString(SR.Invalid_app_VirtualPath), "virtualPath");
}
_virtualPath = virtualPath;
_requestedEntryType = requestedEntryType;
string physicalPath;
if (!ServerConfig.UseServerConfig) {
// Use the hosting environment to map the virtual path
physicalPath = _virtualPath.MapPathInternal();
}
else {
IServerConfig serverConfig = ServerConfig.GetInstance();
_processHostServerConfig = serverConfig as ProcessHostServerConfig;
// Use serverConfig to map the virtual path
physicalPath = serverConfig.MapPath(null, _virtualPath);
if (_requestedEntryType != RequestedEntryType.Files) {
// For MetabaseServerConfig, get the subdirs that are not in the application, and add them to the exclude list.
if (_processHostServerConfig == null) {
string [] virtualSubdirsNotInApp = serverConfig.GetVirtualSubdirs(_virtualPath, false);
if (virtualSubdirsNotInApp != null) {
_exclude = new Hashtable(StringComparer.OrdinalIgnoreCase);
foreach (string subdir in virtualSubdirsNotInApp) {
_exclude[subdir] = subdir;
}
}
}
// Get subdirs that are virtual directories, and record their physical mappings.
// Ignore the virtualPaths if we only need files, since it only contains directories
string [] virtualSubdirsInApp = serverConfig.GetVirtualSubdirs(_virtualPath, true);
if (virtualSubdirsInApp != null) {
_virtualPaths = new Hashtable(StringComparer.OrdinalIgnoreCase);
foreach (string subdir in virtualSubdirsInApp) {
VirtualPath subpath = _virtualPath.SimpleCombineWithDir(subdir);
string subPhysicalPath = serverConfig.MapPath(null, subpath);
if (FileUtil.DirectoryExists(subPhysicalPath)) {
_virtualPaths[subdir] = new MapPathBasedVirtualDirectory(subpath.VirtualPathString);
}
}
// Create enumerator for the virtual paths
_virtualEnumerator = _virtualPaths.Values.GetEnumerator();
}
}
}
// Create an enumerator for the physical files and directories at this path
_fileEnumerator = FileEnumerator.Create(physicalPath);
// Reset the enumerator. Note that we don't support the Reset method.
_useFileEnumerator = false;
}
public override Object InitializeLifetimeService(){
return null; // never expire lease
}
// Dispose the file enumerator
void IDisposable.Dispose() {
if (_fileEnumerator != null) {
((IDisposable)_fileEnumerator).Dispose();
_fileEnumerator = null;
}
}
// First MoveNext() with the file enumerator, then with the virtual directories
// that have not been enumerated.
bool IEnumerator.MoveNext() {
bool more = false;
if (_virtualEnumerator != null)
more = _virtualEnumerator.MoveNext();
if (!more) {
_useFileEnumerator = true;
for (;;) {
more = _fileEnumerator.MoveNext();
if (!more)
break;
FileData fileData = (FileData) _fileEnumerator.Current;
// Ignore all hidden files and directories
if (fileData.IsHidden)
continue;
// Ignore it if it's not of the right type (i.e. directory vs file)
if (fileData.IsDirectory) {
if (_requestedEntryType == RequestedEntryType.Files)
continue;
// Check whether the file is the same as a virtual path
// that we have already enumerated
string name = fileData.Name;
if (_virtualPaths != null && _virtualPaths.Contains(name))
continue;
// Check whether the file should be excluded because it is
// not part of this app.
// MetabaseServerConfig
if (_exclude != null && _exclude.Contains(name))
continue;
// ProcessHostServerConfig
if (_processHostServerConfig != null && !_processHostServerConfig.IsWithinApp(UrlPath.SimpleCombine(_virtualPath.VirtualPathString, name))) {
continue;
}
}
else {
if (_requestedEntryType == RequestedEntryType.Directories)
continue;
}
// We've found the file
break;
}
}
return more;
}
internal VirtualFileBase Current {
get {
if (_useFileEnumerator) {
FileData fileData = (FileData) _fileEnumerator.Current;
VirtualPath childVirtualPath;
if (fileData.IsDirectory) {
childVirtualPath = _virtualPath.SimpleCombineWithDir(fileData.Name);
return new MapPathBasedVirtualDirectory(childVirtualPath.VirtualPathString);
}
else {
childVirtualPath = _virtualPath.SimpleCombine(fileData.Name);
FindFileData ffd = fileData.GetFindFileData();
return new MapPathBasedVirtualFile(childVirtualPath.VirtualPathString, fileData.FullName, ffd);
}
}
else {
return (VirtualFileBase) _virtualEnumerator.Current;
}
}
}
object IEnumerator.Current {
get { return Current; }
}
void IEnumerator.Reset() {
// We don't support reset, though it would be easy to add if needed
throw new InvalidOperationException();
}
}
#if NO
// TEST CODE
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
public class TestEnum {
public static void Enum(HttpResponse response) {
VirtualDirectory vdir = HostingEnvironment.VirtualPathProvider.GetDirectory(
"~");
EnumRecursive(response, vdir);
}
static void EnumRecursive(HttpResponse response, VirtualDirectory vdir) {
foreach (VirtualFile vfile in vdir.Files) {
response.Write("File: " + vfile.VirtualPath + "
\r\n");
}
foreach (VirtualDirectory childVdir in vdir.Directories) {
response.Write("Directory: " + childVdir.VirtualPath + "
\r\n");
EnumRecursive(response, childVdir);
}
}
}
#endif
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
* Implementation of VirtualPathProvider based on the metabase and the standard
* file system. This is what ASP.NET uses by default.
*/
namespace System.Web.Hosting {
using System;
using System.IO;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.Configuration;
using System.Web.Util;
using System.Web.Configuration;
using System.Web.Caching;
using System.Web.Compilation;
using Util=System.Web.UI.Util;
using System.Security.Permissions;
internal class MapPathBasedVirtualPathProvider: VirtualPathProvider {
public override string GetFileHash(string virtualPath, IEnumerable virtualPathDependencies) {
HashCodeCombiner hashCodeCombiner = new HashCodeCombiner();
// Calculate the hash based on the time stamps of all the virtual paths
foreach (string virtualDependency in virtualPathDependencies) {
string physicalDependency = HostingEnvironment.MapPathInternal(virtualDependency);
hashCodeCombiner.AddFile(physicalDependency);
}
return hashCodeCombiner.CombinedHashString;
}
public override CacheDependency GetCacheDependency(string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart) {
if (virtualPathDependencies == null)
return null;
StringCollection physicalDependencies = null;
// Get the list of physical dependencies
foreach (string virtualDependency in virtualPathDependencies) {
string physicalDependency = HostingEnvironment.MapPathInternal(virtualDependency);
if (physicalDependencies == null)
physicalDependencies = new StringCollection();
physicalDependencies.Add(physicalDependency);
}
if (physicalDependencies == null)
return null;
// Copy the list of physical dependencies into an array
string[] physicalDependenciesArray = new string[physicalDependencies.Count];
physicalDependencies.CopyTo(physicalDependenciesArray, 0);
return new CacheDependency(0, physicalDependenciesArray, utcStart);
}
public override bool FileExists(string virtualPath) {
string physicalPath = HostingEnvironment.MapPathInternal(virtualPath);
return File.Exists(physicalPath);
}
public override bool DirectoryExists(string virtualDir) {
string physicalDir = HostingEnvironment.MapPathInternal(virtualDir);
return Directory.Exists(physicalDir);
}
public override VirtualFile GetFile(string virtualPath) {
return new MapPathBasedVirtualFile(virtualPath);
}
public override VirtualDirectory GetDirectory(string virtualDir) {
return new MapPathBasedVirtualDirectory(virtualDir);
}
}
internal class MapPathBasedVirtualFile: VirtualFile {
private string _physicalPath;
private FindFileData _ffd;
internal MapPathBasedVirtualFile(string virtualPath) : base(virtualPath) { }
internal MapPathBasedVirtualFile(string virtualPath, string physicalPath,
FindFileData ffd) : base(virtualPath) {
_physicalPath = physicalPath;
_ffd = ffd;
}
private void EnsureFileInfoObtained() {
// Get the physical path and FindFileData on demand
if (_physicalPath == null) {
Debug.Assert(_ffd == null);
_physicalPath = HostingEnvironment.MapPathInternal(VirtualPath);
FindFileData.FindFile(_physicalPath, out _ffd);
}
}
public override string Name {
get {
EnsureFileInfoObtained();
// If for whatever reason we couldn't get the FindFileData, just call the base (
if (_ffd == null)
return base.Name;
return _ffd.FileNameLong;
}
}
public override Stream Open() {
EnsureFileInfoObtained();
TimeStampChecker.AddFile(VirtualPath, _physicalPath);
return new FileStream(_physicalPath, FileMode.Open, FileAccess.Read, FileShare.Read);
}
internal string PhysicalPath {
get {
EnsureFileInfoObtained();
return _physicalPath;
}
}
}
internal class MapPathBasedVirtualDirectory: VirtualDirectory {
public MapPathBasedVirtualDirectory(string virtualPath) : base(virtualPath) { }
public override IEnumerable Directories {
get {
return new MapPathBasedVirtualPathCollection(
System.Web.VirtualPath.CreateNonRelative(VirtualPath), RequestedEntryType.Directories);
}
}
public override IEnumerable Files {
get {
return new MapPathBasedVirtualPathCollection(
System.Web.VirtualPath.CreateNonRelative(VirtualPath), RequestedEntryType.Files);
}
}
public override IEnumerable Children {
get {
return new MapPathBasedVirtualPathCollection(
System.Web.VirtualPath.CreateNonRelative(VirtualPath), RequestedEntryType.All);
}
}
}
internal enum RequestedEntryType {
Files,
Directories,
All
}
internal class MapPathBasedVirtualPathCollection: MarshalByRefObject, IEnumerable {
private VirtualPath _virtualPath;
private RequestedEntryType _requestedEntryType;
internal MapPathBasedVirtualPathCollection(VirtualPath virtualPath, RequestedEntryType requestedEntryType) {
_virtualPath = virtualPath;
_requestedEntryType = requestedEntryType;
}
public override Object InitializeLifetimeService(){
return null; // never expire lease
}
IEnumerator IEnumerable.GetEnumerator() {
return new MapPathBasedVirtualPathEnumerator(_virtualPath, _requestedEntryType);
}
}
internal class MapPathBasedVirtualPathEnumerator : MarshalByRefObject, IEnumerator, IDisposable {
VirtualPath _virtualPath; // virtual path we are enumerating
Hashtable _exclude; // names of files and dirs to exclude
Hashtable _virtualPaths; // names of virtual directories to include
IEnumerator _fileEnumerator; // the physical file enumerator
IEnumerator _virtualEnumerator; // the virtual file enumerator
bool _useFileEnumerator; // use the file enumerator
RequestedEntryType _requestedEntryType;
ProcessHostServerConfig _processHostServerConfig; // only used with ProcessHostServerConfig
internal MapPathBasedVirtualPathEnumerator(VirtualPath virtualPath, RequestedEntryType requestedEntryType) {
if (virtualPath.IsRelative) {
throw new ArgumentException(SR.GetString(SR.Invalid_app_VirtualPath), "virtualPath");
}
_virtualPath = virtualPath;
_requestedEntryType = requestedEntryType;
string physicalPath;
if (!ServerConfig.UseServerConfig) {
// Use the hosting environment to map the virtual path
physicalPath = _virtualPath.MapPathInternal();
}
else {
IServerConfig serverConfig = ServerConfig.GetInstance();
_processHostServerConfig = serverConfig as ProcessHostServerConfig;
// Use serverConfig to map the virtual path
physicalPath = serverConfig.MapPath(null, _virtualPath);
if (_requestedEntryType != RequestedEntryType.Files) {
// For MetabaseServerConfig, get the subdirs that are not in the application, and add them to the exclude list.
if (_processHostServerConfig == null) {
string [] virtualSubdirsNotInApp = serverConfig.GetVirtualSubdirs(_virtualPath, false);
if (virtualSubdirsNotInApp != null) {
_exclude = new Hashtable(StringComparer.OrdinalIgnoreCase);
foreach (string subdir in virtualSubdirsNotInApp) {
_exclude[subdir] = subdir;
}
}
}
// Get subdirs that are virtual directories, and record their physical mappings.
// Ignore the virtualPaths if we only need files, since it only contains directories
string [] virtualSubdirsInApp = serverConfig.GetVirtualSubdirs(_virtualPath, true);
if (virtualSubdirsInApp != null) {
_virtualPaths = new Hashtable(StringComparer.OrdinalIgnoreCase);
foreach (string subdir in virtualSubdirsInApp) {
VirtualPath subpath = _virtualPath.SimpleCombineWithDir(subdir);
string subPhysicalPath = serverConfig.MapPath(null, subpath);
if (FileUtil.DirectoryExists(subPhysicalPath)) {
_virtualPaths[subdir] = new MapPathBasedVirtualDirectory(subpath.VirtualPathString);
}
}
// Create enumerator for the virtual paths
_virtualEnumerator = _virtualPaths.Values.GetEnumerator();
}
}
}
// Create an enumerator for the physical files and directories at this path
_fileEnumerator = FileEnumerator.Create(physicalPath);
// Reset the enumerator. Note that we don't support the Reset method.
_useFileEnumerator = false;
}
public override Object InitializeLifetimeService(){
return null; // never expire lease
}
// Dispose the file enumerator
void IDisposable.Dispose() {
if (_fileEnumerator != null) {
((IDisposable)_fileEnumerator).Dispose();
_fileEnumerator = null;
}
}
// First MoveNext() with the file enumerator, then with the virtual directories
// that have not been enumerated.
bool IEnumerator.MoveNext() {
bool more = false;
if (_virtualEnumerator != null)
more = _virtualEnumerator.MoveNext();
if (!more) {
_useFileEnumerator = true;
for (;;) {
more = _fileEnumerator.MoveNext();
if (!more)
break;
FileData fileData = (FileData) _fileEnumerator.Current;
// Ignore all hidden files and directories
if (fileData.IsHidden)
continue;
// Ignore it if it's not of the right type (i.e. directory vs file)
if (fileData.IsDirectory) {
if (_requestedEntryType == RequestedEntryType.Files)
continue;
// Check whether the file is the same as a virtual path
// that we have already enumerated
string name = fileData.Name;
if (_virtualPaths != null && _virtualPaths.Contains(name))
continue;
// Check whether the file should be excluded because it is
// not part of this app.
// MetabaseServerConfig
if (_exclude != null && _exclude.Contains(name))
continue;
// ProcessHostServerConfig
if (_processHostServerConfig != null && !_processHostServerConfig.IsWithinApp(UrlPath.SimpleCombine(_virtualPath.VirtualPathString, name))) {
continue;
}
}
else {
if (_requestedEntryType == RequestedEntryType.Directories)
continue;
}
// We've found the file
break;
}
}
return more;
}
internal VirtualFileBase Current {
get {
if (_useFileEnumerator) {
FileData fileData = (FileData) _fileEnumerator.Current;
VirtualPath childVirtualPath;
if (fileData.IsDirectory) {
childVirtualPath = _virtualPath.SimpleCombineWithDir(fileData.Name);
return new MapPathBasedVirtualDirectory(childVirtualPath.VirtualPathString);
}
else {
childVirtualPath = _virtualPath.SimpleCombine(fileData.Name);
FindFileData ffd = fileData.GetFindFileData();
return new MapPathBasedVirtualFile(childVirtualPath.VirtualPathString, fileData.FullName, ffd);
}
}
else {
return (VirtualFileBase) _virtualEnumerator.Current;
}
}
}
object IEnumerator.Current {
get { return Current; }
}
void IEnumerator.Reset() {
// We don't support reset, though it would be easy to add if needed
throw new InvalidOperationException();
}
}
#if NO
// TEST CODE
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
public class TestEnum {
public static void Enum(HttpResponse response) {
VirtualDirectory vdir = HostingEnvironment.VirtualPathProvider.GetDirectory(
"~");
EnumRecursive(response, vdir);
}
static void EnumRecursive(HttpResponse response, VirtualDirectory vdir) {
foreach (VirtualFile vfile in vdir.Files) {
response.Write("File: " + vfile.VirtualPath + "
\r\n");
}
foreach (VirtualDirectory childVdir in vdir.Directories) {
response.Write("Directory: " + childVdir.VirtualPath + "
\r\n");
EnumRecursive(response, childVdir);
}
}
}
#endif
}
// 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
- ArglessEventHandlerProxy.cs
- BuildResult.cs
- ObservableCollectionDefaultValueFactory.cs
- PageCodeDomTreeGenerator.cs
- IIS7ConfigurationLoader.cs
- XmlIgnoreAttribute.cs
- BindingMAnagerBase.cs
- InfoCardTraceRecord.cs
- DataSourceListEditor.cs
- UpdatableGenericsFeature.cs
- WinFormsSecurity.cs
- XmlSchemaValidationException.cs
- PtsHost.cs
- SqlNotificationEventArgs.cs
- TreeWalkHelper.cs
- OuterGlowBitmapEffect.cs
- TextWriter.cs
- StylusLogic.cs
- UnitControl.cs
- MTConfigUtil.cs
- ModelPropertyImpl.cs
- UpdateRecord.cs
- InternalResources.cs
- WorkflowInlining.cs
- ToolStripLocationCancelEventArgs.cs
- Menu.cs
- ApplicationActivator.cs
- PrinterUnitConvert.cs
- AppSettings.cs
- CodeTypeConstructor.cs
- MissingMemberException.cs
- DiscoveryReference.cs
- TimelineGroup.cs
- EventSinkHelperWriter.cs
- DataSourceControl.cs
- ToolStripRenderer.cs
- StyleModeStack.cs
- SqlDataSourceCustomCommandPanel.cs
- HyperLinkField.cs
- AdPostCacheSubstitution.cs
- FixUpCollection.cs
- FileLevelControlBuilderAttribute.cs
- XmlSchemaAll.cs
- NavigationPropertyEmitter.cs
- GridSplitterAutomationPeer.cs
- ExcludePathInfo.cs
- DataGridViewRowEventArgs.cs
- DataBindingExpressionBuilder.cs
- LightweightCodeGenerator.cs
- URLIdentityPermission.cs
- SqlDataRecord.cs
- TableStyle.cs
- DomainUpDown.cs
- MailSettingsSection.cs
- OleDbParameterCollection.cs
- QueryLifecycle.cs
- JavaScriptString.cs
- InvokePattern.cs
- IInstanceContextProvider.cs
- ListBindingHelper.cs
- InvokeBase.cs
- autovalidator.cs
- MissingMethodException.cs
- SqlDataSourceEnumerator.cs
- MaterializeFromAtom.cs
- BuildDependencySet.cs
- EventlogProvider.cs
- Thread.cs
- CodeAttributeDeclaration.cs
- TraceLog.cs
- TemplatePartAttribute.cs
- GridViewRowCollection.cs
- XdrBuilder.cs
- UniformGrid.cs
- HttpCachePolicy.cs
- ApplyHostConfigurationBehavior.cs
- TerminatorSinks.cs
- SecurityPolicySection.cs
- ChildTable.cs
- EntityCommandExecutionException.cs
- SqlClientWrapperSmiStreamChars.cs
- documentsequencetextview.cs
- filewebrequest.cs
- _NegotiateClient.cs
- SetterBaseCollection.cs
- ThreadAttributes.cs
- AuthenticateEventArgs.cs
- Overlapped.cs
- XmlSchemaSimpleContentExtension.cs
- XslAst.cs
- EmptyEnumerator.cs
- MethodToken.cs
- AsymmetricAlgorithm.cs
- ErrorHandlingReceiver.cs
- ErrorTableItemStyle.cs
- UIServiceHelper.cs
- GatewayDefinition.cs
- ScriptManager.cs
- PolyBezierSegmentFigureLogic.cs
- RefExpr.cs