Exemple #1
0
        public void Map(PropertyInfo propertyInfo, ICollection <MetadataProperty> annotations)
        {
            DebugCheck.NotNull(propertyInfo);
            DebugCheck.NotNull(annotations);

            annotations.SetClrAttributes(_attributeProvider.GetAttributes(propertyInfo).ToList());
        }
Exemple #2
0
        /// <summary>
        ///     Creates and configures the <see cref="DbModelBuilder" /> instance that will be used to build the
        ///     <see cref="DbCompiledModel" />.
        /// </summary>
        /// <returns> The builder. </returns>
        public DbModelBuilder CreateModelBuilder()
        {
            var versionAttribute = _attributeProvider.GetAttributes(Owner.GetType())
                                   .OfType <DbModelBuilderVersionAttribute>()
                                   .FirstOrDefault();
            var version = versionAttribute != null ? versionAttribute.Version : DbModelBuilderVersion.Latest;

            var modelBuilder = new DbModelBuilder(version);

            var modelNamespace = StripInvalidCharacters(Owner.GetType().Namespace);

            if (!String.IsNullOrWhiteSpace(modelNamespace))
            {
                modelBuilder.Conventions.Add(new ModelNamespaceConvention(modelNamespace));
            }

            var modelContainer = StripInvalidCharacters(Owner.GetType().Name);

            if (!String.IsNullOrWhiteSpace(modelContainer))
            {
                modelBuilder.Conventions.Add(new ModelContainerConvention(modelContainer));
            }

            new DbSetDiscoveryService(Owner).RegisterSets(modelBuilder);

            Owner.CallOnModelCreating(modelBuilder);

            if (OnModelCreating != null)
            {
                OnModelCreating(modelBuilder);
            }

            return(modelBuilder);
        }
