protected NavigationSourceConfiguration(ODataModelBuilder modelBuilder, EntityTypeConfiguration entityType, string name) { if (modelBuilder == null) { throw Error.ArgumentNull("modelBuilder"); } if (entityType == null) { throw Error.ArgumentNull("entityType"); } if (String.IsNullOrEmpty(name)) { throw Error.ArgumentNullOrEmpty("name"); } _modelBuilder = modelBuilder; Name = name; EntityType = entityType; ClrType = entityType.ClrType; _url = Name; _editLinkBuilder = null; _readLinkBuilder = null; _navigationPropertyLinkBuilders = new Dictionary<NavigationPropertyConfiguration, NavigationLinkBuilder>(); _navigationPropertyBindings = new Dictionary<NavigationPropertyConfiguration, NavigationPropertyBindingConfiguration>(); }
private static void AddBoundActionsAndFunctions(EntityTypeConfiguration<Employee> employee) { var actionConfiguration = employee.Action("AddSkill"); actionConfiguration.Parameter<Skill>("skill"); actionConfiguration.ReturnsCollection<Skill>(); var functionConfiguration = employee.Function("GetAccessLevel"); functionConfiguration.Returns<AccessLevel>(); }
// Returns the base types, this type and all the derived types of this type. public static IEnumerable<EntityTypeConfiguration> ThisAndBaseAndDerivedTypes(this ODataModelBuilder modelBuilder, EntityTypeConfiguration entity) { Contract.Assert(modelBuilder != null); Contract.Assert(entity != null); return entity.BaseTypes() .Concat(new[] { entity }) .Concat(modelBuilder.DerivedTypes(entity)); }
private static void AddBoundActionsAndFunctions(EntityTypeConfiguration<Account> account) { account.Function("GetAddressFunction").Returns<Address>(); account.Function("GetShipAddresses").ReturnsCollection<Address>(); account.Action("IncreaseAgeAction").Returns<AccountInfo>(); ActionConfiguration addShipAddress = account.Action("AddShipAddress"); addShipAddress.Parameter<Address>("address"); addShipAddress.Returns<int>();// Total ship addresses count. }
public void CtorThatTakesEntityTypeConfiguration_Sets_Property_EntityType() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration entityType = new EntityTypeConfiguration(new ODataModelBuilder(), typeof(EntitySetConfigurationTest)); // Act EntitySetConfiguration entityset = new EntitySetConfiguration(builder, entityType, "entityset"); // Assert Assert.Equal(entityType, entityset.EntityType); }
public void CtorThatTakesEntityTypeConfiguration_Sets_Property_EntityType() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration entityType = new EntityTypeConfiguration(new ODataModelBuilder(), typeof(SingletonConfigurationTest)); // Act SingletonConfiguration singleton = new SingletonConfiguration(builder, entityType, "singleton"); // Assert Assert.Equal(entityType, singleton.EntityType); }
/// <summary> /// Initializes a new instance of the <see cref="NavigationPropertyConfiguration"/> class. /// </summary> /// <param name="property">The backing CLR property.</param> /// <param name="multiplicity">The <see cref="EdmMultiplicity"/>.</param> /// <param name="declaringType">The declaring entity type.</param> public NavigationPropertyConfiguration(PropertyInfo property, EdmMultiplicity multiplicity, EntityTypeConfiguration 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.Argument("property", SRResources.ManyToManyNavigationPropertyMustReturnCollection, property.Name, property.ReflectedType.Name); } _relatedType = elementType; } }
// Returns all the derived types of this type. public static IEnumerable<EntityTypeConfiguration> DerivedTypes(this ODataModelBuilder modelBuilder, EntityTypeConfiguration entity) { if (modelBuilder == null) { throw Error.ArgumentNull("modelBuilder"); } if (entity == null) { throw Error.ArgumentNull("entity"); } IEnumerable<EntityTypeConfiguration> derivedEntities = modelBuilder.StructuralTypes.OfType<EntityTypeConfiguration>().Where(e => e.BaseType == entity); foreach (EntityTypeConfiguration derivedEntity in derivedEntities) { yield return derivedEntity; foreach (EntityTypeConfiguration derivedDerivedEntity in modelBuilder.DerivedTypes(derivedEntity)) { yield return derivedDerivedEntity; } } }
/// <summary> /// Initializes a new instance of the <see cref="EntitySetConfiguration"/> class. /// </summary> /// <param name="modelBuilder">The <see cref="ODataModelBuilder"/>.</param> /// <param name="entityType">The entity type <see cref="EntityTypeConfiguration"/> contained in this entity set.</param> /// <param name="name">The name of the entity set.</param> public EntitySetConfiguration(ODataModelBuilder modelBuilder, EntityTypeConfiguration entityType, string name) : base(modelBuilder, entityType, name) { }
/// <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 virtual EntityTypeConfiguration DerivesFrom(EntityTypeConfiguration baseType) { if (baseType == null) { throw Error.ArgumentNull("baseType"); } _baseType = baseType; _baseTypeConfigured = true; if (!baseType.ClrType.IsAssignableFrom(ClrType) || baseType.ClrType == ClrType) { throw Error.Argument("baseType", 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; }
/// <summary> /// Initializes a new instance of the <see cref="NavigationPropertyConfiguration"/> class. /// </summary> /// <param name="property">The backing CLR property.</param> /// <param name="multiplicity">The <see cref="EdmMultiplicity"/>.</param> /// <param name="declaringType">The declaring entity type.</param> public NavigationPropertyConfiguration(PropertyInfo property, EdmMultiplicity multiplicity, EntityTypeConfiguration 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.Argument("property", SRResources.ManyToManyNavigationPropertyMustReturnCollection, property.Name, property.ReflectedType.Name); } _relatedType = elementType; } }
private void CreateNavigationProperty(EntityTypeConfiguration config) { Contract.Assert(config != null); EdmEntityType type = (EdmEntityType)(GetEdmType(config.ClrType)); foreach (NavigationPropertyConfiguration navProp in config.NavigationProperties) { EdmNavigationPropertyInfo info = new EdmNavigationPropertyInfo { Name = navProp.Name, TargetMultiplicity = navProp.Multiplicity, Target = GetEdmType(navProp.RelatedClrType) as IEdmEntityType, ContainsTarget = navProp.ContainsTarget, OnDelete = navProp.OnDeleteAction }; // Principal properties if (navProp.PrincipalProperties.Any()) { info.PrincipalProperties = GetDeclaringPropertyInfo(navProp.PrincipalProperties); } // Dependent properties if (navProp.DependentProperties.Any()) { info.DependentProperties = GetDeclaringPropertyInfo(navProp.DependentProperties); } IEdmProperty edmProperty = type.AddUnidirectionalNavigation(info); if (navProp.PropertyInfo != null && edmProperty != null) { _properties[navProp.PropertyInfo] = edmProperty; } if (edmProperty != null && navProp.IsRestricted) { _propertiesRestrictions[edmProperty] = new QueryableRestrictions(navProp); } } }
/// <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 virtual EntityTypeConfiguration DerivesFromNothing() { _baseType = null; _baseTypeConfigured = true; return this; }
private void CreateEntityTypeBody(EdmEntityType type, EntityTypeConfiguration config) { Contract.Assert(type != null); Contract.Assert(config != null); CreateStructuralTypeBody(type, config); IEnumerable<IEdmStructuralProperty> keys = config.Keys.Select(p => type.DeclaredProperties.OfType<IEdmStructuralProperty>().First(dp => dp.Name == p.Name)); type.AddKeys(keys); foreach (NavigationPropertyConfiguration navProp in config.NavigationProperties) { EdmNavigationPropertyInfo info = new EdmNavigationPropertyInfo { Name = navProp.Name, TargetMultiplicity = navProp.Multiplicity, Target = GetEdmType(navProp.RelatedClrType) as IEdmEntityType, ContainsTarget = navProp.ContainsTarget }; IEdmProperty edmProperty = type.AddUnidirectionalNavigation(info); if (navProp.PropertyInfo != null && edmProperty != null) { _properties[navProp.PropertyInfo] = edmProperty; } if (edmProperty != null && navProp.IsRestricted) { _propertiesRestrictions[edmProperty] = new QueryableRestrictions(navProp); } } }
private void CreateEntityTypeBody(EdmEntityType type, EntityTypeConfiguration config) { Contract.Assert(type != null); Contract.Assert(config != null); CreateStructuralTypeBody(type, config); IEnumerable<IEdmStructuralProperty> keys = config.Keys.Select(p => type.DeclaredProperties.OfType<IEdmStructuralProperty>().First(dp => dp.Name == p.Name)); type.AddKeys(keys); // Add the Enum keys keys = config.EnumKeys.Select(p => type.DeclaredProperties.OfType<IEdmStructuralProperty>().First(dp => dp.Name == p.Name)); type.AddKeys(keys); }
/// <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 virtual EntityTypeConfiguration DerivesFrom(EntityTypeConfiguration baseType) { if ((Keys.Any() || EnumKeys.Any()) && baseType.Keys().Any()) { throw Error.InvalidOperation(SRResources.CannotDefineKeysOnDerivedTypes, FullName, baseType.FullName); } DerivesFromImpl(baseType); return this; }
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.EntityType <Blockbuster>().DerivesFrom <Movie>(); EntityTypeConfiguration movieConfiguration = builder.StructuralTypes.OfType <EntityTypeConfiguration>().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 = builder.Action("InCache4_MovieAction"); incache4_MovieAction.SetBindingParameter("bindingParameter", movieConfiguration); 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 = builder.Action("NotInCache3_NoParameters"); ActionConfiguration notInCache4_AddressParameter = builder.Action("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); IEdmAction[] movieActions = annotation.FindProcedures(movieType) .OfType <IEdmAction>() .ToArray(); IEdmAction[] customerActions = annotation.FindProcedures(customerType) .OfType <IEdmAction>() .ToArray(); IEdmAction[] blockBusterActions = annotation.FindProcedures(blockBusterType) .OfType <IEdmAction>() .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 CanCreateEdmModel_ForBindableFunction_WithSupportedParameterType() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration <Customer> customer = builder.EntityType <Customer>(); customer.HasKey(c => c.CustomerId); customer.Property(c => c.Name); // Act FunctionConfiguration functionBuilder = customer.Function("FunctionName"); functionBuilder.Parameter <int>("primitive"); functionBuilder.CollectionParameter <int>("collectionPrimitive"); functionBuilder.Parameter <bool?>("nullablePrimitive"); functionBuilder.CollectionParameter <bool?>("nullableCollectionPrimitive"); functionBuilder.Parameter <Color>("enum"); functionBuilder.CollectionParameter <Color>("collectionEnum"); functionBuilder.Parameter <Color?>("nullableEnum"); functionBuilder.CollectionParameter <Color?>("nullableCollectionEnum"); functionBuilder.Parameter <Address>("complex"); functionBuilder.CollectionParameter <Address>("collectionComplex"); functionBuilder.EntityParameter <Customer>("entity"); functionBuilder.CollectionEntityParameter <Customer>("collectionEntity"); functionBuilder.Returns <bool>(); IEdmModel model = builder.GetEdmModel(); // Assert Assert.Equal(1, model.SchemaElements.OfType <IEdmFunction>().Count()); IEdmFunction function = Assert.Single(model.SchemaElements.OfType <IEdmFunction>()); Assert.False(function.IsComposable); Assert.True(function.IsBound); Assert.Equal("FunctionName", function.Name); Assert.NotNull(function.ReturnType); Assert.Equal(13, function.Parameters.Count()); function.AssertHasParameter(model, BindingParameterConfiguration.DefaultBindingParameterName, typeof(Customer), true); function.AssertHasParameter(model, parameterName: "primitive", parameterType: typeof(int), isNullable: false); function.AssertHasParameter(model, parameterName: "collectionPrimitive", parameterType: typeof(IList <int>), isNullable: false); function.AssertHasParameter(model, parameterName: "nullablePrimitive", parameterType: typeof(bool?), isNullable: true); function.AssertHasParameter(model, parameterName: "nullableCollectionPrimitive", parameterType: typeof(IList <bool?>), isNullable: true); function.AssertHasParameter(model, parameterName: "enum", parameterType: typeof(Color), isNullable: false); function.AssertHasParameter(model, parameterName: "collectionEnum", parameterType: typeof(IList <Color>), isNullable: false); function.AssertHasParameter(model, parameterName: "nullableEnum", parameterType: typeof(Color?), isNullable: true); function.AssertHasParameter(model, parameterName: "nullableCollectionEnum", parameterType: typeof(IList <Color?>), isNullable: true); function.AssertHasParameter(model, parameterName: "complex", parameterType: typeof(Address), isNullable: true); function.AssertHasParameter(model, parameterName: "collectionComplex", parameterType: typeof(IList <Address>), isNullable: true); function.AssertHasParameter(model, parameterName: "entity", parameterType: typeof(Customer), isNullable: true); function.AssertHasParameter(model, parameterName: "collectionEntity", parameterType: typeof(IList <Customer>), isNullable: true); }
public void CanBuildProcedureBoundToCollectionCacheForIEdmModel() { // 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.EntityType <Blockbuster>().DerivesFrom <Movie>(); EntityTypeConfiguration movieConfiguration = builder.StructuralTypes.OfType <EntityTypeConfiguration>().Single(t => t.Name == "Movie"); // build actions that are bindable to the collection of entity customer.Collection.Action("CollectionCustomerActionInCache1"); customer.Collection.Action("CollectionCustomerActionInCache2"); movie.Collection.Action("CollectionMovieActionInCache3"); ActionConfiguration movieActionIncache4 = builder.Action("CollectionMovieActionInCache4"); CollectionTypeConfiguration collectionConfiguration = new CollectionTypeConfiguration(movieConfiguration, typeof(Movie)); movieActionIncache4.SetBindingParameter("bindingParameter", collectionConfiguration); blockBuster.Collection.Action("CollectionBlockbusterActionInCache5"); // build functions that are bindable to the collection of entity customer.Collection.Function("CollectionCustomerFunctionInCache1").Returns <int>(); customer.Collection.Function("CollectionCustomerFunctionInCache2").Returns <int>(); movie.Collection.Function("CollectionMovieFunctionInCache3").Returns <int>(); blockBuster.Collection.Function("CollectionBlockbusterFunctionInCache5").Returns <int>(); // build actions that are either: bindable to an entity, have no parameter, have only complex parameter customer.Action("CustomersActionNotInCache1"); customer.Function("CustomersFunctionNotInCache1").Returns <int>(); movie.Action("MoviesActionNotInCache2"); builder.Action("NoParametersNotInCache3"); ActionConfiguration addressParameterNotInCache4 = builder.Action("AddressParameterNotInCache4"); addressParameterNotInCache4.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); var movieOperations = annotation.FindProceduresBoundToCollection(movieType).ToArray(); var customerOperations = annotation.FindProceduresBoundToCollection(customerType).ToArray(); var blockBusterOperations = annotation.FindProceduresBoundToCollection(blockBusterType).ToArray(); // Assert Assert.Equal(3, movieOperations.Length); Assert.Single(movieOperations.Where(a => a.Name == "CollectionMovieActionInCache3")); Assert.Single(movieOperations.Where(a => a.Name == "CollectionMovieActionInCache4")); Assert.Single(movieOperations.Where(a => a.Name == "CollectionMovieFunctionInCache3")); Assert.Equal(4, customerOperations.Length); Assert.Single(customerOperations.Where(a => a.Name == "CollectionCustomerActionInCache1")); Assert.Single(customerOperations.Where(a => a.Name == "CollectionCustomerActionInCache2")); Assert.Single(customerOperations.Where(a => a.Name == "CollectionCustomerFunctionInCache1")); Assert.Single(customerOperations.Where(a => a.Name == "CollectionCustomerFunctionInCache2")); Assert.Equal(5, blockBusterOperations.Length); Assert.Single(blockBusterOperations.Where(a => a.Name == "CollectionBlockbusterActionInCache5")); Assert.Single(blockBusterOperations.Where(a => a.Name == "CollectionBlockbusterFunctionInCache5")); Assert.Single(blockBusterOperations.Where(a => a.Name == "CollectionMovieActionInCache3")); Assert.Single(blockBusterOperations.Where(a => a.Name == "CollectionMovieActionInCache4")); Assert.Single(blockBusterOperations.Where(a => a.Name == "CollectionMovieFunctionInCache3")); }
internal EntityCollectionConfiguration(EntityTypeConfiguration elementType) : base(elementType, typeof(IEnumerable <TEntityType>)) { }
/// <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 virtual EntityTypeConfiguration DerivesFromNothing() { _baseType = null; _baseTypeConfigured = true; return(this); }
// the convention model builder MapTypes() method might have went through deep object graphs and added a bunch of types // only to realise after applying the conventions that the user has ignored some of the properties. So, prune the unreachable stuff. private void PruneUnreachableTypes() { Contract.Assert(_explicitlyAddedTypes != null); // Do a BFS starting with the types the user has explicitly added to find out the unreachable nodes. Queue <StructuralTypeConfiguration> reachableTypes = new Queue <StructuralTypeConfiguration>(_explicitlyAddedTypes); HashSet <StructuralTypeConfiguration> visitedTypes = new HashSet <StructuralTypeConfiguration>(); while (reachableTypes.Count != 0) { StructuralTypeConfiguration currentType = reachableTypes.Dequeue(); // go visit other end of each of this node's edges. foreach (PropertyConfiguration property in currentType.Properties.Where(property => property.Kind != PropertyKind.Primitive)) { if (property.Kind == PropertyKind.Collection) { // if the elementType is primitive we don't need to do anything. CollectionPropertyConfiguration colProperty = property as CollectionPropertyConfiguration; if (EdmLibHelpers.GetEdmPrimitiveTypeOrNull(colProperty.ElementType) != null) { continue; } } IEdmTypeConfiguration propertyType = GetStructuralTypeOrNull(property.RelatedClrType); Contract.Assert(propertyType != null, "we should already have seen this type"); var structuralTypeConfiguration = propertyType as StructuralTypeConfiguration; if (structuralTypeConfiguration != null && !visitedTypes.Contains(propertyType)) { reachableTypes.Enqueue(structuralTypeConfiguration); } } // all derived types and the base type are also reachable if (currentType.Kind == EdmTypeKind.Entity) { EntityTypeConfiguration currentEntityType = (EntityTypeConfiguration)currentType; if (currentEntityType.BaseType != null && !visitedTypes.Contains(currentEntityType.BaseType)) { reachableTypes.Enqueue(currentEntityType.BaseType); } foreach (EntityTypeConfiguration derivedType in this.DerivedTypes(currentEntityType)) { if (!visitedTypes.Contains(derivedType)) { reachableTypes.Enqueue(derivedType); } } } else if (currentType.Kind == EdmTypeKind.Complex) { ComplexTypeConfiguration currentComplexType = (ComplexTypeConfiguration)currentType; if (currentComplexType.BaseType != null && !visitedTypes.Contains(currentComplexType.BaseType)) { reachableTypes.Enqueue(currentComplexType.BaseType); } foreach (ComplexTypeConfiguration derivedType in this.DerivedTypes(currentComplexType)) { if (!visitedTypes.Contains(derivedType)) { reachableTypes.Enqueue(derivedType); } } } visitedTypes.Add(currentType); } StructuralTypeConfiguration[] allConfiguredTypes = StructuralTypes.ToArray(); foreach (StructuralTypeConfiguration type in allConfiguredTypes) { if (!visitedTypes.Contains(type)) { // we don't have to fix up any properties because this type is unreachable and cannot be a property of any reachable type. RemoveStructuralType(type.ClrType); } } }
/// <summary> /// Registers a singleton as a part of the model and returns an object that can be used to configure the singleton. /// This method can be called multiple times for the same type to perform multiple lines of configuration. /// </summary> /// <typeparam name="TEntityType">The entity type of the singleton.</typeparam> /// <param name="name">The name of the singleton.</param> /// <returns>The configuration object for the specified singleton.</returns> public SingletonConfiguration <TEntityType> Singleton <TEntityType>(string name) where TEntityType : class { EntityTypeConfiguration entity = AddEntityType(typeof(TEntityType)); return(new SingletonConfiguration <TEntityType>(this, AddSingleton(name, entity))); }
/// <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> /// <typeparam name="TEntityType">The entity type of the entity set.</typeparam> /// <param name="name">The name of the entity set.</param> /// <returns>The configuration object for the specified entity set.</returns> public EntitySetConfiguration <TEntityType> EntitySet <TEntityType>(string name) where TEntityType : class { EntityTypeConfiguration entity = AddEntityType(typeof(TEntityType)); return(new EntitySetConfiguration <TEntityType>(this, AddEntitySet(name, entity))); }
public static bool IsAssignableFrom(this EntityTypeConfiguration baseEntity, EntityTypeConfiguration entity) { while (entity != null) { if (baseEntity == entity) { return true; } entity = entity.BaseType; } return false; }
/// <summary> /// Initializes a new instance of the <see cref="EntitySetConfiguration"/> class. /// </summary> /// <param name="modelBuilder">The <see cref="ODataModelBuilder"/>.</param> /// <param name="entityType">The entity type <see cref="EntityTypeConfiguration"/> contained in this entity set.</param> /// <param name="name">The name of the entity set.</param> public EntitySetConfiguration(ODataModelBuilder modelBuilder, EntityTypeConfiguration entityType, string name) : base(modelBuilder, entityType, name) { }