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));