added multiple db configurations support

Author: morrisjdev

Example/Data/Context.cs

@@ -21,7 +21,7 @@ public class Context : DbContext
         protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
         {
             //Default: JSON-Serialize
-            optionsBuilder.UseFileContextDatabase();
+            //optionsBuilder.UseFileContextDatabase();
 
             //optionsBuilder.UseFileContextDatabase("bson");
 
@@ -37,6 +37,9 @@ protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
 
             //Excel
             //optionsBuilder.UseFileContextDatabase("excel", databaseName: "test");
+
+            //ConnectionString
+            optionsBuilder.UseFileContextDatabaseConnectionString("SeriAlizer=xml;databasenaMe=Test");
         }
 
         protected override void OnModelCreating(ModelBuilder modelBuilder)

Example/Program.cs

@@ -28,6 +28,9 @@ static void Main(string[] args)
             List<User> users2 = db.Users.Include("Contents.Entries").Include("Contents").Include("Contents").ToList();
 
             List<User> user3 = db2.Users.ToList();
+            db2.Users.RemoveRange(user3.Take(2));
+            db2.SaveChanges();
+
 
             db.Users.RemoveRange(db.Users.Skip(40));
             db.SaveChanges();

FileContextCore/Extensions/FileContextDbContextOptionsExtensions.cs

@@ -4,6 +4,8 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using FileContextCore.Diagnostics;
 using FileContextCore.Infrastructure.Internal;
 using FileContextCore.Infrastructure;
