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
- SerialReceived.cs
- MSHTMLHost.cs
- TemplateControlBuildProvider.cs
- ObjectViewQueryResultData.cs
- CmsInterop.cs
- OAVariantLib.cs
- RenderOptions.cs
- DbException.cs
- dbdatarecord.cs
- NullableLongAverageAggregationOperator.cs
- SQLMoney.cs
- CodeTypeOfExpression.cs
- XPathSelectionIterator.cs
- InsufficientMemoryException.cs
- ExpanderAutomationPeer.cs
- DataGridRowHeader.cs
- ArrangedElementCollection.cs
- XhtmlBasicLiteralTextAdapter.cs
- ListItemParagraph.cs
- Viewport2DVisual3D.cs
- PerformanceCounterManager.cs
- Clipboard.cs
- ConfigXmlSignificantWhitespace.cs
- SQLConvert.cs
- Attributes.cs
- _AcceptOverlappedAsyncResult.cs
- DesignerHierarchicalDataSourceView.cs
- OracleException.cs
- MachineKeySection.cs
- RangeValidator.cs
- Size.cs
- DoubleLinkList.cs
- UdpAnnouncementEndpoint.cs
- MetadataSource.cs
- TextTreeTextElementNode.cs
- DateTimeSerializationSection.cs
- UncommonField.cs
- DataGridViewDataConnection.cs
- MissingFieldException.cs
- ConfigXmlText.cs
- MimeTypePropertyAttribute.cs
- StateDesigner.cs
- GeneralTransform2DTo3D.cs
- ImageSource.cs
- WebEventCodes.cs
- DrawingGroup.cs
- DbConnectionStringBuilder.cs
- CounterSample.cs
- SQLInt32.cs
- XmlHierarchicalEnumerable.cs
- StatusBar.cs
- RoleManagerEventArgs.cs
- Type.cs
- UInt32.cs
- UnionQueryOperator.cs
- RegularExpressionValidator.cs
- WorkflowRequestContext.cs
- PersistChildrenAttribute.cs
- WebColorConverter.cs
- RequiredFieldValidator.cs
- XmlSchemaAttributeGroupRef.cs
- ContextStack.cs
- CheckBoxBaseAdapter.cs
- MissingFieldException.cs
- ExpanderAutomationPeer.cs
- ChannelSinkStacks.cs
- MimeTypeMapper.cs
- GenericRootAutomationPeer.cs
- MultiAsyncResult.cs
- XmlDocumentType.cs
- CommonDialog.cs
- PackWebRequest.cs
- ContentOperations.cs
- TimeZoneNotFoundException.cs
- Activator.cs
- HwndSubclass.cs
- CrossContextChannel.cs
- KerberosRequestorSecurityToken.cs
- CounterCreationData.cs
- odbcmetadatacollectionnames.cs
- ImportOptions.cs
- RepeatButton.cs
- PkcsUtils.cs
- Expression.cs
- Block.cs
- SQLRoleProvider.cs
- RequiredAttributeAttribute.cs
- AbstractExpressions.cs
- File.cs
- EventLevel.cs
- CodeNamespaceImportCollection.cs
- BitmapEffectGeneralTransform.cs
- InvalidCommandTreeException.cs
- ComponentDispatcherThread.cs
- MappingSource.cs
- Object.cs
- DelegateHelpers.Generated.cs
- Tuple.cs
- SoapSchemaMember.cs
- DirectoryLocalQuery.cs