public override void Required_non_PK_one_to_one_with_alternate_key_are_cascade_detached_when_Added(
CascadeTiming cascadeDeleteTiming,
CascadeTiming deleteOrphansTiming)
{
base.Required_non_PK_one_to_one_with_alternate_key_are_cascade_detached_when_Added(
cascadeDeleteTiming, deleteOrphansTiming);
}
public virtual void Entity_removed_from_navigation_property_binding_list_is_removed_from_nav_property_but_not_marked_Deleted(
CascadeTiming deleteOrphansTiming)
{
using var context = CreateF1Context();
context.ChangeTracker.DeleteOrphansTiming = deleteOrphansTiming;
var ferrari = context.Teams.Single(t => t.Id == Team.Ferrari);
var navBindingList = ((IListSource)ferrari.Drivers).GetList();
var localDrivers = context.Drivers.Local;
var alonso = localDrivers.Single(d => d.Name == "Fernando Alonso");
navBindingList.Remove(alonso);
Assert.Contains(alonso, localDrivers);
context.ChangeTracker.DetectChanges();
if (deleteOrphansTiming == CascadeTiming.Immediate)
{
Assert.DoesNotContain(alonso, localDrivers);
}
else
{
Assert.Contains(alonso, localDrivers); // Because it is not marked as Deleted
}
Assert.False(ferrari.Drivers.Contains(alonso)); // But has been removed from nav prop
}
public override async Task Load_one_to_one_reference_to_dependent_already_loaded_untyped(
EntityState state, bool async, CascadeTiming cascadeDeleteTiming)
{
await base.Load_one_to_one_reference_to_dependent_already_loaded_untyped(state, async, cascadeDeleteTiming);
AssertSql("");
}
public override void Lazy_load_one_to_one_reference_to_dependent_already_loaded(
EntityState state, CascadeTiming cascadeDeleteTiming)
{
base.Lazy_load_one_to_one_reference_to_dependent_already_loaded(state, cascadeDeleteTiming);
Assert.Equal("", Sql);
}
public override void Required_many_to_one_dependents_with_alternate_key_are_cascade_deleted_in_store(
CascadeTiming cascadeDeleteTiming,
CascadeTiming deleteOrphansTiming)
{
base.Required_many_to_one_dependents_with_alternate_key_are_cascade_deleted_in_store(
cascadeDeleteTiming, deleteOrphansTiming);
}
public override void Lazy_load_many_to_one_reference_to_principal_already_loaded(
EntityState state,
CascadeTiming cascadeDeleteTiming)
{
base.Lazy_load_many_to_one_reference_to_principal_already_loaded(state, cascadeDeleteTiming);
AssertSql(@"");
}
public override async Task Load_collection_using_Query_already_loaded_untyped(
EntityState state, bool async, CascadeTiming cascadeDeleteTiming)
{
await base.Load_collection_using_Query_already_loaded_untyped(state, async, cascadeDeleteTiming);
AssertSql(
@"@__p_0='707' (Nullable = true)
SELECT [c].[Id], [c].[ParentId]
FROM [Child] AS [c]
WHERE [c].[ParentId] = @__p_0");
}
public override async Task Load_one_to_one_reference_to_dependent_using_Query_already_loaded(
EntityState state, bool async, CascadeTiming cascadeDeleteTiming)
{
await base.Load_one_to_one_reference_to_dependent_using_Query_already_loaded(state, async, cascadeDeleteTiming);
AssertSql(
@"@__p_0='707' (Nullable = true)
SELECT TOP(2) [s].[Id], [s].[ParentId]
FROM [Single] AS [s]
WHERE [s].[ParentId] = @__p_0");
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public DbContextPoolConfigurationSnapshot(
bool autoDetectChangesEnabled,
QueryTrackingBehavior queryTrackingBehavior,
bool autoTransactionsEnabled,
bool autoSavepointsEnabled,
bool lazyLoadingEnabled,
CascadeTiming cascadeDeleteTiming,
CascadeTiming deleteOrphansTiming,
EventHandler <SavingChangesEventArgs>?savingChanges,
EventHandler <SavedChangesEventArgs>?savedChanges,
EventHandler <SaveChangesFailedEventArgs>?saveChangesFailed)
{
AutoDetectChangesEnabled = autoDetectChangesEnabled;
QueryTrackingBehavior = queryTrackingBehavior;
AutoTransactionsEnabled = autoTransactionsEnabled;
AutoSavepointsEnabled = autoSavepointsEnabled;
LazyLoadingEnabled = lazyLoadingEnabled;
CascadeDeleteTiming = cascadeDeleteTiming;
DeleteOrphansTiming = deleteOrphansTiming;
SavingChanges = savingChanges;
SavedChanges = savedChanges;
SaveChangesFailed = saveChangesFailed;
}
public override void Required_non_PK_one_to_one_are_cascade_detached_when_Added(
CascadeTiming cascadeDeleteTiming,
CascadeTiming deleteOrphansTiming)
{
}
public override void Required_many_to_one_dependents_are_cascade_deleted_in_store(
CascadeTiming cascadeDeleteTiming,
CascadeTiming deleteOrphansTiming)
{
}
public override void Required_one_to_one_with_alternate_key_are_cascade_deleted_in_store(
CascadeTiming cascadeDeleteTiming,
CascadeTiming deleteOrphansTiming)
{
}
public override void Optional_many_to_one_dependents_are_orphaned_in_store(
CascadeTiming cascadeDeleteTiming,
CascadeTiming deleteOrphansTiming)
{
}
public void IsModified_tracks_detects_deletion_of_related_entity(bool useExplicitPk, CascadeTiming cascadeTiming)
{
using var context = useExplicitPk ? new ExplicitFreezerContext() : new FreezerContext();
context.ChangeTracker.CascadeDeleteTiming = cascadeTiming;
var cherry1 = new Cherry {
Id = 1
};
var cherry2 = new Cherry {
Id = 2
};
var chunky1 = new Chunky {
Id = 1
};
var chunky2 = new Chunky {
Id = 2
};
AttachGraph(context, cherry1, cherry2, chunky1, chunky2);
var relatedToCherry1 = context.Entry(cherry1).Collection(e => e.Chunkies);
var relatedToCherry2 = context.Entry(cherry2).Collection(e => e.Chunkies);
var relatedToChunky1 = context.Entry(chunky1).Collection(e => e.Cherries);
var relatedToChunky2 = context.Entry(chunky2).Collection(e => e.Cherries);
Assert.False(relatedToCherry1.IsModified);
Assert.False(relatedToCherry2.IsModified);
Assert.False(relatedToChunky1.IsModified);
Assert.False(relatedToChunky2.IsModified);
context.Entry(chunky1).State = EntityState.Deleted;
Assert.True(relatedToCherry1.IsModified);
Assert.False(relatedToCherry2.IsModified);
Assert.True(relatedToChunky1.IsModified);
Assert.False(relatedToChunky2.IsModified);
}
/// <summary>
/// Creates a scope in which a DbContext instance behaves differently.
/// The behaviour is resetted on disposal of the scope to what it was before.
/// </summary>
/// <param name="ctx">The context instance to change behavior for.</param>
/// <param name="deferCommit">
/// Suppresses the execution of <see cref="DbContext.SaveChanges()"/> / <see cref="DbContext.SaveChangesAsync(CancellationToken)"/>
/// until this instance is disposed or <see cref="Commit()"/> / <see cref="CommitAsync(CancellationToken)"/> is called explicitly.
/// </param>
/// <param name="retainConnection">
/// Opens connection and retains it until disposal. May increase load/save performance in large scopes.
/// </param>
public DbContextScope(HookingDbContext ctx,
bool?autoDetectChanges = null,
bool?hooksEnabled = null,
bool?lazyLoading = null,
bool?forceNoTracking = null,
bool?deferCommit = false,
bool retainConnection = false,
CascadeTiming?cascadeDeleteTiming = null,
CascadeTiming?deleteOrphansTiming = null,
bool?autoTransactions = null)
{
Guard.NotNull(ctx, nameof(ctx));
var changeTracker = ctx.ChangeTracker;
_ctx = ctx;
_autoDetectChangesEnabled = changeTracker.AutoDetectChangesEnabled;
_hooksEnabled = ctx.HooksEnabled;
_suppressCommit = ctx.SuppressCommit;
_lazyLoadingEnabled = changeTracker.LazyLoadingEnabled;
_queryTrackingBehavior = changeTracker.QueryTrackingBehavior;
_cascadeDeleteTiming = changeTracker.CascadeDeleteTiming;
_deleteOrphansTiming = changeTracker.DeleteOrphansTiming;
_autoTransactionEnabled = ctx.Database.AutoTransactionsEnabled;
_retainConnection = retainConnection;
if (autoDetectChanges.HasValue)
{
changeTracker.AutoDetectChangesEnabled = autoDetectChanges.Value;
}
if (hooksEnabled.HasValue)
{
ctx.HooksEnabled = hooksEnabled.Value;
}
if (lazyLoading.HasValue)
{
changeTracker.LazyLoadingEnabled = lazyLoading.Value;
}
if (forceNoTracking == true)
{
changeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
}
if (deferCommit.HasValue)
{
ctx.SuppressCommit = deferCommit.Value;
}
if (cascadeDeleteTiming.HasValue)
{
changeTracker.CascadeDeleteTiming = cascadeDeleteTiming.Value;
}
if (deleteOrphansTiming.HasValue)
{
changeTracker.DeleteOrphansTiming = deleteOrphansTiming.Value;
}
if (autoTransactions.HasValue)
{
ctx.Database.AutoTransactionsEnabled = autoTransactions.Value;
}
if (retainConnection)
{
ctx.Database.OpenConnection();
}
}
public override void Required_one_to_one_are_cascade_detached_when_Added(
CascadeTiming cascadeDeleteTiming,
CascadeTiming deleteOrphansTiming)
=> base.Required_one_to_one_are_cascade_detached_when_Added(cascadeDeleteTiming, deleteOrphansTiming);
public override async Task Load_collection_already_loaded_untyped(EntityState state, bool async, CascadeTiming cascadeDeleteTiming)
{
await base.Load_collection_already_loaded_untyped(state, async, cascadeDeleteTiming);
AssertSql("");
}
public override void Lazy_load_collection_already_loaded(EntityState state, CascadeTiming cascadeDeleteTiming)
{
base.Lazy_load_collection_already_loaded(state, cascadeDeleteTiming);
Assert.Equal("", Sql);
}
public override void Optional_many_to_one_dependents_with_alternate_key_are_orphaned_in_store(
CascadeTiming cascadeDeleteTiming,
CascadeTiming deleteOrphansTiming)
{
base.Optional_many_to_one_dependents_with_alternate_key_are_orphaned_in_store(cascadeDeleteTiming, deleteOrphansTiming);
}
