private bool PrepareForAdd(EntityState newState)
{
if (newState != EntityState.Added ||
EntityState == EntityState.Added)
{
return(false);
}
// Temporarily change the internal state to unknown so that key generation, including setting key values
// can happen without constraints on changing read-only values kicking in
_stateData.EntityState = EntityState.Unknown;
_stateData.FlagAllProperties(EntityType.Properties.Count(), isFlagged: false);
return(true);
}
private bool PrepareForAdd(EntityState newState)
{
if (newState != EntityState.Added ||
EntityState == EntityState.Added)
{
return(false);
}
if (EntityState == EntityState.Modified)
{
_stateData.FlagAllProperties(EntityType.PropertyCount(), PropertyFlag.TemporaryOrModified, flagged: false);
}
// Temporarily change the internal state to unknown so that key generation, including setting key values
// can happen without constraints on changing read-only values kicking in
_stateData.EntityState = EntityState.Detached;
StateManager.EndSingleQueryMode();
return(true);
}
private IEnumerable <Tuple <IProperty, IValueGenerator> > PrepareForAdd(EntityState newState)
{
if (newState != EntityState.Added ||
EntityState == EntityState.Added)
{
return(null);
}
// Temporarily change the internal state to unknown so that key generation, including setting key values
// can happen without constraints on changing read-only values kicking in
_stateData.EntityState = EntityState.Unknown;
_stateData.FlagAllProperties(_entityType.Properties.Count(), isFlagged: false);
var generators = _entityType.Properties
.Where(p => (p.ValueGeneration == ValueGeneration.OnAdd || p.IsForeignKey()) && HasDefaultValue(p))
.Select(p => Tuple.Create(p, _configuration.ValueGeneratorCache.GetGenerator(p)))
.Where(g => g.Item2 != null)
.ToList();
// Return null if there are no generators to avoid subsequent async method overhead
return(generators.Count > 0 ? generators : null);
}
private void SetEntityState(EntityState newState, Tuple <IProperty, object>[] generatedValues)
{
// The entity state can be Modified even if some properties are not modified so always
// set all properties to modified if the entity state is explicitly set to Modified.
if (newState == EntityState.Modified)
{
_stateData.FlagAllProperties(_entityType.Properties.Count(), isFlagged: true);
// Assuming key properties are not modified
foreach (var keyProperty in EntityType.GetPrimaryKey().Properties)
{
_stateData.FlagProperty(keyProperty.Index, isFlagged: false);
}
}
var oldState = _stateData.EntityState;
if (oldState == newState)
{
return;
}
// An Added entity does not yet exist in the database. If it is then marked as deleted there is
// nothing to delete because it was not yet inserted, so just make sure it doesn't get inserted.
if (oldState == EntityState.Added &&
newState == EntityState.Deleted)
{
newState = EntityState.Unknown;
}
if (newState == EntityState.Unchanged || newState == EntityState.Added)
{
_stateData.FlagAllProperties(_entityType.Properties.Count(), isFlagged: false);
}
_configuration.Services.StateEntryNotifier.StateChanging(this, newState);
if (newState == EntityState.Added)
{
foreach (var generatedValue in generatedValues.Where(v => v != null && v.Item2 != null))
{
this[generatedValue.Item1] = generatedValue.Item2;
// TODO: Set default flag or not based on strategy
_stateData.FlagProperty(generatedValue.Item1.Index, isFlagged: false);
}
}
else
{
Contract.Assert(generatedValues == null);
}
_stateData.EntityState = newState;
if (oldState == EntityState.Unknown)
{
_configuration.StateManager.StartTracking(this);
}
else if (newState == EntityState.Unknown)
{
// TODO: Does changing to Unknown really mean stop tracking?
_configuration.StateManager.StopTracking(this);
}
_configuration.Services.StateEntryNotifier.StateChanged(this, oldState);
}
