protected P_StorageOpCtxBase(PersistenceEfCoreDataContext <TEfDbContext> dataCtx, TEfDbContext efCtx)
: base(outerDependencies: dataCtx.EnsureNotNull(nameof(dataCtx)).Value)
{
efCtx.EnsureNotNull(nameof(efCtx));
//
_dataCtx = dataCtx;
_efCtxGetter = null;
_efCtxLazy = new DisposableLazy <TEfDbContext>(value: efCtx, ownsValue: false);
}
public void WhenDispose_ThenValueIsDisposed()
{
var disposable = new Mock<IDisposable>();
var lazy = new DisposableLazy<IDisposable>(() => disposable.Object);
// ReSharper disable UnusedVariable
var temp = lazy.Value; // force value to be created.
// ReSharper restore UnusedVariable
lazy.Dispose();
disposable.Verify(d => d.Dispose());
}
protected override void Dispose(bool explicitDispose)
{
if (explicitDispose)
{
_efCtxLazy?.Dispose();
}
_dataCtx = null;
_efCtxLazy = null;
_efCtxGetter = null;
//
base.Dispose(explicitDispose);
}
protected override void Dispose(bool explicitDispose)
{
if (explicitDispose)
{
_dependencyScopeLazy?.Dispose();
_outerServiceProviderHandler?.Dispose();
}
_dependencyScopeLazy = null;
_outerServiceProviderHandler = null;
_outerDependencies = null;
//
base.Dispose(explicitDispose);
}
public HeifStreamIO(Stream stream, bool ownsStream = false)
{
Validate.IsNotNull(stream, nameof(stream));
this.stream = stream;
this.ownsStream = ownsStream;
this.heifReaderHandle = new DisposableLazy <SafeCoTaskMemHandle>(CreateHeifReader);
this.heifWriterHandle = new DisposableLazy <SafeCoTaskMemHandle>(CreateHeifWriter);
this.streamBuffer = new byte[MaxBufferSize];
this.getPositionDelegate = GetPosition;
this.readDelegate = Read;
this.seekDelegate = Seek;
this.waitForFileSizeDelegate = WaitForFileSize;
this.writeDelegate = Write;
}
void P_CtorInitializer(IDependencyExporter exporter, bool ownsDependencyExporter = default, IServiceProvider outerServiceProvider = default, object owner = default)
{
exporter.EnsureNotNull(nameof(exporter));
//
_exporter = exporter.ToValueHolder(ownsDependencyExporter);
_owner = owner;
//
_resolutionModelLazy =
new DisposableLazy <IDependencyResolutionModel <DependencyScope> >(
factory: () => new DependencyResolutionModel <DependencyScope>(scope: this, handlerChainSource: ReadDA(ref _exporter, considerDisposeRequest: true).Value.ExportDependencies()),
ownsValue: true);
//
_newDependencyInstancesDisposeRegistry = new DisposeRegistry();
//
_runningResolutionsSpinLock = new PrimitiveSpinLock();
_runningResolutionsUniqueness = new HashSet <IDependencyResolutionContext>(comparer: ReferenceEqualityComparer <IDependencyResolutionContext> .Instance);
_runningResolutionsSequence = new List <IDependencyResolutionContext>();
//
_serviceProviderApi = outerServiceProvider ?? new P_ServiceProviderApi(scope: this);
}
public PersistenceEfCoreDataContext(IPersistenceDataContextProvider <IPersistenceDataContext <TEfDbContext> > provider, DbContextOptions <TEfDbContext> efDbContextOptions, ILogger logger)
: base(outerDependencies: provider.EnsureNotNull(nameof(provider)).Value)
{
efDbContextOptions.EnsureNotNull(nameof(efDbContextOptions));
if (!efDbContextOptions.IsFrozen)
{
throw
new ArgumentException(
message: $"EF context options must be frozen (see {nameof(DbContextOptions)}.{nameof(DbContextOptions.IsFrozen)}) before using by this component.{Environment.NewLine}\tComponent:{this.FmtStr().GNLI2()}",
paramName: nameof(efDbContextOptions));
}
//
_provider = provider;
_efDbContextOptions = efDbContextOptions;
_initializationLock = new SemaphoreSlim(initialCount: 1, maxCount: 1);
_isInitialized = false;
_efCtxLazy = new DisposableLazy <TEfDbContext>(factory: () => P_CreateAndAdjustEfDbContext(isReadOnly: false), ownsValue: true);
_logger = logger;
_txScopes = ImmutableStack <PersistenceEfCoreDataContextTxScope> .Empty;
}
protected HeifWriter()
{
this.heifWriterHandle = new DisposableLazy <SafeCoTaskMemHandle>(CreateHeifWriter);
this.writerErrors = new WriterErrors();
this.writeDelegate = Write;
}
static CtorFactoryDependencyHandler()
{
__DependencyInstanceCtor =
new DisposableLazy <Func <TDependencyInstance> >(() => ActivationUtilities.RequireConstructor <TDependencyInstance>());
}
static EonJsonUtilities()
{
__DefaultSerializer = new DisposableLazy <JsonSerializer>(factory: CreateDefaultSerializer, ownsValue: true);
}
public IsolatedStorageContainer(bool perDomain)
{
// ReSharper disable ConvertClosureToMethodGroup because would cause this problem: http://stackoverflow.com/q/9113791/7011
LazyStorage = new DisposableLazy<IsolatedStorageFile>(() => CreateIsolatedStorage(perDomain));
// ReSharper restore ConvertClosureToMethodGroup
}
static CtorFactoryDependencyHandler()
{
__DependencyInstanceCtor =
new DisposableLazy <Func <TArg1, TArg2, TArg3, TDependencyInstance> >(() => ActivationUtilities.RequireConstructor <TArg1, TArg2, TArg3, TDependencyInstance>(arg1: default));
}
protected DependencySupport(IServiceProvider outerServiceProvider = default, IDependencySupport outerDependencies = default)
{
_outerDependencies = outerDependencies;
_dependencyScopeLazy = new DisposableLazy <IDependencyScope>(factory: P_DependencyScopeLazyInitializer);
_outerServiceProviderHandler = outerServiceProvider is null ? null : new ServiceProviderHandler(serviceProvider: outerServiceProvider);
}
protected override void OnDeserialized(StreamingContext context)
{
base.OnDeserialized(context);
//
_dependencyScopeLazy = new DisposableLazy <IDependencyScope>(factory: P_DependencyScopeLazyInitializer);
}
