public virtual void NotifyReaderCreated([NotNull] DbDataReader dataReader)
=> NonCapturingLazyInitializer
.EnsureInitialized(
ref _valueBufferFactory,
new FactoryAndReader(_valueBufferFactoryFactory, dataReader),
s => QuerySqlGeneratorFactory()
.CreateValueBufferFactory(s.Factory, s.Reader));
/// <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 virtual TContext Rent()
{
TContext context;
if (_pool.TryDequeue(out context))
{
Interlocked.Decrement(ref _count);
Debug.Assert(_count >= 0);
((IDbContextPoolable)context).Resurrect(_configurationSnapshot);
return(context);
}
context = _activator();
NonCapturingLazyInitializer
.EnsureInitialized(
ref _configurationSnapshot,
(IDbContextPoolable)context,
c => c.SnapshotConfiguration());
((IDbContextPoolable)context).SetPool(this);
return(context);
}
private void SetUdtTypeName(DbParameter parameter)
{
NonCapturingLazyInitializer.EnsureInitialized(
ref _udtTypeNameSetter,
parameter.GetType(),
CreateUdtTypeNameAccessor);
_udtTypeNameSetter(parameter, UdtTypeName);
}
private void SetUdtTypeName(DbParameter parameter)
{
NonCapturingLazyInitializer.EnsureInitialized(
ref _udtTypeNameSetter,
parameter.GetType(),
CreateUdtTypeNameAccessor);
if (parameter.Value != null && parameter.Value != DBNull.Value)
{
_udtTypeNameSetter(parameter, UdtTypeName);
}
}
private Func <QueryContext, TResult> EnsureExecutor(TContext context)
=> NonCapturingLazyInitializer.EnsureInitialized(
ref _executor,
context,
_queryExpression,
(c, q) =>
{
var queryCompiler = context.GetService <IQueryCompiler>();
var expression = new QueryExpressionRewriter(c, q.Parameters).Visit(q.Body);
return(CreateCompiledQuery(queryCompiler, expression));
});
public static ITestStoreFactory EnsureInitialized(
ref ITestStoreFactory inst,
InfoCarrierBackendTestStoreFactory backendTestStoreFactory,
Type contextType,
Action <ModelBuilder, DbContext> onModelCreating,
Func <DbContextOptionsBuilder, DbContextOptionsBuilder> onAddOptions = null,
Action <DbContext, DbContext> copyDbContextParameters = null)
=> NonCapturingLazyInitializer.EnsureInitialized(
ref inst,
inst,
_ => new InfoCarrierTestStoreFactory(
new SharedTestStoreProperties
{
ContextType = contextType,
OnModelCreating = onModelCreating,
OnAddOptions = onAddOptions ?? (o => o),
CopyDbContextParameters = copyDbContextParameters,
},
backendTestStoreFactory));
/// <summary>
/// <para>
/// Creates a snapshot of the given instance.
/// </para>
/// <para>
/// Snapshotting is the process of creating a copy of the value into a snapshot so it can
/// later be compared to determine if it has changed. For some types, such as collections,
/// this needs to be a deep copy of the collection rather than just a shallow copy of the
/// reference.
/// </para>
/// </summary>
/// <param name="instance"> The instance. </param>
/// <returns> The snapshot. </returns>
public virtual T Snapshot([CanBeNull] T instance)
=> NonCapturingLazyInitializer.EnsureInitialized(
ref _snapshot, this, c => c.SnapshotExpression.Compile())(instance);
/// <summary>
/// Returns the hash code for the given instance.
/// </summary>
/// <param name="instance"> The instance. </param>
/// <returns> The hash code. </returns>
public virtual int GetHashCode(T instance)
=> NonCapturingLazyInitializer.EnsureInitialized(
ref _hashCode, this, c => c.HashCodeExpression.Compile())(instance);
/// <summary>
/// Compares the two instances to determine if they are equal.
/// </summary>
/// <param name="left"> The first instance. </param>
/// <param name="right"> The second instance. </param>
/// <returns> <c>True</c> if they are equal; <c>false</c> otherwise. </returns>
public virtual bool Equals(T left, T right)
=> NonCapturingLazyInitializer.EnsureInitialized(
ref _equals, this, c => c.EqualsExpression.Compile())(left, right);
/// <summary>
/// <para>
/// Creates a snapshot of the given instance.
/// </para>
/// <para>
/// Snapshotting is the process of creating a copy of the value into a snapshot so it can
/// later be compared to determine if it has changed. For some types, such as collections,
/// this needs to be a deep copy of the collection rather than just a shallow copy of the
/// reference.
/// </para>
/// </summary>
/// <param name="instance"> The instance. </param>
/// <returns> The snapshot. </returns>
public override object Snapshot(object instance)
=> NonCapturingLazyInitializer.EnsureInitialized(
ref _snapshot,
this,
c => c.SnapshotExpression.Compile())
.DynamicInvoke(instance);
/// <summary>
/// Returns the hash code for the given instance.
/// </summary>
/// <param name="instance"> The instance. </param>
/// <returns> The hash code. </returns>
public override int GetHashCode(object instance)
=> (int)NonCapturingLazyInitializer.EnsureInitialized(
ref _hashCode,
this,
c => c.HashCodeExpression.Compile())
.DynamicInvoke(instance);
/// <summary>
/// Compares the two instances to determine if they are equal.
/// </summary>
/// <param name="left"> The first instance. </param>
/// <param name="right"> The second instance. </param>
/// <returns> <c>True</c> if they are equal; <c>false</c> otherwise. </returns>
public override bool Equals(object left, object right)
=> (bool)NonCapturingLazyInitializer.EnsureInitialized(
ref _equals,
this,
c => c.EqualsExpression.Compile())
.DynamicInvoke(left, right);
/// <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 virtual IPrincipalKeyValueFactory <TKey> GetPrincipalKeyValueFactory <TKey>()
=> (IPrincipalKeyValueFactory <TKey>)NonCapturingLazyInitializer.EnsureInitialized(
ref _principalKeyValueFactory, this, k => new KeyValueFactoryFactory().Create <TKey>(k));
/// <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 virtual INullableValueFactory <TKey> GetNullableValueFactory <TKey>()
=> (INullableValueFactory <TKey>)NonCapturingLazyInitializer.EnsureInitialized(
ref _nullableValueFactory, this, i => new CompositeNullableValueFactory(i.Properties));
