added initialization of store manager, file manager and serilizer with dependency injection

morrisjdev · morrisjdev · commit 3cdd864565c2 · 2020-06-07T12:55:06.000+02:00
diff --git a/Example/Data/Context.cs b/Example/Data/Context.cs
@@ -1,8 +1,6 @@
 ﻿using Example.Data.Entities;
 using FileContextCore;
-using FileContextCore.StoreManager;
 using Microsoft.EntityFrameworkCore;
-using OfficeOpenXml;
 
 namespace Example.Data
 {
diff --git a/FileContextCore/Extensions/FileContextDbContextOptionsExtensions.cs b/FileContextCore/Extensions/FileContextDbContextOptionsExtensions.cs
@@ -91,7 +91,7 @@ public static DbContextOptionsBuilder UseFileContextDatabase(
                             ?? new FileContextOptionsExtension();
 
             extension = extension.WithCustomOptions(databaseName, location, password,
-                typeof(DefaultStoreManager<JSONSerializer, DefaultFileManager>));
+                typeof(DefaultStoreManager), typeof(JSONSerializer), typeof(DefaultFileManager));
 
             if (databaseRoot != null)
             {
@@ -183,7 +183,7 @@ public static DbContextOptionsBuilder UseFileContextDatabase<TSerializer, TFileM
                             ?? new FileContextOptionsExtension();
 
             extension = extension.WithCustomOptions(databaseName, location, password,
-                typeof(DefaultStoreManager<TSerializer, TFileManager>));
+                typeof(DefaultStoreManager), typeof(TSerializer), typeof(TFileManager));
 
             if (databaseRoot != null)
             {
@@ -270,7 +270,7 @@ public static DbContextOptionsBuilder UseFileContextDatabase<TStoreManager>(
             var extension = optionsBuilder.Options.FindExtension<FileContextOptionsExtension>()
                             ?? new FileContextOptionsExtension();
 
-            extension = extension.WithCustomOptions(databaseName, location, password, typeof(TStoreManager));
+            extension = extension.WithCustomOptions(databaseName, location, password, typeof(TStoreManager), null, null);
 
             if (databaseRoot != null)
             {
diff --git a/FileContextCore/Extensions/FileContextServiceCollectionExtensions.cs b/FileContextCore/Extensions/FileContextServiceCollectionExtensions.cs
@@ -4,10 +4,13 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using FileContextCore.Diagnostics.Internal;
+using FileContextCore.FileManager;
 using FileContextCore.Infrastructure.Internal;
 using FileContextCore.Metadata.Conventions;
 using FileContextCore.Query.Internal;
+using FileContextCore.Serializer;
 using FileContextCore.Storage.Internal;
+using FileContextCore.StoreManager;
 using FileContextCore.ValueGeneration.Internal;
 using FileContextCore.Utilities;
 using JetBrains.Annotations;
@@ -70,7 +73,16 @@ public static IServiceCollection AddEntityFrameworkFileContextDatabase([NotNull]
                     b => b
                         .TryAddSingleton<IFileContextSingletonOptions, FileContextSingletonOptions>()
                         .TryAddSingleton<IFileContextStoreCache, FileContextStoreCache>()
-                        .TryAddScoped<IFileContextDatabase, FileContextDatabase>());
+                        .TryAddScoped<IFileContextDatabase, FileContextDatabase>()
+                        .TryAddTransient<EXCELStoreManager, EXCELStoreManager>()
+                        .TryAddTransient<DefaultStoreManager, DefaultStoreManager>()
+                        .TryAddTransient<BSONSerializer, BSONSerializer>()
+                        .TryAddTransient<CSVSerializer, CSVSerializer>()
+                        .TryAddTransient<JSONSerializer, JSONSerializer>()
+                        .TryAddTransient<XMLSerializer, XMLSerializer>()
+                        .TryAddTransient<DefaultFileManager, DefaultFileManager>()
+                        .TryAddTransient<EncryptedFileManager, EncryptedFileManager>()
+                        .TryAddTransient<PrivateFileManager, PrivateFileManager>());
 
             builder.TryAddCoreServices();
 
diff --git a/FileContextCore/Infrastructure/Internal/FileContextOptionsExtension.cs b/FileContextCore/Infrastructure/Internal/FileContextOptionsExtension.cs
@@ -28,7 +28,7 @@ public class FileContextOptionsExtension : IDbContextOptionsExtension
         public FileContextOptionsExtension()
         {
             _options = new FileContextScopedOptions(null, null, null,
-                typeof(DefaultStoreManager<JSONSerializer, DefaultFileManager>));
+                typeof(DefaultStoreManager), typeof(JSONSerializer), typeof(DefaultFileManager));
         }
 
     
@@ -49,10 +49,10 @@ public virtual DbContextOptionsExtensionInfo Info
         public virtual FileContextScopedOptions Options => _options;
 
     
-        public virtual FileContextOptionsExtension WithCustomOptions(string databaseName, string location, string password, Type storeManagerType)
+        public virtual FileContextOptionsExtension WithCustomOptions(string databaseName, string location, string password, Type storeManagerType, Type serializerType, Type fileManagerType)
         {
             var clone = Clone();
-            clone._options = new FileContextScopedOptions(databaseName, location, password, storeManagerType);
+            clone._options = new FileContextScopedOptions(databaseName, location, password, storeManagerType, serializerType, fileManagerType);
             return clone;
         }
 
@@ -105,6 +105,9 @@ public override string LogFragment
                         builder.Append("Location=").Append(Extension.Options.Location).Append(' ');
                         builder.Append("DatabaseName=").Append(Extension.Options.DatabaseName).Append(' ');
                         builder.Append("StoreManager=").Append(Extension.Options.StoreManagerType).Append(' ');
+                        builder.Append("Serializer=").Append(Extension.Options.SerializerType).Append(' ');
+                        builder.Append("FileManager=").Append(Extension.Options.FileManagerType).Append(' ');
+                        builder.Append("StoreManager=").Append(Extension.Options.StoreManagerType).Append(' ');
                         builder.Append("Password=").Append("<Password>").Append(' ');
 
                         _logFragment = builder.ToString();
diff --git a/FileContextCore/Infrastructure/Internal/FileContextScopedOptions.cs b/FileContextCore/Infrastructure/Internal/FileContextScopedOptions.cs
@@ -1,18 +1,17 @@
 ﻿using System;
-using System.Collections.Generic;
-using System.Text;
-using Microsoft.EntityFrameworkCore.Infrastructure;
 
 namespace FileContextCore.Infrastructure.Internal
 {
     public class FileContextScopedOptions : IFileContextScopedOptions
     {
-        public FileContextScopedOptions(string databaseName, string location, string password, Type storeManagerType)
+        public FileContextScopedOptions(string databaseName, string location, string password, Type storeManagerType, Type serializerType, Type fileManagerType)
         {
             DatabaseName = databaseName;
             Location = location;
             Password = password;
             StoreManagerType = storeManagerType;
+            SerializerType = serializerType;
+            FileManagerType = fileManagerType;
         }
 
         public string DatabaseName { get; }
@@ -22,10 +21,14 @@ public FileContextScopedOptions(string databaseName, string location, string pas
         public string Password { get; }
 
         public Type StoreManagerType { get; }
+        
+        public Type SerializerType { get; }
+        
+        public Type FileManagerType { get; }
 
         public override int GetHashCode()
         {
-            return (DatabaseName + Location + Password + StoreManagerType).GetHashCode();
+            return (DatabaseName + Location + Password + StoreManagerType + SerializerType + FileManagerType).GetHashCode();
         }
 
         public override bool Equals(object obj)
@@ -37,7 +40,8 @@ public override bool Equals(object obj)
 
             FileContextScopedOptions optionsCompare = (FileContextScopedOptions) obj;
             return optionsCompare.DatabaseName == DatabaseName && optionsCompare.Location == Location &&
-                   optionsCompare.Password == Password && optionsCompare.StoreManagerType == StoreManagerType;
+                   optionsCompare.Password == Password && optionsCompare.StoreManagerType == StoreManagerType && 
+                   optionsCompare.SerializerType == SerializerType && optionsCompare.FileManagerType == FileManagerType;
         }
     }
 }
diff --git a/FileContextCore/Infrastructure/Internal/IFileContextScopedOptions.cs b/FileContextCore/Infrastructure/Internal/IFileContextScopedOptions.cs
@@ -8,5 +8,7 @@ public interface IFileContextScopedOptions
        string Location { get; }
        string Password { get; }
        Type StoreManagerType { get; }
+       Type SerializerType { get; }
+       Type FileManagerType { get; }
     }
 }
