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)
{
}