public ModelTypeDescriptor(ICustomTypeDescriptor parent, object instance, IList<ModelProperty> properties)
     : base(parent)
 {
     modelPropertyDescriptors = properties
         .Select(p => new ModelPropertyDescriptor(p))
         .ToArray();
 }

        /// <summary>
        /// Constructor taking a metadata context, an structural type, and a parent custom type descriptor
        /// </summary>
        /// <param name="typeDescriptionContext">The <see cref="LinqToEntitiesTypeDescriptionContext"/> context.</param>
        /// <param name="edmType">The <see cref="StructuralType"/> type (can be an entity or complex type).</param>
        /// <param name="parent">The parent custom type descriptor.</param>
        public LinqToEntitiesTypeDescriptor(LinqToEntitiesTypeDescriptionContext typeDescriptionContext, StructuralType edmType, ICustomTypeDescriptor parent)
            : base(parent)
        {
            _typeDescriptionContext = typeDescriptionContext;
            _edmType = edmType;

            EdmMember[] timestampMembers = _edmType.Members.Where(p => ObjectContextUtilities.IsConcurrencyTimestamp(p)).ToArray();
            if (timestampMembers.Length == 1)
            {
                _timestampMember = timestampMembers[0];
            }

            if (edmType.BuiltInTypeKind == BuiltInTypeKind.EntityType)
            {
                // if any FK member of any association is also part of the primary key, then the key cannot be marked
                // Editable(false)
                EntityType entityType = (EntityType)edmType;
                _foreignKeyMembers = new HashSet<EdmMember>(entityType.NavigationProperties.SelectMany(p => p.GetDependentProperties()));
                foreach (EdmProperty foreignKeyMember in _foreignKeyMembers)
                {
                    if (entityType.KeyMembers.Contains(foreignKeyMember))
                    {
                        _keyIsEditable = true;
                        break;
                    }
                }
            }
        }

 public DomainTypeDescriptor(Type entityType, ICustomTypeDescriptor parent, bool keyIsEditable, HashSet<string> foreignKeyMembers)
     : base(parent)
 {
     this._entityType = entityType;
     this._keyIsEditable = keyIsEditable;
     this._foreignKeyMembers = foreignKeyMembers;
 }

        //=====================================================================

        /// <summary>
        /// This gets a custom type descriptor for the given type and object
        /// </summary>
        /// <param name="objectType">The type of object for which to retrieve the type descriptor.</param>
        /// <param name="instance">An instance of the type.  This may be null if not instance was passed to the
        /// type descriptor.</param>
        /// <returns>An <see cref="ICustomTypeDescriptor"/> that can provide metadata for the type</returns>
        public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance)
        {
            if(customTD == null)
                customTD = new ChildPropertyTypeDescriptor(base.GetTypeDescriptor(objectType, instance));

            return customTD;
        }

    internal static ICustomTypeDescriptor GetTypeDescriptor( Type objectType, ICustomTypeDescriptor descriptor )
    {
      if( descriptor == null )
        return null;

      return new DataItemTypeDescriptor( descriptor, objectType );
    }

 public GenericTypeDescriptor(Type objectType, ICustomTypeDescriptor parent)
 {
     if (objectType == null) throw new ArgumentNullException("objectType");
     if (parent == null) throw new ArgumentNullException("parent");
     type = objectType;
     parentDescriptor = parent;
 }

        /// <summary>
        /// Returns a custom type descriptor for the specified type (either an entity or complex type).
        /// </summary>
        /// <param name="objectType">Type of object for which we need the descriptor</param>
        /// <param name="parent">The parent type descriptor</param>
        /// <returns>Custom type description for the specified type</returns>
        public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, ICustomTypeDescriptor parent)
        {
            // No need to deal with concurrency... Worst case scenario we have multiple 
            // instances of this thing.
            ICustomTypeDescriptor td = null;
            if (!_descriptors.TryGetValue(objectType, out td))
            {
                // call into base so the TDs are chained
                parent = base.GetTypeDescriptor(objectType, parent);

                StructuralType edmType = _typeDescriptionContext.GetEdmType(objectType);
                if (edmType != null &&
                    (edmType.BuiltInTypeKind == BuiltInTypeKind.EntityType || edmType.BuiltInTypeKind == BuiltInTypeKind.ComplexType))
                {
                    // only add an LTE TypeDescriptor if the type is an EF Entity or ComplexType
                    td = new LinqToEntitiesTypeDescriptor(_typeDescriptionContext, edmType, parent);
                }
                else
                {
                    td = parent;
                }

                _descriptors[objectType] = td;
            }

            return td;
        }

 public ComponentImporter(Type type, ICustomTypeDescriptor typeDescriptor) : base(type)
 {
     if (typeDescriptor == null)
     {
         typeDescriptor = new Maticsoft.Json.Conversion.CustomTypeDescriptor(type);
     }
     int num = 0;
     PropertyDescriptorCollection properties = typeDescriptor.GetProperties();
     IObjectMemberImporter[] importerArray = new IObjectMemberImporter[properties.Count];
     for (int i = 0; i < properties.Count; i++)
     {
         IServiceProvider provider = properties[i] as IServiceProvider;
         if (provider != null)
         {
             IObjectMemberImporter service = (IObjectMemberImporter) provider.GetService(typeof(IObjectMemberImporter));
             if (service != null)
             {
                 importerArray[i++] = service;
                 num++;
             }
         }
     }
     this._properties = properties;
     if (num > 0)
     {
         this._importers = importerArray;
     }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="T:DescriptorBase"/> class.
 /// </summary>
 /// <param name="provider">The provider.</param>
 /// <param name="parentdescriptor">The parentdescriptor.</param>
 /// <param name="objectType">Type of the object.</param>
 public DescriptorBase(ShapeProvider provider, ICustomTypeDescriptor parentdescriptor, Type objectType)
     : base(parentdescriptor)
 {
     this.provider = provider;
     this.type = objectType;
     mProperties = new PropertyDescriptorCollection(null);
 }

        public NHibernateTypeDescriptor(Type entityType, ICustomTypeDescriptor parent,
                                        Configuration nhibernateConfiguration, Type metaDataType)
            : base(parent)
        {
            Type metaDataType1 = metaDataType;

            while (entityType != null && entityType.Name.EndsWith("Proxy") &&
                   entityType.Assembly.GetName().Name.EndsWith("ProxyAssembly"))
                entityType = entityType.BaseType;
            this.entityType = entityType;
            this._nhibernateConfiguration = nhibernateConfiguration;
            _classMetadata = nhibernateConfiguration.GetClassMapping(this.entityType);
            _identifierCols = _classMetadata.Identifier.ColumnIterator;

            if (metaDataType1 != null)
            {
                var memberInfos =
                    metaDataType1.GetMembers(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance);
                foreach (var memberInfo in memberInfos)
                {
                    var attributes = memberInfo.GetCustomAttributes(false).Cast<Attribute>();
                    if (attributes.Any())
                        _metaDataAttributes.Add(memberInfo.Name, attributes);
                }
            }
        }

        /// <summary>
        /// Returns a custom type descriptor for the specified entity type
        /// </summary>
        /// <param name="objectType">Type of object for which we need the descriptor</param>
        /// <param name="parent">The parent type descriptor</param>
        /// <returns>a custom type descriptor for the specified entity type</returns>
        public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, ICustomTypeDescriptor parent)
        {
            // No need to deal with concurrency... Worst case scenario we have multiple 
            // instances of this thing.
            ICustomTypeDescriptor td = null;
            if (!this._descriptors.TryGetValue(objectType, out td))
            {
                // call into base so the TDs are chained
                parent = base.GetTypeDescriptor(objectType, parent);

                MetaType metaType = this._typeDescriptionContext.MetaModel.GetMetaType(objectType);
                if (metaType.IsEntity)
                {
                    // only add an LTS TypeDescriptor if the type is a LTS Entity type
                    td = new LinqToSqlTypeDescriptor(this._typeDescriptionContext, metaType, parent);
                }
                else
                {
                    td = parent;
                }

                this._descriptors[objectType] = td;
            }

            return td;
        }

 public AssociatedMetadataTypeTypeDescriptor(ICustomTypeDescriptor parent, Type type, Type associatedMetadataType)
     : base(parent) {
     if (associatedMetadataType != null) {
         CheckAssociatedMetadataType(type, associatedMetadataType);
         AssociatedMetadataType = associatedMetadataType;
     }
 }

        public ComponentImporter(Type type, ICustomTypeDescriptor typeDescriptor) :
            base(type)
        {
            if (typeDescriptor == null)
                typeDescriptor = new CustomTypeDescriptor(type);
            
            int count = 0;
            PropertyDescriptorCollection properties = typeDescriptor.GetProperties();
            IObjectMemberImporter[] importers = new IObjectMemberImporter[properties.Count];
            
            for (int i = 0; i < properties.Count; i++)
            {
                IServiceProvider sp = properties[i] as IServiceProvider;
                
                if (sp == null)
                    continue;
                
                IObjectMemberImporter importer = (IObjectMemberImporter) sp.GetService(typeof(IObjectMemberImporter));
                
                if (importer == null)
                    continue;
                
                importers[i++] = importer;
                count++;
            }

            _properties = properties;

            if (count > 0)
                _importers = importers;
        }

        //=================================================================

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="typeDescriptor">The type descriptor</param>
        /// <param name="propertyDescriptor">The property descriptor</param>
        public DynamicReadOnlyPropertyDescriptor(
          ICustomTypeDescriptor typeDescriptor,
          PropertyDescriptor propertyDescriptor) : base(propertyDescriptor)
        {
            typeDesc = typeDescriptor;
            propDesc = propertyDescriptor;
        }

 public override ICustomTypeDescriptor GetTypeDescriptor(Type type, ICustomTypeDescriptor parent)
 {
     if (this.LookupIsEntityType(type))
     {
         return new TableMetadataTypeDescriptor(type, base.GetTypeDescriptor(type, parent));
     }
     return base.GetTypeDescriptor(type, parent);
 }

 public AssociatedMetadataTypeTypeDescriptor(ICustomTypeDescriptor parent, Type type, Type associatedMetadataType)
     : base(parent) {
     AssociatedMetadataType = associatedMetadataType ?? TypeDescriptorCache.GetAssociatedMetadataType(type);
     IsSelfAssociated = (type == AssociatedMetadataType);
     if (AssociatedMetadataType != null) {
         TypeDescriptorCache.ValidateMetadataType(type, AssociatedMetadataType);
     }
 }

 public ComponentImporter(Type type, ICustomTypeDescriptor typeDescriptor) :
     base(type)
 {
     if (typeDescriptor == null)
         typeDescriptor = new CustomTypeDescriptor(type);
     
     _properties = typeDescriptor.GetProperties();
 }

 public FilteredPropertiesTypeDescriptor(FilteredPropertiesTypeDescriptorProvider provider, ICustomTypeDescriptor descriptor, Type objType)
     : base(descriptor)
 {
     if (provider == null) throw new ArgumentNullException("provider");
     if (descriptor == null) throw new ArgumentNullException("descriptor");
     if (objType == null) throw new ArgumentNullException("objectType");
     objectType = objType;
 }

        /// <summary>
        /// Gets the value of an <see cref="ICustomTypeDescriptor" /> 
        /// implementation's named property.
        /// </summary>
        /// <param name="item">
        /// The <see cref="ICustomTypeDescriptor" /> implementation, from 
        /// which to extract a named property's value.
        /// </param>
        /// <param name="propertyName">
        /// The name of the property.
        /// </param>
        /// <param name="usesCaseSensitivePropertyNameMatch">
        /// A value indicating whether the property name match should be 
        /// case-sensitive.
        /// </param>
        /// <param name="exceptionThrownIfNoMatch">
        /// A value indicating whether an exception should be thrown if 
        /// no matching property can be found.
        /// </param>
        /// <returns>
        /// The value of the property named by 
        /// propertyName on item,
        /// or a null reference if 
        /// exceptionThrownIfNoMatch is false and 
        /// propertyName does not name a property on 
        /// item.
        /// </returns>
        private static object GetNamedPropertyValue(
            ICustomTypeDescriptor item,
            string propertyName,
            bool usesCaseSensitivePropertyNameMatch,
            bool exceptionThrownIfNoMatch)
        {
            PropertyDescriptor descriptor;
            StringComparison comparisonType;

            if (item == null)
            {
                throw new ArgumentNullException("item");
            }

            if (string.IsNullOrEmpty("propertyName"))
            {
                throw new ArgumentException(
                    "propertyName is a null reference or empty string.",
                    "propertyName");
            }

            if (usesCaseSensitivePropertyNameMatch)
            {
                comparisonType = StringComparison.CurrentCulture;
            }
            else
            {
                comparisonType = StringComparison.CurrentCultureIgnoreCase;
            }

            descriptor = default(PropertyDescriptor);
            foreach (PropertyDescriptor pd in item.GetProperties())
            {
                if (string.Equals(propertyName, pd.Name, comparisonType))
                {
                    descriptor = pd;
                    break;
                }
            }

            if (descriptor == default(PropertyDescriptor))
            {
                if (exceptionThrownIfNoMatch)
                {
                    throw new ArgumentException(
                        "propertyName does not name a property on item.",
                        "propertyName");
                }
                else
                {
                    return null;
                }
            }
            else
            {
                return descriptor.GetValue(item);
            }
        }

    internal DataItemTypeDescriptor( ICustomTypeDescriptor parent, Type objectType )
      : base( parent )
    {
      if( parent == null )
        throw new ArgumentNullException( "parent" );

      m_targetType = objectType;
      m_descriptorType = parent.GetType();
    }