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 IList Members
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 IList Members
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
- UrlPropertyAttribute.cs
- SqlWebEventProvider.cs
- EmptyTextWriter.cs
- MembershipAdapter.cs
- TextTrailingCharacterEllipsis.cs
- XmlWrappingReader.cs
- QueryInterceptorAttribute.cs
- SecuritySessionSecurityTokenProvider.cs
- X509ClientCertificateAuthenticationElement.cs
- OwnerDrawPropertyBag.cs
- XmlSchemaChoice.cs
- FrameworkObject.cs
- DesignerRegionCollection.cs
- TcpSocketManager.cs
- InternalConfigHost.cs
- PageCodeDomTreeGenerator.cs
- SuppressMergeCheckAttribute.cs
- CurrentChangedEventManager.cs
- ZoomPercentageConverter.cs
- PeerTransportSecurityElement.cs
- FillRuleValidation.cs
- DockingAttribute.cs
- TextRunCacheImp.cs
- HttpModuleAction.cs
- Label.cs
- XamlWriter.cs
- XmlSchemaType.cs
- HierarchicalDataSourceIDConverter.cs
- GuidConverter.cs
- ItemsChangedEventArgs.cs
- StylusOverProperty.cs
- SByte.cs
- RegistrationServices.cs
- HtmlProps.cs
- ExpandedWrapper.cs
- AppearanceEditorPart.cs
- SplineKeyFrames.cs
- FusionWrap.cs
- SettingsProviderCollection.cs
- oledbmetadatacollectionnames.cs
- InteropTrackingRecord.cs
- DateTimeValueSerializer.cs
- BrushValueSerializer.cs
- PackagePartCollection.cs
- StreamReader.cs
- DesignerHost.cs
- ConstructorBuilder.cs
- DirectoryObjectSecurity.cs
- _FixedSizeReader.cs
- ByteKeyFrameCollection.cs
- AncestorChangedEventArgs.cs
- SBCSCodePageEncoding.cs
- ValidatorCollection.cs
- Ipv6Element.cs
- XmlDocumentViewSchema.cs
- ControlEvent.cs
- ReaderWriterLockWrapper.cs
- SmtpReplyReader.cs
- ConfigViewGenerator.cs
- CodePropertyReferenceExpression.cs
- InputMethodStateChangeEventArgs.cs
- CircleHotSpot.cs
- AccessDataSourceView.cs
- ColorContext.cs
- PowerModeChangedEventArgs.cs
- ClassValidator.cs
- XmlDocumentSerializer.cs
- IndependentlyAnimatedPropertyMetadata.cs
- PerformanceCounterManager.cs
- WebPartsSection.cs
- Rotation3D.cs
- FixedSOMPageConstructor.cs
- HybridObjectCache.cs
- AutoCompleteStringCollection.cs
- NameValueFileSectionHandler.cs
- PersonalizationStateInfo.cs
- CultureMapper.cs
- Image.cs
- InternalMappingException.cs
- CriticalExceptions.cs
- AppModelKnownContentFactory.cs
- StreamingContext.cs
- ConnectionConsumerAttribute.cs
- CookielessData.cs
- DocobjHost.cs
- ObjectItemLoadingSessionData.cs
- HyperLinkStyle.cs
- ValidatedControlConverter.cs
- ColumnResizeAdorner.cs
- GridViewAutomationPeer.cs
- SizeKeyFrameCollection.cs
- ObsoleteAttribute.cs
- ProtocolViolationException.cs
- TraceContextRecord.cs
- ComEventsSink.cs
- CellParaClient.cs
- BackgroundWorker.cs
- FileDialogCustomPlace.cs
- RecognizerStateChangedEventArgs.cs
- DeobfuscatingStream.cs