Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / EntityModel / SchemaObjectModel / Function.cs / 1305376 / Function.cs
//---------------------------------------------------------------------- //// Copyright (c) Microsoft Corporation. All rights reserved. // // // @owner [....] // @backupOwner [....] //--------------------------------------------------------------------- using System; using System.Collections; using System.Collections.Generic; using System.Collections.Specialized; using System.Diagnostics; using System.Globalization; using System.Xml; using System.Xml.Schema; using System.Data; using System.IO; using System.Data.Metadata.Edm; using System.Data.Entity; namespace System.Data.EntityModel.SchemaObjectModel { ////// class representing the Schema element in the schema /// internal class Function : SchemaType { #region Instance Fields // if adding properties also add to InitializeObject()! private bool _isAggregate = false; private bool _isBuiltIn = false; private bool _isNiladicFunction = false; protected bool _isComposable = true; private string _unresolvedEntitySet = null; protected FunctionCommandText _commandText = null; private string _storeFunctionName = null; protected SchemaType _type = null; private string _unresolvedType = null; protected bool _isRefType = false; // both are not specified protected SchemaElementLookUpTable_parameters = null; protected ReturnType _returnType = null; private CollectionKind _returnTypeCollectionKind = CollectionKind.None; private ParameterTypeSemantics _parameterTypeSemantics; private EntityContainer _container = null; // container is known only for function imports private EntityContainerEntitySet _entitySet = null; private string _schema; private string _functionStrongName; #endregion #region Static Fields private static System.Text.RegularExpressions.Regex s_typeParser = new System.Text.RegularExpressions.Regex(@"^(? ((Collection)|(Ref)))\s*\(\s*(? \S*)\s*\)$", System.Text.RegularExpressions.RegexOptions.Compiled); /// /// /// /// ///internal static void RemoveTypeModifier(ref string type, out TypeModifier typeModifier, out bool isRefType) { isRefType = false; typeModifier = TypeModifier.None; System.Text.RegularExpressions.Match match = s_typeParser.Match(type); if (match.Success) { type = match.Groups["typeName"].Value; switch (match.Groups["modifier"].Value) { case "Collection": typeModifier = TypeModifier.Array; return; case "Ref": isRefType = true; return; default: Debug.Assert(false, "Unexpected modifier: " + match.Groups["modifier"].Value); break; } } } #endregion #region Public Methods /// /// ctor for a schema function /// public Function(Schema parentElement) : base(parentElement) { } ////// ctor for a function import, which is scoped to the entity container /// /// Parent container; must not be null. protected Function(EntityContainer container) : base(container.Schema) { if (Schema.DataModel == SchemaDataModelOption.EntityDataModel) OtherContent.Add(Schema.SchemaSource); Debug.Assert(null != container); _container = container; // override defaults for function imports _isComposable = false; } #endregion #region Public Properties public bool IsAggregate { get { return _isAggregate; } internal set { _isAggregate = value; } } public bool IsBuiltIn { get { return _isBuiltIn; } internal set { _isBuiltIn = value; } } public bool IsNiladicFunction { get { return _isNiladicFunction; } internal set { _isNiladicFunction = value; } } public bool IsComposable { get { return _isComposable; } internal set { _isComposable = value; } } public string CommandText { get { if (_commandText != null) { return _commandText.CommandText; } return null; } } public ParameterTypeSemantics ParameterTypeSemantics { get { return _parameterTypeSemantics; } internal set { _parameterTypeSemantics = value; } } public string StoreFunctionName { get { return _storeFunctionName; } internal set { Debug.Assert(value != null, "StoreFunctionName should never be set null value"); _storeFunctionName = value; } } public virtual SchemaType Type { get { if (null != this.ReturnType) { return this.ReturnType.Type; } else return this._type; } } public ReturnType ReturnType { get { return this._returnType; } } public SchemaElementLookUpTableParameters { get { if (_parameters == null) { _parameters = new SchemaElementLookUpTable (); } return _parameters; } } public CollectionKind CollectionKind { get { return _returnTypeCollectionKind; } internal set { _returnTypeCollectionKind = value; } } public override string Identity { get { if (String.IsNullOrEmpty(_functionStrongName)) { string name = this.FQName; System.Text.StringBuilder stringBuilder = new Text.StringBuilder(name); bool first = true; stringBuilder.Append('('); foreach (Parameter parameter in this.Parameters) { if (!first) { stringBuilder.Append(','); } else { first = false; } stringBuilder.Append(Helper.ToString(parameter.ParameterDirection)); stringBuilder.Append(' '); // we don't include the facets in the identity, since we are *not* // taking them into consideration inside the // RankFunctionParameters method of TypeResolver.cs parameter.WriteIdentity(stringBuilder); } stringBuilder.Append(')'); _functionStrongName = stringBuilder.ToString(); } return _functionStrongName; } } public bool IsReturnAttributeReftype { get { return _isRefType; } } public virtual bool IsFunctionImport { get { return false; } } public EntityContainerEntitySet EntitySet { get { return _entitySet; } } public string DbSchema { get { return _schema; } } #endregion #region Protected Properties protected override bool HandleElement(XmlReader reader) { if (base.HandleElement(reader)) { return true; } else if (CanHandleElement(reader, XmlConstants.CommandText)) { HandleCommandTextFunctionElment(reader); return true; } else if (CanHandleElement(reader, XmlConstants.Parameter)) { HandleParameterElement(reader); return true; } else if (CanHandleElement(reader, XmlConstants.ReturnTypeElement)) { if (ParentElement.Schema.DataModel == SchemaDataModelOption.ProviderManifestModel || ParentElement.Schema.DataModel == SchemaDataModelOption.EntityDataModel) { HandleReturnTypeElement(reader); } else { SkipThroughElement(reader); } return true; } return false; } protected override bool HandleAttribute(XmlReader reader) { if (base.HandleAttribute(reader)) { return true; } else if (CanHandleAttribute(reader, XmlConstants.ReturnType)) { HandleReturnTypeAttribute(reader); return true; } else if (CanHandleAttribute(reader, XmlConstants.AggregateAttribute)) { HandleAggregateAttribute(reader); return true; } else if (CanHandleAttribute(reader, XmlConstants.BuiltInAttribute)) { HandleBuiltInAttribute(reader); return true; } else if (CanHandleAttribute(reader, XmlConstants.StoreFunctionName)) { HandleStoreFunctionNameAttribute(reader); return true; } else if (CanHandleAttribute(reader, XmlConstants.NiladicFunction)) { HandleNiladicFunctionAttribute(reader); return true; } else if (CanHandleAttribute(reader, XmlConstants.IsComposable)) { HandleIsComposableFunctionAttribute(reader); return true; } else if (CanHandleAttribute(reader, XmlConstants.ParameterTypeSemantics)) { HandleParameterTypeSemanticsAttribute(reader); return true; } else if (CanHandleAttribute(reader, XmlConstants.Schema)) { HandleDbSchemaAttribute(reader); return true; } else if (CanHandleAttribute(reader, XmlConstants.EntitySet)) { HandleEntitySetAttribute(reader); return true; } return false; } #endregion #region Internal Methods internal override void ResolveTopLevelNames() { base.ResolveTopLevelNames(); if (ReturnType != null) { // provider manifest Debug.Assert(Schema.DataModel == SchemaDataModelOption.ProviderManifestModel, "Only ProviderManifest will allow ReturnType elements"); ReturnType.ResolveTopLevelNames(); } else { // if resolved, then the _type is not null any more Debug.Assert(this._type == null, "This must be resolved exactly once"); if (null != UnresolvedReturnType) { Debug.Assert(Schema.DataModel != SchemaDataModelOption.ProviderManifestModel, "ProviderManifest cannot have ReturnType as an attribute"); if (Schema.ResolveTypeName(this, UnresolvedReturnType, out _type)) { if (this.IsFunctionImport) { //csdl if (!MeetsFunctionImportReturnTypeRequirements(_type)) { AddError(ErrorCode.FunctionImportUnsupportedReturnType, EdmSchemaErrorSeverity.Error, this, GetReturnTypeErrorMessage(Schema.SchemaVersion, this.Name) ); } } else if(Schema.DataModel == SchemaDataModelOption.ProviderDataModel) { // ssdl if (!(_type is ScalarType)) { AddError(ErrorCode.FunctionWithNonScalarTypeNotSupported, EdmSchemaErrorSeverity.Error, this, System.Data.Entity.Strings.FunctionWithNonScalarTypeNotSupported(_type.FQName, this.FQName)); } } } } } if (IsFunctionImport) { Debug.Assert(null != _container, "function imports must know container"); // resolve entity set if (null == _entitySet && null != _unresolvedEntitySet) { _entitySet = _container.FindEntitySet(_unresolvedEntitySet); if (null == _entitySet) { AddError(ErrorCode.FunctionImportUnknownEntitySet, EdmSchemaErrorSeverity.Error, System.Data.Entity.Strings.FunctionImportUnknownEntitySet(_unresolvedEntitySet, this.Name)); } } } foreach (Parameter parameter in this.Parameters) { parameter.ResolveTopLevelNames(); } } private bool MeetsFunctionImportReturnTypeRequirements(SchemaType type) { if (_type is ScalarType && _returnTypeCollectionKind == CollectionKind.Bag) return true; if (_type is SchemaEntityType && _returnTypeCollectionKind == CollectionKind.Bag) return true; if (Schema.SchemaVersion == XmlConstants.EdmVersionForV1_1) { if (_type is ScalarType && _returnTypeCollectionKind == CollectionKind.None) return true; if (_type is SchemaEntityType && _returnTypeCollectionKind == CollectionKind.None) return true; if (_type is SchemaComplexType && _returnTypeCollectionKind == CollectionKind.None) return true; if (_type is SchemaComplexType && _returnTypeCollectionKind == CollectionKind.Bag) return true; } if (Schema.SchemaVersion == XmlConstants.EdmVersionForV2) { if (_type is SchemaComplexType && _returnTypeCollectionKind == CollectionKind.Bag) return true; } return false; } private string GetReturnTypeErrorMessage(double schemaVersion, string functionName) { string errorMessage; if (Schema.SchemaVersion == XmlConstants.EdmVersionForV1) { errorMessage = Strings.FunctionImportWithUnsupportedReturnTypeV1(functionName); } else if (Schema.SchemaVersion == XmlConstants.EdmVersionForV1_1) { errorMessage = Strings.FunctionImportWithUnsupportedReturnTypeV1_1(functionName); } else { Debug.Assert( XmlConstants.EdmVersionForV2 == XmlConstants.SchemaVersionLatest, "Please update the error message accordingly"); errorMessage = Strings.FunctionImportWithUnsupportedReturnTypeV2(functionName); } return errorMessage; } /// /// Perform local validation on function definition. /// internal override void Validate() { base.Validate(); if (_returnType != null && _type != null) { AddError(ErrorCode.ReturnTypeDeclaredAsAttributeAndElement, EdmSchemaErrorSeverity.Error, Strings.ReturnTypeDeclaredAsAttributeAndElement); } if (_commandText != null) { _commandText.Validate(); } if (Schema.DataModel != SchemaDataModelOption.EntityDataModel) { if (null == this.Type) { // only non-composable types can omit return type if (this.IsComposable) { AddError(ErrorCode.ComposableFunctionWithoutReturnType, EdmSchemaErrorSeverity.Error, Strings.ComposableFunctionMustDeclareReturnType); } } else { // non-composable functions may not declare a return type (except for function imports) if (!this.IsComposable && !this.IsFunctionImport) { AddError(ErrorCode.NonComposableFunctionWithReturnType, EdmSchemaErrorSeverity.Error, Strings.NonComposableFunctionMustNotDeclareReturnType); } } if (IsAggregate) { // Make sure that the function has exactly one parameter and that takes // a collection type if (Parameters.Count != 1) { AddError(ErrorCode.InvalidNumberOfParametersForAggregateFunction, EdmSchemaErrorSeverity.Error, this, System.Data.Entity.Strings.InvalidNumberOfParametersForAggregateFunction(FQName)); } else if (Parameters.GetElementAt(0).CollectionKind == CollectionKind.None) { // Since we have already checked that there should be exactly one parameter, it should be safe to get the // first parameter for the function Parameter param = Parameters.GetElementAt(0); AddError(ErrorCode.InvalidParameterTypeForAggregateFunction, EdmSchemaErrorSeverity.Error, this, System.Data.Entity.Strings.InvalidParameterTypeForAggregateFunction(param.Name, FQName)); } } if (!this.IsComposable) { // non-composable functions do not permit aggregate, build-in, or niladic attribute if (this.IsAggregate || this.IsNiladicFunction || this.IsBuiltIn) { AddError(ErrorCode.NonComposableFunctionAttributesNotValid, EdmSchemaErrorSeverity.Error, Strings.NonComposableFunctionHasDisallowedAttribute); } } if (null != this.CommandText) { // functions with command text are not composable if (this.IsComposable) { AddError(ErrorCode.ComposableFunctionWithCommandText, EdmSchemaErrorSeverity.Error, Strings.CommandTextFunctionsNotComposable); } // functions with command text cannot declare store function name if (null != this.StoreFunctionName) { AddError(ErrorCode.FunctionDeclaresCommandTextAndStoreFunctionName, EdmSchemaErrorSeverity.Error, Strings.CommandTextFunctionsCannotDeclareStoreFunctionName); } } } if (this.IsFunctionImport) { ValidateReturnType(this.Type); } } internal override void ResolveSecondLevelNames() { foreach (var parameter in _parameters) { parameter.ResolveSecondLevelNames(); } } ////// validate the following negative scenarios: /// ReturnType="Collection(EntityTypeA)" /// ReturnType="Collection(EntityTypeA)" EntitySet="ESet.EType is not oftype EntityTypeA" /// EntitySet="A" /// ReturnType="Collection(ComplexTypeA)" EntitySet="something" /// ReturnType="Collection(ComplexTypeA)", but the ComplexTypeA has a nested complexType property, this scenario will be handle in the runtime /// /// private void ValidateReturnType(SchemaType returnType) { // if entity type, verify specification of entity set and that the type is appropriate // for the entity set SchemaEntityType entityType = returnType as SchemaEntityType; if (null != entityType) { // entity type if (null == this.EntitySet) { // ReturnType="Collection(EntityTypeA)" AddError(ErrorCode.FunctionImportReturnsEntitiesButDoesNotSpecifyEntitySet, EdmSchemaErrorSeverity.Error, System.Data.Entity.Strings.FunctionImportReturnEntitiesButDoesNotSpecifyEntitySet(this.Name)); } else if (null != this.EntitySet.EntityType && !entityType.IsOfType(this.EntitySet.EntityType)) { // ReturnType="Collection(EntityTypeA)" EntitySet="ESet.EType is not oftype EntityTypeA" AddError(ErrorCode.FunctionImportEntityTypeDoesNotMatchEntitySet, EdmSchemaErrorSeverity.Error, System.Data.Entity.Strings.FunctionImportEntityTypeDoesNotMatchEntitySet( this.FQName, this.EntitySet.EntityType.FQName, this.EntitySet.Name, this.ParentElement.FQName)); } } else { // complex type SchemaComplexType complexType = returnType as SchemaComplexType; if (null != complexType) { if (null != EntitySet) { // ReturnType="Collection(ComplexTypeA)" EntitySet="something" AddError( ErrorCode.ComplexTypeAsReturnTypeAndDefinedEntitySet, EdmSchemaErrorSeverity.Error, this.LineNumber, this.LinePosition, System.Data.Entity.Strings.ComplexTypeAsReturnTypeAndDefinedEntitySet( this.Name, complexType.Name, EntitySet.Name)); } } else { // scalar type or no return type if (null != EntitySet) { // EntitySet="A" AddError(ErrorCode.FunctionImportSpecifiesEntitySetButDoesNotReturnEntityType, EdmSchemaErrorSeverity.Error, System.Data.Entity.Strings.FunctionImportSpecifiesEntitySetButNotEntityType(this.Name, this.ParentElement.FQName)); } } } } internal override SchemaElement Clone(SchemaElement parentElement) { Debug.Assert(IsFunctionImport, "we only support clone for FunctionImports"); Function function = new FunctionImportElement((EntityContainer)parentElement); function._isAggregate = _isAggregate; function._isBuiltIn = _isBuiltIn; function._isNiladicFunction = _isNiladicFunction; function._isComposable = _isComposable; function._entitySet = _entitySet; function._commandText = _commandText; function._storeFunctionName = _storeFunctionName; function._type = _type; function._returnType = _returnType; function._returnTypeCollectionKind = _returnTypeCollectionKind; function._parameterTypeSemantics = _parameterTypeSemantics; function._schema = _schema; function.Name = this.Name; // Clone all the parameters foreach (Parameter parameter in this.Parameters) { AddErrorKind error = function.Parameters.TryAdd((Parameter)parameter.Clone(function)); Debug.Assert(error == AddErrorKind.Succeeded, "Since we are cloning a validated function, this should never fail"); } return function; } #endregion #region Internal Properties ////// /// ///internal string UnresolvedReturnType { get { return _unresolvedType; } set { _unresolvedType = value; } } #endregion //Internal Properties #region Private Methods /// /// The method that is called when a DbSchema attribute is encountered. /// /// An XmlReader positioned at the Type attribute. private void HandleDbSchemaAttribute(XmlReader reader) { Debug.Assert(Schema.DataModel == SchemaDataModelOption.ProviderDataModel, "We shouldn't see this attribute unless we are parsing ssdl"); Debug.Assert(reader != null); _schema = reader.Value; } ////// Handler for the Version attribute /// /// xml reader currently positioned at Version attribute private void HandleAggregateAttribute(XmlReader reader) { Debug.Assert(reader != null); bool isAggregate = false; HandleBoolAttribute(reader, ref isAggregate); IsAggregate = isAggregate; } ////// Handler for the Namespace attribute /// /// xml reader currently positioned at Namespace attribute private void HandleBuiltInAttribute(XmlReader reader) { Debug.Assert(reader != null); bool isBuiltIn = false; HandleBoolAttribute(reader, ref isBuiltIn); IsBuiltIn = isBuiltIn; } ////// Handler for the Alias attribute /// /// xml reader currently positioned at Alias attribute private void HandleStoreFunctionNameAttribute(XmlReader reader) { Debug.Assert(reader != null); string value = reader.Value.ToString(); if (!String.IsNullOrEmpty(value)) { value = value.Trim(); StoreFunctionName = value; } } ////// Handler for the NiladicFunction attribute /// /// xml reader currently positioned at Namespace attribute private void HandleNiladicFunctionAttribute(XmlReader reader) { Debug.Assert(reader != null); bool isNiladicFunction = false; HandleBoolAttribute(reader, ref isNiladicFunction); IsNiladicFunction = isNiladicFunction; } ////// Handler for the IsComposable attribute /// /// xml reader currently positioned at Namespace attribute private void HandleIsComposableFunctionAttribute(XmlReader reader) { Debug.Assert(reader != null); bool isComposable = true; HandleBoolAttribute(reader, ref isComposable); IsComposable = isComposable; } private void HandleCommandTextFunctionElment(XmlReader reader) { Debug.Assert(reader != null); FunctionCommandText commandText = new FunctionCommandText(this); commandText.Parse(reader); _commandText = commandText; } protected virtual void HandleReturnTypeAttribute(XmlReader reader) { Debug.Assert(reader != null); Debug.Assert(UnresolvedReturnType == null); string type; if (!Utils.GetString(Schema, reader, out type)) return; TypeModifier typeModifier; RemoveTypeModifier(ref type, out typeModifier, out _isRefType); switch (typeModifier) { case TypeModifier.Array: CollectionKind = CollectionKind.Bag; break; case TypeModifier.None: break; default: Debug.Assert(false, "RemoveTypeModifier already checks for this"); break; } if (!Utils.ValidateDottedName(Schema, reader, type)) return; UnresolvedReturnType = type; } ////// Handler for the Parameter Element /// /// xml reader currently positioned at Parameter Element protected void HandleParameterElement(XmlReader reader) { Debug.Assert(reader != null); Parameter parameter = new Parameter(this); parameter.Parse(reader); Parameters.Add(parameter, true, Strings.ParameterNameAlreadyDefinedDuplicate); } ////// Handler for the ReturnType element /// /// xml reader currently positioned at ReturnType element protected void HandleReturnTypeElement(XmlReader reader) { Debug.Assert(reader != null); ReturnType returnType = new ReturnType(this); returnType.Parse(reader); this._returnType = returnType; } ////// Handles ParameterTypeSemantics attribute /// /// private void HandleParameterTypeSemanticsAttribute(XmlReader reader) { Debug.Assert(reader != null); string value = reader.Value; if (String.IsNullOrEmpty(value)) { return; } value = value.Trim(); if (!String.IsNullOrEmpty(value)) { switch (value) { case "ExactMatchOnly": ParameterTypeSemantics = ParameterTypeSemantics.ExactMatchOnly; break; case "AllowImplicitPromotion": ParameterTypeSemantics = ParameterTypeSemantics.AllowImplicitPromotion; break; case "AllowImplicitConversion": ParameterTypeSemantics = ParameterTypeSemantics.AllowImplicitConversion; break; default: // don't try to use the name of the function, because we are still parsing the // attributes, and we may not be to the name attribute yet. AddError(ErrorCode.InvalidValueForParameterTypeSemantics, EdmSchemaErrorSeverity.Error, reader, System.Data.Entity.Strings.InvalidValueForParameterTypeSemanticsAttribute( value)); break; } } } ////// Handler for the EntitySet attribute /// /// xml reader currently positioned at EntitySet attribute private void HandleEntitySetAttribute(XmlReader reader) { Debug.Assert(reader != null); string entitySetName; if (Utils.GetString(Schema, reader, out entitySetName)) { _unresolvedEntitySet = entitySetName; } } #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
- LiteralControl.cs
- XmlArrayAttribute.cs
- _HTTPDateParse.cs
- GeneralTransformCollection.cs
- ReadContentAsBinaryHelper.cs
- DataSourceXmlSubItemAttribute.cs
- ExceptionWrapper.cs
- HttpCacheParams.cs
- TypeValidationEventArgs.cs
- DateTimeStorage.cs
- MsmqIntegrationChannelFactory.cs
- ComponentCommands.cs
- GeometryConverter.cs
- InlineUIContainer.cs
- ConstNode.cs
- ObjectHandle.cs
- FilterEventArgs.cs
- CacheAxisQuery.cs
- ServiceObjectContainer.cs
- FunctionImportElement.cs
- TabRenderer.cs
- RankException.cs
- Int16KeyFrameCollection.cs
- Timer.cs
- EntityKeyElement.cs
- ImageSourceConverter.cs
- QueryLifecycle.cs
- SignatureHelper.cs
- ValidationErrorInfo.cs
- TrustManagerPromptUI.cs
- TextDpi.cs
- SimpleWorkerRequest.cs
- _SafeNetHandles.cs
- ExternalException.cs
- StaticExtensionConverter.cs
- BrowserInteropHelper.cs
- SByte.cs
- SecurityChannelFaultConverter.cs
- UnionExpr.cs
- CapabilitiesUse.cs
- SimpleWebHandlerParser.cs
- Int64Storage.cs
- CombinedGeometry.cs
- base64Transforms.cs
- DotExpr.cs
- FontStretch.cs
- HWStack.cs
- IResourceProvider.cs
- UnmanagedHandle.cs
- ScriptBehaviorDescriptor.cs
- ByteStream.cs
- UIAgentInitializationException.cs
- HashAlgorithm.cs
- OleDbRowUpdatingEvent.cs
- GridViewEditEventArgs.cs
- EventSinkActivityDesigner.cs
- ExtenderControl.cs
- RuleInfoComparer.cs
- DataGridViewComboBoxCell.cs
- DataGridBoolColumn.cs
- RequestContext.cs
- QueryConverter.cs
- WhitespaceSignificantCollectionAttribute.cs
- XmlSiteMapProvider.cs
- X509SubjectKeyIdentifierClause.cs
- Function.cs
- InvalidAsynchronousStateException.cs
- GlobalizationSection.cs
- ActiveXContainer.cs
- ExplicitDiscriminatorMap.cs
- Matrix.cs
- Fonts.cs
- Int32Storage.cs
- TriggerActionCollection.cs
- ObjectHandle.cs
- WebServiceMethodData.cs
- ManagedIStream.cs
- CreateRefExpr.cs
- DecoderReplacementFallback.cs
- PrimitiveXmlSerializers.cs
- ObjectView.cs
- AssemblyHash.cs
- PreviewPageInfo.cs
- UseLicense.cs
- ZipIOEndOfCentralDirectoryBlock.cs
- PointHitTestResult.cs
- ListViewDataItem.cs
- HttpClientCertificate.cs
- AcceleratedTokenProvider.cs
- DataRowChangeEvent.cs
- DrawingBrush.cs
- RadioButtonAutomationPeer.cs
- MsmqHostedTransportManager.cs
- Avt.cs
- ContextBase.cs
- ActivitiesCollection.cs
- Convert.cs
- ActionItem.cs
- Vector.cs
- HMAC.cs