Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / fx / src / Configuration / System / Configuration / OverrideMode.cs / 1 / OverrideMode.cs
//------------------------------------------------------------------------------ //// Copyright (c) Microsoft Corporation. All rights reserved. // //----------------------------------------------------------------------------- namespace System.Configuration { using System.Configuration.Internal; using System.Collections; using System.Collections.Generic; using System.Collections.Specialized; using System.Configuration; using System.Globalization; using System.IO; using System.Reflection; using System.Runtime.InteropServices; using System.Security.Permissions; using System.Security; using System.Text; using System.Xml; // This is the public type of the override mode enum visible to the API users // The override mode is an attribute of atag and controls if the sections inside this tag // can be defined in child web.config files public enum OverrideMode { // Default ( aka Indiferent ) - When specified on a location tag means the location tag will not alter // the locking mode ( locked or unlocked ). Rather, the locking mode should be picked // from the tag with the closest parent path in the current file, or the parent file if no such location in the current one, // or the default for the specific section ( section.OverrideModeDefault ) Inherit = 0, // Allow overriding in child config files. I.e. unlock the settings for overridiing Allow = 1, // Deny overriding of the settings defined in the tag. It is an error for the sections in the tag // to appear in a child config file. It is not an error for them to appear in another tag in the current file Deny = 2, } // This is a class that abstracts the usage of the override mode setting internal struct OverrideModeSetting { private const byte ApiDefinedLegacy = 0x10; // allowOverride was set thourhg the API private const byte ApiDefinedNewMode = 0x20; // overrideMode was set thourhg the API private const byte ApiDefinedAny = ApiDefinedLegacy | ApiDefinedNewMode; // allowOverride or overrideMode was set through the API private const byte XmlDefinedLegacy = 0x40; // allowOverride was defined in the XML private const byte XmlDefinedNewMode = 0x80; // overrideMode was defined in the XML private const byte XmlDefinedAny = XmlDefinedLegacy | XmlDefinedNewMode; // overrideMode or allowOverride was defined in the XML private const byte ModeMask = 0x0f; // logical AND this with the current value to get the mode part only private byte _mode; internal static OverrideModeSetting SectionDefault; internal static OverrideModeSetting LocationDefault; static OverrideModeSetting() { SectionDefault = new OverrideModeSetting(); // Default for section is ALLOW ( to be consistent with Whidbey ) SectionDefault._mode = (byte)OverrideMode.Allow; LocationDefault = new OverrideModeSetting(); // Default for location tags is INHERIT. Note that we do not make the value as existant in the XML or specified by the API LocationDefault._mode = (byte)OverrideMode.Inherit; } static internal OverrideModeSetting CreateFromXmlReadValue(bool allowOverride) { // Create a mode from the old "allowOverride" attribute in the xml // The conversion is true -> OverrideMode.Inherit // The conversion is false -> OverrideMode.Deny // This is consistent with Whidbey where true means true unless there is a false somewhere above OverrideModeSetting result = new OverrideModeSetting(); result.SetMode(allowOverride ? OverrideMode.Inherit : OverrideMode.Deny); result._mode |= XmlDefinedLegacy; return result; } static internal OverrideModeSetting CreateFromXmlReadValue(OverrideMode mode) { OverrideModeSetting result = new OverrideModeSetting(); result.SetMode(mode); result._mode |= XmlDefinedNewMode; return result; } internal static OverrideMode ParseOverrideModeXmlValue(string value, XmlUtil xmlUtil) { // 'value' is the string representation of OverrideMode enum // Try to parse the string to the enum and generate errors if not possible switch (value) { case BaseConfigurationRecord.KEYWORD_OVERRIDEMODE_INHERIT: return OverrideMode.Inherit; case BaseConfigurationRecord.KEYWORD_OVERRIDEMODE_ALLOW: return OverrideMode.Allow; case BaseConfigurationRecord.KEYWORD_OVERRIDEMODE_DENY: return OverrideMode.Deny; default: throw new ConfigurationErrorsException( SR.GetString(SR.Config_section_override_mode_attribute_invalid), xmlUtil); } } internal static bool CanUseSameLocationTag(OverrideModeSetting x, OverrideModeSetting y) { // This function tells if the two OverrideModeSettings are compatible enough to be used in only one location tag // or each of them should go to a separate one // The rules here are ( in order of importance ) // 1. The effective mode is the same ( we will use only the new OverrideMode to compare ) // 2. When the mode was changed( i.e. API change ) - both must be changed the same way ( i.e. using either allowOverride or OverrideMode ) // 3. When mode was not changed the XML - they must've been the same in the xml ( i.e. allowOverride specified on both, or overrideMode or neither of them ) bool result = false; result = (x.OverrideMode == y.OverrideMode); if (result == true) { result = false; // Check for an API change for each setting first // If one mode was set through the API - the other mode has to be set in the same way through the API or has to be using the same type in the xml // Handle case where "x" was API modified if ((x._mode & ApiDefinedAny) != 0) { result = IsMatchingApiChangedLocationTag(x, y); } // Handle case where "y" was API modified else if ((y._mode & ApiDefinedAny) != 0) { result = IsMatchingApiChangedLocationTag(y, x); } // Handle case where neither "x" nor "y" was API modified else { // If one of the settings was XML defined - they are a match only if both were XML defined in the same way if ( ((x._mode & XmlDefinedAny) != 0) || ((y._mode & XmlDefinedAny) != 0)) { result = (x._mode & XmlDefinedAny) == (y._mode & XmlDefinedAny); } // Neither "x" nor "y" was XML defined - they are a match since they can both go // to a default with no explicit mode setting written out else { result = true; } } } return result; } private static bool IsMatchingApiChangedLocationTag(OverrideModeSetting x, OverrideModeSetting y) { // x must be a changed through the API setting // Returns true if x and y can share the same location tag Debug.Assert((x._mode & ApiDefinedAny) != 0); bool result = false; // If "y" was modified through the API as well - the modified setting must be the same ( i.e. allowOvverride or overrideMode must be modified in both settings ) if ((y._mode & ApiDefinedAny) != 0) { result = (x._mode & ApiDefinedAny) == (y._mode & ApiDefinedAny); } // "y" was not API modified - they are still a match if "y" was a XML setting from the same mode else if ((y._mode & XmlDefinedAny) != 0) { result = ( (((x._mode & ApiDefinedLegacy) != 0) && ((y._mode & XmlDefinedLegacy) != 0)) || // "x" was API changed in Legacy and "y" was XML defined in Legacy (((x._mode & ApiDefinedNewMode) != 0) && ((y._mode & XmlDefinedNewMode) != 0))); // "x" was API changed in New and "y" was XML defined in New } // "y" was not API or XML modified - since "x" was API modified - they are not a match ( i.e. "y" should go to an with no explicit mode written out ) else { } return result; } internal bool IsDefaultForSection { get { // Returns true if the current value of the overrideMode setting is the default one on a section declaration // The current default value for a section's overrideMode ( i.e. overrideModeDefault ) is Allow ( see CreateDefaultForSection ) // It would've been nice not to repeat that rule here but since OverrideMode.Inherited means the same in this specific context we have to // I.e. the default for a section is both Allow and Inherited. In this case they mean the same OverrideMode mode = OverrideMode; // Return true if mode is Allow or Inherit return ((mode == OverrideMode.Allow) || (mode == OverrideMode.Inherit)); } } internal bool IsDefaultForLocationTag { get { // Returns true if the current setting is the same as the default value for a location tag // Note that if the setting was an API modified or XmlDefined it is not a default since it // cannot go to the default tag which does not explicitlly specify a mode OverrideModeSetting defaultSetting = LocationDefault; return (defaultSetting.OverrideMode == this.OverrideMode) && ((_mode & ApiDefinedAny) == 0) && ((_mode & XmlDefinedAny) == 0); } } internal bool IsLocked { get { return OverrideMode == OverrideMode.Deny;} } internal string LocationTagXmlString { get { // Returns the string for this setting which is to be written in the xml tag string result = String.Empty; string value = null; string attrib = null; bool needToWrite = false; bool useLegacy = false; // If there was an API change - it has highest priority if ((_mode & ApiDefinedAny) != 0) { // Whichever was changed by the API dictates what is to be written useLegacy = (_mode & ApiDefinedLegacy) != 0; needToWrite = true; Debug.Assert(useLegacy || (_mode & ApiDefinedNewMode) != 0); } // It wasn't changed through the API - check if it was read originally from the XML else if ((_mode & XmlDefinedAny) != 0) { // Whatever was defined in the XML is to be written out useLegacy = (_mode & XmlDefinedLegacy) != 0; needToWrite = true; Debug.Assert(useLegacy || (_mode & XmlDefinedNewMode) != 0); } if (needToWrite) { // Legacy - allowOverride if (useLegacy) { attrib = BaseConfigurationRecord.KEYWORD_LOCATION_ALLOWOVERRIDE; value = AllowOverride ? BaseConfigurationRecord.KEYWORD_TRUE : BaseConfigurationRecord.KEYWORD_FALSE; } else { attrib = BaseConfigurationRecord.KEYWORD_LOCATION_OVERRIDEMODE; value = OverrideModeXmlValue; } result = String.Format(CultureInfo.InvariantCulture, BaseConfigurationRecord.KEYWORD_LOCATION_OVERRIDEMODE_STRING, attrib, value); } return result; } } internal string OverrideModeXmlValue { get { // Returns the xml (string) value of the current setting for override mode switch(OverrideMode) { case OverrideMode.Inherit: return BaseConfigurationRecord.KEYWORD_OVERRIDEMODE_INHERIT; case OverrideMode.Allow: return BaseConfigurationRecord.KEYWORD_OVERRIDEMODE_ALLOW; case OverrideMode.Deny: return BaseConfigurationRecord.KEYWORD_OVERRIDEMODE_DENY; default: Debug.Assert(false, "Missing xml keyword for OverrideMode enum value"); break; } return null; } } // Use this method to change only the value of the setting when not done through the public API internal void ChangeModeInternal(OverrideMode mode) { SetMode(mode); } // Properties to enable external chnages to the mode. // Note that those changes will be tracked as made by the public API // There shouldn't be a reason for those to be used except in this specific case internal OverrideMode OverrideMode { get { return (OverrideMode)(_mode & ModeMask); } set { // Note that changing the mode through the API ( which is the purpose of this setter ) // overrides the setting in the XML ( if any ) // and hence we dont keep a track of it anymore // Error condition: We do not allow changes to the mode through both AllowOverride and OverrideMode // If one was changed first we require that API users stick with it VerifyConsistentChangeModel(ApiDefinedNewMode); SetMode(value); _mode |= ApiDefinedNewMode; } } internal bool AllowOverride { get { bool result = true; switch(OverrideMode) { case OverrideMode.Inherit: case OverrideMode.Allow: result = true; break; case OverrideMode.Deny: result = false; break; default: Debug.Assert(false, "Unrecognized OverrideMode"); break; } return result; } set { // Note that changing the mode through the API ( which is the purpose of this setter ) // overrides the setting in the XML ( if any ) // and hence we dont keep a track of it anymore // Error condition: We do not allow changes to the mode through both AllowOverride and OverrideMode // If one was changed first we require that API users stick with it VerifyConsistentChangeModel(ApiDefinedLegacy); SetMode(value ? OverrideMode.Inherit : OverrideMode.Deny); _mode |= ApiDefinedLegacy; } } private void SetMode(OverrideMode mode) { _mode = (byte)mode; } private void VerifyConsistentChangeModel(byte required) { // The required API change model ( i.e. was allowOverride used or OverrideMode ) should be consistent // I.e. its not possible to change both on the same OverrideModeSetting object byte current = (byte)(_mode & ApiDefinedAny); // Shows whats the current setting: 0 ( none ), ApiDefinedLegacy or ApiDefinedNew if (current != 0 && current != required) { throw new ConfigurationErrorsException(SR.GetString(SR.Cannot_change_both_AllowOverride_and_OverrideMode)); } } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. //------------------------------------------------------------------------------ // // Copyright (c) Microsoft Corporation. All rights reserved. // //----------------------------------------------------------------------------- namespace System.Configuration { using System.Configuration.Internal; using System.Collections; using System.Collections.Generic; using System.Collections.Specialized; using System.Configuration; using System.Globalization; using System.IO; using System.Reflection; using System.Runtime.InteropServices; using System.Security.Permissions; using System.Security; using System.Text; using System.Xml; // This is the public type of the override mode enum visible to the API users // The override mode is an attribute of atag and controls if the sections inside this tag // can be defined in child web.config files public enum OverrideMode { // Default ( aka Indiferent ) - When specified on a location tag means the location tag will not alter // the locking mode ( locked or unlocked ). Rather, the locking mode should be picked // from the tag with the closest parent path in the current file, or the parent file if no such location in the current one, // or the default for the specific section ( section.OverrideModeDefault ) Inherit = 0, // Allow overriding in child config files. I.e. unlock the settings for overridiing Allow = 1, // Deny overriding of the settings defined in the tag. It is an error for the sections in the tag // to appear in a child config file. It is not an error for them to appear in another tag in the current file Deny = 2, } // This is a class that abstracts the usage of the override mode setting internal struct OverrideModeSetting { private const byte ApiDefinedLegacy = 0x10; // allowOverride was set thourhg the API private const byte ApiDefinedNewMode = 0x20; // overrideMode was set thourhg the API private const byte ApiDefinedAny = ApiDefinedLegacy | ApiDefinedNewMode; // allowOverride or overrideMode was set through the API private const byte XmlDefinedLegacy = 0x40; // allowOverride was defined in the XML private const byte XmlDefinedNewMode = 0x80; // overrideMode was defined in the XML private const byte XmlDefinedAny = XmlDefinedLegacy | XmlDefinedNewMode; // overrideMode or allowOverride was defined in the XML private const byte ModeMask = 0x0f; // logical AND this with the current value to get the mode part only private byte _mode; internal static OverrideModeSetting SectionDefault; internal static OverrideModeSetting LocationDefault; static OverrideModeSetting() { SectionDefault = new OverrideModeSetting(); // Default for section is ALLOW ( to be consistent with Whidbey ) SectionDefault._mode = (byte)OverrideMode.Allow; LocationDefault = new OverrideModeSetting(); // Default for location tags is INHERIT. Note that we do not make the value as existant in the XML or specified by the API LocationDefault._mode = (byte)OverrideMode.Inherit; } static internal OverrideModeSetting CreateFromXmlReadValue(bool allowOverride) { // Create a mode from the old "allowOverride" attribute in the xml // The conversion is true -> OverrideMode.Inherit // The conversion is false -> OverrideMode.Deny // This is consistent with Whidbey where true means true unless there is a false somewhere above OverrideModeSetting result = new OverrideModeSetting(); result.SetMode(allowOverride ? OverrideMode.Inherit : OverrideMode.Deny); result._mode |= XmlDefinedLegacy; return result; } static internal OverrideModeSetting CreateFromXmlReadValue(OverrideMode mode) { OverrideModeSetting result = new OverrideModeSetting(); result.SetMode(mode); result._mode |= XmlDefinedNewMode; return result; } internal static OverrideMode ParseOverrideModeXmlValue(string value, XmlUtil xmlUtil) { // 'value' is the string representation of OverrideMode enum // Try to parse the string to the enum and generate errors if not possible switch (value) { case BaseConfigurationRecord.KEYWORD_OVERRIDEMODE_INHERIT: return OverrideMode.Inherit; case BaseConfigurationRecord.KEYWORD_OVERRIDEMODE_ALLOW: return OverrideMode.Allow; case BaseConfigurationRecord.KEYWORD_OVERRIDEMODE_DENY: return OverrideMode.Deny; default: throw new ConfigurationErrorsException( SR.GetString(SR.Config_section_override_mode_attribute_invalid), xmlUtil); } } internal static bool CanUseSameLocationTag(OverrideModeSetting x, OverrideModeSetting y) { // This function tells if the two OverrideModeSettings are compatible enough to be used in only one location tag // or each of them should go to a separate one // The rules here are ( in order of importance ) // 1. The effective mode is the same ( we will use only the new OverrideMode to compare ) // 2. When the mode was changed( i.e. API change ) - both must be changed the same way ( i.e. using either allowOverride or OverrideMode ) // 3. When mode was not changed the XML - they must've been the same in the xml ( i.e. allowOverride specified on both, or overrideMode or neither of them ) bool result = false; result = (x.OverrideMode == y.OverrideMode); if (result == true) { result = false; // Check for an API change for each setting first // If one mode was set through the API - the other mode has to be set in the same way through the API or has to be using the same type in the xml // Handle case where "x" was API modified if ((x._mode & ApiDefinedAny) != 0) { result = IsMatchingApiChangedLocationTag(x, y); } // Handle case where "y" was API modified else if ((y._mode & ApiDefinedAny) != 0) { result = IsMatchingApiChangedLocationTag(y, x); } // Handle case where neither "x" nor "y" was API modified else { // If one of the settings was XML defined - they are a match only if both were XML defined in the same way if ( ((x._mode & XmlDefinedAny) != 0) || ((y._mode & XmlDefinedAny) != 0)) { result = (x._mode & XmlDefinedAny) == (y._mode & XmlDefinedAny); } // Neither "x" nor "y" was XML defined - they are a match since they can both go // to a default with no explicit mode setting written out else { result = true; } } } return result; } private static bool IsMatchingApiChangedLocationTag(OverrideModeSetting x, OverrideModeSetting y) { // x must be a changed through the API setting // Returns true if x and y can share the same location tag Debug.Assert((x._mode & ApiDefinedAny) != 0); bool result = false; // If "y" was modified through the API as well - the modified setting must be the same ( i.e. allowOvverride or overrideMode must be modified in both settings ) if ((y._mode & ApiDefinedAny) != 0) { result = (x._mode & ApiDefinedAny) == (y._mode & ApiDefinedAny); } // "y" was not API modified - they are still a match if "y" was a XML setting from the same mode else if ((y._mode & XmlDefinedAny) != 0) { result = ( (((x._mode & ApiDefinedLegacy) != 0) && ((y._mode & XmlDefinedLegacy) != 0)) || // "x" was API changed in Legacy and "y" was XML defined in Legacy (((x._mode & ApiDefinedNewMode) != 0) && ((y._mode & XmlDefinedNewMode) != 0))); // "x" was API changed in New and "y" was XML defined in New } // "y" was not API or XML modified - since "x" was API modified - they are not a match ( i.e. "y" should go to an with no explicit mode written out ) else { } return result; } internal bool IsDefaultForSection { get { // Returns true if the current value of the overrideMode setting is the default one on a section declaration // The current default value for a section's overrideMode ( i.e. overrideModeDefault ) is Allow ( see CreateDefaultForSection ) // It would've been nice not to repeat that rule here but since OverrideMode.Inherited means the same in this specific context we have to // I.e. the default for a section is both Allow and Inherited. In this case they mean the same OverrideMode mode = OverrideMode; // Return true if mode is Allow or Inherit return ((mode == OverrideMode.Allow) || (mode == OverrideMode.Inherit)); } } internal bool IsDefaultForLocationTag { get { // Returns true if the current setting is the same as the default value for a location tag // Note that if the setting was an API modified or XmlDefined it is not a default since it // cannot go to the default tag which does not explicitlly specify a mode OverrideModeSetting defaultSetting = LocationDefault; return (defaultSetting.OverrideMode == this.OverrideMode) && ((_mode & ApiDefinedAny) == 0) && ((_mode & XmlDefinedAny) == 0); } } internal bool IsLocked { get { return OverrideMode == OverrideMode.Deny;} } internal string LocationTagXmlString { get { // Returns the string for this setting which is to be written in the xml tag string result = String.Empty; string value = null; string attrib = null; bool needToWrite = false; bool useLegacy = false; // If there was an API change - it has highest priority if ((_mode & ApiDefinedAny) != 0) { // Whichever was changed by the API dictates what is to be written useLegacy = (_mode & ApiDefinedLegacy) != 0; needToWrite = true; Debug.Assert(useLegacy || (_mode & ApiDefinedNewMode) != 0); } // It wasn't changed through the API - check if it was read originally from the XML else if ((_mode & XmlDefinedAny) != 0) { // Whatever was defined in the XML is to be written out useLegacy = (_mode & XmlDefinedLegacy) != 0; needToWrite = true; Debug.Assert(useLegacy || (_mode & XmlDefinedNewMode) != 0); } if (needToWrite) { // Legacy - allowOverride if (useLegacy) { attrib = BaseConfigurationRecord.KEYWORD_LOCATION_ALLOWOVERRIDE; value = AllowOverride ? BaseConfigurationRecord.KEYWORD_TRUE : BaseConfigurationRecord.KEYWORD_FALSE; } else { attrib = BaseConfigurationRecord.KEYWORD_LOCATION_OVERRIDEMODE; value = OverrideModeXmlValue; } result = String.Format(CultureInfo.InvariantCulture, BaseConfigurationRecord.KEYWORD_LOCATION_OVERRIDEMODE_STRING, attrib, value); } return result; } } internal string OverrideModeXmlValue { get { // Returns the xml (string) value of the current setting for override mode switch(OverrideMode) { case OverrideMode.Inherit: return BaseConfigurationRecord.KEYWORD_OVERRIDEMODE_INHERIT; case OverrideMode.Allow: return BaseConfigurationRecord.KEYWORD_OVERRIDEMODE_ALLOW; case OverrideMode.Deny: return BaseConfigurationRecord.KEYWORD_OVERRIDEMODE_DENY; default: Debug.Assert(false, "Missing xml keyword for OverrideMode enum value"); break; } return null; } } // Use this method to change only the value of the setting when not done through the public API internal void ChangeModeInternal(OverrideMode mode) { SetMode(mode); } // Properties to enable external chnages to the mode. // Note that those changes will be tracked as made by the public API // There shouldn't be a reason for those to be used except in this specific case internal OverrideMode OverrideMode { get { return (OverrideMode)(_mode & ModeMask); } set { // Note that changing the mode through the API ( which is the purpose of this setter ) // overrides the setting in the XML ( if any ) // and hence we dont keep a track of it anymore // Error condition: We do not allow changes to the mode through both AllowOverride and OverrideMode // If one was changed first we require that API users stick with it VerifyConsistentChangeModel(ApiDefinedNewMode); SetMode(value); _mode |= ApiDefinedNewMode; } } internal bool AllowOverride { get { bool result = true; switch(OverrideMode) { case OverrideMode.Inherit: case OverrideMode.Allow: result = true; break; case OverrideMode.Deny: result = false; break; default: Debug.Assert(false, "Unrecognized OverrideMode"); break; } return result; } set { // Note that changing the mode through the API ( which is the purpose of this setter ) // overrides the setting in the XML ( if any ) // and hence we dont keep a track of it anymore // Error condition: We do not allow changes to the mode through both AllowOverride and OverrideMode // If one was changed first we require that API users stick with it VerifyConsistentChangeModel(ApiDefinedLegacy); SetMode(value ? OverrideMode.Inherit : OverrideMode.Deny); _mode |= ApiDefinedLegacy; } } private void SetMode(OverrideMode mode) { _mode = (byte)mode; } private void VerifyConsistentChangeModel(byte required) { // The required API change model ( i.e. was allowOverride used or OverrideMode ) should be consistent // I.e. its not possible to change both on the same OverrideModeSetting object byte current = (byte)(_mode & ApiDefinedAny); // Shows whats the current setting: 0 ( none ), ApiDefinedLegacy or ApiDefinedNew if (current != 0 && current != required) { throw new ConfigurationErrorsException(SR.GetString(SR.Cannot_change_both_AllowOverride_and_OverrideMode)); } } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- StreamUpdate.cs
- PageThemeBuildProvider.cs
- VirtualDirectoryMappingCollection.cs
- TablePattern.cs
- StylusPointDescription.cs
- ColumnMapVisitor.cs
- XmlSchemaSimpleType.cs
- TableRowsCollectionEditor.cs
- XmlSchemaIdentityConstraint.cs
- Rotation3DKeyFrameCollection.cs
- TableProviderWrapper.cs
- PersistenceContext.cs
- DBCommand.cs
- TextRangeBase.cs
- SmtpCommands.cs
- OleDbMetaDataFactory.cs
- ViewCellRelation.cs
- ChineseLunisolarCalendar.cs
- ResourceAssociationType.cs
- SendMailErrorEventArgs.cs
- RpcCryptoContext.cs
- PropertyValueUIItem.cs
- LOSFormatter.cs
- DataReceivedEventArgs.cs
- WebPartRestoreVerb.cs
- SafeNativeMethods.cs
- BaseProcessor.cs
- SharedDp.cs
- XPathMultyIterator.cs
- InkSerializer.cs
- BaseValidatorDesigner.cs
- Processor.cs
- MetaModel.cs
- UIElement3D.cs
- TextDecorationCollection.cs
- __FastResourceComparer.cs
- COM2ExtendedBrowsingHandler.cs
- AttachedAnnotation.cs
- DataGridViewBand.cs
- BaseDataList.cs
- StylusPointPropertyUnit.cs
- DesignerAttribute.cs
- OdbcRowUpdatingEvent.cs
- SyncMethodInvoker.cs
- SiteMap.cs
- base64Transforms.cs
- AliasExpr.cs
- OracleParameterCollection.cs
- PropertyDescriptors.cs
- ToolStripSplitButton.cs
- RecognizedWordUnit.cs
- VisualStateManager.cs
- SchemaObjectWriter.cs
- Exceptions.cs
- StorageAssociationSetMapping.cs
- ResourceExpressionBuilder.cs
- basecomparevalidator.cs
- StandardTransformFactory.cs
- SafeNativeMethods.cs
- BuilderInfo.cs
- PersonalizationState.cs
- MimeAnyImporter.cs
- TextHidden.cs
- ResourceExpression.cs
- SpellCheck.cs
- AlignmentYValidation.cs
- PageRequestManager.cs
- QilInvokeEarlyBound.cs
- InputChannel.cs
- OuterGlowBitmapEffect.cs
- SecurityUtils.cs
- ReceiveErrorHandling.cs
- NameValuePermission.cs
- StrokeRenderer.cs
- ValueTable.cs
- DataGridViewButtonCell.cs
- XmlNotation.cs
- DeflateStream.cs
- SHA256.cs
- DataGridViewRowDividerDoubleClickEventArgs.cs
- XmlTextReader.cs
- DocumentAutomationPeer.cs
- TrailingSpaceComparer.cs
- ScrollBarRenderer.cs
- SqlStatistics.cs
- MorphHelper.cs
- RelationshipEndCollection.cs
- RegexCompilationInfo.cs
- _NegoState.cs
- FieldNameLookup.cs
- EncryptedKey.cs
- DeadCharTextComposition.cs
- TextTreeTextNode.cs
- Publisher.cs
- CompilerError.cs
- TextEffect.cs
- CustomCredentialPolicy.cs
- SafePEFileHandle.cs
- BitmapMetadata.cs
- UserControlAutomationPeer.cs