Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Query / PlanCompiler / TypeInfo.cs / 1305376 / TypeInfo.cs
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
using System;
using System.Collections.Generic;
//using System.Diagnostics; // Please use PlanCompiler.Assert instead of Debug.Assert in this class...
using System.Globalization;
using System.Data.Common;
using md = System.Data.Metadata.Edm;
using System.Data.Query.InternalTrees;
namespace System.Data.Query.PlanCompiler
{
///
/// The kind of type-id in use
///
internal enum TypeIdKind
{
UserSpecified = 0,
Generated
}
///
/// The TypeInfo class encapsulates various pieces of information about a type.
/// The most important of these include the "flattened" record type - corresponding
/// to the type, and the TypeId field for nominal types
///
internal class TypeInfo
{
#region private state
private readonly md.TypeUsage m_type; // the type
private object m_typeId; // the type's Id, assigned by the StructuredTypeInfo processing.
private List m_immediateSubTypes; // the list of children below this type in it's type hierarchy.
private readonly TypeInfo m_superType; // the type one level up in this types type hierarchy -- the base type.
private readonly RootTypeInfo m_rootType; // the top-most type in this types type hierarchy
#endregion
#region Constructors and factory methods
///
/// Creates type information for a type
///
///
///
/// ();
m_superType = superType;
if (superType != null)
{
// Add myself to my supertype's list of subtypes
superType.m_immediateSubTypes.Add(this);
// my supertype's root type is mine as well
m_rootType = superType.RootType;
}
}
#endregion
#region "public" properties for all types
///
/// Is this the root type?
/// True for entity, complex types and ref types, if this is the root of the
/// hierarchy.
/// Always true for Record types
///
internal bool IsRootType
{
get
{
return m_rootType == null;
}
}
///
/// the types that derive from this type
///
internal List ImmediateSubTypes
{
get
{
return m_immediateSubTypes;
}
}
///
/// the immediate parent type of this type.
///
internal TypeInfo SuperType
{
get
{
return m_superType;
}
}
///
/// the top most type in the hierarchy.
///
internal RootTypeInfo RootType
{
get
{
return m_rootType ?? (RootTypeInfo)this;
}
}
///
/// The metadata type
///
internal md.TypeUsage Type
{
get
{
return m_type;
}
}
///
/// The typeid value for this type - only applies to nominal types
///
internal object TypeId
{
get
{
return m_typeId;
}
set
{
m_typeId = value;
}
}
#endregion
#region "public" properties for root types
// These properties are actually stored on the RootType but we let
// let folks use the TypeInfo class as the proxy to get to them.
// Essentially, they are mostly sugar to simplify coding.
//
// For example:
//
// You could either write:
//
// typeinfo.RootType.FlattenedType
//
// or you can write:
//
// typeinfo.FlattenedType
//
///
/// Flattened record version of the type
///
internal virtual md.RowType FlattenedType
{
get
{
return RootType.FlattenedType;
}
}
///
/// TypeUsage that encloses the Flattened record version of the type
///
internal virtual md.TypeUsage FlattenedTypeUsage
{
get
{
return RootType.FlattenedTypeUsage;
}
}
///
/// Get the property describing the entityset (if any)
///
internal virtual md.EdmProperty EntitySetIdProperty
{
get
{
return RootType.EntitySetIdProperty;
}
}
///
/// Does this type have an entitySetId property
///
internal bool HasEntitySetIdProperty
{
get
{
return RootType.EntitySetIdProperty != null;
}
}
///
/// Get the nullSentinel property (if any)
///
internal virtual md.EdmProperty NullSentinelProperty
{
get
{
return RootType.NullSentinelProperty;
}
}
///
/// Does this type have a nullSentinel property?
///
internal bool HasNullSentinelProperty
{
get
{
return RootType.NullSentinelProperty != null;
}
}
///
/// The typeid property in the flattened type - applies only to nominal types
/// this will be used as the type discriminator column.
///
internal virtual md.EdmProperty TypeIdProperty
{
get
{
return RootType.TypeIdProperty;
}
}
///
/// Does this type need a typeid property? (Needed for complex types and entity types in general)
///
internal bool HasTypeIdProperty
{
get
{
return RootType.TypeIdProperty != null;
}
}
///
/// All the properties of this type.
///
internal virtual IEnumerable PropertyRefList
{
get
{
return RootType.PropertyRefList;
}
}
///
/// Get the new property for the supplied propertyRef
///
/// property reference (on the old type)
///
/// Get the list of "key" properties (in the flattened type)
///
/// the key property equivalents in the flattened type
internal IEnumerable GetKeyPropertyRefs()
{
md.EntityTypeBase entityType = null;
md.RefType refType = null;
if (TypeHelpers.TryGetEdmType(m_type, out refType))
{
entityType = refType.ElementType;
}
else
{
entityType = TypeHelpers.GetEdmType(m_type);
}
// Walk through the list of keys of the entity type, and find their analogs in the
// "flattened" type
foreach (md.EdmMember p in entityType.KeyMembers)
{
// Eventually this could be RelationshipEndMember, but currently only properties are suppported as key members
PlanCompiler.Assert(p is md.EdmProperty, "Non-EdmProperty key members are not supported");
SimplePropertyRef spr = new SimplePropertyRef(p);
yield return spr;
}
}
///
/// Get the list of "identity" properties in the flattened type.
/// The identity properties include the entitysetid property, followed by the
/// key properties
///
/// List of identity properties
internal IEnumerable GetIdentityPropertyRefs()
{
if (this.HasEntitySetIdProperty)
{
yield return EntitySetIdPropertyRef.Instance;
}
foreach (PropertyRef p in this.GetKeyPropertyRefs())
{
yield return p;
}
}
///
/// Get the list of all properties in the flattened type
///
/// GetAllPropertyRefs()
{
foreach (PropertyRef p in this.PropertyRefList)
{
yield return p;
}
}
///
/// Get the list of all properties in the flattened type
///
/// GetAllProperties()
{
foreach (md.EdmProperty m in this.FlattenedType.Properties)
{
yield return m;
}
}
///
/// Gets all types in the hierarchy rooted at this.
///
internal List GetTypeHierarchy()
{
List result = new List();
GetTypeHierarchy(result);
return result;
}
///
/// Adds all types in the hierarchy to the given list.
///
private void GetTypeHierarchy(List result)
{
result.Add(this);
foreach (TypeInfo subType in this.ImmediateSubTypes)
{
subType.GetTypeHierarchy(result);
}
}
#endregion
}
///
/// A subclass of the TypeInfo class above that only represents information
/// about "root" types
///
internal class RootTypeInfo : TypeInfo
{
#region private state
private readonly List m_propertyRefList;
private readonly Dictionary m_propertyMap;
private md.EdmProperty m_nullSentinelProperty;
private md.EdmProperty m_typeIdProperty;
private TypeIdKind m_typeIdKind;
private md.TypeUsage m_typeIdType;
private readonly ExplicitDiscriminatorMap m_discriminatorMap;
private md.EdmProperty m_entitySetIdProperty;
private md.RowType m_flattenedType;
private md.TypeUsage m_flattenedTypeUsage;
#endregion
#region Constructor
///
/// Constructor for a root type
///
///
internal RootTypeInfo(md.TypeUsage type, ExplicitDiscriminatorMap discriminatorMap)
: base(type, null)
{
PlanCompiler.Assert(type.EdmType.BaseType == null, "only root types allowed here");
m_propertyMap = new Dictionary();
m_propertyRefList = new List();
m_discriminatorMap = discriminatorMap;
m_typeIdKind = TypeIdKind.Generated;
}
#endregion
#region "public" surface area
///
/// Kind of the typeid column (if any)
///
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal TypeIdKind TypeIdKind
{
get { return m_typeIdKind; }
set { m_typeIdKind = value; }
}
///
/// Datatype of the typeid column (if any)
///
internal md.TypeUsage TypeIdType
{
get { return m_typeIdType; }
set { m_typeIdType = value; }
}
///
/// Add a mapping from the propertyRef (of the old type) to the
/// corresponding property in the new type.
///
/// NOTE: Only to be used by StructuredTypeInfo
///
///
///
internal void AddPropertyMapping(PropertyRef propertyRef, md.EdmProperty newProperty)
{
m_propertyMap[propertyRef] = newProperty;
if (propertyRef is TypeIdPropertyRef)
{
m_typeIdProperty = newProperty;
}
else if (propertyRef is EntitySetIdPropertyRef)
{
m_entitySetIdProperty = newProperty;
}
else if (propertyRef is NullSentinelPropertyRef)
{
m_nullSentinelProperty = newProperty;
}
}
///
/// Adds a new property reference to the list of desired properties
/// NOTE: Only to be used by StructuredTypeInfo
///
///
internal void AddPropertyRef(PropertyRef propertyRef)
{
m_propertyRefList.Add(propertyRef);
}
///
/// Flattened record version of the type
///
internal new md.RowType FlattenedType
{
get
{
return m_flattenedType;
}
set
{
m_flattenedType = value;
m_flattenedTypeUsage = md.TypeUsage.Create(value);
}
}
///
/// TypeUsage that encloses the Flattened record version of the type
///
internal new md.TypeUsage FlattenedTypeUsage
{
get
{
return m_flattenedTypeUsage;
}
}
///
/// Gets map information for types mapped using simple discriminator pattern.
///
internal ExplicitDiscriminatorMap DiscriminatorMap
{
get
{
return m_discriminatorMap;
}
}
///
/// Get the property describing the entityset (if any)
///
internal new md.EdmProperty EntitySetIdProperty
{
get
{
return m_entitySetIdProperty;
}
}
internal new md.EdmProperty NullSentinelProperty
{
get
{
return m_nullSentinelProperty;
}
}
///
/// Get the list of property refs for this type
///
internal new IEnumerable PropertyRefList
{
get
{
return m_propertyRefList;
}
}
///
/// Determines the offset for structured types in Flattened type. For instance, if the original type is of the form:
///
/// { int X, ComplexType Y }
///
/// and the flattened type is of the form:
///
/// { int X, Y_ComplexType_Prop1, Y_ComplexType_Prop2 }
///
/// GetNestedStructureOffset(Y) returns 1
///
/// Complex property.
/// Offset.
internal int GetNestedStructureOffset(PropertyRef property)
{
// m_propertyRefList contains every element of the flattened type
for (int i = 0; i < m_propertyRefList.Count; i++)
{
NestedPropertyRef nestedPropertyRef = m_propertyRefList[i] as NestedPropertyRef;
// match offset of the first element of the complex type property
if (null != nestedPropertyRef && nestedPropertyRef.InnerProperty.Equals(property))
{
return i;
}
}
PlanCompiler.Assert(false, "no complex structure " + property + " found in TypeInfo");
// return something so that the compiler doesn't complain
return default(int);
}
///
/// Get the new property for the supplied propertyRef
///
/// property reference (on the old type)
///
/// The typeid property in the flattened type - applies only to nominal types
/// this will be used as the type discriminator column.
///
internal new md.EdmProperty TypeIdProperty
{
get
{
return m_typeIdProperty;
}
}
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
using System;
using System.Collections.Generic;
//using System.Diagnostics; // Please use PlanCompiler.Assert instead of Debug.Assert in this class...
using System.Globalization;
using System.Data.Common;
using md = System.Data.Metadata.Edm;
using System.Data.Query.InternalTrees;
namespace System.Data.Query.PlanCompiler
{
///
/// The kind of type-id in use
///
internal enum TypeIdKind
{
UserSpecified = 0,
Generated
}
///
/// The TypeInfo class encapsulates various pieces of information about a type.
/// The most important of these include the "flattened" record type - corresponding
/// to the type, and the TypeId field for nominal types
///
internal class TypeInfo
{
#region private state
private readonly md.TypeUsage m_type; // the type
private object m_typeId; // the type's Id, assigned by the StructuredTypeInfo processing.
private List m_immediateSubTypes; // the list of children below this type in it's type hierarchy.
private readonly TypeInfo m_superType; // the type one level up in this types type hierarchy -- the base type.
private readonly RootTypeInfo m_rootType; // the top-most type in this types type hierarchy
#endregion
#region Constructors and factory methods
///
/// Creates type information for a type
///
///
///
/// ();
m_superType = superType;
if (superType != null)
{
// Add myself to my supertype's list of subtypes
superType.m_immediateSubTypes.Add(this);
// my supertype's root type is mine as well
m_rootType = superType.RootType;
}
}
#endregion
#region "public" properties for all types
///
/// Is this the root type?
/// True for entity, complex types and ref types, if this is the root of the
/// hierarchy.
/// Always true for Record types
///
internal bool IsRootType
{
get
{
return m_rootType == null;
}
}
///
/// the types that derive from this type
///
internal List ImmediateSubTypes
{
get
{
return m_immediateSubTypes;
}
}
///
/// the immediate parent type of this type.
///
internal TypeInfo SuperType
{
get
{
return m_superType;
}
}
///
/// the top most type in the hierarchy.
///
internal RootTypeInfo RootType
{
get
{
return m_rootType ?? (RootTypeInfo)this;
}
}
///
/// The metadata type
///
internal md.TypeUsage Type
{
get
{
return m_type;
}
}
///
/// The typeid value for this type - only applies to nominal types
///
internal object TypeId
{
get
{
return m_typeId;
}
set
{
m_typeId = value;
}
}
#endregion
#region "public" properties for root types
// These properties are actually stored on the RootType but we let
// let folks use the TypeInfo class as the proxy to get to them.
// Essentially, they are mostly sugar to simplify coding.
//
// For example:
//
// You could either write:
//
// typeinfo.RootType.FlattenedType
//
// or you can write:
//
// typeinfo.FlattenedType
//
///
/// Flattened record version of the type
///
internal virtual md.RowType FlattenedType
{
get
{
return RootType.FlattenedType;
}
}
///
/// TypeUsage that encloses the Flattened record version of the type
///
internal virtual md.TypeUsage FlattenedTypeUsage
{
get
{
return RootType.FlattenedTypeUsage;
}
}
///
/// Get the property describing the entityset (if any)
///
internal virtual md.EdmProperty EntitySetIdProperty
{
get
{
return RootType.EntitySetIdProperty;
}
}
///
/// Does this type have an entitySetId property
///
internal bool HasEntitySetIdProperty
{
get
{
return RootType.EntitySetIdProperty != null;
}
}
///
/// Get the nullSentinel property (if any)
///
internal virtual md.EdmProperty NullSentinelProperty
{
get
{
return RootType.NullSentinelProperty;
}
}
///
/// Does this type have a nullSentinel property?
///
internal bool HasNullSentinelProperty
{
get
{
return RootType.NullSentinelProperty != null;
}
}
///
/// The typeid property in the flattened type - applies only to nominal types
/// this will be used as the type discriminator column.
///
internal virtual md.EdmProperty TypeIdProperty
{
get
{
return RootType.TypeIdProperty;
}
}
///
/// Does this type need a typeid property? (Needed for complex types and entity types in general)
///
internal bool HasTypeIdProperty
{
get
{
return RootType.TypeIdProperty != null;
}
}
///
/// All the properties of this type.
///
internal virtual IEnumerable PropertyRefList
{
get
{
return RootType.PropertyRefList;
}
}
///
/// Get the new property for the supplied propertyRef
///
/// property reference (on the old type)
///
/// Get the list of "key" properties (in the flattened type)
///
/// the key property equivalents in the flattened type
internal IEnumerable GetKeyPropertyRefs()
{
md.EntityTypeBase entityType = null;
md.RefType refType = null;
if (TypeHelpers.TryGetEdmType(m_type, out refType))
{
entityType = refType.ElementType;
}
else
{
entityType = TypeHelpers.GetEdmType(m_type);
}
// Walk through the list of keys of the entity type, and find their analogs in the
// "flattened" type
foreach (md.EdmMember p in entityType.KeyMembers)
{
// Eventually this could be RelationshipEndMember, but currently only properties are suppported as key members
PlanCompiler.Assert(p is md.EdmProperty, "Non-EdmProperty key members are not supported");
SimplePropertyRef spr = new SimplePropertyRef(p);
yield return spr;
}
}
///
/// Get the list of "identity" properties in the flattened type.
/// The identity properties include the entitysetid property, followed by the
/// key properties
///
/// List of identity properties
internal IEnumerable GetIdentityPropertyRefs()
{
if (this.HasEntitySetIdProperty)
{
yield return EntitySetIdPropertyRef.Instance;
}
foreach (PropertyRef p in this.GetKeyPropertyRefs())
{
yield return p;
}
}
///
/// Get the list of all properties in the flattened type
///
/// GetAllPropertyRefs()
{
foreach (PropertyRef p in this.PropertyRefList)
{
yield return p;
}
}
///
/// Get the list of all properties in the flattened type
///
/// GetAllProperties()
{
foreach (md.EdmProperty m in this.FlattenedType.Properties)
{
yield return m;
}
}
///
/// Gets all types in the hierarchy rooted at this.
///
internal List GetTypeHierarchy()
{
List result = new List();
GetTypeHierarchy(result);
return result;
}
///
/// Adds all types in the hierarchy to the given list.
///
private void GetTypeHierarchy(List result)
{
result.Add(this);
foreach (TypeInfo subType in this.ImmediateSubTypes)
{
subType.GetTypeHierarchy(result);
}
}
#endregion
}
///
/// A subclass of the TypeInfo class above that only represents information
/// about "root" types
///
internal class RootTypeInfo : TypeInfo
{
#region private state
private readonly List m_propertyRefList;
private readonly Dictionary m_propertyMap;
private md.EdmProperty m_nullSentinelProperty;
private md.EdmProperty m_typeIdProperty;
private TypeIdKind m_typeIdKind;
private md.TypeUsage m_typeIdType;
private readonly ExplicitDiscriminatorMap m_discriminatorMap;
private md.EdmProperty m_entitySetIdProperty;
private md.RowType m_flattenedType;
private md.TypeUsage m_flattenedTypeUsage;
#endregion
#region Constructor
///
/// Constructor for a root type
///
///
internal RootTypeInfo(md.TypeUsage type, ExplicitDiscriminatorMap discriminatorMap)
: base(type, null)
{
PlanCompiler.Assert(type.EdmType.BaseType == null, "only root types allowed here");
m_propertyMap = new Dictionary();
m_propertyRefList = new List();
m_discriminatorMap = discriminatorMap;
m_typeIdKind = TypeIdKind.Generated;
}
#endregion
#region "public" surface area
///
/// Kind of the typeid column (if any)
///
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal TypeIdKind TypeIdKind
{
get { return m_typeIdKind; }
set { m_typeIdKind = value; }
}
///
/// Datatype of the typeid column (if any)
///
internal md.TypeUsage TypeIdType
{
get { return m_typeIdType; }
set { m_typeIdType = value; }
}
///
/// Add a mapping from the propertyRef (of the old type) to the
/// corresponding property in the new type.
///
/// NOTE: Only to be used by StructuredTypeInfo
///
///
///
internal void AddPropertyMapping(PropertyRef propertyRef, md.EdmProperty newProperty)
{
m_propertyMap[propertyRef] = newProperty;
if (propertyRef is TypeIdPropertyRef)
{
m_typeIdProperty = newProperty;
}
else if (propertyRef is EntitySetIdPropertyRef)
{
m_entitySetIdProperty = newProperty;
}
else if (propertyRef is NullSentinelPropertyRef)
{
m_nullSentinelProperty = newProperty;
}
}
///
/// Adds a new property reference to the list of desired properties
/// NOTE: Only to be used by StructuredTypeInfo
///
///
internal void AddPropertyRef(PropertyRef propertyRef)
{
m_propertyRefList.Add(propertyRef);
}
///
/// Flattened record version of the type
///
internal new md.RowType FlattenedType
{
get
{
return m_flattenedType;
}
set
{
m_flattenedType = value;
m_flattenedTypeUsage = md.TypeUsage.Create(value);
}
}
///
/// TypeUsage that encloses the Flattened record version of the type
///
internal new md.TypeUsage FlattenedTypeUsage
{
get
{
return m_flattenedTypeUsage;
}
}
///
/// Gets map information for types mapped using simple discriminator pattern.
///
internal ExplicitDiscriminatorMap DiscriminatorMap
{
get
{
return m_discriminatorMap;
}
}
///
/// Get the property describing the entityset (if any)
///
internal new md.EdmProperty EntitySetIdProperty
{
get
{
return m_entitySetIdProperty;
}
}
internal new md.EdmProperty NullSentinelProperty
{
get
{
return m_nullSentinelProperty;
}
}
///
/// Get the list of property refs for this type
///
internal new IEnumerable PropertyRefList
{
get
{
return m_propertyRefList;
}
}
///
/// Determines the offset for structured types in Flattened type. For instance, if the original type is of the form:
///
/// { int X, ComplexType Y }
///
/// and the flattened type is of the form:
///
/// { int X, Y_ComplexType_Prop1, Y_ComplexType_Prop2 }
///
/// GetNestedStructureOffset(Y) returns 1
///
/// Complex property.
/// Offset.
internal int GetNestedStructureOffset(PropertyRef property)
{
// m_propertyRefList contains every element of the flattened type
for (int i = 0; i < m_propertyRefList.Count; i++)
{
NestedPropertyRef nestedPropertyRef = m_propertyRefList[i] as NestedPropertyRef;
// match offset of the first element of the complex type property
if (null != nestedPropertyRef && nestedPropertyRef.InnerProperty.Equals(property))
{
return i;
}
}
PlanCompiler.Assert(false, "no complex structure " + property + " found in TypeInfo");
// return something so that the compiler doesn't complain
return default(int);
}
///
/// Get the new property for the supplied propertyRef
///
/// property reference (on the old type)
///
/// The typeid property in the flattened type - applies only to nominal types
/// this will be used as the type discriminator column.
///
internal new md.EdmProperty TypeIdProperty
{
get
{
return m_typeIdProperty;
}
}
#endregion
}
}
// 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
- BaseCodeDomTreeGenerator.cs
- CapabilitiesRule.cs
- ShowExpandedMultiValueConverter.cs
- PartialArray.cs
- MetadataProperty.cs
- GeneralTransform3D.cs
- QuaternionAnimation.cs
- EmptyEnumerable.cs
- PolyLineSegment.cs
- WebScriptServiceHostFactory.cs
- Attributes.cs
- FormViewDeletedEventArgs.cs
- XamlVector3DCollectionSerializer.cs
- RuntimeHelpers.cs
- AnnotationResourceChangedEventArgs.cs
- XamlTreeBuilder.cs
- WrapPanel.cs
- Point3DKeyFrameCollection.cs
- ListCommandEventArgs.cs
- DataGridViewSortCompareEventArgs.cs
- GACMembershipCondition.cs
- RuleInfoComparer.cs
- SqlDependency.cs
- ArgumentNullException.cs
- HostingPreferredMapPath.cs
- Constants.cs
- ASCIIEncoding.cs
- PasswordDeriveBytes.cs
- SqlTriggerAttribute.cs
- DefaultHttpHandler.cs
- WriterOutput.cs
- CompilerGeneratedAttribute.cs
- StaticDataManager.cs
- XpsS0ValidatingLoader.cs
- DbMetaDataColumnNames.cs
- Triangle.cs
- Region.cs
- MethodImplAttribute.cs
- SqlXmlStorage.cs
- CultureSpecificStringDictionary.cs
- DynamicContractTypeBuilder.cs
- SecuritySessionClientSettings.cs
- MapPathBasedVirtualPathProvider.cs
- WebPartTransformerCollection.cs
- ObjectDataSource.cs
- storepermissionattribute.cs
- WindowsListViewScroll.cs
- NetMsmqBindingElement.cs
- XmlSchemaCollection.cs
- CompilerTypeWithParams.cs
- HTMLTextWriter.cs
- SessionStateItemCollection.cs
- Attributes.cs
- LogicalExpressionEditor.cs
- TextCharacters.cs
- Shape.cs
- ValueTypeFixupInfo.cs
- Point.cs
- MatrixAnimationBase.cs
- AdapterSwitches.cs
- CacheSection.cs
- TranslateTransform.cs
- SQLByte.cs
- CollectionContainer.cs
- ExtensionSurface.cs
- AttachedPropertyBrowsableWhenAttributePresentAttribute.cs
- DictionaryEntry.cs
- ListViewAutomationPeer.cs
- followingsibling.cs
- SID.cs
- MetadataCollection.cs
- DataGridViewCellCollection.cs
- EncoderParameter.cs
- HttpCachePolicyWrapper.cs
- Util.cs
- Wizard.cs
- WebPartUtil.cs
- RegistrationServices.cs
- XXXInfos.cs
- PropertyStore.cs
- ColorContextHelper.cs
- FilteredAttributeCollection.cs
- WebRequestModuleElementCollection.cs
- StorageComplexTypeMapping.cs
- DataListItemEventArgs.cs
- HTMLTextWriter.cs
- EncryptedData.cs
- ResourceReferenceExpression.cs
- XmlSchemaSimpleContentExtension.cs
- HandleRef.cs
- ResetableIterator.cs
- SharedPersonalizationStateInfo.cs
- HyperLinkColumn.cs
- OleCmdHelper.cs
- OpCellTreeNode.cs
- Line.cs
- UnionExpr.cs
- ActivationWorker.cs
- XPathException.cs
- StylusShape.cs