diff --git a/FileContextCore/Serializer/JSONSerializer.cs b/FileContextCore/Serializer/JSONSerializer.cs
@@ -1,11 +1,10 @@
-﻿using Microsoft.EntityFrameworkCore.Metadata;
-using Newtonsoft.Json.Linq;
-using System;
+﻿using System;
 using System.Collections.Generic;
 using System.Linq;
 using FileContextCore.Infrastructure.Internal;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.ChangeTracking.Internal;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Newtonsoft.Json.Linq;
 
 namespace FileContextCore.Serializer
 {
@@ -15,7 +14,7 @@ public class JSONSerializer : ISerializer
         private object _keyValueFactory;
         private string[] _propertyKeys;
         private Type[] _typeList;
-        
+
         public void Initialize(IFileContextScopedOptions _, IEntityType entityType, object keyValueFactory)
         {
             _keyValueFactory = keyValueFactory;
diff --git a/FileContextCore/Storage/Internal/FileContextStoreCache.cs b/FileContextCore/Storage/Internal/FileContextStoreCache.cs
@@ -3,6 +3,7 @@
 // Modified version by morrisjdev
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Concurrent;
 using System.Threading;
 using FileContextCore.Infrastructure.Internal;
@@ -15,15 +16,18 @@ namespace FileContextCore.Storage.Internal
     public class FileContextStoreCache : IFileContextStoreCache
     {
         [NotNull] private readonly ILoggingOptions _loggingOptions;
+        private readonly IServiceProvider _serviceProvider;
         private readonly bool _useNameMatching;
         private readonly ConcurrentDictionary<IFileContextScopedOptions, IFileContextStore> _namedStores;
 
     
         public FileContextStoreCache(
             [NotNull] ILoggingOptions loggingOptions,
-            [CanBeNull] IFileContextSingletonOptions options)
+            [CanBeNull] IFileContextSingletonOptions options,
+            IServiceProvider serviceProvider)
         {
             _loggingOptions = loggingOptions;
+            _serviceProvider = serviceProvider;
             if (options?.DatabaseRoot != null)
             {
                 _useNameMatching = true;
@@ -43,7 +47,7 @@ public FileContextStoreCache(
     
         public virtual IFileContextStore GetStore(IFileContextScopedOptions options)
         {
-            return _namedStores.GetOrAdd(options, _ => new FileContextStore(new FileContextTableFactory(_loggingOptions, options), _useNameMatching));
+            return _namedStores.GetOrAdd(options, _ => new FileContextStore(new FileContextTableFactory(_loggingOptions, options, _serviceProvider), _useNameMatching));
         }
     }
 }
diff --git a/FileContextCore/Storage/Internal/FileContextTable.cs b/FileContextCore/Storage/Internal/FileContextTable.cs
@@ -33,6 +33,7 @@ public class FileContextTable<TKey> : IFileContextTable
         private readonly bool _sensitiveLoggingEnabled;
         private readonly IEntityType _entityType;
         private readonly IFileContextScopedOptions _options;
+        private readonly IServiceProvider _serviceProvider;
         private readonly Dictionary<TKey, object[]> _rows;
 
         private IStoreManager _storeManager;
@@ -44,12 +45,14 @@ public FileContextTable(
             [NotNull] Microsoft.EntityFrameworkCore.ChangeTracking.Internal.IPrincipalKeyValueFactory<TKey> keyValueFactory,
             bool sensitiveLoggingEnabled,
             IEntityType entityType,
-            IFileContextScopedOptions options)
+            IFileContextScopedOptions options,
+            IServiceProvider serviceProvider)
         {
             _keyValueFactory = keyValueFactory;
             _sensitiveLoggingEnabled = sensitiveLoggingEnabled;
             _entityType = entityType;
             _options = options;
+            _serviceProvider = serviceProvider;
 
             _rows = Init();
         }
@@ -242,7 +245,7 @@ protected virtual void ThrowUpdateConcurrencyException([NotNull] IUpdateEntry en
 
         private Dictionary<TKey, object[]> Init()
         {
-            _storeManager = (IStoreManager)Activator.CreateInstance(_options.StoreManagerType);
+            _storeManager = (IStoreManager)_serviceProvider.GetService(_options.StoreManagerType);
             _storeManager.Initialize(_options, _entityType, _keyValueFactory);
 
             Dictionary<TKey, object[]> newList = new Dictionary<TKey, object[]>(_keyValueFactory.EqualityComparer);
diff --git a/FileContextCore/Storage/Internal/FileContextTableFactory.cs b/FileContextCore/Storage/Internal/FileContextTableFactory.cs
@@ -5,34 +5,34 @@
 
 using System;
 using System.Collections.Concurrent;
-using System.Linq;
 using System.Reflection;
 using FileContextCore.Infrastructure.Internal;
 using FileContextCore.Utilities;
 using JetBrains.Annotations;
-using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.ChangeTracking.Internal;
 using Microsoft.EntityFrameworkCore.Diagnostics;
-using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Metadata;
-using Microsoft.EntityFrameworkCore.Utilities;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
 
 namespace FileContextCore.Storage.Internal
 {
 
     public class FileContextTableFactory
         // WARNING: The in-memory provider is using EF internal code here. This should not be copied by other providers. See #15096
-        : Microsoft.EntityFrameworkCore.ChangeTracking.Internal.IdentityMapFactoryFactoryBase, IFileContextTableFactory
+        : IdentityMapFactoryFactoryBase, IFileContextTableFactory
     {
         private readonly IFileContextScopedOptions _options;
+        private readonly IServiceProvider _serviceProvider;
         private readonly bool _sensitiveLoggingEnabled;
 
         private readonly ConcurrentDictionary<IKey, Func<IFileContextTable>> _factories
             = new ConcurrentDictionary<IKey, Func<IFileContextTable>>();
 
     
-        public FileContextTableFactory([NotNull] ILoggingOptions loggingOptions, [NotNull] IFileContextScopedOptions options)
+        public FileContextTableFactory([NotNull] ILoggingOptions loggingOptions, [NotNull] IFileContextScopedOptions options, IServiceProvider serviceProvider)
         {
             _options = options;
+            _serviceProvider = serviceProvider;
             Check.NotNull(loggingOptions, nameof(loggingOptions));
 
             _sensitiveLoggingEnabled = loggingOptions.IsSensitiveDataLoggingEnabled;
@@ -46,15 +46,16 @@ private Func<IFileContextTable> Create([NotNull] IKey key)
             => (Func<IFileContextTable>)typeof(FileContextTableFactory).GetTypeInfo()
                 .GetDeclaredMethod(nameof(CreateFactory))
                 .MakeGenericMethod(GetKeyType(key))
-                .Invoke(null, new object[] { key, key.DeclaringEntityType, _sensitiveLoggingEnabled, _options });
+                .Invoke(null, new object[] { key, key.DeclaringEntityType, _sensitiveLoggingEnabled, _options, _serviceProvider });
 
         [UsedImplicitly]
-        private static Func<IFileContextTable> CreateFactory<TKey>(IKey key, IEntityType entityType, bool sensitiveLoggingEnabled, IFileContextScopedOptions options)
+        private static Func<IFileContextTable> CreateFactory<TKey>(IKey key, IEntityType entityType, bool sensitiveLoggingEnabled, IFileContextScopedOptions options, IServiceProvider serviceProvider)
             => () => new FileContextTable<TKey>(
                 // WARNING: The in-memory provider is using EF internal code here. This should not be copied by other providers. See #15096
-                Microsoft.EntityFrameworkCore.Metadata.Internal.KeyExtensions.GetPrincipalKeyValueFactory<TKey>(key),
+                KeyExtensions.GetPrincipalKeyValueFactory<TKey>(key),
                 sensitiveLoggingEnabled,
                 entityType,
-                options);
+                options,
+                serviceProvider);
     }
 }
diff --git a/FileContextCore/StoreManager/DefaultStoreManager.cs b/FileContextCore/StoreManager/DefaultStoreManager.cs
@@ -7,25 +7,28 @@
 
 namespace FileContextCore.StoreManager
 {
-    public class DefaultStoreManager<TSerializer, TFileManager> : IStoreManager
-        where TSerializer : ISerializer
-        where TFileManager : IFileManager
-    {
+    class DefaultStoreManager : IStoreManager {
+        private readonly IServiceProvider _serviceProvider;
         private ISerializer _serializer;
         private IFileManager _fileManager;
         private object _keyValueFactory;
         private IEntityType _entityType;
+
+        public DefaultStoreManager(IServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+        }
         
         public void Initialize(IFileContextScopedOptions options, IEntityType entityType,
             object keyValueFactory)
         {
             _keyValueFactory = keyValueFactory;
             _entityType = entityType;
-            
-            _serializer = (ISerializer)Activator.CreateInstance(typeof(TSerializer));
+
+            _serializer = (ISerializer)_serviceProvider.GetService(options.SerializerType);
             _serializer.Initialize(options, _entityType, _keyValueFactory);
-            
-            _fileManager = (IFileManager)Activator.CreateInstance(typeof(TFileManager));
+
+            _fileManager = (IFileManager)_serviceProvider.GetService(options.FileManagerType);
             _fileManager.Initialize(options, entityType, _serializer.FileType);
         }
 

Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,6 @@`
`1`	`1`	`using Example.Data.Entities;`
`2`	`2`	`using FileContextCore;`
`3`		`-using FileContextCore.StoreManager;`
`4`	`3`	`using Microsoft.EntityFrameworkCore;`
`5`		`-using OfficeOpenXml;`
`6`	`4`
`7`	`5`	`namespace Example.Data`
`8`	`6`	`{`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ public static DbContextOptionsBuilder UseFileContextDatabase(`
`91`	`91`	`?? new FileContextOptionsExtension();`
`92`	`92`
`93`	`93`	`extension = extension.WithCustomOptions(databaseName, location, password,`
`94`		`- typeof(DefaultStoreManager<JSONSerializer, DefaultFileManager>));`
	`94`	`+ typeof(DefaultStoreManager), typeof(JSONSerializer), typeof(DefaultFileManager));`
`95`	`95`
`96`	`96`	`if (databaseRoot != null)`
`97`	`97`	`{`
`@@ -183,7 +183,7 @@ public static DbContextOptionsBuilder UseFileContextDatabase<TSerializer, TFileM`
`183`	`183`	`?? new FileContextOptionsExtension();`
`184`	`184`
`185`	`185`	`extension = extension.WithCustomOptions(databaseName, location, password,`
`186`		`- typeof(DefaultStoreManager<TSerializer, TFileManager>));`
	`186`	`+ typeof(DefaultStoreManager), typeof(TSerializer), typeof(TFileManager));`
`187`	`187`
`188`	`188`	`if (databaseRoot != null)`
`189`	`189`	`{`
`@@ -270,7 +270,7 @@ public static DbContextOptionsBuilder UseFileContextDatabase<TStoreManager>(`
`270`	`270`	`var extension = optionsBuilder.Options.FindExtension<FileContextOptionsExtension>()`
`271`	`271`	`?? new FileContextOptionsExtension();`
`272`	`272`
`273`		`- extension = extension.WithCustomOptions(databaseName, location, password, typeof(TStoreManager));`
	`273`	`+ extension = extension.WithCustomOptions(databaseName, location, password, typeof(TStoreManager), null, null);`
`274`	`274`
`275`	`275`	`if (databaseRoot != null)`
`276`	`276`	`{`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public class FileContextOptionsExtension : IDbContextOptionsExtension`
`28`	`28`	`public FileContextOptionsExtension()`
`29`	`29`	`{`
`30`	`30`	`_options = new FileContextScopedOptions(null, null, null,`
`31`		`- typeof(DefaultStoreManager<JSONSerializer, DefaultFileManager>));`
	`31`	`+ typeof(DefaultStoreManager), typeof(JSONSerializer), typeof(DefaultFileManager));`
`32`	`32`	`}`
`33`	`33`
`34`	`34`
`@@ -49,10 +49,10 @@ public virtual DbContextOptionsExtensionInfo Info`
`49`	`49`	`public virtual FileContextScopedOptions Options => _options;`
`50`	`50`
`51`	`51`
`52`		`- public virtual FileContextOptionsExtension WithCustomOptions(string databaseName, string location, string password, Type storeManagerType)`
	`52`	`+ public virtual FileContextOptionsExtension WithCustomOptions(string databaseName, string location, string password, Type storeManagerType, Type serializerType, Type fileManagerType)`
`53`	`53`	`{`
`54`	`54`	`var clone = Clone();`
`55`		`- clone._options = new FileContextScopedOptions(databaseName, location, password, storeManagerType);`
	`55`	`+ clone._options = new FileContextScopedOptions(databaseName, location, password, storeManagerType, serializerType, fileManagerType);`
`56`	`56`	`return clone;`
`57`	`57`	`}`
`58`	`58`
`@@ -105,6 +105,9 @@ public override string LogFragment`
`105`	`105`	`builder.Append("Location=").Append(Extension.Options.Location).Append(' ');`
`106`	`106`	`builder.Append("DatabaseName=").Append(Extension.Options.DatabaseName).Append(' ');`
`107`	`107`	`builder.Append("StoreManager=").Append(Extension.Options.StoreManagerType).Append(' ');`
	`108`	`+ builder.Append("Serializer=").Append(Extension.Options.SerializerType).Append(' ');`
	`109`	`+ builder.Append("FileManager=").Append(Extension.Options.FileManagerType).Append(' ');`
	`110`	`+ builder.Append("StoreManager=").Append(Extension.Options.StoreManagerType).Append(' ');`
`108`	`111`	`builder.Append("Password=").Append("<Password>").Append(' ');`
`109`	`112`
`110`	`113`	`_logFragment = builder.ToString();`
Original file line number	Diff line number	Diff line change
`@@ -1,18 +1,17 @@`
`1`	`1`	`using System;`
`2`		`-using System.Collections.Generic;`
`3`		`-using System.Text;`
`4`		`-using Microsoft.EntityFrameworkCore.Infrastructure;`
`5`	`2`
`6`	`3`	`namespace FileContextCore.Infrastructure.Internal`
`7`	`4`	`{`
`8`	`5`	`public class FileContextScopedOptions : IFileContextScopedOptions`
`9`	`6`	`{`
`10`		`- public FileContextScopedOptions(string databaseName, string location, string password, Type storeManagerType)`
	`7`	`+ public FileContextScopedOptions(string databaseName, string location, string password, Type storeManagerType, Type serializerType, Type fileManagerType)`
`11`	`8`	`{`
`12`	`9`	`DatabaseName = databaseName;`
`13`	`10`	`Location = location;`
`14`	`11`	`Password = password;`
`15`	`12`	`StoreManagerType = storeManagerType;`
	`13`	`+ SerializerType = serializerType;`
	`14`	`+ FileManagerType = fileManagerType;`
`16`	`15`	`}`
`17`	`16`
`18`	`17`	`public string DatabaseName { get; }`
`@@ -22,10 +21,14 @@ public FileContextScopedOptions(string databaseName, string location, string pas`
`22`	`21`	`public string Password { get; }`
`23`	`22`
`24`	`23`	`public Type StoreManagerType { get; }`
	`24`	`+`
	`25`	`+ public Type SerializerType { get; }`
	`26`	`+`
	`27`	`+ public Type FileManagerType { get; }`
`25`	`28`
`26`	`29`	`public override int GetHashCode()`
`27`	`30`	`{`
`28`		`- return (DatabaseName + Location + Password + StoreManagerType).GetHashCode();`
	`31`	`+ return (DatabaseName + Location + Password + StoreManagerType + SerializerType + FileManagerType).GetHashCode();`
`29`	`32`	`}`
`30`	`33`
`31`	`34`	`public override bool Equals(object obj)`
`@@ -37,7 +40,8 @@ public override bool Equals(object obj)`
`37`	`40`
`38`	`41`	`FileContextScopedOptions optionsCompare = (FileContextScopedOptions) obj;`
`39`	`42`	`return optionsCompare.DatabaseName == DatabaseName && optionsCompare.Location == Location &&`
`40`		`- optionsCompare.Password == Password && optionsCompare.StoreManagerType == StoreManagerType;`
	`43`	`+ optionsCompare.Password == Password && optionsCompare.StoreManagerType == StoreManagerType &&`
	`44`	`+ optionsCompare.SerializerType == SerializerType && optionsCompare.FileManagerType == FileManagerType;`
`41`	`45`	`}`
`42`	`46`	`}`
`43`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,5 +8,7 @@ public interface IFileContextScopedOptions`
`8`	`8`	`string Location { get; }`
`9`	`9`	`string Password { get; }`
`10`	`10`	`Type StoreManagerType { get; }`
	`11`	`+ Type SerializerType { get; }`
	`12`	`+ Type FileManagerType { get; }`
`11`	`13`	`}`
`12`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`// Modified version by morrisjdev`
`4`	`4`	`// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.`
`5`	`5`
	`6`	`+using System;`
`6`	`7`	`using System.Collections.Concurrent;`
`7`	`8`	`using System.Threading;`
`8`	`9`	`using FileContextCore.Infrastructure.Internal;`
`@@ -15,15 +16,18 @@ namespace FileContextCore.Storage.Internal`
`15`	`16`	`public class FileContextStoreCache : IFileContextStoreCache`
`16`	`17`	`{`
`17`	`18`	`[NotNull] private readonly ILoggingOptions _loggingOptions;`
	`19`	`+ private readonly IServiceProvider _serviceProvider;`
`18`	`20`	`private readonly bool _useNameMatching;`
`19`	`21`	`private readonly ConcurrentDictionary<IFileContextScopedOptions, IFileContextStore> _namedStores;`
`20`	`22`
`21`	`23`
`22`	`24`	`public FileContextStoreCache(`
`23`	`25`	`[NotNull] ILoggingOptions loggingOptions,`
`24`		`- [CanBeNull] IFileContextSingletonOptions options)`
	`26`	`+ [CanBeNull] IFileContextSingletonOptions options,`
	`27`	`+ IServiceProvider serviceProvider)`
`25`	`28`	`{`
`26`	`29`	`_loggingOptions = loggingOptions;`
	`30`	`+ _serviceProvider = serviceProvider;`
`27`	`31`	`if (options?.DatabaseRoot != null)`
`28`	`32`	`{`
`29`	`33`	`_useNameMatching = true;`
`@@ -43,7 +47,7 @@ public FileContextStoreCache(`
`43`	`47`
`44`	`48`	`public virtual IFileContextStore GetStore(IFileContextScopedOptions options)`
`45`	`49`	`{`
`46`		`- return _namedStores.GetOrAdd(options, _ => new FileContextStore(new FileContextTableFactory(_loggingOptions, options), _useNameMatching));`
	`50`	`+ return _namedStores.GetOrAdd(options, _ => new FileContextStore(new FileContextTableFactory(_loggingOptions, options, _serviceProvider), _useNameMatching));`
`47`	`51`	`}`
`48`	`52`	`}`
`49`	`53`	`}`