/// <summary>
/// <para>
/// Configures a relationship where this entity type has a reference that points
/// to a single instance of the other type in the relationship.
/// </para>
/// <para>
/// After calling this method, you should chain a call to
/// <see cref="ReferenceNavigationBuilder{TEntity,TRelatedEntity}
/// .WithMany(Expression{Func{TRelatedEntity,IEnumerable{TEntity}}})" />
/// or
/// <see cref="ReferenceNavigationBuilder{TEntity,TRelatedEntity}
/// .WithOne(Expression{Func{TRelatedEntity,TEntity}})" />
/// to fully configure the relationship. Calling just this method without the chained call will not
/// produce a valid relationship.
/// </para>
/// </summary>
/// <typeparam name="TNewRelatedEntity"> The entity type that this relationship targets. </typeparam>
/// <param name="navigationExpression">
/// A lambda expression representing the reference navigation property on this entity type that represents
/// the relationship (<c>post => post.Blog</c>). If no property is specified, the relationship will be
/// configured without a navigation property on this end.
/// </param>
/// <returns> An object that can be used to configure the relationship. </returns>
public virtual ReferenceNavigationBuilder <TRelatedEntity, TNewRelatedEntity> HasOne <TNewRelatedEntity>(
[CanBeNull] Expression <Func <TRelatedEntity, TNewRelatedEntity> > navigationExpression = null)
where TNewRelatedEntity : class
{
var relatedEntityType = RelatedEntityType.FindInDefinitionPath(typeof(TNewRelatedEntity)) ??
Builder.ModelBuilder.Entity(typeof(TNewRelatedEntity), ConfigurationSource.Explicit).Metadata;
var navigation = navigationExpression?.GetPropertyAccess();
return(new ReferenceNavigationBuilder <TRelatedEntity, TNewRelatedEntity>(
RelatedEntityType,
relatedEntityType,
navigation,
RelatedEntityType.Builder.Navigation(relatedEntityType.Builder, navigation, ConfigurationSource.Explicit,
setTargetAsPrincipal: RelatedEntityType == relatedEntityType)));
}
/// <summary>
/// <para>
/// Configures a relationship where this entity type has a reference that points
/// to a single instance of the other type in the relationship.
/// </para>
/// <para>
/// After calling this method, you should chain a call to
/// <see cref="ReferenceNavigationBuilder.WithMany" />
/// or <see cref="ReferenceNavigationBuilder.WithOne" /> to fully configure
/// the relationship. Calling just this method without the chained call will not
/// produce a valid relationship.
/// </para>
/// </summary>
/// <param name="relatedTypeName"> The name of the entity type that this relationship targets. </param>
/// <param name="navigationName">
/// The name of the reference navigation property on this entity type that represents the relationship. If
/// no property is specified, the relationship will be configured without a navigation property on this
/// end.
/// </param>
/// <returns> An object that can be used to configure the relationship. </returns>
public virtual ReferenceNavigationBuilder HasOne(
[NotNull] string relatedTypeName,
[CanBeNull] string navigationName = null)
{
Check.NotEmpty(relatedTypeName, nameof(relatedTypeName));
Check.NullButNotEmpty(navigationName, nameof(navigationName));
var relatedEntityType = RelatedEntityType.FindInDefinitionPath(relatedTypeName) ??
RelatedEntityType.Builder.ModelBuilder.Entity(relatedTypeName, ConfigurationSource.Explicit).Metadata;
return(new ReferenceNavigationBuilder(
RelatedEntityType,
relatedEntityType,
navigationName,
RelatedEntityType.Builder.Navigation(relatedEntityType.Builder, navigationName, ConfigurationSource.Explicit,
setTargetAsPrincipal: RelatedEntityType == relatedEntityType)));
}
