public override void Apply(IEntityTypeConfiguration entity, ODataModelBuilder model) { if (entity.IsAbstract == null) { entity.IsAbstract = entity.ClrType.IsAbstract; } }
public static ICodeFirst ApplyConfiguration <TEntity>(this ICodeFirst codeFirst, IEntityTypeConfiguration <TEntity> configuration) where TEntity : class { return(codeFirst.Entity <TEntity>(eb => { configuration.Configure(eb); })); }
/// <summary> /// Sets the base type of this entity type. /// </summary> /// <param name="baseType">The base entity type.</param> /// <returns>Returns itself so that multiple calls can be chained.</returns> public IEntityTypeConfiguration DerivesFrom(IEntityTypeConfiguration baseType) { if (baseType == null) { throw Error.ArgumentNull("baseType"); } _baseType = baseType; _baseTypeConfigured = true; if (!baseType.ClrType.IsAssignableFrom(ClrType) || baseType.ClrType == ClrType) { throw Error.InvalidOperation(SRResources.TypeDoesNotInheritFromBaseType, ClrType.FullName, baseType.ClrType.FullName); } if (Keys.Any()) { throw Error.InvalidOperation(SRResources.CannotDefineKeysOnDerivedTypes, FullName, baseType.FullName); } foreach (PropertyConfiguration property in Properties) { ValidatePropertyNotAlreadyDefinedInBaseTypes(property.PropertyInfo); } foreach (PropertyConfiguration property in this.DerivedProperties()) { ValidatePropertyNotAlreadyDefinedInDerivedTypes(property.PropertyInfo); } return(this); }
public void CanCreateActionWithEntityReturnType() { // Arrange // Act ODataModelBuilder builder = new ODataModelBuilder(); ActionConfiguration createGoodCustomer = new ActionConfiguration(builder, "CreateGoodCustomer"); createGoodCustomer.ReturnsFromEntitySet <Customer>("GoodCustomers"); ActionConfiguration createBadCustomers = new ActionConfiguration(builder, "CreateBadCustomers"); createBadCustomers.ReturnsCollectionFromEntitySet <Customer>("BadCustomers"); // Assert IEntityTypeConfiguration customer = createGoodCustomer.ReturnType as IEntityTypeConfiguration; Assert.NotNull(customer); Assert.Equal(typeof(Customer).FullName, customer.FullName); IEntitySetConfiguration goodCustomers = builder.EntitySets.SingleOrDefault(s => s.Name == "GoodCustomers"); Assert.NotNull(goodCustomers); Assert.Same(createGoodCustomer.EntitySet, goodCustomers); ICollectionTypeConfiguration customers = createBadCustomers.ReturnType as ICollectionTypeConfiguration; Assert.NotNull(customers); customer = customers.ElementType as IEntityTypeConfiguration; Assert.NotNull(customer); IEntitySetConfiguration badCustomers = builder.EntitySets.SingleOrDefault(s => s.Name == "BadCustomers"); Assert.NotNull(badCustomers); Assert.Same(createBadCustomers.EntitySet, badCustomers); }
internal void MapDerivedTypes(IEntityTypeConfiguration entity) { HashSet <Type> visitedEntities = new HashSet <Type>(); Queue <IEntityTypeConfiguration> entitiesToBeVisited = new Queue <IEntityTypeConfiguration>(); entitiesToBeVisited.Enqueue(entity); // populate all the derived types while (entitiesToBeVisited.Count != 0) { IEntityTypeConfiguration baseEntity = entitiesToBeVisited.Dequeue(); visitedEntities.Add(baseEntity.ClrType); List <Type> derivedTypes; if (_allTypesWithDerivedTypeMapping.Value.TryGetValue(baseEntity.ClrType, out derivedTypes)) { foreach (Type derivedType in derivedTypes) { if (!visitedEntities.Contains(derivedType) && !IsIgnoredType(derivedType)) { IEntityTypeConfiguration derivedEntity = AddEntity(derivedType); entitiesToBeVisited.Enqueue(derivedEntity); } } } } }
public void AssociationSetDiscoveryConvention_AddsBindingForBaseAndDerivedNavigationProperties() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); IEntityTypeConfiguration vehicle = builder.AddEntity(typeof(Vehicle)); IEntityTypeConfiguration car = builder.AddEntity(typeof(Car)).DerivesFrom(vehicle); NavigationPropertyConfiguration carNavigationProperty = car.AddNavigationProperty(typeof(Car).GetProperty("Manufacturer"), EdmMultiplicity.ZeroOrOne); IEntityTypeConfiguration motorcycle = builder.AddEntity(typeof(Motorcycle)).DerivesFrom(vehicle); NavigationPropertyConfiguration motorcycleNavigationProperty = motorcycle.AddNavigationProperty(typeof(Motorcycle).GetProperty("Manufacturer"), EdmMultiplicity.ZeroOrOne); IEntityTypeConfiguration manufacturer = builder.AddEntity(typeof(Manufacturer)); IEntityTypeConfiguration motorcycleManufacturer = builder.AddEntity(typeof(MotorcycleManufacturer)).DerivesFrom(manufacturer); IEntityTypeConfiguration carManufacturer = builder.AddEntity(typeof(CarManufacturer)).DerivesFrom(manufacturer); IEntitySetConfiguration manufacturers = builder.AddEntitySet("manufacturers", manufacturer); Mock <IEntitySetConfiguration> entitySet = new Mock <IEntitySetConfiguration>(MockBehavior.Strict); entitySet.Setup(v => v.EntityType).Returns(vehicle); entitySet.Setup(v => v.AddBinding(motorcycleNavigationProperty, manufacturers)).Returns <NavigationPropertyConfiguration>(null); entitySet.Setup(v => v.AddBinding(carNavigationProperty, manufacturers)).Returns <NavigationPropertyConfiguration>(null); // Act _convention.Apply(entitySet.Object, builder); // Assert entitySet.VerifyAll(); }
/// <summary> /// Registers an entity set as a part of the model and returns an object that can be used to configure the entity set. /// This method can be called multiple times for the same type to perform multiple lines of configuration. /// </summary> /// <param name="name">The name of the entity set.</param> /// <param name="entityType">The type to be registered or configured.</param> /// <returns>The configuration object for the specified entity set.</returns> public virtual IEntitySetConfiguration AddEntitySet(string name, IEntityTypeConfiguration entityType) { if (String.IsNullOrWhiteSpace(name)) { throw Error.ArgumentNullOrEmpty("name"); } if (entityType == null) { throw Error.ArgumentNull("entityType"); } if (name.Contains(".")) { throw Error.NotSupported(SRResources.InvalidEntitySetName, name); } EntitySetConfiguration entitySet = null; if (_entitySets.ContainsKey(name)) { entitySet = _entitySets[name] as EntitySetConfiguration; if (entitySet.EntityType != entityType) { throw Error.Argument("entityType", SRResources.EntitySetAlreadyConfiguredDifferentEntityType, entitySet.Name, entitySet.EntityType.Name); } } else { entitySet = new EntitySetConfiguration(this, entityType, name); _entitySets[name] = entitySet; } return entitySet; }
private void CreateEdmTypeHeader(IStructuralTypeConfiguration config) { if (!_types.ContainsKey(config.ClrType)) { if (config.Kind == EdmTypeKind.Complex) { _types.Add(config.ClrType, new EdmComplexType(config.Namespace, config.Name)); } else { IEntityTypeConfiguration entity = config as IEntityTypeConfiguration; Contract.Assert(entity != null); IEdmEntityType baseType = null; if (entity.BaseType != null) { CreateEdmTypeHeader(entity.BaseType); baseType = _types[entity.BaseType.ClrType] as IEdmEntityType; Contract.Assert(baseType != null); } _types.Add(config.ClrType, new EdmEntityType(config.Namespace, config.Name, baseType, entity.IsAbstract ?? false, isOpen: false)); } } }
private void MapEntityType(IEntityTypeConfiguration entity) { IEnumerable <PropertyInfo> properties = ConventionsHelpers.GetProperties(entity); foreach (PropertyInfo property in properties) { bool isCollection; IStructuralTypeConfiguration mappedType; PropertyKind propertyKind = GetPropertyType(property, out isCollection, out mappedType); if (propertyKind == PropertyKind.Primitive || propertyKind == PropertyKind.Complex) { MapStructuralProperty(entity, property, propertyKind, isCollection); } else { // don't add this property if the user has already added it. if (!entity.NavigationProperties.Where(p => p.Name == property.Name).Any()) { if (!isCollection) { entity.AddNavigationProperty(property, EdmMultiplicity.ZeroOrOne); } else { entity.AddNavigationProperty(property, EdmMultiplicity.Many); } } } } MapDerivedTypes(entity); }
private void MapEntityType(IEntityTypeConfiguration entity) { PropertyInfo[] properties = ConventionsHelpers.GetProperties(entity); foreach (PropertyInfo property in properties) { bool isCollection; IStructuralTypeConfiguration mappedType; PropertyKind propertyKind = GetPropertyType(property, out isCollection, out mappedType); if (propertyKind == PropertyKind.Primitive || propertyKind == PropertyKind.Complex) { MapStructuralProperty(entity, property, propertyKind, isCollection); } else { if (!isCollection) { entity.AddNavigationProperty(property, EdmMultiplicity.ZeroOrOne); } else { entity.AddNavigationProperty(property, EdmMultiplicity.Many); } } } }
public void ThisAndBaseTypes_ReturnsThisType() { ODataModelBuilder builder = GetMockVehicleModel(); IEntityTypeConfiguration sportbike = builder.StructuralTypes.OfType <IEntityTypeConfiguration>().Where(e => e.Name == "sportbike").Single(); Assert.Contains(sportbike, sportbike.ThisAndBaseTypes()); }
private void MapEntityType(IEntityTypeConfiguration entity) { PropertyInfo[] properties = ConventionsHelpers.GetProperties(entity.ClrType); foreach (PropertyInfo property in properties) { if (EdmLibHelpers.GetEdmPrimitiveTypeOrNull(property.PropertyType) != null) { PrimitivePropertyConfiguration primitiveProperty = entity.AddProperty(property); primitiveProperty.OptionalProperty = IsNullable(property.PropertyType); } else { IStructuralTypeConfiguration mappedType = GetStructuralTypeOrNull(property.PropertyType); if (mappedType != null) { if (mappedType is IComplexTypeConfiguration) { entity.AddComplexProperty(property); } else { entity.AddNavigationProperty(property, property.PropertyType.IsCollection() ? EdmMultiplicity.Many : EdmMultiplicity.ZeroOrOne); } } else { // we are not really sure if this should be a complex property or an navigation property. // Assume that it is a navigation property and patch later in RediscoverComplexTypes(). entity.AddNavigationProperty(property, property.PropertyType.IsCollection() ? EdmMultiplicity.Many : EdmMultiplicity.ZeroOrOne); } } } }
private void Configure <TModel, TModelConfig>(ModelBuilder modelBuilder) where TModel : class where TModelConfig : IEntityTypeConfiguration <TModel> { IEntityTypeConfiguration <TModel> configuration = Activator.CreateInstance <TModelConfig>(); modelBuilder.ApplyConfiguration(configuration); }
private void Configure <TEntity, TEntityConfig>(ModelBuilder builder) where TEntity : class where TEntityConfig : IEntityTypeConfiguration <TEntity> { IEntityTypeConfiguration <TEntity> configuration = Activator.CreateInstance <TEntityConfig>(); builder.ApplyConfiguration(configuration); }
public static void AddType <TEntity>(IEntityTypeConfiguration <TEntity> configuration) where TEntity : class { var builder = new EntityTypeBuilder <TEntity>(); configuration.Configure(builder); AnalyzeType(typeof(TEntity)); }
public void CanBuildBoundProcedureCacheForIEdmModel() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration <Customer> customer = builder.EntitySet <Customer>("Customers").EntityType; customer.HasKey(c => c.ID); customer.Property(c => c.Name); customer.ComplexProperty(c => c.Address); EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType; movie.HasKey(m => m.ID); movie.HasKey(m => m.Name); EntityTypeConfiguration <Blockbuster> blockBuster = builder.Entity <Blockbuster>().DerivesFrom <Movie>(); IEntityTypeConfiguration movieConfiguration = builder.StructuralTypes.OfType <IEntityTypeConfiguration>().Single(t => t.Name == "Movie"); // build actions that are bindable to a single entity customer.Action("InCache1_CustomerAction"); customer.Action("InCache2_CustomerAction"); movie.Action("InCache3_MovieAction"); ActionConfiguration incache4_MovieAction = new ActionConfiguration(builder, "InCache4_MovieAction"); incache4_MovieAction.SetBindingParameter("bindingParameter", movieConfiguration, true); blockBuster.Action("InCache5_BlockbusterAction"); // build actions that are either: bindable to a collection of entities, have no parameter, have only complex parameter customer.Collection.Action("NotInCache1_CustomersAction"); movie.Collection.Action("NotInCache2_MoviesAction"); ActionConfiguration notInCache3_NoParameters = new ActionConfiguration(builder, "NotInCache3_NoParameters"); ActionConfiguration notInCache4_AddressParameter = new ActionConfiguration(builder, "NotInCache4_AddressParameter"); notInCache4_AddressParameter.Parameter <Address>("address"); IEdmModel model = builder.GetEdmModel(); IEdmEntityType customerType = model.SchemaElements.OfType <IEdmEntityType>().Single(e => e.Name == "Customer"); IEdmEntityType movieType = model.SchemaElements.OfType <IEdmEntityType>().Single(e => e.Name == "Movie"); IEdmEntityType blockBusterType = model.SchemaElements.OfType <IEdmEntityType>().Single(e => e.Name == "Blockbuster"); // Act BindableProcedureFinder annotation = new BindableProcedureFinder(model); IEdmFunctionImport[] movieActions = annotation.FindProcedures(movieType).ToArray(); IEdmFunctionImport[] customerActions = annotation.FindProcedures(customerType).ToArray(); IEdmFunctionImport[] blockBusterActions = annotation.FindProcedures(blockBusterType).ToArray(); // Assert Assert.Equal(2, customerActions.Length); Assert.NotNull(customerActions.SingleOrDefault(a => a.Name == "InCache1_CustomerAction")); Assert.NotNull(customerActions.SingleOrDefault(a => a.Name == "InCache2_CustomerAction")); Assert.Equal(2, movieActions.Length); Assert.NotNull(movieActions.SingleOrDefault(a => a.Name == "InCache3_MovieAction")); Assert.NotNull(movieActions.SingleOrDefault(a => a.Name == "InCache4_MovieAction")); Assert.Equal(3, blockBusterActions.Length); Assert.NotNull(blockBusterActions.SingleOrDefault(a => a.Name == "InCache3_MovieAction")); Assert.NotNull(blockBusterActions.SingleOrDefault(a => a.Name == "InCache4_MovieAction")); Assert.NotNull(blockBusterActions.SingleOrDefault(a => a.Name == "InCache5_BlockbusterAction")); }
public void Apply(IEdmTypeConfiguration edmTypeConfiguration, ODataModelBuilder model) { IEntityTypeConfiguration entity = edmTypeConfiguration as IEntityTypeConfiguration; if (entity != null) { Apply(entity, model); } }
/// <summary> /// Applies configuration that is defined in an <see cref="IEntityTypeConfiguration{TEntity}" /> instance. /// </summary> /// <typeparam name="TEntity"> The entity type to be configured. </typeparam> /// <param name="configuration"> The configuration to be applied. </param> /// <returns> /// The same <see cref="ModelBuilder" /> instance so that additional configuration calls can be chained. /// </returns> public virtual ModelBuilder ApplyConfiguration <TEntity>([NotNull] IEntityTypeConfiguration <TEntity> configuration) where TEntity : class { Check.NotNull(configuration, nameof(configuration)); configuration.Configure(Entity <TEntity>()); return(this); }
// Returns the base types, this type and all the derived types of this type. public static IEnumerable<IEntityTypeConfiguration> ThisAndBaseAndDerivedTypes(this ODataModelBuilder modelBuilder, IEntityTypeConfiguration entity) { Contract.Assert(modelBuilder != null); Contract.Assert(entity != null); return entity.BaseTypes() .Concat(new[] { entity }) .Concat(modelBuilder.DerivedTypes(entity)); }
public void ThisAndBaseAndDerivedTypes_Works() { ODataModelBuilder builder = GetMockVehicleModel(); IEntityTypeConfiguration vehicle = builder.StructuralTypes.OfType <IEntityTypeConfiguration>().Where(e => e.Name == "vehicle").Single(); Assert.Equal( builder.ThisAndBaseAndDerivedTypes(vehicle).Select(e => e.Name).OrderBy(name => name), builder.StructuralTypes.Select(e => e.Name).OrderBy(name => name)); }
internal EntityTypeConfiguration(ODataModelBuilder modelBuilder, IEntityTypeConfiguration configuration) : base(configuration) { Contract.Assert(modelBuilder != null); Contract.Assert(configuration != null); _modelBuilder = modelBuilder; _configuration = configuration; _collection = new EntityCollectionConfiguration <TEntityType>(configuration); }
public ModelBuilder ApplyConfiguration <TEntity>(IEntityTypeConfiguration <TEntity> entityTypeConfiguration) where TEntity : class { if (entityTypeConfiguration is null) { throw new ArgumentNullException(nameof(entityTypeConfiguration)); } entityTypeConfiguration.Configure(Entity <TEntity>()); return(this); }
public override IEntityTypeConfiguration AddEntity(Type type) { IEntityTypeConfiguration entityTypeConfiguration = base.AddEntity(type); if (_isModelBeingBuilt) { MapType(entityTypeConfiguration); } return(entityTypeConfiguration); }
public override IEntitySetConfiguration AddEntitySet(string name, IEntityTypeConfiguration entityType) { IEntitySetConfiguration entitySetConfiguration = base.AddEntitySet(name, entityType); if (_isModelBeingBuilt) { ApplyEntitySetConventions(entitySetConfiguration); } return(entitySetConfiguration); }
private static void ApplyConfiguration <T>(this ModelBuilder modelBuilder, IEntityTypeConfiguration <T> configuration) where T : class { Type entityType = FindEntityType(configuration.GetType()); dynamic entityTypeBuilder = EntityMethod .MakeGenericMethod(entityType) .Invoke(modelBuilder, new object[0]); configuration.Configure(entityTypeBuilder); }
internal EntitySetConfiguration(ODataModelBuilder modelBuilder, IEntityTypeConfiguration entityType, string name) { _modelBuilder = modelBuilder; Name = name; EntityType = entityType; ClrType = entityType.ClrType; _url = Name; _editLinkFactory = null; _readLinkFactory = null; _navigationPropertyLinkBuilders = new Dictionary<string, Func<EntityInstanceContext, IEdmNavigationProperty, Uri>>(); }
public void DerivedTypes_Works() { ODataModelBuilder builder = GetMockVehicleModel(); IEntityTypeConfiguration vehicle = builder.StructuralTypes.OfType <IEntityTypeConfiguration>().Where(e => e.Name == "vehicle").Single(); IEntityTypeConfiguration car = builder.StructuralTypes.OfType <IEntityTypeConfiguration>().Where(e => e.Name == "car").Single(); IEntityTypeConfiguration motorcycle = builder.StructuralTypes.OfType <IEntityTypeConfiguration>().Where(e => e.Name == "motorcycle").Single(); IEntityTypeConfiguration sportbike = builder.StructuralTypes.OfType <IEntityTypeConfiguration>().Where(e => e.Name == "sportbike").Single(); Assert.Equal( builder.DerivedTypes(vehicle).Select(e => e.Name).OrderBy(name => name), new[] { sportbike, motorcycle, car }.Select(e => e.Name).OrderBy(name => name)); }
internal EntitySetConfiguration(ODataModelBuilder modelBuilder, IEntityTypeConfiguration entityType, string name) { _modelBuilder = modelBuilder; Name = name; EntityType = entityType; ClrType = entityType.ClrType; _url = Name; _editLinkFactory = null; _readLinkFactory = null; _navigationPropertyLinkBuilders = new Dictionary <NavigationPropertyConfiguration, Func <EntityInstanceContext, IEdmNavigationProperty, Uri> >(); }
public void IsAssignableFrom_ReturnsFalseForBaseType() { ODataModelBuilder builder = GetMockVehicleModel(); IEntityTypeConfiguration vehicle = builder.StructuralTypes.OfType <IEntityTypeConfiguration>().Where(e => e.Name == "vehicle").Single(); IEntityTypeConfiguration car = builder.StructuralTypes.OfType <IEntityTypeConfiguration>().Where(e => e.Name == "car").Single(); IEntityTypeConfiguration motorcycle = builder.StructuralTypes.OfType <IEntityTypeConfiguration>().Where(e => e.Name == "motorcycle").Single(); IEntityTypeConfiguration sportbike = builder.StructuralTypes.OfType <IEntityTypeConfiguration>().Where(e => e.Name == "sportbike").Single(); Assert.False(car.IsAssignableFrom(vehicle)); Assert.False(motorcycle.IsAssignableFrom(vehicle)); Assert.False(sportbike.IsAssignableFrom(vehicle)); }
// Returns the base types for this type. public static IEnumerable <IEntityTypeConfiguration> BaseTypes(this IEntityTypeConfiguration entity) { Contract.Assert(entity != null); entity = entity.BaseType; while (entity != null) { yield return(entity); entity = entity.BaseType; } }
public static bool IsAssignableFrom(this IEntityTypeConfiguration baseEntity, IEntityTypeConfiguration entity) { while (entity != null) { if (baseEntity == entity) { return(true); } entity = entity.BaseType; } return(false); }
public void GetTargetEntitySet_Returns_Null_IfNoMatchingTargetEntitySet() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); IEntityTypeConfiguration motorcycle = builder.AddEntity(typeof(Motorcycle)); NavigationPropertyConfiguration navigationProperty = motorcycle.AddNavigationProperty(typeof(Motorcycle).GetProperty("Manufacturer"), EdmMultiplicity.ZeroOrOne); // Act IEntitySetConfiguration targetEntitySet = AssociationSetDiscoveryConvention.GetTargetEntitySet(navigationProperty, builder); // Assert Assert.Null(targetEntitySet); }
public override void Apply(IEntityTypeConfiguration entity, ODataModelBuilder model) { if (entity == null) { throw Error.ArgumentNull("entity"); } PropertyInfo key = ConventionsHelpers.GetKeyProperty(entity.ClrType); if (key != null) { entity.HasKey(key); } }
private static PropertyConfiguration GetKeyProperty(IEntityTypeConfiguration entityType) { IEnumerable<PropertyConfiguration> keys = entityType.Properties .Where(p => (p.Name.Equals(entityType.Name + "Id", StringComparison.OrdinalIgnoreCase) || p.Name.Equals("Id", StringComparison.OrdinalIgnoreCase)) && EdmLibHelpers.GetEdmPrimitiveTypeOrNull(p.PropertyInfo.PropertyType) != null); if (keys.Count() == 1) { return keys.Single(); } return null; }
public static string GetEntityKeyValue(EntityInstanceContext entityContext, IEntityTypeConfiguration entityTypeConfiguration) { // TODO: BUG 453795: reflection cleanup if (entityTypeConfiguration.Keys.Count() == 1) { return GetUriRepresentationForKeyValue(entityTypeConfiguration.Keys.First().PropertyInfo, entityContext.EntityInstance); } else { return String.Join( ",", entityTypeConfiguration .Keys .Select( key => String.Format(CultureInfo.InvariantCulture, "{0}={1}", key.Name, GetUriRepresentationForKeyValue(key.PropertyInfo, entityContext.EntityInstance)))); } }
/// <summary> /// Figures out the key properties and marks them as Keys in the EDM model. /// </summary> /// <param name="entity">The entity type being configured.</param> /// <param name="model">The <see cref="ODataModelBuilder"/>.</param> public override void Apply(IEntityTypeConfiguration entity, ODataModelBuilder model) { if (entity == null) { throw Error.ArgumentNull("entity"); } // Try to figure out keys only if there is no base type. if (entity.BaseType == null) { PropertyConfiguration key = GetKeyProperty(entity); if (key != null) { entity.HasKey(key.PropertyInfo); } } }
public NavigationPropertyConfiguration(PropertyInfo property, EdmMultiplicity multiplicity, IEntityTypeConfiguration declaringType) : base(property, declaringType) { if (property == null) { throw Error.ArgumentNull("property"); } Multiplicity = multiplicity; _relatedType = property.PropertyType; if (multiplicity == EdmMultiplicity.Many) { Type elementType; if (!_relatedType.IsCollection(out elementType)) { throw Error.InvalidOperation(SRResources.ManyToManyNavigationPropertyMustReturnCollection, property.Name, property.ReflectedType.Name); } _relatedType = elementType; } }
// Returns all the derived types of this type. public static IEnumerable<IEntityTypeConfiguration> DerivedTypes(this ODataModelBuilder modelBuilder, IEntityTypeConfiguration entity) { if (modelBuilder == null) { throw Error.ArgumentNull("modelBuilder"); } if (entity == null) { throw Error.ArgumentNull("entity"); } IEnumerable<IEntityTypeConfiguration> derivedEntities = modelBuilder.StructuralTypes.OfType<IEntityTypeConfiguration>().Where(e => e.BaseType == entity); foreach (IEntityTypeConfiguration derivedEntity in derivedEntities) { yield return derivedEntity; foreach (IEntityTypeConfiguration derivedDerivedEntity in modelBuilder.DerivedTypes(derivedEntity)) { yield return derivedDerivedEntity; } } }
private static IEntitySetConfiguration GetDefaultEntitySet(IEntityTypeConfiguration targetEntityType, ODataModelBuilder model) { if (targetEntityType == null) { return null; } IEnumerable<IEntitySetConfiguration> matchingEntitySets = model.EntitySets.Where(e => e.EntityType == targetEntityType); if (matchingEntitySets.Count() > 1) { // no default entity set if more than one entity set match. return null; } else if (matchingEntitySets.Count() == 1) { return matchingEntitySets.Single(); } else { // default entity set is the same as the default entity set for the base type. return GetDefaultEntitySet(targetEntityType.BaseType, model); } }
/// <summary> /// Sets the base type of this entity type to <c>null</c> meaning that this entity type /// does not derive from anything. /// </summary> /// <returns>Returns itself so that multiple calls can be chained.</returns> public IEntityTypeConfiguration DerivesFromNothing() { _baseType = null; _baseTypeConfigured = true; return this; }
/// <summary> /// Applies the convention. /// </summary> /// <param name="entity">The <see cref="IEntityTypeConfiguration"/> to apply the convention on.</param> /// <param name="model">The <see cref="ODataModelBuilder"/> instance.</param> public abstract void Apply(IEntityTypeConfiguration entity, ODataModelBuilder model);
public override IEntitySetConfiguration AddEntitySet(string name, IEntityTypeConfiguration entityType) { IEntitySetConfiguration entitySetConfiguration = base.AddEntitySet(name, entityType); if (_isModelBeingBuilt) { ApplyEntitySetConventions(entitySetConfiguration); } return entitySetConfiguration; }
/// <summary> /// Sets the base type of this entity type. /// </summary> /// <param name="baseType">The base entity type.</param> /// <returns>Returns itself so that multiple calls can be chained.</returns> public IEntityTypeConfiguration DerivesFrom(IEntityTypeConfiguration baseType) { if (baseType == null) { throw Error.ArgumentNull("baseType"); } if (!baseType.ClrType.IsAssignableFrom(ClrType) || baseType.ClrType == ClrType) { throw Error.InvalidOperation(SRResources.TypeDoesNotInheritFromBaseType, ClrType.FullName, baseType.ClrType.FullName); } if (Keys.Any()) { throw Error.InvalidOperation(SRResources.CannotDefineKeysOnDerivedTypes, FullName, baseType.FullName); } _baseType = baseType; foreach (PropertyConfiguration property in Properties) { ValidatePropertyNotAlreadyDefinedInBaseTypes(property.PropertyInfo); } foreach (PropertyConfiguration property in this.DerivedProperties()) { ValidatePropertyNotAlreadyDefinedInDerivedTypes(property.PropertyInfo); } return this; }
private void CreateEntityTypeBody(EdmEntityType type, IEntityTypeConfiguration config) { CreateStructuralTypeBody(type, config); IEdmStructuralProperty[] keys = config.Keys.Select(p => type.DeclaredProperties.OfType<IEdmStructuralProperty>().First(dp => dp.Name == p.PropertyInfo.Name)).ToArray(); type.AddKeys(keys); foreach (NavigationPropertyConfiguration navProp in config.NavigationProperties) { EdmNavigationPropertyInfo info = new EdmNavigationPropertyInfo(); info.Name = navProp.Name; info.TargetMultiplicity = navProp.Multiplicity; info.Target = _types[navProp.RelatedClrType] as IEdmEntityType; //TODO: If target end has a multiplity of 1 this assumes the source end is 0..1. // I think a better default multiplicity is * type.AddUnidirectionalNavigation(info); } }
public static bool IsAssignableFrom(this IEntityTypeConfiguration baseEntity, IEntityTypeConfiguration entity) { while (entity != null) { if (baseEntity == entity) { return true; } entity = entity.BaseType; } return false; }