Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Shared / MS / Internal / CharacterBuffer.cs / 1407647 / CharacterBuffer.cs
//---------------------------------------------------------------------------- // // Copyright (c) Microsoft Corporation. All rights reserved. // // // Description: Definition of readonly character memory buffer // // // History: // 03/31/2003 : WChao - Created // 12/01/2004 : MLeonov - Moved to wcp\shared and made CharacterBuffer implement IList// //--------------------------------------------------------------------------- using System; using System.Windows; using System.Collections; using System.Collections.Generic; using System.Diagnostics; using System.Text; using System.Runtime.InteropServices; using System.Security; using System.Security.Permissions; using SR=MS.Internal.PresentationCore.SR; using SRID=MS.Internal.PresentationCore.SRID; namespace MS.Internal { /// /// Abstraction of a readonly character buffer /// internal abstract class CharacterBuffer : IList{ /// /// Get fixed address of the character buffer /// ////// Critical:This code manipulates a pointer and returns it /// [SecurityCritical] public abstract unsafe char* GetCharacterPointer(); ////// Get fixed address of the character buffer and Pin if necessary. /// Note: This call should only be used when we know that we are not pinning /// memory for a long time so as not to fragment the heap. /// public abstract IntPtr PinAndGetCharacterPointer(int offset, out GCHandle gcHandle); ////// This is a matching call for PinAndGetCharacterPointer to unpin the memory. /// public abstract void UnpinCharacterPointer(GCHandle gcHandle); ////// Add character buffer's content to a StringBuilder /// /// string builder to add content to /// character offset to first character to append /// number of character appending ///string builder public abstract void AppendToStringBuilder( StringBuilder stringBuilder, int characterOffset, int length ); #region IListMembers public int IndexOf(char item) { for (int i = 0; i < Count; ++i) { if (item == this[i]) return i; } return -1; } public void Insert(int index, char item) { // CharacterBuffer is read only. throw new NotSupportedException(); } public abstract char this[int index] { get; set; } public void RemoveAt(int index) { // CharacterBuffer is read only. throw new NotSupportedException(); } #endregion #region ICollection Members public void Add(char item) { // CharacterBuffer is read only. throw new NotSupportedException(); } public void Clear() { // CharacterBuffer is read only. throw new NotSupportedException(); } public bool Contains(char item) { return IndexOf(item) != -1; } public void CopyTo(char[] array, int arrayIndex) { for (int i = 0; i < Count; ++i) { array[arrayIndex + i] = this[i]; } } public abstract int Count { get; } public bool IsReadOnly { get { return true; } } public bool Remove(char item) { // CharacterBuffer is read only. throw new NotSupportedException(); } #endregion #region IEnumerable Members IEnumerator IEnumerable .GetEnumerator() { for (int i = 0; i < Count; ++i) yield return this[i]; } #endregion #region IEnumerable Members IEnumerator IEnumerable.GetEnumerator() { return ((IEnumerable )this).GetEnumerator(); } #endregion } /// /// Character memory buffer implemented by managed character array /// internal sealed class CharArrayCharacterBuffer : CharacterBuffer { private char[] _characterArray; ////// Creating a character memory buffer from character array /// /// character array public CharArrayCharacterBuffer( char[] characterArray ) { if (characterArray == null) { throw new ArgumentNullException("characterArray"); } _characterArray = characterArray; } ////// Read a character from buffer at the specified character index /// public override char this[int characterOffset] { get { return _characterArray[characterOffset]; } set { throw new NotSupportedException(); } } ////// Buffer character length /// public override int Count { get { return _characterArray.Length; } } ////// Get fixed address of the character buffer /// ////// Critical:This code manipulates a pointer and returns it /// [SecurityCritical] public override unsafe char* GetCharacterPointer() { // Even though we could allocate GCHandle for this purpose, we would need // to manage how to release them appropriately. It is even worse if we // consider performance implication of doing so. In typical UI scenario, // there are so many string objects running around in GC heap. Getting // GCHandle for every one of them is very expensive and demote GC's ability // to compact its heap. return null; } ////// Get fixed address of the character buffer and Pin if necessary. /// Note: This call should only be used when we know that we are not pinning /// memory for a long time so as not to fragment the heap. /// /// Critical:This code manipulates a pointer and returns it /// [SecurityCritical] public unsafe override IntPtr PinAndGetCharacterPointer(int offset, out GCHandle gcHandle) { gcHandle = GCHandle.Alloc(_characterArray, GCHandleType.Pinned); return new IntPtr(((char*)gcHandle.AddrOfPinnedObject().ToPointer()) + offset); } ////// This is a matching call for PinAndGetCharacterPointer to unpin the memory. /// ////// Critical : This method has access to GCHandle which can provide memory address info. /// Treat As Safe: This method does not expose any security critical info. /// [SecurityCritical, SecurityTreatAsSafe] public override void UnpinCharacterPointer(GCHandle gcHandle) { gcHandle.Free(); } ////// Add character buffer's content to a StringBuilder /// /// string builder to add content to /// index to first character in the buffer to append /// number of character appending public override void AppendToStringBuilder( StringBuilder stringBuilder, int characterOffset, int characterLength ) { Debug.Assert(characterOffset >= 0 && characterOffset < _characterArray.Length, "Invalid character index"); if ( characterLength < 0 || characterOffset + characterLength > _characterArray.Length) { characterLength = _characterArray.Length - characterOffset; } stringBuilder.Append(_characterArray, characterOffset, characterLength); } } ////// Character buffer implemented by string /// internal sealed class StringCharacterBuffer : CharacterBuffer { private string _string; ////// Creating a character buffer from string /// /// character string public StringCharacterBuffer( string characterString ) { if (characterString == null) { throw new ArgumentNullException("characterString"); } _string = characterString; } ////// Read a character from buffer at the specified character index /// public override char this[int characterOffset] { get { return _string[characterOffset]; } set { throw new NotSupportedException(); } } ////// Buffer character length /// public override int Count { get { return _string.Length; } } ////// Get fixed address of the character buffer /// ////// Critical:This code manipulates a pointer and returns it /// [SecurityCritical] public override unsafe char* GetCharacterPointer() { // Even though we could allocate GCHandle for this purpose, we would need // to manage how to release them appropriately. It is even worse if we // consider performance implication of doing so. In typical UI scenario, // there are so many string objects running around in GC heap. Getting // GCHandle for every one of them is very expensive and demote GC's ability // to compact its heap. return null; } ////// Get fixed address of the character buffer and Pin if necessary. /// Note: This call should only be used when we know that we are not pinning /// memory for a long time so as not to fragment the heap. /// /// Critical:This code manipulates a pointer and returns it /// [SecurityCritical] public unsafe override IntPtr PinAndGetCharacterPointer(int offset, out GCHandle gcHandle) { gcHandle = GCHandle.Alloc(_string, GCHandleType.Pinned); return new IntPtr(((char*)gcHandle.AddrOfPinnedObject().ToPointer()) + offset); } ////// This is a matching call for PinAndGetCharacterPointer to unpin the memory. /// ////// Critical : This method has access to GCHandle which can provide memory address info. /// Treat As Safe: This method does not expose any security critical info. /// [SecurityCritical, SecurityTreatAsSafe] public override void UnpinCharacterPointer(GCHandle gcHandle) { gcHandle.Free(); } ////// Add character buffer's content to a StringBuilder /// /// string builder to add content to /// index to first character in the buffer to append /// number of character appending public override void AppendToStringBuilder( StringBuilder stringBuilder, int characterOffset, int characterLength ) { Debug.Assert(characterOffset >= 0 && characterOffset < _string.Length, "Invalid character index"); if ( characterLength < 0 || characterOffset + characterLength > _string.Length) { characterLength = _string.Length - characterOffset; } stringBuilder.Append(_string, characterOffset, characterLength); } } ////// Character buffer implemented as unsafe pointer to character string /// internal sealed unsafe class UnsafeStringCharacterBuffer : CharacterBuffer { ////// Critical: This code is unsafe since it holds a pointer /// EnforcementCritical /// [SecurityCritical] private char* _unsafeString; ////// Critical: Length is critical to avoid buffer overrun. /// [SecurityCritical] private int _length; ////// Creating a character buffer from an unsafe pointer to character string /// /// unsafe pointer to character string /// number of valid characters referenced by the unsafe pointer ////// Critical: This code is unsafe since it manipulates a pointer, it constructs an object with /// length data from user /// [SecurityCritical] public UnsafeStringCharacterBuffer( char* characterString, int length ) { if (characterString == null) { throw new ArgumentNullException("characterString"); } if (length <= 0) { throw new ArgumentOutOfRangeException("length", SR.Get(SRID.ParameterValueMustBeGreaterThanZero)); } _unsafeString = characterString; _length = length; } ////// Read a character from buffer at the specified character index /// ////// Critical: This code is unsafe since it manipulates a pointer /// Safe: Info is safe to expose and method does bound check /// public override char this[int characterOffset] { [SecurityCritical, SecurityTreatAsSafe] get { if (characterOffset >= _length || characterOffset < 0) throw new ArgumentOutOfRangeException("characterOffset", SR.Get(SRID.ParameterMustBeBetween,0,_length)); return _unsafeString[characterOffset]; } [SecurityCritical, SecurityTreatAsSafe] set { throw new NotSupportedException(); } } ////// Buffer character length /// ////// Critical: Lenght is critical data when dealing with unsafe pointer. /// Safe: This value is safe to give out. /// public override int Count { [SecurityCritical, SecurityTreatAsSafe] get { return _length; } } ////// Get fixed address of the character buffer /// ////// Critical:This returns the pointer /// [SecurityCritical] public override unsafe char* GetCharacterPointer() { return _unsafeString; } ////// Get fixed address of the character buffer and Pin if necessary. /// Note: This call should only be used when we know that we are not pinning /// memory for a long time so as not to fragment the heap. /// /// Critical:This code manipulates a pointer and returns it /// [SecurityCritical] public override IntPtr PinAndGetCharacterPointer(int offset, out GCHandle gcHandle) { gcHandle = new GCHandle(); return new IntPtr(_unsafeString + offset); } ////// This is a matching call for PinAndGetCharacterPointer to unpin the memory. /// ////// Critical : This method has access to GCHandle which can provide memory address info. /// Treat As Safe: This method does not expose any security critical info. /// [SecurityCritical, SecurityTreatAsSafe] public override void UnpinCharacterPointer(GCHandle gcHandle) { } ////// Add character buffer's content to a StringBuilder /// /// string builder to add content to /// index to first character in the buffer to append /// number of character appending ////// Critical: This returns the string in a string builder object, critical because it accesses the pointer /// and returns its contents embedded in the stringbuilder passed in. /// Safe: This method does proper bound check. /// [SecurityCritical, SecurityTreatAsSafe] public override void AppendToStringBuilder( StringBuilder stringBuilder, int characterOffset, int characterLength ) { if (characterOffset >= _length || characterOffset < 0) { throw new ArgumentOutOfRangeException("characterOffset", SR.Get(SRID.ParameterMustBeBetween,0,_length)); } if (characterLength < 0 || characterOffset + characterLength > _length) { throw new ArgumentOutOfRangeException("characterLength", SR.Get(SRID.ParameterMustBeBetween,0, _length - characterOffset)); } stringBuilder.Append(new string(_unsafeString, characterOffset, characterLength)); } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. //---------------------------------------------------------------------------- // // Copyright (c) Microsoft Corporation. All rights reserved. // // // Description: Definition of readonly character memory buffer // // // History: // 03/31/2003 : WChao - Created // 12/01/2004 : MLeonov - Moved to wcp\shared and made CharacterBuffer implement IList// //--------------------------------------------------------------------------- using System; using System.Windows; using System.Collections; using System.Collections.Generic; using System.Diagnostics; using System.Text; using System.Runtime.InteropServices; using System.Security; using System.Security.Permissions; using SR=MS.Internal.PresentationCore.SR; using SRID=MS.Internal.PresentationCore.SRID; namespace MS.Internal { /// /// Abstraction of a readonly character buffer /// internal abstract class CharacterBuffer : IList{ /// /// Get fixed address of the character buffer /// ////// Critical:This code manipulates a pointer and returns it /// [SecurityCritical] public abstract unsafe char* GetCharacterPointer(); ////// Get fixed address of the character buffer and Pin if necessary. /// Note: This call should only be used when we know that we are not pinning /// memory for a long time so as not to fragment the heap. /// public abstract IntPtr PinAndGetCharacterPointer(int offset, out GCHandle gcHandle); ////// This is a matching call for PinAndGetCharacterPointer to unpin the memory. /// public abstract void UnpinCharacterPointer(GCHandle gcHandle); ////// Add character buffer's content to a StringBuilder /// /// string builder to add content to /// character offset to first character to append /// number of character appending ///string builder public abstract void AppendToStringBuilder( StringBuilder stringBuilder, int characterOffset, int length ); #region IListMembers public int IndexOf(char item) { for (int i = 0; i < Count; ++i) { if (item == this[i]) return i; } return -1; } public void Insert(int index, char item) { // CharacterBuffer is read only. throw new NotSupportedException(); } public abstract char this[int index] { get; set; } public void RemoveAt(int index) { // CharacterBuffer is read only. throw new NotSupportedException(); } #endregion #region ICollection Members public void Add(char item) { // CharacterBuffer is read only. throw new NotSupportedException(); } public void Clear() { // CharacterBuffer is read only. throw new NotSupportedException(); } public bool Contains(char item) { return IndexOf(item) != -1; } public void CopyTo(char[] array, int arrayIndex) { for (int i = 0; i < Count; ++i) { array[arrayIndex + i] = this[i]; } } public abstract int Count { get; } public bool IsReadOnly { get { return true; } } public bool Remove(char item) { // CharacterBuffer is read only. throw new NotSupportedException(); } #endregion #region IEnumerable Members IEnumerator IEnumerable .GetEnumerator() { for (int i = 0; i < Count; ++i) yield return this[i]; } #endregion #region IEnumerable Members IEnumerator IEnumerable.GetEnumerator() { return ((IEnumerable )this).GetEnumerator(); } #endregion } /// /// Character memory buffer implemented by managed character array /// internal sealed class CharArrayCharacterBuffer : CharacterBuffer { private char[] _characterArray; ////// Creating a character memory buffer from character array /// /// character array public CharArrayCharacterBuffer( char[] characterArray ) { if (characterArray == null) { throw new ArgumentNullException("characterArray"); } _characterArray = characterArray; } ////// Read a character from buffer at the specified character index /// public override char this[int characterOffset] { get { return _characterArray[characterOffset]; } set { throw new NotSupportedException(); } } ////// Buffer character length /// public override int Count { get { return _characterArray.Length; } } ////// Get fixed address of the character buffer /// ////// Critical:This code manipulates a pointer and returns it /// [SecurityCritical] public override unsafe char* GetCharacterPointer() { // Even though we could allocate GCHandle for this purpose, we would need // to manage how to release them appropriately. It is even worse if we // consider performance implication of doing so. In typical UI scenario, // there are so many string objects running around in GC heap. Getting // GCHandle for every one of them is very expensive and demote GC's ability // to compact its heap. return null; } ////// Get fixed address of the character buffer and Pin if necessary. /// Note: This call should only be used when we know that we are not pinning /// memory for a long time so as not to fragment the heap. /// /// Critical:This code manipulates a pointer and returns it /// [SecurityCritical] public unsafe override IntPtr PinAndGetCharacterPointer(int offset, out GCHandle gcHandle) { gcHandle = GCHandle.Alloc(_characterArray, GCHandleType.Pinned); return new IntPtr(((char*)gcHandle.AddrOfPinnedObject().ToPointer()) + offset); } ////// This is a matching call for PinAndGetCharacterPointer to unpin the memory. /// ////// Critical : This method has access to GCHandle which can provide memory address info. /// Treat As Safe: This method does not expose any security critical info. /// [SecurityCritical, SecurityTreatAsSafe] public override void UnpinCharacterPointer(GCHandle gcHandle) { gcHandle.Free(); } ////// Add character buffer's content to a StringBuilder /// /// string builder to add content to /// index to first character in the buffer to append /// number of character appending public override void AppendToStringBuilder( StringBuilder stringBuilder, int characterOffset, int characterLength ) { Debug.Assert(characterOffset >= 0 && characterOffset < _characterArray.Length, "Invalid character index"); if ( characterLength < 0 || characterOffset + characterLength > _characterArray.Length) { characterLength = _characterArray.Length - characterOffset; } stringBuilder.Append(_characterArray, characterOffset, characterLength); } } ////// Character buffer implemented by string /// internal sealed class StringCharacterBuffer : CharacterBuffer { private string _string; ////// Creating a character buffer from string /// /// character string public StringCharacterBuffer( string characterString ) { if (characterString == null) { throw new ArgumentNullException("characterString"); } _string = characterString; } ////// Read a character from buffer at the specified character index /// public override char this[int characterOffset] { get { return _string[characterOffset]; } set { throw new NotSupportedException(); } } ////// Buffer character length /// public override int Count { get { return _string.Length; } } ////// Get fixed address of the character buffer /// ////// Critical:This code manipulates a pointer and returns it /// [SecurityCritical] public override unsafe char* GetCharacterPointer() { // Even though we could allocate GCHandle for this purpose, we would need // to manage how to release them appropriately. It is even worse if we // consider performance implication of doing so. In typical UI scenario, // there are so many string objects running around in GC heap. Getting // GCHandle for every one of them is very expensive and demote GC's ability // to compact its heap. return null; } ////// Get fixed address of the character buffer and Pin if necessary. /// Note: This call should only be used when we know that we are not pinning /// memory for a long time so as not to fragment the heap. /// /// Critical:This code manipulates a pointer and returns it /// [SecurityCritical] public unsafe override IntPtr PinAndGetCharacterPointer(int offset, out GCHandle gcHandle) { gcHandle = GCHandle.Alloc(_string, GCHandleType.Pinned); return new IntPtr(((char*)gcHandle.AddrOfPinnedObject().ToPointer()) + offset); } ////// This is a matching call for PinAndGetCharacterPointer to unpin the memory. /// ////// Critical : This method has access to GCHandle which can provide memory address info. /// Treat As Safe: This method does not expose any security critical info. /// [SecurityCritical, SecurityTreatAsSafe] public override void UnpinCharacterPointer(GCHandle gcHandle) { gcHandle.Free(); } ////// Add character buffer's content to a StringBuilder /// /// string builder to add content to /// index to first character in the buffer to append /// number of character appending public override void AppendToStringBuilder( StringBuilder stringBuilder, int characterOffset, int characterLength ) { Debug.Assert(characterOffset >= 0 && characterOffset < _string.Length, "Invalid character index"); if ( characterLength < 0 || characterOffset + characterLength > _string.Length) { characterLength = _string.Length - characterOffset; } stringBuilder.Append(_string, characterOffset, characterLength); } } ////// Character buffer implemented as unsafe pointer to character string /// internal sealed unsafe class UnsafeStringCharacterBuffer : CharacterBuffer { ////// Critical: This code is unsafe since it holds a pointer /// EnforcementCritical /// [SecurityCritical] private char* _unsafeString; ////// Critical: Length is critical to avoid buffer overrun. /// [SecurityCritical] private int _length; ////// Creating a character buffer from an unsafe pointer to character string /// /// unsafe pointer to character string /// number of valid characters referenced by the unsafe pointer ////// Critical: This code is unsafe since it manipulates a pointer, it constructs an object with /// length data from user /// [SecurityCritical] public UnsafeStringCharacterBuffer( char* characterString, int length ) { if (characterString == null) { throw new ArgumentNullException("characterString"); } if (length <= 0) { throw new ArgumentOutOfRangeException("length", SR.Get(SRID.ParameterValueMustBeGreaterThanZero)); } _unsafeString = characterString; _length = length; } ////// Read a character from buffer at the specified character index /// ////// Critical: This code is unsafe since it manipulates a pointer /// Safe: Info is safe to expose and method does bound check /// public override char this[int characterOffset] { [SecurityCritical, SecurityTreatAsSafe] get { if (characterOffset >= _length || characterOffset < 0) throw new ArgumentOutOfRangeException("characterOffset", SR.Get(SRID.ParameterMustBeBetween,0,_length)); return _unsafeString[characterOffset]; } [SecurityCritical, SecurityTreatAsSafe] set { throw new NotSupportedException(); } } ////// Buffer character length /// ////// Critical: Lenght is critical data when dealing with unsafe pointer. /// Safe: This value is safe to give out. /// public override int Count { [SecurityCritical, SecurityTreatAsSafe] get { return _length; } } ////// Get fixed address of the character buffer /// ////// Critical:This returns the pointer /// [SecurityCritical] public override unsafe char* GetCharacterPointer() { return _unsafeString; } ////// Get fixed address of the character buffer and Pin if necessary. /// Note: This call should only be used when we know that we are not pinning /// memory for a long time so as not to fragment the heap. /// /// Critical:This code manipulates a pointer and returns it /// [SecurityCritical] public override IntPtr PinAndGetCharacterPointer(int offset, out GCHandle gcHandle) { gcHandle = new GCHandle(); return new IntPtr(_unsafeString + offset); } ////// This is a matching call for PinAndGetCharacterPointer to unpin the memory. /// ////// Critical : This method has access to GCHandle which can provide memory address info. /// Treat As Safe: This method does not expose any security critical info. /// [SecurityCritical, SecurityTreatAsSafe] public override void UnpinCharacterPointer(GCHandle gcHandle) { } ////// Add character buffer's content to a StringBuilder /// /// string builder to add content to /// index to first character in the buffer to append /// number of character appending ////// Critical: This returns the string in a string builder object, critical because it accesses the pointer /// and returns its contents embedded in the stringbuilder passed in. /// Safe: This method does proper bound check. /// [SecurityCritical, SecurityTreatAsSafe] public override void AppendToStringBuilder( StringBuilder stringBuilder, int characterOffset, int characterLength ) { if (characterOffset >= _length || characterOffset < 0) { throw new ArgumentOutOfRangeException("characterOffset", SR.Get(SRID.ParameterMustBeBetween,0,_length)); } if (characterLength < 0 || characterOffset + characterLength > _length) { throw new ArgumentOutOfRangeException("characterLength", SR.Get(SRID.ParameterMustBeBetween,0, _length - characterOffset)); } stringBuilder.Append(new string(_unsafeString, characterOffset, characterLength)); } } } // 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
- RequestBringIntoViewEventArgs.cs
- ExpandCollapseProviderWrapper.cs
- SoapEnumAttribute.cs
- LoginUtil.cs
- VisualStyleInformation.cs
- SessionEndedEventArgs.cs
- DataGridViewRowsAddedEventArgs.cs
- EntityFunctions.cs
- DataGridItemCollection.cs
- Encoding.cs
- InputLanguageCollection.cs
- EmptyCollection.cs
- Helpers.cs
- Attributes.cs
- TextServicesDisplayAttributePropertyRanges.cs
- Contracts.cs
- FrameworkEventSource.cs
- DynamicMethod.cs
- ConfigXmlSignificantWhitespace.cs
- XsltConvert.cs
- SecurityCriticalDataForSet.cs
- BinHexEncoder.cs
- ConfigUtil.cs
- HiddenFieldPageStatePersister.cs
- DbDataReader.cs
- CodeTypeDelegate.cs
- HttpClientCertificate.cs
- PopupRoot.cs
- NonBatchDirectoryCompiler.cs
- BrowserDefinition.cs
- TerminateWorkflow.cs
- System.Data_BID.cs
- CommandDesigner.cs
- TableCell.cs
- FaultException.cs
- ItemsControlAutomationPeer.cs
- ManifestSignatureInformation.cs
- ButtonRenderer.cs
- MetadataProperty.cs
- BitmapFrameEncode.cs
- PropertyPathWorker.cs
- HttpCacheVary.cs
- FormsAuthenticationEventArgs.cs
- RequestedSignatureDialog.cs
- CaseInsensitiveComparer.cs
- OneOfTypeConst.cs
- PointCollection.cs
- CompensatableSequenceActivity.cs
- UnsafeNativeMethods.cs
- TreeNodeCollectionEditor.cs
- RequestTimeoutManager.cs
- SoapIncludeAttribute.cs
- RoleExceptions.cs
- DesignerActionListCollection.cs
- Point3D.cs
- TableColumnCollectionInternal.cs
- PolygonHotSpot.cs
- OperationSelectorBehavior.cs
- SamlAuthorizationDecisionStatement.cs
- SelectionEditingBehavior.cs
- PropertyReference.cs
- ScrollableControl.cs
- MailWriter.cs
- XmlBinaryReader.cs
- OptimizerPatterns.cs
- DataServiceConfiguration.cs
- XPathNavigatorReader.cs
- GlobalDataBindingHandler.cs
- IIS7UserPrincipal.cs
- XmlNodeList.cs
- ListViewGroup.cs
- XmlSchemaAttributeGroup.cs
- Directory.cs
- CompareValidator.cs
- ImageAttributes.cs
- NumericUpDownAcceleration.cs
- ConvertersCollection.cs
- ToolStripDropDownClosedEventArgs.cs
- SqlConnectionHelper.cs
- AutomationElement.cs
- InternalSafeNativeMethods.cs
- ControlIdConverter.cs
- Facet.cs
- NativeMethodsCLR.cs
- PolygonHotSpot.cs
- DoubleAnimationUsingPath.cs
- XmlSchemaSimpleContent.cs
- ProfilePropertySettingsCollection.cs
- EditorZoneBase.cs
- Misc.cs
- Point.cs
- ComEventsMethod.cs
- HijriCalendar.cs
- ThreadStaticAttribute.cs
- DataGridViewCellMouseEventArgs.cs
- MailHeaderInfo.cs
- VisualBasicSettingsHandler.cs
- IImplicitResourceProvider.cs
- CodeEntryPointMethod.cs
- FileEnumerator.cs