public IEntityConfigurationWrapper <T> ToUseNaturalKey <TKey>(Expression <Func <T, TKey> > naturalKeySelector)
{
var memberExpression = default(MemberExpression);
Guard.Against.InvalidMemberExpression(() => naturalKeySelector, out memberExpression);
var naturalKey = new NaturalKey(typeof(T), memberExpression.Member.Name, typeof(TKey), this.typeAnalyzerService);
this.entityType.ConfigureNaturalKey(naturalKey);
return(this);
}
public void Scenario(Subject instance, NaturalKey naturalKey)
{
"Given a natural key that is a value object"
.f(() => naturalKey = new NaturalKey("naturalKey"));
"When an instance of an aggregate root is created with that natural key"
.f(() => instance = new Subject(naturalKey));
"Then the natural key of that instance should be the original natural key"
.f(() => instance.NaturalKey.Should().Be(naturalKey));
"And the instance should contain a single uncommitted 'NewSubject' event with a natural key value matching the original natural key value"
.f(() => instance.GetUncommittedEvents().Should().ContainSingle(
@event => @event is NewSubject && ((NewSubject)@event).NaturalKeyValue == naturalKey.Value));
}
/// <summary>
/// Initializes a new instance of the <see cref="EntityType"/> class.
/// </summary>
/// <param name="runtimeType">The runtime type.</param>
/// <param name="typeAnalyzerService">The type analyzer service.</param>
public EntityType(Type runtimeType, ITypeAnalyzerService typeAnalyzerService)
: base(new NaturalKey(typeof(EntityType), "RuntimeType", typeof(Type), DefaultTypeAnalyzerService))
{
Guard.Against.Null(() => runtimeType);
Guard.Against.Null(() => typeAnalyzerService);
if (!typeAnalyzerService.IsValidEntity(runtimeType))
{
throw new BusinessException(
string.Format(CultureInfo.InvariantCulture, "The specified runtime type '{0}' is not an entity.", runtimeType));
}
this.RuntimeType = runtimeType;
this.entityNaturalKey = typeAnalyzerService.GetNaturalKey(runtimeType);
this.Mappings = new MapperCollection();
}
/// <summary>
/// Initializes a new instance of the <see cref="EntityType"/> class.
/// </summary>
/// <param name="runtimeType">Type of the runtime.</param>
/// <param name="entityAnalyzerService">The entity analyzer service.</param>
/// <param name="baseEntity">The base entity.</param>
public EntityType(Type runtimeType, ITypeAnalyzerService entityAnalyzerService, EntityType baseEntity)
: this(runtimeType, entityAnalyzerService)
{
Guard.Against.Null(() => runtimeType);
Guard.Against.Null(() => baseEntity);
if (baseEntity.RuntimeType != runtimeType.BaseType)
{
throw new BusinessException(
string.Format(
CultureInfo.InvariantCulture,
"The specified base entity runtime type '{0}' does not match the runtime type base type '{1}'.",
baseEntity.RuntimeType,
runtimeType.BaseType));
}
this.baseEntityNaturalKey = baseEntity.NaturalKey;
}
private void Handle(NewSubject @event)
{
this.NaturalKey = Map.Event(@event).ToValueObject <NaturalKey>();
}
public Subject(NaturalKey key)
{
var @event = Map.ValueObject(key).ToEvent <NewSubject>();
this.Apply(@event);
}
/// <summary>
/// Configures the natural key for this entity type.
/// </summary>
/// <param name="naturalKey">The natural key.</param>
public void ConfigureNaturalKey(NaturalKey naturalKey)
{
Guard.Against.Null(() => naturalKey);
if (this.entityNaturalKey == naturalKey)
{
return;
}
if (naturalKey.RuntimeType != this.RuntimeType)
{
throw new BusinessException(
string.Format(
CultureInfo.InvariantCulture,
"Invalid natural key specified. The natural key must have a declaring type of '{0}'.",
this.RuntimeType));
}
if (this.entityNaturalKey != null)
{
throw new BusinessException(
string.Format(
CultureInfo.InvariantCulture,
"Cannot configure the natural key for the entity '{0}' to be the property '{1}' as the natural key is already configured to be the property '{2}'.",
this.RuntimeType,
naturalKey.PropertyName,
this.NaturalKey.PropertyName));
}
this.entityNaturalKey = naturalKey;
}
