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
- InvalidPropValue.cs
- ConstantExpression.cs
- DataListDesigner.cs
- FacetDescription.cs
- KeyboardEventArgs.cs
- RenderingEventArgs.cs
- OdbcFactory.cs
- NativeWindow.cs
- TransformValueSerializer.cs
- PermissionSet.cs
- EncryptedData.cs
- XmlSchemaValidationException.cs
- TextEditorDragDrop.cs
- BaseDataList.cs
- TemplatePagerField.cs
- RemoveStoryboard.cs
- MissingMethodException.cs
- DetailsViewPageEventArgs.cs
- basenumberconverter.cs
- TitleStyle.cs
- Timer.cs
- IUnknownConstantAttribute.cs
- NTAccount.cs
- AdornerHitTestResult.cs
- List.cs
- _ConnectStream.cs
- BitVector32.cs
- RequestCache.cs
- HttpWrapper.cs
- DifferencingCollection.cs
- CounterSampleCalculator.cs
- ArraySortHelper.cs
- AutomationPattern.cs
- _KerberosClient.cs
- XmlCountingReader.cs
- NGCPageContentCollectionSerializerAsync.cs
- CatalogPartChrome.cs
- SafeFileMappingHandle.cs
- SpeechAudioFormatInfo.cs
- XmlChildNodes.cs
- TemplateBindingExpressionConverter.cs
- SourceChangedEventArgs.cs
- KnownBoxes.cs
- TreeViewCancelEvent.cs
- AccessDataSource.cs
- WindowsRichEdit.cs
- AddingNewEventArgs.cs
- DataGridViewColumnHeaderCell.cs
- SqlNotificationEventArgs.cs
- ProxyGenerator.cs
- XmlSchemaAll.cs
- NativeMethods.cs
- ListViewCommandEventArgs.cs
- TrustLevelCollection.cs
- DateTimeFormatInfoScanner.cs
- RestClientProxyHandler.cs
- PeerResolverBindingElement.cs
- XamlGridLengthSerializer.cs
- BooleanStorage.cs
- ImageUrlEditor.cs
- HtmlLinkAdapter.cs
- UIElementParaClient.cs
- log.cs
- MemberJoinTreeNode.cs
- oledbmetadatacollectionnames.cs
- Int64.cs
- CalendarTable.cs
- SqlProviderServices.cs
- GcSettings.cs
- XsdBuildProvider.cs
- FixedDSBuilder.cs
- XmlWrappingReader.cs
- HandleTable.cs
- HostExecutionContextManager.cs
- CoreSwitches.cs
- CustomExpressionEventArgs.cs
- safesecurityhelperavalon.cs
- SQLChars.cs
- ImageDrawing.cs
- EntitySetBaseCollection.cs
- CompositeKey.cs
- SqlBooleanizer.cs
- ChannelTraceRecord.cs
- FontStyle.cs
- QilUnary.cs
- TextRangeSerialization.cs
- WebFormDesignerActionService.cs
- SqlCharStream.cs
- ActivityExecutorSurrogate.cs
- XmlNodeChangedEventManager.cs
- TextBoxLine.cs
- ApplicationInfo.cs
- FreezableCollection.cs
- IndexerNameAttribute.cs
- MsmqIntegrationSecurityMode.cs
- PackageDigitalSignature.cs
- UDPClient.cs
- FrameworkContentElement.cs
- SByteStorage.cs
- CustomAttributeFormatException.cs