API review bundle

src/EFCore.Abstractions/IndexAttribute.cs

@@ -19,10 +19,25 @@ public sealed class IndexAttribute : Attribute
  private bool? _isUnique;
  private bool[]? _isDescending;
 
+ /// <summary>
+ /// Initializes a new instance of the <see cref="IndexAttribute" /> class.
+ /// </summary>
+ /// <param name="propertyName">The first (or only) property in the index.</param>
+ /// <param name="additionalPropertyNames">The additional properties which constitute the index, if any, in order.</param>
+ public IndexAttribute(string propertyName, params string[] additionalPropertyNames)
+ {
+ Check.NotEmpty(propertyName, nameof(propertyName));
+ Check.HasNoEmptyElements(additionalPropertyNames, nameof(additionalPropertyNames));
+
+ PropertyNames = new List<string> { propertyName };
+ ((List<string>)PropertyNames).AddRange(additionalPropertyNames);
+ }
+
  /// <summary>
  /// Initializes a new instance of the <see cref="IndexAttribute" /> class.
  /// </summary>
  /// <param name="propertyNames">The properties which constitute the index, in order (there must be at least one).</param>
+ [Obsolete("Use the other constructor")]
  public IndexAttribute(params string[] propertyNames)
  {
  Check.NotEmpty(propertyNames, nameof(propertyNames));

src/EFCore.Proxies/Proxies/Internal/ProxyBindingInterceptor.cs

@@ -36,8 +36,9 @@ public ProxyBindingInterceptor(IProxyFactory proxyFactory)
  /// 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 virtual InstantiationBinding ModifyBinding(IEntityType entityType, string entityInstanceName, InstantiationBinding binding)
+ public virtual InstantiationBinding ModifyBinding(InstantiationBindingInterceptionData interceptionData, InstantiationBinding binding)
  {
+ var entityType = interceptionData.EntityType;
  var proxyType = _proxyFactory.CreateProxyType(entityType);
 
  if ((bool?)entityType.Model[ProxyAnnotationNames.LazyLoading] == true)

src/EFCore/ChangeTracking/Internal/StateManager.cs

@@ -781,14 +781,15 @@ public virtual bool ResolveToExistingEntry(
  {
  if (_resolutionInterceptor != null)
  {
+ var interceptionData = new IdentityResolutionInterceptionData(Context);
  var needsTracking = false;
  foreach (var key in newEntry.EntityType.GetKeys())
  {
  var existingEntry = FindIdentityMap(key)?.TryGetEntry(newEntry);
  if (existingEntry != null)
  {
  _resolutionInterceptor.UpdateTrackedInstance(
- Context,
+ interceptionData,
  new EntityEntry(existingEntry),
  newEntry.Entity);
 

src/EFCore/Diagnostics/CoreLoggerExtensions.cs

@@ -479,7 +479,7 @@ public static (Expression Query, QueryExpressionEventData? EventData) QueryCompi
 
  if (interceptor != null)
  {
- return (interceptor.ProcessingQuery(queryExpression, eventData), eventData);
+ return (interceptor.QueryCompilationStarting(queryExpression, eventData), eventData);
  }
  }
 

src/EFCore/Diagnostics/IIdentityResolutionInterceptor.cs

@@ -35,8 +35,8 @@ public interface IIdentityResolutionInterceptor : IInterceptor
  /// an already tracked instance. This method must apply any property values and relationship changes from the new instance
  /// into the existing instance. The new instance is then discarded.
  /// </summary>
- /// <param name="context">The <see cref="DbContext"/> is use.</param>
+ /// <param name="interceptionData">Contextual information about the identity resolution.</param>
  /// <param name="existingEntry">The entry for the existing tracked entity instance.</param>
- /// <param name="newInstance">The new entity instance, which will be discarded after this call.</param>
- void UpdateTrackedInstance(DbContext context, EntityEntry existingEntry, object newInstance);
+ /// <param name="newEntity">The new entity instance, which will be discarded after this call.</param>
+ void UpdateTrackedInstance(IdentityResolutionInterceptionData interceptionData, EntityEntry existingEntry, object newEntity);
 }

src/EFCore/Diagnostics/IInstantiationBindingInterceptor.cs

@@ -17,9 +17,8 @@ public interface IInstantiationBindingInterceptor : ISingletonInterceptor
  /// <summary>
  /// Returns a new <see cref="InstantiationBinding" /> for the given entity type, potentially modified from the given binding.
  /// </summary>
- /// <param name="entityType">The entity type for which the binding is being used.</param>
- /// <param name="entityInstanceName">The name of the instance being materialized.</param>
+ /// <param name="interceptionData">Contextual information about the binding.</param>
  /// <param name="binding">The current binding.</param>
  /// <returns>A new binding.</returns>
- InstantiationBinding ModifyBinding(IEntityType entityType, string entityInstanceName, InstantiationBinding binding);
+ InstantiationBinding ModifyBinding(InstantiationBindingInterceptionData interceptionData, InstantiationBinding binding);
 }

src/EFCore/Diagnostics/IMaterializationInterceptor.cs

@@ -37,24 +37,24 @@ InterceptionResult<object> CreatingInstance(MaterializationInterceptionData mate
  /// any properties values not set by the constructor have been set.
  /// </summary>
  /// <param name="materializationData">Contextual information about the materialization happening.</param>
- /// <param name="instance">
+ /// <param name="entity">
  /// The entity instance that has been created.
  /// This value is typically used as the return value for the implementation of this method.
  /// </param>
  /// <returns>
  /// The entity instance that EF will use.
  /// An implementation of this method for any interceptor that is not attempting to change the instance used
- /// must return the <paramref name="instance" /> value passed in.
+ /// must return the <paramref name="entity" /> value passed in.
  /// </returns>
- object CreatedInstance(MaterializationInterceptionData materializationData, object instance)
- => instance;
+ object CreatedInstance(MaterializationInterceptionData materializationData, object entity)
+ => entity;
 
  /// <summary>
  /// Called immediately before EF is going to set property values of an entity that has just been created. Note that property values
  /// set by the constructor will already have been set.
  /// </summary>
  /// <param name="materializationData">Contextual information about the materialization happening.</param>
- /// <param name="instance">The entity instance for which property values will be set.</param>
+ /// <param name="entity">The entity instance for which property values will be set.</param>
  /// <param name="result">
  /// Represents the current result if one exists.
  /// This value will have <see cref="InterceptionResult.IsSuppressed" /> set to <see langword="true" /> if some previous
@@ -67,22 +67,22 @@ object CreatedInstance(MaterializationInterceptionData materializationData, obje
  /// An implementation of this method for any interceptor that is not attempting to suppress
  /// setting property values must return the <paramref name="result" /> value passed in.
  /// </returns>
- InterceptionResult InitializingInstance(MaterializationInterceptionData materializationData, object instance, InterceptionResult result)
+ InterceptionResult InitializingInstance(MaterializationInterceptionData materializationData, object entity, InterceptionResult result)
  => result;
 
  /// <summary>
  /// Called immediately after EF has set property values of an entity that has just been created.
  /// </summary>
  /// <param name="materializationData">Contextual information about the materialization happening.</param>
- /// <param name="instance">
+ /// <param name="entity">
  /// The entity instance that has been created.
  /// This value is typically used as the return value for the implementation of this method.
  /// </param>
  /// <returns>
  /// The entity instance that EF will use.
  /// An implementation of this method for any interceptor that is not attempting to change the instance used
- /// must return the <paramref name="instance" /> value passed in.
+ /// must return the <paramref name="entity" /> value passed in.
  /// </returns>
- object InitializedInstance(MaterializationInterceptionData materializationData, object instance)
- => instance;
+ object InitializedInstance(MaterializationInterceptionData materializationData, object entity)
+ => entity;
 }

src/EFCore/Diagnostics/IQueryExpressionInterceptor.cs

@@ -28,36 +28,8 @@ public interface IQueryExpressionInterceptor : IInterceptor
  /// <param name="queryExpression">The query expression.</param>
  /// <param name="eventData">Contextual information about the query environment.</param>
  /// <returns>The query expression tree to continue with, which may have been changed by the interceptor.</returns>
- Expression ProcessingQuery(
+ Expression QueryCompilationStarting(
  Expression queryExpression,
  QueryExpressionEventData eventData)
  => queryExpression;
-
- /// <summary>
- /// Called when EF is about to compile the query delegate that will be used to execute the query.
- /// </summary>
- /// <param name="queryExpression">The query expression.</param>
- /// <param name="queryExecutorExpression">The expression that will be compiled into the execution delegate.</param>
- /// <param name="eventData">Contextual information about the query environment.</param>
- /// <typeparam name="TResult">The return type of the execution delegate.</typeparam>
- /// <returns>The expression that will be compiled into the execution delegate, which may have been changed by the interceptor.</returns>
- Expression<Func<QueryContext, TResult>> CompilingQuery<TResult>(
- Expression queryExpression,
- Expression<Func<QueryContext, TResult>> queryExecutorExpression,
- QueryExpressionEventData eventData)
- => queryExecutorExpression;
-
- /// <summary>
- /// Called when EF is about to compile the query delegate that will be used to execute the query.
- /// </summary>
- /// <param name="queryExpression">The query expression.</param>
- /// <param name="eventData">Contextual information about the query environment.</param>
- /// <param name="queryExecutor">The delegate that will be used to execute the query.</param>
- /// <typeparam name="TResult">The return type of the execution delegate.</typeparam>
- /// <returns>The delegate that will be used to execute the query, which may have been changed by the interceptor.</returns>
- Func<QueryContext, TResult> CompiledQuery<TResult>(
- Expression queryExpression,
- QueryExpressionEventData eventData,
- Func<QueryContext, TResult> queryExecutor)
- => queryExecutor;
 }

src/EFCore/Diagnostics/IdentityResolutionInterceptionData.cs

@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.EntityFrameworkCore.Diagnostics;
+
+/// <summary>
+/// A parameter object passed to <see cref="IIdentityResolutionInterceptor" /> methods.
+/// </summary>
+/// <remarks>
+/// See <see href="https://aka.ms/efcore-docs-diagnostics">Logging, events, and diagnostics</see> for more information and examples.
+/// </remarks>
+public readonly struct IdentityResolutionInterceptionData
+{
+ /// <summary>
+ /// Constructs the parameter object.
+ /// </summary>
+ /// <param name="context">The <see cref="DbContext"/> in use.</param>
+ public IdentityResolutionInterceptionData(DbContext context)
+ {
+ Context = context;
+ }
+
+ /// <summary>
+ /// The current <see cref="DbContext" /> instance being used.
+ /// </summary>
+ public DbContext Context { get; }
+}

src/EFCore/Diagnostics/SkippingIdentityResolutionInterceptor.cs → src/EFCore/Diagnostics/IgnoringIdentityResolutionInterceptor.cs

@@ -7,17 +7,17 @@ namespace Microsoft.EntityFrameworkCore.Diagnostics;
 /// A <see cref="IIdentityResolutionInterceptor"/> that ignores the new instance and retains property values from the existing
 /// tracked instance.
 /// </summary>
-public class SkippingIdentityResolutionInterceptor : IIdentityResolutionInterceptor
+public class IgnoringIdentityResolutionInterceptor : IIdentityResolutionInterceptor
 {
  /// <summary>
  /// Called when a <see cref="DbContext"/> attempts to track a new instance of an entity with the same primary key value as
  /// an already tracked instance. This implementation does nothing, such that property values from the existing tracked
  /// instance are retained.
  /// </summary>
- /// <param name="context">The <see cref="DbContext"/> is use.</param>
+ /// <param name="interceptionData">Contextual information about the identity resolution.</param>
  /// <param name="existingEntry">The entry for the existing tracked entity instance.</param>
- /// <param name="newInstance">The new entity instance, which will be discarded after this call.</param>
- public virtual void UpdateTrackedInstance(DbContext context, EntityEntry existingEntry, object newInstance)
+ /// <param name="newEntity">The new entity instance, which will be discarded after this call.</param>
+ public virtual void UpdateTrackedInstance(IdentityResolutionInterceptionData interceptionData, EntityEntry existingEntry, object newEntity)
  {
  }
 }

src/EFCore/Diagnostics/InstantiationBindingInterceptionData.cs

@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.EntityFrameworkCore.Diagnostics;
+
+/// <summary>
+/// A parameter object passed to <see cref="IInstantiationBindingInterceptor" /> methods.
+/// </summary>
+/// <remarks>
+/// See <see href="https://aka.ms/efcore-docs-diagnostics">Logging, events, and diagnostics</see> for more information and examples.
+/// </remarks>
+public readonly struct InstantiationBindingInterceptionData
+{
+
+ /// <summary>
+ /// Constructs the parameter object.
+ /// </summary>
+ /// <param name="entityType">The entity type for which the binding is being used.</param>
+ public InstantiationBindingInterceptionData(IEntityType entityType)
+ {
+ EntityType = entityType;
+ }
+
+ /// <summary>
+ /// The entity type for which the binding is being used.
+ /// </summary>
+ public IEntityType EntityType { get; }
+}

src/EFCore/Diagnostics/Internal/IdentityResolutionInterceptorAggregator.cs

@@ -24,11 +24,11 @@ public CompositeIdentityResolutionInterceptor(IEnumerable<IIdentityResolutionInt
  _interceptors = interceptors.ToArray();
  }
 
- public void UpdateTrackedInstance(DbContext context, EntityEntry existingEntry, object newInstance)
+ public void UpdateTrackedInstance(IdentityResolutionInterceptionData interceptionData, EntityEntry existingEntry, object newEntity)
  {
  for (var i = 0; i < _interceptors.Length; i++)
  {
- _interceptors[i].UpdateTrackedInstance(context, existingEntry, newInstance);
+ _interceptors[i].UpdateTrackedInstance(interceptionData, existingEntry, newEntity);
  }
  }
  }

src/EFCore/Diagnostics/Internal/MaterializationInterceptorAggregator.cs

@@ -42,39 +42,39 @@ public InterceptionResult<object> CreatingInstance(
 
  public object CreatedInstance(
  MaterializationInterceptionData materializationData,
- object instance)
+ object entity)
  {
  for (var i = 0; i < _interceptors.Length; i++)
  {
- instance = _interceptors[i].CreatedInstance(materializationData, instance);
+ entity = _interceptors[i].CreatedInstance(materializationData, entity);
  }
 
- return instance;
+ return entity;
  }
 
  public InterceptionResult InitializingInstance(
  MaterializationInterceptionData materializationData,
- object instance,
+ object entity,
  InterceptionResult result)
  {
  for (var i = 0; i < _interceptors.Length; i++)
  {
- result = _interceptors[i].InitializingInstance(materializationData, instance, result);
+ result = _interceptors[i].InitializingInstance(materializationData, entity, result);
  }
 
  return result;
  }
 
  public object InitializedInstance(
  MaterializationInterceptionData materializationData,
- object instance)
+ object entity)
  {
  for (var i = 0; i < _interceptors.Length; i++)
  {
- instance = _interceptors[i].InitializedInstance(materializationData, instance);
+ entity = _interceptors[i].InitializedInstance(materializationData, entity);
  }
 
- return instance;
+ return entity;
  }
  }
 }

src/EFCore/Diagnostics/Internal/QueryExpressionInterceptorAggregator.cs

@@ -24,42 +24,16 @@ public CompositeQueryExpressionInterceptor(IEnumerable<IQueryExpressionIntercept
  _interceptors = interceptors.ToArray();
  }
 
- public Expression ProcessingQuery(
+ public Expression QueryCompilationStarting(
  Expression queryExpression,
  QueryExpressionEventData eventData)
  {
  for (var i = 0; i < _interceptors.Length; i++)
  {
- queryExpression = _interceptors[i].ProcessingQuery(queryExpression, eventData);
+ queryExpression = _interceptors[i].QueryCompilationStarting(queryExpression, eventData);
  }
 
  return queryExpression;
  }
-
- public Expression<Func<QueryContext, TResult>> CompilingQuery<TResult>(
- Expression queryExpression,
- Expression<Func<QueryContext, TResult>> queryExecutorExpression,
- QueryExpressionEventData eventData)
- {
- for (var i = 0; i < _interceptors.Length; i++)
- {
- queryExecutorExpression = _interceptors[i].CompilingQuery(queryExpression, queryExecutorExpression, eventData);
- }
-
- return queryExecutorExpression;
- }
-
- public Func<QueryContext, TResult> CompiledQuery<TResult>(
- Expression queryExpression,
- QueryExpressionEventData eventData,
- Func<QueryContext, TResult> queryExecutor)
- {
- for (var i = 0; i < _interceptors.Length; i++)
- {
- queryExecutor = _interceptors[i].CompiledQuery(queryExpression, eventData, queryExecutor);
- }
-
- return queryExecutor;
- }
  }
 }

src/EFCore/Diagnostics/UpdatingIdentityResolutionInterceptor.cs

@@ -36,12 +36,12 @@ public UpdatingIdentityResolutionInterceptor(
  /// an already tracked instance. This implementation copies property values from the new entity instance into the
  /// tracked entity instance.
  /// </summary>
- /// <param name="context">The <see cref="DbContext" /> is use.</param>
+ /// <param name="interceptionData">Contextual information about the identity resolution.</param>
  /// <param name="existingEntry">The entry for the existing tracked entity instance.</param>
- /// <param name="newInstance">The new entity instance, which will be discarded after this call.</param>
- public virtual void UpdateTrackedInstance(DbContext context, EntityEntry existingEntry, object newInstance)
+ /// <param name="newEntity">The new entity instance, which will be discarded after this call.</param>
+ public virtual void UpdateTrackedInstance(IdentityResolutionInterceptionData interceptionData, EntityEntry existingEntry, object newEntity)
  {
- var tempEntry = context.Entry(newInstance);
+ var tempEntry = interceptionData.Context.Entry(newEntity);
 
  if (existingEntry.State == EntityState.Added)
  {