Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / fx / src / Data / System / Data / Common / DBSchemaRow.cs / 1 / DBSchemaRow.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
// [....]
//-----------------------------------------------------------------------------
namespace System.Data.Common {
using System;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Globalization;
sealed internal class DbSchemaRow {
internal const string SchemaMappingUnsortedIndex = "SchemaMapping Unsorted Index";
DbSchemaTable schemaTable;
DataRow dataRow;
static internal DbSchemaRow[] GetSortedSchemaRows(DataTable dataTable, bool returnProviderSpecificTypes) { // MDAC 60609
DataColumn sortindex= dataTable.Columns[SchemaMappingUnsortedIndex];
if (null == sortindex) { // WebData 100390
sortindex = new DataColumn(SchemaMappingUnsortedIndex, typeof(Int32)); // MDAC 67050
dataTable.Columns.Add(sortindex);
}
int count = dataTable.Rows.Count;
for (int i = 0; i < count; ++i) {
dataTable.Rows[i][sortindex] = i;
};
DbSchemaTable schemaTable = new DbSchemaTable(dataTable, returnProviderSpecificTypes);
const DataViewRowState rowStates = DataViewRowState.Unchanged | DataViewRowState.Added | DataViewRowState.ModifiedCurrent;
DataRow[] dataRows = dataTable.Select(null, "ColumnOrdinal ASC", rowStates);
Debug.Assert(null != dataRows, "GetSchemaRows: unexpected null dataRows");
DbSchemaRow[] schemaRows = new DbSchemaRow[dataRows.Length];
for (int i = 0; i < dataRows.Length; ++i) {
schemaRows[i] = new DbSchemaRow(schemaTable, dataRows[i]);
}
return schemaRows;
}
internal DbSchemaRow(DbSchemaTable schemaTable, DataRow dataRow) {
this.schemaTable = schemaTable;
this.dataRow = dataRow;
}
internal DataRow DataRow {
get {
return dataRow;
}
}
internal string ColumnName {
get {
Debug.Assert(null != schemaTable.ColumnName, "no column ColumnName");
object value = dataRow[schemaTable.ColumnName, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToString(value, CultureInfo.InvariantCulture);
}
return "";
}
/*set {
Debug.Assert(null != schemaTable.ColumnName, "missing column ColumnName");
dataRow[schemaTable.ColumnName] = value;
}*/
}
//internal Int32 Ordinal {
/*get {
Debug.Assert(null != schemaTable.Ordinal, "no column Ordinal");
return Convert.ToInt32(dataRow[schemaTable.Ordinal, DataRowVersion.Default], CultureInfo.InvariantCulture);
}*/
/*set {
Debug.Assert(null != schemaTable.Ordinal, "missing column Ordinal");
dataRow[schemaTable.Ordinal] = value;
}*/
//}
internal Int32 Size {
get {
Debug.Assert(null != schemaTable.Size, "no column Size");
object value = dataRow[schemaTable.Size, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToInt32(value, CultureInfo.InvariantCulture);
}
return 0;
}
/*set {
Debug.Assert(null != schemaTable.Size, "missing column Size");
dataRow[schemaTable.Size] = value;
}*/
}
internal string BaseColumnName {
get {
if (null != schemaTable.BaseColumnName) {
object value = dataRow[schemaTable.BaseColumnName, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToString(value, CultureInfo.InvariantCulture);
}
}
return "";
}
/*set {
Debug.Assert(null != schemaTable.BaseColumnName, "missing column BaseColumnName");
dataRow[schemaTable.BaseColumnName] = value;
}*/
}
internal string BaseServerName {
get {
if (null != schemaTable.BaseServerName) {
object value = dataRow[schemaTable.BaseServerName, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToString(value, CultureInfo.InvariantCulture);
}
}
return "";
}
/*set {
Debug.Assert(null != schemaTable.BaseServerName, "missing column BaseServerName");
dataRow[schemaTable.BaseServerName] = value;
}*/
}
internal string BaseCatalogName {
get {
if (null != schemaTable.BaseCatalogName) {
object value = dataRow[schemaTable.BaseCatalogName, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToString(value, CultureInfo.InvariantCulture);
}
}
return "";
}
/*set {
Debug.Assert(null != schemaTable.BaseCatalogName, "missing column BaseCatalogName");
dataRow[schemaTable.BaseCatalogName] = value;
}*/
}
internal string BaseSchemaName {
get {
if (null != schemaTable.BaseSchemaName) {
object value = dataRow[schemaTable.BaseSchemaName, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToString(value, CultureInfo.InvariantCulture);
}
}
return "";
}
/*set {
Debug.Assert(null != schemaTable.BaseSchemaName, "missing column BaseSchemaName");
dataRow[schemaTable.BaseSchemaName] = value;
}*/
}
internal string BaseTableName {
get {
if (null != schemaTable.BaseTableName) {
object value = dataRow[schemaTable.BaseTableName, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToString(value, CultureInfo.InvariantCulture);
}
}
return "";
}
/*set {
Debug.Assert(null != schemaTable.BaseTableName, "missing column BaseTableName");
dataRow[schemaTable.BaseTableName] = value;
}*/
}
internal bool IsAutoIncrement {
get {
if (null != schemaTable.IsAutoIncrement) {
object value = dataRow[schemaTable.IsAutoIncrement, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}
/*set {
Debug.Assert(null != schemaTable.IsAutoIncrement, "missing column IsAutoIncrement");
dataRow[schemaTable.IsAutoIncrement] = (bool)value;
}*/
}
internal bool IsUnique {
get {
if (null != schemaTable.IsUnique) {
object value = dataRow[schemaTable.IsUnique, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}
/*set {
Debug.Assert(null != schemaTable.IsUnique, "missing column IsUnique");
dataRow[schemaTable.IsUnique] = (bool)value;
}*/
}
internal bool IsRowVersion {
get {
if (null != schemaTable.IsRowVersion) {
object value = dataRow[schemaTable.IsRowVersion, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}
/*set {
Debug.Assert(null != schemaTable.IsRowVersion, "missing column IsRowVersion");
dataRow[schemaTable.IsRowVersion] = value;
}*/
}
internal bool IsKey {
get {
if (null != schemaTable.IsKey) {
object value = dataRow[schemaTable.IsKey, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}
/*set {
Debug.Assert(null != schemaTable.IsKey, "missing column IsKey");
dataRow[schemaTable.IsKey] = value;
}*/
}
// consider: just do comparison directly -> (object)(baseColumnName) == (object)(columnName)
//internal bool IsAliased {
/*get {
if (null != schemaTable.IsAliased) { // MDAC 62336
object value = dataRow[schemaTable.IsAliased, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}*/
/*set {
Debug.Assert(null != schemaTable.IsAliased, "missing column IsAliased");
dataRow[schemaTable.IsAliased] = value;
}*/
//}
internal bool IsExpression {
get {
if (null != schemaTable.IsExpression) { // MDAC 62336
object value = dataRow[schemaTable.IsExpression, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}
/*set {
Debug.Assert(null != schemaTable.IsExpression, "missing column IsExpression");
dataRow[schemaTable.IsExpression] = value;
}*/
}
//internal bool IsIdentity {
/*get {
if (null != schemaTable.IsIdentity) { // MDAC 62336
object value = dataRow[schemaTable.IsIdentity, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}*/
/*set {
Debug.Assert(null != schemaTable.IsIdentity, "missing column IsIdentity");
dataRow[schemaTable.IsIdentity] = value;
}*/
//}
internal bool IsHidden {
get {
if (null != schemaTable.IsHidden) { // MDAC 62336
object value = dataRow[schemaTable.IsHidden, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}
/*set {
Debug.Assert(null != schemaTable.IsHidden, "missing column IsHidden");
dataRow[schemaTable.IsHidden] = value;
}*/
}
internal bool IsLong {
get {
if (null != schemaTable.IsLong) { // MDAC 62336
object value = dataRow[schemaTable.IsLong, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}
/*set {
Debug.Assert(null != schemaTable.IsLong, "missing column IsHidden");
dataRow[schemaTable.IsLong] = value;
}*/
}
internal bool IsReadOnly {
get {
if (null != schemaTable.IsReadOnly) { // MDAC 62336
object value = dataRow[schemaTable.IsReadOnly, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}
/*set {
Debug.Assert(null != schemaTable.IsReadOnly, "missing column IsReadOnly");
dataRow[schemaTable.IsReadOnly] = value;
}*/
}
internal System.Type DataType {
get {
if (null != schemaTable.DataType) {
object value = dataRow[schemaTable.DataType, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return(System.Type) value;
}
}
return null;
}
/*set {
Debug.Assert(null != schemaTable.DataType, "missing column DataType");
dataRow[schemaTable.DataType] = value;
}*/
}
internal bool AllowDBNull {
get {
if (null != schemaTable.AllowDBNull) {
object value = dataRow[schemaTable.AllowDBNull, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return true;
}
/*set {
Debug.Assert(null != schemaTable.AllowDBNull, "missing column MaybeNull");
dataRow[schemaTable.AllowDBNull] = value;
}*/
}
/*internal Int32 ProviderType {
get {
if (null != schemaTable.ProviderType) {
object value = dataRow[schemaTable.ProviderType, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToInt32(value);
}
}
return 0;
}
set {
Debug.Assert(null != schemaTable.ProviderType, "missing column ProviderType");
dataRow[schemaTable.ProviderType] = value;
}
}*/
internal Int32 UnsortedIndex {
get {
return (Int32) dataRow[schemaTable.UnsortedIndex, DataRowVersion.Default];
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
// [....]
//-----------------------------------------------------------------------------
namespace System.Data.Common {
using System;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Globalization;
sealed internal class DbSchemaRow {
internal const string SchemaMappingUnsortedIndex = "SchemaMapping Unsorted Index";
DbSchemaTable schemaTable;
DataRow dataRow;
static internal DbSchemaRow[] GetSortedSchemaRows(DataTable dataTable, bool returnProviderSpecificTypes) { // MDAC 60609
DataColumn sortindex= dataTable.Columns[SchemaMappingUnsortedIndex];
if (null == sortindex) { // WebData 100390
sortindex = new DataColumn(SchemaMappingUnsortedIndex, typeof(Int32)); // MDAC 67050
dataTable.Columns.Add(sortindex);
}
int count = dataTable.Rows.Count;
for (int i = 0; i < count; ++i) {
dataTable.Rows[i][sortindex] = i;
};
DbSchemaTable schemaTable = new DbSchemaTable(dataTable, returnProviderSpecificTypes);
const DataViewRowState rowStates = DataViewRowState.Unchanged | DataViewRowState.Added | DataViewRowState.ModifiedCurrent;
DataRow[] dataRows = dataTable.Select(null, "ColumnOrdinal ASC", rowStates);
Debug.Assert(null != dataRows, "GetSchemaRows: unexpected null dataRows");
DbSchemaRow[] schemaRows = new DbSchemaRow[dataRows.Length];
for (int i = 0; i < dataRows.Length; ++i) {
schemaRows[i] = new DbSchemaRow(schemaTable, dataRows[i]);
}
return schemaRows;
}
internal DbSchemaRow(DbSchemaTable schemaTable, DataRow dataRow) {
this.schemaTable = schemaTable;
this.dataRow = dataRow;
}
internal DataRow DataRow {
get {
return dataRow;
}
}
internal string ColumnName {
get {
Debug.Assert(null != schemaTable.ColumnName, "no column ColumnName");
object value = dataRow[schemaTable.ColumnName, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToString(value, CultureInfo.InvariantCulture);
}
return "";
}
/*set {
Debug.Assert(null != schemaTable.ColumnName, "missing column ColumnName");
dataRow[schemaTable.ColumnName] = value;
}*/
}
//internal Int32 Ordinal {
/*get {
Debug.Assert(null != schemaTable.Ordinal, "no column Ordinal");
return Convert.ToInt32(dataRow[schemaTable.Ordinal, DataRowVersion.Default], CultureInfo.InvariantCulture);
}*/
/*set {
Debug.Assert(null != schemaTable.Ordinal, "missing column Ordinal");
dataRow[schemaTable.Ordinal] = value;
}*/
//}
internal Int32 Size {
get {
Debug.Assert(null != schemaTable.Size, "no column Size");
object value = dataRow[schemaTable.Size, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToInt32(value, CultureInfo.InvariantCulture);
}
return 0;
}
/*set {
Debug.Assert(null != schemaTable.Size, "missing column Size");
dataRow[schemaTable.Size] = value;
}*/
}
internal string BaseColumnName {
get {
if (null != schemaTable.BaseColumnName) {
object value = dataRow[schemaTable.BaseColumnName, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToString(value, CultureInfo.InvariantCulture);
}
}
return "";
}
/*set {
Debug.Assert(null != schemaTable.BaseColumnName, "missing column BaseColumnName");
dataRow[schemaTable.BaseColumnName] = value;
}*/
}
internal string BaseServerName {
get {
if (null != schemaTable.BaseServerName) {
object value = dataRow[schemaTable.BaseServerName, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToString(value, CultureInfo.InvariantCulture);
}
}
return "";
}
/*set {
Debug.Assert(null != schemaTable.BaseServerName, "missing column BaseServerName");
dataRow[schemaTable.BaseServerName] = value;
}*/
}
internal string BaseCatalogName {
get {
if (null != schemaTable.BaseCatalogName) {
object value = dataRow[schemaTable.BaseCatalogName, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToString(value, CultureInfo.InvariantCulture);
}
}
return "";
}
/*set {
Debug.Assert(null != schemaTable.BaseCatalogName, "missing column BaseCatalogName");
dataRow[schemaTable.BaseCatalogName] = value;
}*/
}
internal string BaseSchemaName {
get {
if (null != schemaTable.BaseSchemaName) {
object value = dataRow[schemaTable.BaseSchemaName, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToString(value, CultureInfo.InvariantCulture);
}
}
return "";
}
/*set {
Debug.Assert(null != schemaTable.BaseSchemaName, "missing column BaseSchemaName");
dataRow[schemaTable.BaseSchemaName] = value;
}*/
}
internal string BaseTableName {
get {
if (null != schemaTable.BaseTableName) {
object value = dataRow[schemaTable.BaseTableName, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToString(value, CultureInfo.InvariantCulture);
}
}
return "";
}
/*set {
Debug.Assert(null != schemaTable.BaseTableName, "missing column BaseTableName");
dataRow[schemaTable.BaseTableName] = value;
}*/
}
internal bool IsAutoIncrement {
get {
if (null != schemaTable.IsAutoIncrement) {
object value = dataRow[schemaTable.IsAutoIncrement, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}
/*set {
Debug.Assert(null != schemaTable.IsAutoIncrement, "missing column IsAutoIncrement");
dataRow[schemaTable.IsAutoIncrement] = (bool)value;
}*/
}
internal bool IsUnique {
get {
if (null != schemaTable.IsUnique) {
object value = dataRow[schemaTable.IsUnique, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}
/*set {
Debug.Assert(null != schemaTable.IsUnique, "missing column IsUnique");
dataRow[schemaTable.IsUnique] = (bool)value;
}*/
}
internal bool IsRowVersion {
get {
if (null != schemaTable.IsRowVersion) {
object value = dataRow[schemaTable.IsRowVersion, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}
/*set {
Debug.Assert(null != schemaTable.IsRowVersion, "missing column IsRowVersion");
dataRow[schemaTable.IsRowVersion] = value;
}*/
}
internal bool IsKey {
get {
if (null != schemaTable.IsKey) {
object value = dataRow[schemaTable.IsKey, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}
/*set {
Debug.Assert(null != schemaTable.IsKey, "missing column IsKey");
dataRow[schemaTable.IsKey] = value;
}*/
}
// consider: just do comparison directly -> (object)(baseColumnName) == (object)(columnName)
//internal bool IsAliased {
/*get {
if (null != schemaTable.IsAliased) { // MDAC 62336
object value = dataRow[schemaTable.IsAliased, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}*/
/*set {
Debug.Assert(null != schemaTable.IsAliased, "missing column IsAliased");
dataRow[schemaTable.IsAliased] = value;
}*/
//}
internal bool IsExpression {
get {
if (null != schemaTable.IsExpression) { // MDAC 62336
object value = dataRow[schemaTable.IsExpression, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}
/*set {
Debug.Assert(null != schemaTable.IsExpression, "missing column IsExpression");
dataRow[schemaTable.IsExpression] = value;
}*/
}
//internal bool IsIdentity {
/*get {
if (null != schemaTable.IsIdentity) { // MDAC 62336
object value = dataRow[schemaTable.IsIdentity, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}*/
/*set {
Debug.Assert(null != schemaTable.IsIdentity, "missing column IsIdentity");
dataRow[schemaTable.IsIdentity] = value;
}*/
//}
internal bool IsHidden {
get {
if (null != schemaTable.IsHidden) { // MDAC 62336
object value = dataRow[schemaTable.IsHidden, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}
/*set {
Debug.Assert(null != schemaTable.IsHidden, "missing column IsHidden");
dataRow[schemaTable.IsHidden] = value;
}*/
}
internal bool IsLong {
get {
if (null != schemaTable.IsLong) { // MDAC 62336
object value = dataRow[schemaTable.IsLong, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}
/*set {
Debug.Assert(null != schemaTable.IsLong, "missing column IsHidden");
dataRow[schemaTable.IsLong] = value;
}*/
}
internal bool IsReadOnly {
get {
if (null != schemaTable.IsReadOnly) { // MDAC 62336
object value = dataRow[schemaTable.IsReadOnly, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return false;
}
/*set {
Debug.Assert(null != schemaTable.IsReadOnly, "missing column IsReadOnly");
dataRow[schemaTable.IsReadOnly] = value;
}*/
}
internal System.Type DataType {
get {
if (null != schemaTable.DataType) {
object value = dataRow[schemaTable.DataType, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return(System.Type) value;
}
}
return null;
}
/*set {
Debug.Assert(null != schemaTable.DataType, "missing column DataType");
dataRow[schemaTable.DataType] = value;
}*/
}
internal bool AllowDBNull {
get {
if (null != schemaTable.AllowDBNull) {
object value = dataRow[schemaTable.AllowDBNull, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
}
}
return true;
}
/*set {
Debug.Assert(null != schemaTable.AllowDBNull, "missing column MaybeNull");
dataRow[schemaTable.AllowDBNull] = value;
}*/
}
/*internal Int32 ProviderType {
get {
if (null != schemaTable.ProviderType) {
object value = dataRow[schemaTable.ProviderType, DataRowVersion.Default];
if (!Convert.IsDBNull(value)) {
return Convert.ToInt32(value);
}
}
return 0;
}
set {
Debug.Assert(null != schemaTable.ProviderType, "missing column ProviderType");
dataRow[schemaTable.ProviderType] = value;
}
}*/
internal Int32 UnsortedIndex {
get {
return (Int32) dataRow[schemaTable.UnsortedIndex, DataRowVersion.Default];
}
}
}
}
// 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
- MatrixCamera.cs
- DataTableReader.cs
- ListViewInsertionMark.cs
- IdentityModelStringsVersion1.cs
- DataGridParentRows.cs
- BooleanStorage.cs
- EncodingDataItem.cs
- AdornedElementPlaceholder.cs
- DisplayMemberTemplateSelector.cs
- TypefaceCollection.cs
- Control.cs
- HtmlInputCheckBox.cs
- Span.cs
- RowBinding.cs
- OleDbMetaDataFactory.cs
- IntSecurity.cs
- ObjectDisposedException.cs
- TextParentUndoUnit.cs
- IdnElement.cs
- CalendarItem.cs
- TreeNodeConverter.cs
- LinkDescriptor.cs
- SqlSelectClauseBuilder.cs
- Int64Storage.cs
- ConstraintConverter.cs
- SqlVisitor.cs
- EncoderNLS.cs
- ConfigurationValue.cs
- AsyncDataRequest.cs
- ConstraintConverter.cs
- AuthenticatingEventArgs.cs
- Connection.cs
- TextBreakpoint.cs
- XmlSerializerVersionAttribute.cs
- XslCompiledTransform.cs
- ImageDrawing.cs
- SecureConversationSecurityTokenParameters.cs
- WhiteSpaceTrimStringConverter.cs
- XslVisitor.cs
- DataServiceHost.cs
- ByteStorage.cs
- ToolTip.cs
- SubpageParaClient.cs
- ConfigXmlElement.cs
- TypeDependencyAttribute.cs
- PageContentCollection.cs
- Visitors.cs
- MarshalDirectiveException.cs
- ByteStreamGeometryContext.cs
- DataSourceXmlSubItemAttribute.cs
- AspNetSynchronizationContext.cs
- InfoCardSymmetricCrypto.cs
- PeerApplication.cs
- LinkedResource.cs
- sitestring.cs
- InputProcessorProfiles.cs
- ChildrenQuery.cs
- TypeLibraryHelper.cs
- ListBoxItemAutomationPeer.cs
- UiaCoreProviderApi.cs
- IdentityNotMappedException.cs
- RenderDataDrawingContext.cs
- TrackingMemoryStream.cs
- TrustLevelCollection.cs
- MasterPageBuildProvider.cs
- ForeignKeyConstraint.cs
- ToolBarTray.cs
- ForwardPositionQuery.cs
- AdRotator.cs
- XomlCompilerParameters.cs
- TextEditorSelection.cs
- RightsManagementEncryptedStream.cs
- SerializationSectionGroup.cs
- DataGridViewRowStateChangedEventArgs.cs
- IndexedEnumerable.cs
- Authorization.cs
- CompositeScriptReference.cs
- LinqDataSourceUpdateEventArgs.cs
- ReflectionHelper.cs
- ReadOnlyNameValueCollection.cs
- EventHandlerList.cs
- PhysicalOps.cs
- WrapPanel.cs
- ToolStripGripRenderEventArgs.cs
- XNodeValidator.cs
- MetadataItemSerializer.cs
- NumericPagerField.cs
- SqlBooleanMismatchVisitor.cs
- RotationValidation.cs
- DesignBindingPicker.cs
- SequenceDesignerAccessibleObject.cs
- BinaryMessageEncoder.cs
- WebPartZoneCollection.cs
- RoutedEventValueSerializer.cs
- RequestCacheValidator.cs
- DynamicRendererThreadManager.cs
- Matrix3DConverter.cs
- RenderOptions.cs
- Screen.cs
- GradientBrush.cs