basemetadatamappingvisitor.cs source code in C# .NET

                        
Code:
                         / Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / ndp / fx / src / DataEntity / System / Data / Mapping / basemetadatamappingvisitor.cs / 1 / basemetadatamappingvisitor.cs
                        

                        
                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
 
// @owner       [....]
// @backupOwner [....] 
//--------------------------------------------------------------------- 

using System; 
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Metadata.Edm; 
using System.Data.Common;
using System.Data.Common.Utils; 
using System.Data.Mapping; 
using System.Diagnostics;
using System.Globalization; 

namespace System.Data.Mapping
{
    internal abstract class BaseMetadataMappingVisitor 
    {
        protected BaseMetadataMappingVisitor() 
        { 
        }
 
        protected virtual void Visit(StorageEntityContainerMapping storageEntityContainerMapping)
        {
            Visit(storageEntityContainerMapping.EdmEntityContainer);
            Visit(storageEntityContainerMapping.StorageEntityContainer); 
            foreach (var mapping in storageEntityContainerMapping.EntitySetMaps)
            { 
                Visit(mapping); 
            }
        } 

        protected virtual void Visit(EntitySetBase entitySetBase)
        {
            // this is a switching node, so no object header and footer will be add for this node, 
            // also this Visit won't add the object to the seen list
 
            switch (entitySetBase.BuiltInTypeKind) 
            {
                case BuiltInTypeKind.EntitySet: 
                    Visit((EntitySet)entitySetBase);
                    break;
                case BuiltInTypeKind.AssociationSet:
                    Visit((AssociationSet)entitySetBase); 
                    break;
                default: 
                    Debug.Fail(string.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", entitySetBase.BuiltInTypeKind)); 
                    break;
            } 
        }

        protected virtual void Visit(StorageSetMapping storageSetMapping)
        { 
            foreach (var typeMapping in storageSetMapping.TypeMappings)
            { 
                Visit(typeMapping); 
            }
            Visit(storageSetMapping.EntityContainerMapping); 
        }

        protected virtual void Visit(EntityContainer entityContainer)
        { 
            foreach (var set in entityContainer.BaseEntitySets)
            { 
                Visit(set); 
            }
        } 

        protected virtual void Visit(EntitySet entitySet)
        {
            Visit(entitySet.ElementType); 
            Visit(entitySet.EntityContainer);
        } 
 
        protected virtual void Visit(AssociationSet associationSet)
        { 
            Visit(associationSet.ElementType);
            Visit(associationSet.EntityContainer);
            foreach (var end in associationSet.AssociationSetEnds)
            { 
                Visit(end);
            } 
        } 
        protected virtual void Visit(EntityType entityType)
        { 
            foreach (var kmember in entityType.KeyMembers)
            {
                Visit(kmember);
            } 

            foreach (var member in entityType.GetDeclaredOnlyMembers()) 
            { 
                Visit(member);
            } 

            foreach (var nproperty in entityType.NavigationProperties)
            {
                Visit(nproperty); 
            }
 
            foreach (var property in entityType.Properties) 
            {
                Visit(property); 
            }
        }

        protected virtual void Visit(AssociationType associationType) 
        {
            foreach (var endMember in associationType.AssociationEndMembers) 
            { 
                Visit(endMember);
            } 
            Visit(associationType.BaseType);
            foreach (var keyMember in associationType.KeyMembers)
            {
                Visit(keyMember); 
            }
            foreach (var member in associationType.GetDeclaredOnlyMembers()) 
            { 
                Visit(member);
            } 
            foreach (var item in associationType.ReferentialConstraints)
            {
                Visit(item);
            } 
            foreach (var item in associationType.RelationshipEndMembers)
            { 
                Visit(item); 
            }
        } 

        protected virtual void Visit(AssociationSetEnd associationSetEnd)
        {
            Visit(associationSetEnd.CorrespondingAssociationEndMember); 
            Visit(associationSetEnd.EntitySet);
            Visit(associationSetEnd.ParentAssociationSet); 
        } 
        protected virtual void Visit(EdmProperty edmProperty)
        { 
            Visit(edmProperty.TypeUsage);
        }
        protected virtual void Visit(NavigationProperty navigationProperty)
        { 
            Visit(navigationProperty.FromEndMember);
            Visit(navigationProperty.RelationshipType); 
            Visit(navigationProperty.ToEndMember); 
            Visit(navigationProperty.TypeUsage);
        } 

        protected virtual void Visit(EdmMember edmMember)
        {
            Visit(edmMember.TypeUsage); 
        }
        protected virtual void Visit(AssociationEndMember associationEndMember) 
        { 
            Visit(associationEndMember.TypeUsage);
        } 

        protected virtual void Visit(ReferentialConstraint referentialConstraint)
        {
            foreach (var property in referentialConstraint.FromProperties) 
            {
                Visit(property); 
            } 
            Visit(referentialConstraint.FromRole);
 
            foreach (var property in referentialConstraint.ToProperties)
            {
                Visit(property);
            } 
            Visit(referentialConstraint.ToRole);
        } 
        protected virtual void Visit(RelationshipEndMember relationshipEndMember) 
        {
            Visit(relationshipEndMember.TypeUsage); 
        }
        protected virtual void Visit(TypeUsage typeUsage)
        {
            Visit(typeUsage.EdmType); 
            foreach (var facet in typeUsage.Facets)
            { 
                Visit(facet); 
            }
        } 
        protected virtual void Visit(RelationshipType relationshipType)
        {
            // switching node, will not be add to the seen list
            if (relationshipType == null) 
            {
                return; 
            } 

            #region Inner data visit 
            switch (relationshipType.BuiltInTypeKind)
            {
                case BuiltInTypeKind.AssociationType:
                    Visit((AssociationType)relationshipType); 
                    break;
                default: 
                    Debug.Fail(String.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", relationshipType.BuiltInTypeKind)); 
                    break;
            } 
            #endregion
        }
        protected virtual void Visit(EdmType edmType)
        { 
            // switching node, will not be add to the seen list
            if (edmType == null) 
            { 
                return;
            } 

            #region Inner data visit
            switch (edmType.BuiltInTypeKind)
            { 
                case BuiltInTypeKind.EntityType:
                    Visit((EntityType)edmType); 
                    break; 
                case BuiltInTypeKind.AssociationType:
                    Visit((AssociationType)edmType); 
                    break;
                case BuiltInTypeKind.EdmFunction:
                    Visit((EdmFunction)edmType);
                    break; 
                case BuiltInTypeKind.ComplexType:
                    Visit((ComplexType)edmType); 
                    break; 
                case BuiltInTypeKind.PrimitiveType:
                    Visit((PrimitiveType)edmType); 
                    break;
                case BuiltInTypeKind.RefType:
                    Visit((RefType)edmType);
                    break; 
                case BuiltInTypeKind.CollectionType:
                    Visit((CollectionType)edmType); 
                    break; 
                case BuiltInTypeKind.EnumType:
                    Visit((EnumType)edmType); 
                    break;
                default:
                    Debug.Fail(String.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", edmType.BuiltInTypeKind));
                    break; 
            }
            #endregion 
        } 
        protected virtual void Visit(Facet facet)
        { 
            Visit(facet.FacetType);
        }
        protected virtual void Visit(EdmFunction edmFunction)
        { 
            Visit(edmFunction.BaseType);
            Visit(edmFunction.EntitySet); 
            foreach (var functionParameter in edmFunction.Parameters) 
            {
                Visit(functionParameter); 
            }

            Visit(edmFunction.ReturnParameter);
        } 
        protected virtual void Visit(PrimitiveType primitiveType)
        { 
        } 
        protected virtual void Visit(ComplexType complexType)
        { 
            Visit(complexType.BaseType);
            foreach (var member in complexType.Members)
            {
                Visit(member); 
            }
            foreach (var property in complexType.Properties) 
            { 
                Visit(property);
            } 
        }
        protected virtual void Visit(RefType refType)
        {
            Visit(refType.BaseType); 
            Visit(refType.ElementType);
        } 
        protected virtual void Visit(EnumType enumType) 
        {
            foreach (var member in enumType.EnumMembers) 
            {
                Visit(member);
            }
        } 
        protected virtual void Visit(EnumMember enumMember)
        { 
        } 
        protected virtual void Visit(CollectionType collectionType)
        { 
            Visit(collectionType.BaseType);
            Visit(collectionType.TypeUsage);
        }
        protected virtual void Visit(EntityTypeBase entityTypeBase) 
        {
            // switching node 
            if (entityTypeBase == null) 
            {
                return; 
            }
            switch (entityTypeBase.BuiltInTypeKind)
            {
                case BuiltInTypeKind.AssociationType: 
                    Visit((AssociationType)entityTypeBase);
                    break; 
                case BuiltInTypeKind.EntityType: 
                    Visit((EntityType)entityTypeBase);
                    break; 
                default:
                    Debug.Fail(String.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", entityTypeBase.BuiltInTypeKind));
                    break;
            } 
        }
        protected virtual void Visit(FunctionParameter functionParameter) 
        { 
            Visit(functionParameter.DeclaringFunction);
            Visit(functionParameter.TypeUsage); 
        }
        protected virtual void Visit(DbProviderManifest providerManifest)
        {
        } 
        protected virtual void Visit(StorageTypeMapping storageTypeMapping)
        { 
            foreach (var type in storageTypeMapping.IsOfTypes) 
            {
                Visit(type); 
            }

            foreach (var fragment in storageTypeMapping.MappingFragments)
            { 
                Visit(fragment);
            } 
 
            Visit(storageTypeMapping.SetMapping);
 
            foreach (var type in storageTypeMapping.Types)
            {
                Visit(type);
            } 
        }
        protected virtual void Visit(StorageMappingFragment storageMappingFragment) 
        { 
            foreach (var property in storageMappingFragment.AllProperties)
            { 
                Visit(property);
            }

            Visit((EntitySetBase)storageMappingFragment.TableSet); 
        }
        protected virtual void Visit(StoragePropertyMapping storagePropertyMapping) 
        { 
            // this is a switching node, so no object header and footer will be add for this node,
            // also this Visit won't add the object to the seen list 

            if (storagePropertyMapping.GetType() == typeof(StorageComplexPropertyMapping))
            {
                Visit((StorageComplexPropertyMapping)storagePropertyMapping); 
            }
            else if (storagePropertyMapping.GetType() == typeof(StorageConditionPropertyMapping)) 
            { 
                Visit((StorageConditionPropertyMapping)storagePropertyMapping);
            } 
            else if (storagePropertyMapping.GetType() == typeof(StorageScalarPropertyMapping))
            {
                Visit((StorageScalarPropertyMapping)storagePropertyMapping);
            } 
            else
            { 
                Debug.Fail(String.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", storagePropertyMapping.GetType())); 
            }
        } 
        protected virtual void Visit(StorageComplexPropertyMapping storageComplexPropertyMapping)
        {
            Visit(storageComplexPropertyMapping.EdmProperty);
            foreach (var mapping in storageComplexPropertyMapping.TypeMappings) 
            {
                Visit(mapping); 
            } 
        }
        protected virtual void Visit(StorageConditionPropertyMapping storageConditionPropertyMapping) 
        {
            Visit(storageConditionPropertyMapping.ColumnProperty);
            Visit(storageConditionPropertyMapping.EdmProperty);
        } 
        protected virtual void Visit(StorageScalarPropertyMapping storageScalarPropertyMapping)
        { 
            Visit(storageScalarPropertyMapping.ColumnProperty); 
            Visit(storageScalarPropertyMapping.EdmProperty);
        } 

        protected virtual void Visit(StorageComplexTypeMapping storageComplexTypeMapping)
        {
            foreach (var property in storageComplexTypeMapping.AllProperties) 
            {
                Visit(property); 
            } 

            foreach (var type in storageComplexTypeMapping.IsOfTypes) 
            {
                Visit(type);
            }
 
            foreach (var type in storageComplexTypeMapping.Types)
            { 
                Visit(type); 
            }
        } 
    }
}

// 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.Linq;
using System.Text;
using System.Data.Metadata.Edm; 
using System.Data.Common;
using System.Data.Common.Utils; 
using System.Data.Mapping; 
using System.Diagnostics;
using System.Globalization; 

namespace System.Data.Mapping
{
    internal abstract class BaseMetadataMappingVisitor 
    {
        protected BaseMetadataMappingVisitor() 
        { 
        }
 
        protected virtual void Visit(StorageEntityContainerMapping storageEntityContainerMapping)
        {
            Visit(storageEntityContainerMapping.EdmEntityContainer);
            Visit(storageEntityContainerMapping.StorageEntityContainer); 
            foreach (var mapping in storageEntityContainerMapping.EntitySetMaps)
            { 
                Visit(mapping); 
            }
        } 

        protected virtual void Visit(EntitySetBase entitySetBase)
        {
            // this is a switching node, so no object header and footer will be add for this node, 
            // also this Visit won't add the object to the seen list
 
            switch (entitySetBase.BuiltInTypeKind) 
            {
                case BuiltInTypeKind.EntitySet: 
                    Visit((EntitySet)entitySetBase);
                    break;
                case BuiltInTypeKind.AssociationSet:
                    Visit((AssociationSet)entitySetBase); 
                    break;
                default: 
                    Debug.Fail(string.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", entitySetBase.BuiltInTypeKind)); 
                    break;
            } 
        }

        protected virtual void Visit(StorageSetMapping storageSetMapping)
        { 
            foreach (var typeMapping in storageSetMapping.TypeMappings)
            { 
                Visit(typeMapping); 
            }
            Visit(storageSetMapping.EntityContainerMapping); 
        }

        protected virtual void Visit(EntityContainer entityContainer)
        { 
            foreach (var set in entityContainer.BaseEntitySets)
            { 
                Visit(set); 
            }
        } 

        protected virtual void Visit(EntitySet entitySet)
        {
            Visit(entitySet.ElementType); 
            Visit(entitySet.EntityContainer);
        } 
 
        protected virtual void Visit(AssociationSet associationSet)
        { 
            Visit(associationSet.ElementType);
            Visit(associationSet.EntityContainer);
            foreach (var end in associationSet.AssociationSetEnds)
            { 
                Visit(end);
            } 
        } 
        protected virtual void Visit(EntityType entityType)
        { 
            foreach (var kmember in entityType.KeyMembers)
            {
                Visit(kmember);
            } 

            foreach (var member in entityType.GetDeclaredOnlyMembers()) 
            { 
                Visit(member);
            } 

            foreach (var nproperty in entityType.NavigationProperties)
            {
                Visit(nproperty); 
            }
 
            foreach (var property in entityType.Properties) 
            {
                Visit(property); 
            }
        }

        protected virtual void Visit(AssociationType associationType) 
        {
            foreach (var endMember in associationType.AssociationEndMembers) 
            { 
                Visit(endMember);
            } 
            Visit(associationType.BaseType);
            foreach (var keyMember in associationType.KeyMembers)
            {
                Visit(keyMember); 
            }
            foreach (var member in associationType.GetDeclaredOnlyMembers()) 
            { 
                Visit(member);
            } 
            foreach (var item in associationType.ReferentialConstraints)
            {
                Visit(item);
            } 
            foreach (var item in associationType.RelationshipEndMembers)
            { 
                Visit(item); 
            }
        } 

        protected virtual void Visit(AssociationSetEnd associationSetEnd)
        {
            Visit(associationSetEnd.CorrespondingAssociationEndMember); 
            Visit(associationSetEnd.EntitySet);
            Visit(associationSetEnd.ParentAssociationSet); 
        } 
        protected virtual void Visit(EdmProperty edmProperty)
        { 
            Visit(edmProperty.TypeUsage);
        }
        protected virtual void Visit(NavigationProperty navigationProperty)
        { 
            Visit(navigationProperty.FromEndMember);
            Visit(navigationProperty.RelationshipType); 
            Visit(navigationProperty.ToEndMember); 
            Visit(navigationProperty.TypeUsage);
        } 

        protected virtual void Visit(EdmMember edmMember)
        {
            Visit(edmMember.TypeUsage); 
        }
        protected virtual void Visit(AssociationEndMember associationEndMember) 
        { 
            Visit(associationEndMember.TypeUsage);
        } 

        protected virtual void Visit(ReferentialConstraint referentialConstraint)
        {
            foreach (var property in referentialConstraint.FromProperties) 
            {
                Visit(property); 
            } 
            Visit(referentialConstraint.FromRole);
 
            foreach (var property in referentialConstraint.ToProperties)
            {
                Visit(property);
            } 
            Visit(referentialConstraint.ToRole);
        } 
        protected virtual void Visit(RelationshipEndMember relationshipEndMember) 
        {
            Visit(relationshipEndMember.TypeUsage); 
        }
        protected virtual void Visit(TypeUsage typeUsage)
        {
            Visit(typeUsage.EdmType); 
            foreach (var facet in typeUsage.Facets)
            { 
                Visit(facet); 
            }
        } 
        protected virtual void Visit(RelationshipType relationshipType)
        {
            // switching node, will not be add to the seen list
            if (relationshipType == null) 
            {
                return; 
            } 

            #region Inner data visit 
            switch (relationshipType.BuiltInTypeKind)
            {
                case BuiltInTypeKind.AssociationType:
                    Visit((AssociationType)relationshipType); 
                    break;
                default: 
                    Debug.Fail(String.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", relationshipType.BuiltInTypeKind)); 
                    break;
            } 
            #endregion
        }
        protected virtual void Visit(EdmType edmType)
        { 
            // switching node, will not be add to the seen list
            if (edmType == null) 
            { 
                return;
            } 

            #region Inner data visit
            switch (edmType.BuiltInTypeKind)
            { 
                case BuiltInTypeKind.EntityType:
                    Visit((EntityType)edmType); 
                    break; 
                case BuiltInTypeKind.AssociationType:
                    Visit((AssociationType)edmType); 
                    break;
                case BuiltInTypeKind.EdmFunction:
                    Visit((EdmFunction)edmType);
                    break; 
                case BuiltInTypeKind.ComplexType:
                    Visit((ComplexType)edmType); 
                    break; 
                case BuiltInTypeKind.PrimitiveType:
                    Visit((PrimitiveType)edmType); 
                    break;
                case BuiltInTypeKind.RefType:
                    Visit((RefType)edmType);
                    break; 
                case BuiltInTypeKind.CollectionType:
                    Visit((CollectionType)edmType); 
                    break; 
                case BuiltInTypeKind.EnumType:
                    Visit((EnumType)edmType); 
                    break;
                default:
                    Debug.Fail(String.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", edmType.BuiltInTypeKind));
                    break; 
            }
            #endregion 
        } 
        protected virtual void Visit(Facet facet)
        { 
            Visit(facet.FacetType);
        }
        protected virtual void Visit(EdmFunction edmFunction)
        { 
            Visit(edmFunction.BaseType);
            Visit(edmFunction.EntitySet); 
            foreach (var functionParameter in edmFunction.Parameters) 
            {
                Visit(functionParameter); 
            }

            Visit(edmFunction.ReturnParameter);
        } 
        protected virtual void Visit(PrimitiveType primitiveType)
        { 
        } 
        protected virtual void Visit(ComplexType complexType)
        { 
            Visit(complexType.BaseType);
            foreach (var member in complexType.Members)
            {
                Visit(member); 
            }
            foreach (var property in complexType.Properties) 
            { 
                Visit(property);
            } 
        }
        protected virtual void Visit(RefType refType)
        {
            Visit(refType.BaseType); 
            Visit(refType.ElementType);
        } 
        protected virtual void Visit(EnumType enumType) 
        {
            foreach (var member in enumType.EnumMembers) 
            {
                Visit(member);
            }
        } 
        protected virtual void Visit(EnumMember enumMember)
        { 
        } 
        protected virtual void Visit(CollectionType collectionType)
        { 
            Visit(collectionType.BaseType);
            Visit(collectionType.TypeUsage);
        }
        protected virtual void Visit(EntityTypeBase entityTypeBase) 
        {
            // switching node 
            if (entityTypeBase == null) 
            {
                return; 
            }
            switch (entityTypeBase.BuiltInTypeKind)
            {
                case BuiltInTypeKind.AssociationType: 
                    Visit((AssociationType)entityTypeBase);
                    break; 
                case BuiltInTypeKind.EntityType: 
                    Visit((EntityType)entityTypeBase);
                    break; 
                default:
                    Debug.Fail(String.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", entityTypeBase.BuiltInTypeKind));
                    break;
            } 
        }
        protected virtual void Visit(FunctionParameter functionParameter) 
        { 
            Visit(functionParameter.DeclaringFunction);
            Visit(functionParameter.TypeUsage); 
        }
        protected virtual void Visit(DbProviderManifest providerManifest)
        {
        } 
        protected virtual void Visit(StorageTypeMapping storageTypeMapping)
        { 
            foreach (var type in storageTypeMapping.IsOfTypes) 
            {
                Visit(type); 
            }

            foreach (var fragment in storageTypeMapping.MappingFragments)
            { 
                Visit(fragment);
            } 
 
            Visit(storageTypeMapping.SetMapping);
 
            foreach (var type in storageTypeMapping.Types)
            {
                Visit(type);
            } 
        }
        protected virtual void Visit(StorageMappingFragment storageMappingFragment) 
        { 
            foreach (var property in storageMappingFragment.AllProperties)
            { 
                Visit(property);
            }

            Visit((EntitySetBase)storageMappingFragment.TableSet); 
        }
        protected virtual void Visit(StoragePropertyMapping storagePropertyMapping) 
        { 
            // this is a switching node, so no object header and footer will be add for this node,
            // also this Visit won't add the object to the seen list 

            if (storagePropertyMapping.GetType() == typeof(StorageComplexPropertyMapping))
            {
                Visit((StorageComplexPropertyMapping)storagePropertyMapping); 
            }
            else if (storagePropertyMapping.GetType() == typeof(StorageConditionPropertyMapping)) 
            { 
                Visit((StorageConditionPropertyMapping)storagePropertyMapping);
            } 
            else if (storagePropertyMapping.GetType() == typeof(StorageScalarPropertyMapping))
            {
                Visit((StorageScalarPropertyMapping)storagePropertyMapping);
            } 
            else
            { 
                Debug.Fail(String.Format(CultureInfo.InvariantCulture, "Found type '{0}', did we add a new type?", storagePropertyMapping.GetType())); 
            }
        } 
        protected virtual void Visit(StorageComplexPropertyMapping storageComplexPropertyMapping)
        {
            Visit(storageComplexPropertyMapping.EdmProperty);
            foreach (var mapping in storageComplexPropertyMapping.TypeMappings) 
            {
                Visit(mapping); 
            } 
        }
        protected virtual void Visit(StorageConditionPropertyMapping storageConditionPropertyMapping) 
        {
            Visit(storageConditionPropertyMapping.ColumnProperty);
            Visit(storageConditionPropertyMapping.EdmProperty);
        } 
        protected virtual void Visit(StorageScalarPropertyMapping storageScalarPropertyMapping)
        { 
            Visit(storageScalarPropertyMapping.ColumnProperty); 
            Visit(storageScalarPropertyMapping.EdmProperty);
        } 

        protected virtual void Visit(StorageComplexTypeMapping storageComplexTypeMapping)
        {
            foreach (var property in storageComplexTypeMapping.AllProperties) 
            {
                Visit(property); 
            } 

            foreach (var type in storageComplexTypeMapping.IsOfTypes) 
            {
                Visit(type);
            }
 
            foreach (var type in storageComplexTypeMapping.Types)
            { 
                Visit(type); 
            }
        } 
    }
}

// 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

• GridView.cs
• Point4D.cs
• CapiSymmetricAlgorithm.cs
• ByteStreamGeometryContext.cs
• SqlBooleanizer.cs
• AppDomainUnloadedException.cs
• XmlSchemaImport.cs
• Compiler.cs
• EnterpriseServicesHelper.cs
• FocusManager.cs
• CallContext.cs
• SafeNativeMethods.cs
• EditableRegion.cs
• ToolboxItemCollection.cs
• XhtmlConformanceSection.cs
• BuildProviderAppliesToAttribute.cs
• AutomationProperties.cs
• SerializerWriterEventHandlers.cs
• BinaryMethodMessage.cs
• ConnectionProviderAttribute.cs
• PasswordPropertyTextAttribute.cs
• DbTransaction.cs
• TargetConverter.cs
• LocalizedNameDescriptionPair.cs
• XmlHierarchicalEnumerable.cs
• ExpandedProjectionNode.cs
• AmbiguousMatchException.cs
• GZipUtils.cs
• LiteralText.cs
• TextServicesCompartmentEventSink.cs
• CommonGetThemePartSize.cs
• ToolStripDropDownButton.cs
• OledbConnectionStringbuilder.cs
• BindableTemplateBuilder.cs
• WebHttpEndpoint.cs
• XamlWriter.cs
• ParserStack.cs
• TypeBuilderInstantiation.cs
• DBDataPermissionAttribute.cs
• COM2IProvidePropertyBuilderHandler.cs
• AttributeSetAction.cs
• LateBoundBitmapDecoder.cs
• DeleteCardRequest.cs
• NonDualMessageSecurityOverHttp.cs
• DynamicUpdateCommand.cs
• FormatterServices.cs
• WrappedIUnknown.cs
• PropertyGridEditorPart.cs
• CodeTypeReference.cs
• X500Name.cs
• UpdateCommand.cs
• ConfigurationLocationCollection.cs
• LinkLabelLinkClickedEvent.cs
• ResizeGrip.cs
• WindowsFormsHelpers.cs
• InvokeBase.cs
• InheritedPropertyChangedEventArgs.cs
• CaseInsensitiveComparer.cs
• ThemeableAttribute.cs
• XmlSchemaException.cs
• ServiceDescription.cs
• ColumnReorderedEventArgs.cs
• ValidationError.cs
• ReferencedCollectionType.cs
• RegisteredExpandoAttribute.cs
• ServiceControllerDesigner.cs
• TimelineGroup.cs
• UnionCqlBlock.cs
• XamlDesignerSerializationManager.cs
• EncoderParameters.cs
• NameObjectCollectionBase.cs
• DropShadowBitmapEffect.cs
• DataGridAutoFormat.cs
• DataServiceHostFactory.cs
• ResourcesBuildProvider.cs
• EmissiveMaterial.cs
• CodeNamespaceCollection.cs
• FormClosingEvent.cs
• DataGridTableCollection.cs
• DataGridTextBox.cs
• PrintEvent.cs
• ObjectQueryProvider.cs
• EventManager.cs
• AuthenticatingEventArgs.cs
• IArgumentProvider.cs
• StorageEndPropertyMapping.cs
• LayoutTableCell.cs
• CryptoConfig.cs
• SafeEventLogWriteHandle.cs
• MenuItemBinding.cs
• TextTreeFixupNode.cs
• ControlIdConverter.cs
• SchemaNames.cs
• EntityDataSourceUtil.cs
• PersonalizationAdministration.cs
• TemplateControl.cs
• TemplateControlCodeDomTreeGenerator.cs
• MessageQueueException.cs
• DescendantBaseQuery.cs
• MultiDataTrigger.cs