/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public NavigationFixer(
[NotNull] IChangeDetector changeDetector,
[NotNull] IEntityGraphAttacher attacher)
{
_changeDetector = changeDetector;
_attacher = attacher;
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public QueryBuffer(
[NotNull] IStateManager stateManager,
[NotNull] IChangeDetector changeDetector)
{
_stateManager = stateManager;
_changeDetector = changeDetector;
}
public ChangeTrackerFactory(
[NotNull] IStateManager stateManager,
[NotNull] IChangeDetector changeDetector,
[NotNull] IEntityEntryGraphIterator graphIterator,
[NotNull] ICurrentDbContext currentContext)
{
_stateManager = stateManager;
_changeDetector = changeDetector;
_graphIterator = graphIterator;
_context = currentContext.Context;
}
/// <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 ChangeTrackerFactory(
[NotNull] ICurrentDbContext currentContext,
[NotNull] IStateManager stateManager,
[NotNull] IChangeDetector changeDetector,
[NotNull] IModel model,
[NotNull] IEntityEntryGraphIterator graphIterator)
{
_context = currentContext.Context;
_stateManager = stateManager;
_changeDetector = changeDetector;
_model = model;
_graphIterator = graphIterator;
}
public MySQLMigrationsModelDiffer(
[NotNull] IRelationalTypeMappingSource typeMappingSource,
[NotNull] IMigrationsAnnotationProvider migrationsAnnotations,
[NotNull] IChangeDetector changeDetector,
[NotNull] IUpdateAdapterFactory updateAdapterFactory,
[NotNull] CommandBatchPreparerDependencies commandBatchPreparerDependencies)
: base(
typeMappingSource,
migrationsAnnotations,
changeDetector,
updateAdapterFactory,
commandBatchPreparerDependencies)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ChangeTracker" /> class. Instances of this class are typically
/// obtained from <see cref="DbContext.ChangeTracker" /> and it is not designed to be directly constructed
/// in your application code.
/// </summary>
/// <param name="stateManager"> The internal state manager being used to store information about tracked entities. </param>
/// <param name="changeDetector"> The internal change detector used to identify changes in tracked entities. </param>
/// <param name="graphIterator"> The internal graph iterator used to traverse graphs of entities. </param>
/// <param name="context"> The context this change tracker belongs to. </param>
public ChangeTracker(
[NotNull] IStateManager stateManager,
[NotNull] IChangeDetector changeDetector,
[NotNull] IEntityEntryGraphIterator graphIterator,
[NotNull] DbContext context)
{
Check.NotNull(stateManager, nameof(stateManager));
Check.NotNull(changeDetector, nameof(changeDetector));
Check.NotNull(graphIterator, nameof(graphIterator));
Check.NotNull(context, nameof(context));
_stateManager = stateManager;
_changeDetector = changeDetector;
_graphIterator = graphIterator;
_context = context;
}
public ChangeTrackerFactory(
[NotNull] IStateManager stateManager,
[NotNull] IChangeDetector changeDetector,
[NotNull] IEntityEntryGraphIterator graphIterator,
[NotNull] DbContext context)
{
Check.NotNull(stateManager, nameof(stateManager));
Check.NotNull(changeDetector, nameof(changeDetector));
Check.NotNull(graphIterator, nameof(graphIterator));
Check.NotNull(context, nameof(context));
_stateManager = stateManager;
_changeDetector = changeDetector;
_graphIterator = graphIterator;
_context = context;
}
/// <summary>
/// Releases the allocated resources for this context.
/// </summary>
public virtual void Dispose()
{
if (!_disposed)
{
_disposed = true;
_stateManager?.Unsubscribe();
_serviceScope?.Dispose();
_setInitializer = null;
_changeTracker = null;
_stateManager = null;
_changeDetector = null;
_graphAttacher = null;
_model = null;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SchemaAwareMigrationsModelDiffer"/> class.
/// </summary>
/// <param name="typeMappingSource">The type mapping source to use.</param>
/// <param name="migrationsAnnotations">The migration annotation provider.</param>
/// <param name="changeDetector">The change detector.</param>
/// <param name="stateManagerDependencies">The state manager dependencies.</param>
/// <param name="commandBatchPreparerDependencies">The command batch preparer dependencies.</param>
public SchemaAwareMigrationsModelDiffer
(
IRelationalTypeMappingSource typeMappingSource,
IMigrationsAnnotationProvider migrationsAnnotations,
IChangeDetector changeDetector,
StateManagerDependencies stateManagerDependencies,
CommandBatchPreparerDependencies commandBatchPreparerDependencies
)
: base
(
typeMappingSource,
migrationsAnnotations,
changeDetector,
stateManagerDependencies,
commandBatchPreparerDependencies
)
{
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public DbContextDependencies(
[NotNull] IChangeDetector changeDetector,
[NotNull] IDbSetSource setSource,
[NotNull] IEntityFinderSource entityFinderSource,
[NotNull] IEntityGraphAttacher entityGraphAttacher,
[NotNull] IModel model,
[NotNull] IAsyncQueryProvider queryProvider,
[NotNull] IStateManager stateManager,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Update> updateLogger,
[NotNull] IDiagnosticsLogger <DbLoggerCategory.Infrastructure> infrastuctureLogger)
{
ChangeDetector = changeDetector;
SetSource = setSource;
EntityFinderSource = entityFinderSource;
EntityGraphAttacher = entityGraphAttacher;
Model = model;
QueryProvider = queryProvider;
StateManager = stateManager;
UpdateLogger = updateLogger;
InfrastructureLogger = infrastuctureLogger;
}
public ListeningInitializer(IChangeDetector detector)
{
_detector = detector ?? throw new ArgumentNullException(nameof(detector));
}
public DbContextDependenciesEx(ICurrentDbContext currentContext, IChangeDetector changeDetector, IDbSetSource setSource, IEntityFinderSource entityFinderSource, IEntityGraphAttacher entityGraphAttacher, IModel model, IAsyncQueryProvider queryProvider, IStateManager stateManager, IDiagnosticsLogger <DbLoggerCategory.Update> updateLogger, IDiagnosticsLogger <DbLoggerCategory.Infrastructure> infrastructureLogger)
{
inner = new DbContextDependencies(currentContext, changeDetector, setSource, entityFinderSource, entityGraphAttacher, model, queryProvider, new StateManagerWrapper(stateManager), updateLogger, infrastructureLogger);
}
public virtual void Add(IChangeDetector detector)
{
_detectors.Add(new WeakReference <IChangeDetector>(detector));
}
public CassandraMigrationsModelDiffer(RelationalConnectionDependencies relationalConnectionDependencies, IRelationalTypeMappingSource typeMappingSource, IMigrationsAnnotationProvider migrationsAnnotations, IChangeDetector changeDetector, IUpdateAdapterFactory updateAdapterFactory, CommandBatchPreparerDependencies commandBatchPreparerDependencies) : base(typeMappingSource, migrationsAnnotations, changeDetector, updateAdapterFactory, commandBatchPreparerDependencies)
{
_cassandraOptionsExtension = CassandraOptionsExtension.Extract(relationalConnectionDependencies.ContextOptions);
}
public SecurityQueryContextFactory([NotNull] DbContext dbContext, [NotNull] ICurrentDbContext currentContext, [NotNull] IStateManager stateManager, [NotNull] IConcurrencyDetector concurrencyDetector, [NotNull] IChangeDetector changeDetector) : base(currentContext, concurrencyDetector)
{
this.dbContext = (BaseSecurityDbContext)dbContext;
this.stateManager = new LazyRef <IStateManager>(stateManager);
this.concurrencyDetector = concurrencyDetector;
}
/// <inheritdoc />
public virtual void DetectingChanges(IChangeDetector changeDetector, IStateManager stateManager)
{
}
public SqlChangeTrackingMigrationsModelDiffer(IRelationalTypeMappingSource typeMappingSource,
IMigrationsAnnotationProvider migrationsAnnotations, IChangeDetector changeDetector,
IUpdateAdapterFactory updateAdapterFactory,
CommandBatchPreparerDependencies commandBatchPreparerDependencies) : base(typeMappingSource,
migrationsAnnotations, changeDetector, updateAdapterFactory, commandBatchPreparerDependencies)
{
}
public AbstraXProviderChangeTrackerFactory(ICurrentDbContext currentContext, IStateManager stateManager, IChangeDetector changeDetector, IModel model, IEntityEntryGraphIterator graphIterator) : base(currentContext, stateManager, changeDetector, model, graphIterator)
{
this.currentContext = currentContext;
this.stateManager = stateManager;
this.changeDetectory = changeDetector;
this.model = model;
this.graphIterator = graphIterator;
}
public Repository(IServiceProvider _serviceProvider)
{
this.ChangeDetector = _serviceProvider?.GetService <IChangeDetector>();
this.cache = _serviceProvider?.GetService <IMemoryCache>();;
}
/// <inheritdoc />
public virtual void DetectingEntryChanges(IChangeDetector changeDetector, IStateManager stateManager, InternalEntityEntry entry)
{
}
public void Add(IChangeDetector detector) => Store.Add(detector);
public override void DetectingChanges(IChangeDetector changeDetector, IStateManager stateManager) => DetectingChangesCalled = true;
public MyQueryContextFactory(IStateManager stateManager,
IConcurrencyDetector concurrencyDetector,
IChangeDetector changeDetector)
: base(stateManager, concurrencyDetector, changeDetector)
{
}
/// <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 UpdateAdapter(IStateManager stateManager)
{
_stateManager = stateManager;
_changeDetector = _stateManager.Context.GetDependencies().ChangeDetector;
}
public override void DetectingEntryChanges(IChangeDetector changeDetector, IStateManager stateManager, InternalEntityEntry entry) => DetectingEntryChangesCalled = true;
public MyQueryContextFactory(IStateManager stateManager,
IConcurrencyDetector concurrencyDetector,
IChangeDetector changeDetector)
: base(stateManager, concurrencyDetector, changeDetector)
{
}
public NavigationFixer([NotNull] IModel model, [NotNull] IChangeDetector changeDetector)
{
_model = model;
_changeDetector = changeDetector;
}
public FileContextQueryContextFactory(IStateManager stateManager, ICurrentDbContext context, IConcurrencyDetector concurrencyDetector, IChangeDetector changeDetector)
: base(context, concurrencyDetector)
{
}
internal DefaultEntityContext(IEntitySource entitySource, IMappingsRepository mappingsRepository, IChangeDetector changeDetector)
{
_entitySource = entitySource;
Mappings = mappingsRepository;
_changeDetector = changeDetector;
_deletedEntities = new List <Iri>();
_entityCache = new ConcurrentDictionary <Iri, Entity>();
}