@@ -24,6 +26,30 @@ namespace FileContextCore
     /// </summary>
     public static class FileContextDbContextOptionsExtensions
     {
+        /// <summary>
+        ///     Configures the context to connect to an in-memory database.
+        ///     The in-memory database is shared anywhere the same name is used, but only for a given
+        ///     service provider.
+        /// </summary>
+        /// <typeparam name="TContext"> The type of context being configured. </typeparam>
+        /// <param name="optionsBuilder"> The builder being used to configure the context. </param>
+        /// <param name="connectionString">A connection string that is used to build the options</param>
+        /// <param name="databaseRoot">
+        ///     All in-memory databases will be rooted in this object, allowing the application
+        ///     to control their lifetime. This is useful when sometimes the context instance
+        ///     is created explicitly with <c>new</c> while at other times it is resolved using dependency injection.
+        /// </param>
+        /// <param name="inMemoryOptionsAction">An optional action to allow additional in-memory specific configuration.</param>
+        /// <returns> The options builder so that further configuration can be chained. </returns>
+        public static DbContextOptionsBuilder<TContext> UseFileContextDatabaseConnectionString<TContext>(
+            [NotNull] this DbContextOptionsBuilder<TContext> optionsBuilder,
+            string connectionString,
+            [CanBeNull] FileContextDatabaseRoot databaseRoot = null,
+            [CanBeNull] Action<FileContextDbContextOptionsBuilder> inMemoryOptionsAction = null)
+            where TContext : DbContext
+            => (DbContextOptionsBuilder<TContext>)UseFileContextDatabaseConnectionString(
+                (DbContextOptionsBuilder)optionsBuilder, connectionString, databaseRoot, inMemoryOptionsAction);
+
         /// <summary>
         ///     Configures the context to connect to an in-memory database.
         ///     The in-memory database is shared anywhere the same name is used, but only for a given
@@ -63,21 +89,53 @@ public static DbContextOptionsBuilder<TContext> UseFileContextDatabase<TContext>
         ///     service provider.
         /// </summary>
         /// <param name="optionsBuilder"> The builder being used to configure the context. </param>
-        /// <param name="databaseName">
-        ///     The name of the in-memory database. This allows the scope of the in-memory database to be controlled
-        ///     independently of the context. The in-memory database is shared anywhere the same name is used.
-        /// </param>
-        /// <param name="location">An optional parameter to define the location where the files are stored</param>
+        /// <param name="connectionString">A connection string that is used to build the options</param>
         /// <param name="databaseRoot">
         ///     All in-memory databases will be rooted in this object, allowing the application
         ///     to control their lifetime. This is useful when sometimes the context instance
         ///     is created explicitly with <c>new</c> while at other times it is resolved using dependency injection.
         /// </param>
         /// <param name="inMemoryOptionsAction">An optional action to allow additional in-memory specific configuration.</param>
-        /// <param name="serializer">The serializer to be used. Defaults to json</param>
-        /// <param name="filemanager">The file manager to be used.</param>
         /// <returns> The options builder so that further configuration can be chained. </returns>
-        public static DbContextOptionsBuilder UseFileContextDatabase(
+        public static DbContextOptionsBuilder UseFileContextDatabaseConnectionString(
+            [NotNull] this DbContextOptionsBuilder optionsBuilder,
+            string connectionString,
+            [CanBeNull] FileContextDatabaseRoot databaseRoot = null,
+            [CanBeNull] Action<FileContextDbContextOptionsBuilder> inMemoryOptionsAction = null)
+        {
+            string[] connectionStringParts = connectionString.Split(';');
+            Dictionary<string, string> connectionStringSplitted = connectionStringParts
+                .Select(segment => segment.Split('='))
+                .ToDictionary(parts => parts[0].Trim().ToLowerInvariant(), parts => parts[1].Trim());
+
+            return UseFileContextDatabase(optionsBuilder, 
+                connectionStringSplitted.GetValueOrDefault("serializer"),
+                connectionStringSplitted.GetValueOrDefault("filemanager"),
+                connectionStringSplitted.GetValueOrDefault("databasename"),
+                connectionStringSplitted.GetValueOrDefault("location"), databaseRoot, inMemoryOptionsAction);
+        }
+
+        /// <summary>
+            ///     Configures the context to connect to a named in-memory database.
+            ///     The in-memory database is shared anywhere the same name is used, but only for a given
+            ///     service provider.
+            /// </summary>
+            /// <param name="optionsBuilder"> The builder being used to configure the context. </param>
+            /// <param name="databaseName">
+            ///     The name of the in-memory database. This allows the scope of the in-memory database to be controlled
+            ///     independently of the context. The in-memory database is shared anywhere the same name is used.
+            /// </param>
+            /// <param name="location">An optional parameter to define the location where the files are stored</param>
+            /// <param name="databaseRoot">
+            ///     All in-memory databases will be rooted in this object, allowing the application
+            ///     to control their lifetime. This is useful when sometimes the context instance
+            ///     is created explicitly with <c>new</c> while at other times it is resolved using dependency injection.
+            /// </param>
+            /// <param name="inMemoryOptionsAction">An optional action to allow additional in-memory specific configuration.</param>
+            /// <param name="serializer">The serializer to be used. Defaults to json</param>
+            /// <param name="filemanager">The file manager to be used.</param>
+            /// <returns> The options builder so that further configuration can be chained. </returns>
+            public static DbContextOptionsBuilder UseFileContextDatabase(
             [NotNull] this DbContextOptionsBuilder optionsBuilder,
             string serializer = "json",
             string filemanager = "default",
@@ -91,8 +149,7 @@ public static DbContextOptionsBuilder UseFileContextDatabase(
             var extension = optionsBuilder.Options.FindExtension<FileContextOptionsExtension>()
                             ?? new FileContextOptionsExtension();
 
-            extension = extension.WithStoreName(databaseName);
-            extension = extension.WithCustomOptions(serializer, filemanager, location);
+            extension = extension.WithCustomOptions(databaseName, serializer, filemanager, location);
 
             if (databaseRoot != null)
             {

FileContextCore/Extensions/FileContextServiceCollectionExtensions.cs

@@ -45,7 +45,7 @@ public static class FileContextServiceCollectionExtensions
         /// <returns>
         ///     The same service collection so that multiple calls can be chained.
         /// </returns>
-        public static IServiceCollection AddEntityFrameworkFileContextDatabase([NotNull] this IServiceCollection serviceCollection, FileContextOptionsExtension optionsExtension = null)
+        public static IServiceCollection AddEntityFrameworkFileContextDatabase([NotNull] this IServiceCollection serviceCollection)
         {
             Check.NotNull(serviceCollection, nameof(serviceCollection));
 
@@ -69,9 +69,7 @@ public static IServiceCollection AddEntityFrameworkFileContextDatabase([NotNull]
                 .TryAddProviderSpecificServices(
                     b => b
                         .TryAddSingleton<IFileContextSingletonOptions, FileContextSingletonOptions>()
-                        .TryAddScoped<IFileContextScopedOptions, FileContextScopedOptions>((serviceProvider) => new FileContextScopedOptions(optionsExtension))
                         .TryAddSingleton<IFileContextStoreCache, FileContextStoreCache>()
-                        .TryAddSingleton<IFileContextTableFactory, FileContextTableFactory>()
                         .TryAddScoped<IFileContextDatabase, FileContextDatabase>());
 
             builder.TryAddCoreServices();

FileContextCore/FileContextCore.csproj

@@ -5,7 +5,7 @@
     <SignAssembly Condition="'$(OS)' == 'Windows_NT'">true</SignAssembly>
     <AssemblyOriginatorKeyFile>FileContextCoreCert.pfx</AssemblyOriginatorKeyFile>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-    <Version>3.2.0</Version>
+    <Version>3.2.1</Version>
     <Company>morrisjdev</Company>
     <Authors>morrisjdev</Authors>
     <Description>File provider for Entity Framework Core (to be used for development purposes)</Description>
@@ -19,8 +19,8 @@
     <PackageProjectUrl>https://github.com/morrisjdev/FileContextCore</PackageProjectUrl>
     <NeutralLanguage>en-US</NeutralLanguage>
     <DelaySign>false</DelaySign>
-    <AssemblyVersion>3.2.0.0</AssemblyVersion>
-    <FileVersion>3.2.0.0</FileVersion>
+    <AssemblyVersion>3.2.1.0</AssemblyVersion>
+    <FileVersion>3.2.1.0</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>

FileContextCore/Infrastructure/Internal/FileContextOptionsExtension.cs

@@ -22,12 +22,9 @@ namespace FileContextCore.Infrastructure.Internal
     /// </summary>
     public class FileContextOptionsExtension : IDbContextOptionsExtension
     {
-        private string _storeName;
-        public string serializer;
-        public string filemanager;
-        public string location;
         private FileContextDatabaseRoot _databaseRoot;
         private DbContextOptionsExtensionInfo _info;
+        private FileContextScopedOptions _options;
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -37,6 +34,7 @@ public class FileContextOptionsExtension : IDbContextOptionsExtension
         /// </summary>
         public FileContextOptionsExtension()
         {
+            _options = new FileContextScopedOptions(null, null, null, null);
         }
 
         /// <summary>
@@ -47,11 +45,7 @@ public FileContextOptionsExtension()
         /// </summary>
         protected FileContextOptionsExtension([NotNull] FileContextOptionsExtension copyFrom)
         {
-            serializer = copyFrom.serializer;
-            filemanager = copyFrom.filemanager;
-            location = copyFrom.location;
-            
-            _storeName = copyFrom._storeName;
+            _options = (FileContextScopedOptions)copyFrom._options.Clone();
             _databaseRoot = copyFrom._databaseRoot;
         }
 
@@ -78,36 +72,21 @@ public virtual DbContextOptionsExtensionInfo Info
         ///     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 string StoreName => _storeName;
+        public virtual FileContextScopedOptions Options => _options;
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
         ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
         ///     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 FileContextOptionsExtension WithStoreName([NotNull] string storeName)
+        public virtual FileContextOptionsExtension WithCustomOptions(string databaseName, string serializer, string fileManager, string location)
         {
             var clone = Clone();
-
-            clone._storeName = storeName;
-
-            return clone;
-        }
-
-        /// <summary>
-        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
-        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
-        ///     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 FileContextOptionsExtension WithCustomOptions(string serializer, string filemanager, string location)
-        {
-            var clone = Clone();
-
-            clone.serializer = serializer;
-            clone.filemanager = filemanager;
-            clone.location = location;
+            clone._options.Location = location;
+            clone._options.DatabaseName = databaseName;
+            clone._options.FileManager = fileManager;
+            clone._options.Serializer = serializer;
 
             return clone;
         }
@@ -143,7 +122,7 @@ public virtual FileContextOptionsExtension WithDatabaseRoot([NotNull] FileContex
         /// </summary>
         public virtual void ApplyServices(IServiceCollection services)
         {
-            services.AddEntityFrameworkFileContextDatabase(this);
+            services.AddEntityFrameworkFileContextDatabase();
         }
 
         /// <summary>
@@ -178,7 +157,10 @@ public override string LogFragment
                     {
                         var builder = new StringBuilder();
 
-                        builder.Append("StoreName=").Append(Extension._storeName).Append(' ');
+                        builder.Append("Location=").Append(Extension.Options.Location).Append(' ');
+                        builder.Append("DatabaseName=").Append(Extension.Options.DatabaseName).Append(' ');
+                        builder.Append("Serializer=").Append(Extension.Options.Serializer).Append(' ');
+                        builder.Append("FileManager=").Append(Extension.Options.FileManager).Append(' ');
 
                         _logFragment = builder.ToString();
                     }

FileContextCore/Infrastructure/Internal/FileContextScopedOptions.cs

@@ -5,25 +5,44 @@
 
 namespace FileContextCore.Infrastructure.Internal
 {
-    public class FileContextScopedOptions : IFileContextScopedOptions
+    public class FileContextScopedOptions : IFileContextScopedOptions, ICloneable
     {
-        public FileContextScopedOptions(FileContextOptionsExtension options)
+        public FileContextScopedOptions(string databaseName, string serializer, string fileManager, string location)
         {
-            if (options != null)
-            {
-                Serializer = options.serializer;
-                DatabaseName = options.StoreName;
-                FileManager = options.filemanager;
-                Location = options.location;
-            }
+            Serializer = serializer;
+            DatabaseName = databaseName;
+            FileManager = fileManager;
+            Location = location;
         }
 
-        public virtual string DatabaseName { get; private set; }
+        public string DatabaseName { get; set; }
+
+        public string Serializer { get; set; }
+
+        public string FileManager { get; set; }
+
+        public string Location { get; set; }
+
+        public override int GetHashCode()
+        {
+            return (DatabaseName + Serializer + FileManager + Location).GetHashCode();
+        }
 
-        public virtual string Serializer { get; private set; }
+        public object Clone()
+        {
+            return new FileContextScopedOptions(DatabaseName, Serializer, FileManager, Location);
+        }
 
-        public virtual string FileManager { get; private set; }
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
 
-        public virtual string Location { get; private set; }
+            FileContextScopedOptions optionsCompare = (FileContextScopedOptions) obj;
+            return optionsCompare.Serializer == Serializer && optionsCompare.DatabaseName == DatabaseName &&
+                   optionsCompare.FileManager == FileManager && optionsCompare.Location == Location;
+        }
     }
 }

FileContextCore/Metadata/Conventions/FileContextConventionSetBuilder.cs

@@ -52,7 +52,7 @@ public static ConventionSet Build()
             var serviceProvider = new ServiceCollection()
                 .AddEntityFrameworkFileContextDatabase()
                 .AddDbContext<DbContext>((p, o) =>
-                    o.UseFileContextDatabase(Guid.NewGuid().ToString())
+                    o.UseFileContextDatabase(databaseName: Guid.NewGuid().ToString())
                         .UseInternalServiceProvider(p))
                 .BuildServiceProvider();
 

FileContextCore/Serializer/EXCELSerializer.cs

@@ -99,7 +99,7 @@ public EXCELSerializer(IEntityType _entityType, string _password, string databas
 
         public Dictionary<TKey, object[]> Deserialize<TKey>(Dictionary<TKey, object[]> newList)
         {
-            for (int y = 2; y < worksheet.Dimension.Rows; y++)
+            for (int y = 2; y <= worksheet.Dimension.Rows; y++)
             {
                 List<object> value = new List<object>();
 
@@ -156,7 +156,7 @@ private void FillRows<TKey>(Dictionary<TKey, object[]> list)
 
         private void DeleteUnusedRows(int lastRow)
         {
-            if (worksheet.Dimension.Rows > lastRow)
+            if (worksheet.Dimension.Rows >= lastRow)
             {
                 int count = worksheet.Dimension.Rows - lastRow;
                 worksheet.DeleteRow(lastRow + 1, count);