Exemple #3
0
 /// <summary>
 /// Initializes a new instance of the <see cref="TypeAttributeConfigurationConvention{TAttribute}"/> class.
 /// </summary>
 protected TypeAttributeConfigurationConvention()
 {
     Types().Having(t => _attributeProvider.GetAttributes(t).OfType <TAttribute>())
     .Configure((configuration, attributes) =>
     {
         foreach (var attribute in attributes)
         {
             Apply(configuration, attribute);
         }
     });
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="PrimitivePropertyAttributeConfigurationConvention{TAttribute}"/> class.
 /// </summary>
 protected PrimitivePropertyAttributeConfigurationConvention()
 {
     Properties().Having(pi => _attributeProvider.GetAttributes(pi).OfType <TAttribute>()).Configure(
         (configuration, attributes) =>
     {
         foreach (var attribute in attributes)
         {
             Apply(configuration, attribute);
         }
     });
 }
        void IConfigurationConvention <TMemberInfo, TConfiguration> .Apply(
            TMemberInfo memberInfo, Func <TConfiguration> configuration)
        {
            Check.NotNull(memberInfo, "memberInfo");
            Check.NotNull(configuration, "configuration");

            foreach (var attribute in _attributeProvider.GetAttributes(memberInfo).OfType <TAttribute>())
            {
                Apply(memberInfo, configuration(), attribute);
            }
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="PropertyAttributeConfigurationConvention{TAttribute}"/> class.
 /// </summary>
 protected PropertyAttributeConfigurationConvention()
 {
     Types().Configure(
         ec =>
     {
         foreach (var propertyInfo in ec.ClrType.GetProperties(PropertyFilter.DefaultBindingFlags))
         {
             foreach (var attribute in _attributeProvider.GetAttributes(propertyInfo).OfType <TAttribute>())
             {
                 Apply(propertyInfo, ec, attribute);
             }
         }
     });
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="PropertyAttributeConfigurationConvention{TAttribute}"/> class.
 /// </summary>
 protected PropertyAttributeConfigurationConvention()
 {
     Types().Configure(
         ec =>
     {
         foreach (var propertyInfo in ec.ClrType.GetInstanceProperties())
         {
             foreach (var attribute in _attributeProvider.GetAttributes(propertyInfo).OfType <TAttribute>())
             {
                 Apply(propertyInfo, ec, attribute);
             }
         }
     });
 }
        /// <summary>
        ///     Extracted method from BuildEntityValidator and BuildComplexTypeValidator
        /// </summary>
        private T BuildTypeValidator <T>(
            Type clrType,
            IEnumerable <EdmProperty> edmProperties,
            IEnumerable <NavigationProperty> navigationProperties,
            Func <IEnumerable <PropertyValidator>, IEnumerable <IValidator>, T> validatorFactoryFunc)
            where T : TypeValidator
        {
            var propertyValidators = BuildValidatorsForProperties(
                GetPublicInstanceProperties(clrType), edmProperties, navigationProperties);

            var attributes = _attributeProvider.GetAttributes(clrType);

            var typeLevelValidators = BuildValidationAttributeValidators(attributes);

            if (typeof(IValidatableObject).IsAssignableFrom(clrType))
            {
                typeLevelValidators.Add(
                    new ValidatableObjectValidator(attributes.OfType <DisplayAttribute>().SingleOrDefault()));
            }

            return(propertyValidators.Any() || typeLevelValidators.Any()
                       ? validatorFactoryFunc(propertyValidators, typeLevelValidators)
                       : null);
        }
Exemple #9
0
        // Not using the public API to avoid including the property in the model if it wasn't in before
        internal override void ApplyPropertyTypeConfiguration <TStructuralTypeConfiguration>(
            PropertyInfo propertyInfo, Func <TStructuralTypeConfiguration> structuralTypeConfiguration, ModelConfiguration modelConfiguration)
        {
            DebugCheck.NotNull(propertyInfo);
            DebugCheck.NotNull(structuralTypeConfiguration);
            DebugCheck.NotNull(modelConfiguration);

            if (typeof(TStructuralTypeConfiguration) == typeof(EntityTypeConfiguration) &&
                _attributeProvider.GetAttributes(propertyInfo).OfType <KeyAttribute>().Any())
            {
                var entityTypeConfiguration = (EntityTypeConfiguration)(object)structuralTypeConfiguration();

                if (propertyInfo.IsValidEdmScalarProperty())
                {
                    entityTypeConfiguration.Key(propertyInfo);
                }
            }
        }
        // Not using the public API to avoid configuring the property as a navigation property if it wasn't one before
        internal override void ApplyPropertyConfiguration(
            PropertyInfo propertyInfo, Func<PropertyConfiguration> propertyConfiguration, ModelConfiguration modelConfiguration)
        {
            DebugCheck.NotNull(propertyInfo);
            DebugCheck.NotNull(propertyConfiguration);
            DebugCheck.NotNull(modelConfiguration);

            if (propertyInfo.IsValidEdmNavigationProperty()
                && !propertyInfo.PropertyType.IsCollection()
                && _attributeProvider.GetAttributes(propertyInfo).OfType<RequiredAttribute>().Any())
            {
                var navigationPropertyConfiguration = (NavigationPropertyConfiguration)propertyConfiguration();

                if (navigationPropertyConfiguration.RelationshipMultiplicity == null)
                {
                    navigationPropertyConfiguration.RelationshipMultiplicity = (RelationshipMultiplicity.One);
                }
            }
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="PropertyAttributeConfigurationConvention{TAttribute}"/> class.
 /// </summary>
 protected PropertyAttributeConfigurationConvention()
 {
     Types().Configure(
         ec =>
     {
         // PERF: this code is part of a critical section, consider its performance when refactoring
         foreach (var propertyInfo in ec.ClrType.GetInstanceProperties())
         {
             var attributes = (IList <Attribute>)_attributeProvider.GetAttributes(propertyInfo);
             // ReSharper disable once ForCanBeConvertedToForeach
             for (var i = 0; i < attributes.Count; ++i)
             {
                 var attribute = attributes[i] as TAttribute;
                 if (attribute != null)
                 {
                     Apply(propertyInfo, ec, attribute);
                 }
             }
         }
     });
 }
Exemple #12
0
        public AttributeToTableAnnotationConvention(
            string annotationName,
            Func <Type, IList <TAttribute>, TAnnotation> annotationFactory)
        {
            Check.NotEmpty(annotationName, nameof(annotationName));
            Check.NotNull <Func <Type, IList <TAttribute>, TAnnotation> >(annotationFactory, nameof(annotationFactory));
            AttributeProvider attributeProvider = DbConfiguration.DependencyResolver.GetService <AttributeProvider>();

            this.Types().Having <List <TAttribute> >((Func <Type, List <TAttribute> >)(t => attributeProvider.GetAttributes(t).OfType <TAttribute>().ToList <TAttribute>())).Configure((Action <ConventionTypeConfiguration, List <TAttribute> >)((c, a) =>
            {
                if (!a.Any <TAttribute>())
                {
                    return;
                }
                c.HasTableAnnotation(annotationName, (object)annotationFactory(c.ClrType, (IList <TAttribute>)a));
            }));
        }
Exemple #13
0
        public AttributeToColumnAnnotationConvention(
            string annotationName,
            Func <PropertyInfo, IList <TAttribute>, TAnnotation> annotationFactory)
        {
            Check.NotEmpty(annotationName, nameof(annotationName));
            Check.NotNull <Func <PropertyInfo, IList <TAttribute>, TAnnotation> >(annotationFactory, nameof(annotationFactory));
            AttributeProvider attributeProvider = DbConfiguration.DependencyResolver.GetService <AttributeProvider>();

            this.Properties().Having <List <TAttribute> >((Func <PropertyInfo, List <TAttribute> >)(pi => attributeProvider.GetAttributes(pi).OfType <TAttribute>().ToList <TAttribute>())).Configure((Action <ConventionPrimitivePropertyConfiguration, List <TAttribute> >)((c, a) =>
            {
                if (!a.Any <TAttribute>())
                {
                    return;
                }
                c.HasColumnAnnotation(annotationName, (object)annotationFactory(c.ClrPropertyInfo, (IList <TAttribute>)a));
            }));
        }