Merge pull request #24 from AutoMapper/development

TylerCarlson1 · web-flow · commit 251df9eb8478 · 2019-10-20T10:44:25.000-05:00
merge to master for release
diff --git a/NuGet.Config b/NuGet.Config
@@ -1,6 +1,6 @@
 ﻿<?xml version="1.0" encoding="utf-8"?>
 <configuration>
-  <packageSources> 
+  <packageSources>
     <add key="AutoMapper" value="https://www.myget.org/F/automapperdev/api/v2" /> 
   </packageSources> 
 </configuration>
diff --git a/README.md b/README.md
@@ -1,28 +1,41 @@
 <img src="https://s3.amazonaws.com/automapper/logo.png" alt="AutoMapper"> 
 
-AutoMapper.Collection.EFCore
-================================
-`Automapper.Collection.EntityFrameworkCore` will help you mapping of EntityFramework Core DbContext-object.
-	
-    Mapper.Initialize(cfg =>
-    {
-        cfg.AddCollectionMappers();
-        cfg.UseEntityFrameworkCoreModel<DB>(serviceProvider);
-        // Configuration code
-    });
-
-User defined equality expressions will overwrite primary key expressions.
+# AutoMapper.Collection.EntityFrameworkCore
+
+`Automapper.Collection.EntityFrameworkCore` will help you mapping of EntityFrameowrk Core DbContext-object.
+
+## Configuration examples
+
+- Usage together with Dependency injection and AutoMapper.Extensions.Microsoft.DependencyInjection pacakge
+```	
+var services = new ServiceCollection();
+services
+    .AddEntityFrameworkInMemoryDatabase()
+    .AddDbContext<DB>();
+
+services.AddAutoMapper((serviceProvider, automapper) =>
+{
+    automapper.AddCollectionMappers();
+    automapper.UseEntityFrameworkCoreModel<DB>(serviceProvider);
+}, typeof(DB).Assembly);
+
+var serviceProvider = services.BuildServiceProvider();
+```
+
+**Note:** User defined equality expressions will overwrite primary key expressions.
 
 What about comparing to a single existing Entity for updating?
 --------------------------------
-Automapper.Collection.EntityFramework does that as well through extension method from of DbSet<TEntity>.
+Automapper.Collection.EntityFrameworkCore does that as well through extension method from of DbSet<TEntity>.
 
 Translate equality between dto and EF object to an expression of just the EF using the dto's values as constants.
 
-	dbContext.Orders.Persist().InsertOrUpdate<OrderDTO>(newOrderDto);
-	dbContext.Orders.Persist().InsertOrUpdate<OrderDTO>(existingOrderDto);
-	dbContext.Orders.Persist().Remove<OrderDTO>(deletedOrderDto);
+```
+	dbContext.Orders.Persist(mapper).InsertOrUpdate<OrderDTO>(newOrderDto);
+	dbContext.Orders.Persist(mapper).InsertOrUpdate<OrderDTO>(existingOrderDto);
+	dbContext.Orders.Persist(mapper).Remove<OrderDTO>(deletedOrderDto);
 	dbContext.SubmitChanges();
+```
 
 **Note:** This is done by converting the OrderDTO to Expression<Func<Order,bool>> and using that to find matching type in the database.  You can also map objects to expressions as well.
 
@@ -31,6 +44,7 @@ Persist doesn't call submit changes automatically
 How to get it
 --------------------------------
 Use NuGet Package Manager to install the package or use any of the following command in NuGet Package Manager Console.
-	
-	PM> Install-Package AutoMapper.Collection.EntityFrameworkCore
 
+```	
+PM> Install-Package AutoMapper.Collection.EntityFrameworkCore
+```
diff --git a/build.ps1 b/build.ps1
@@ -49,7 +49,7 @@ task compile -depends clean {
 	# restore all project references (creating project.assets.json for each project)
 	exec { dotnet restore $base_dir\AutoMapper.Collection.EFCore.sln /nologo }
 
-	exec { dotnet build $base_dir\AutoMapper.Collection.EFCore.sln -c $config $buildParam /nologo --no-restore }
+	exec { dotnet build $base_dir\AutoMapper.Collection.EFCore.sln -c $config $buildParam --no-restore /nologo }
 
 	exec { dotnet pack $base_dir\AutoMapper.Collection.EFCore.sln -c $config --include-symbols --no-build --no-restore --output $artifacts_dir $packageParam /nologo}
 
diff --git a/src/AutoMapper.Collection.EntityFrameworkCore.Tests/AutoMapper.Collection.EntityFrameworkCore.Tests.csproj b/src/AutoMapper.Collection.EntityFrameworkCore.Tests/AutoMapper.Collection.EntityFrameworkCore.Tests.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net462</TargetFrameworks>
+    <TargetFrameworks>net462;netcoreapp2.0</TargetFrameworks>
     <AssemblyName>AutoMapper.Collection.EntityFrameworkCore.Tests</AssemblyName>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
@@ -19,7 +19,7 @@
     <PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="6.0.0" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="2.1.1" />
     <PackageReference Include="FluentAssertions" Version="5.4.1" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.1.0" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.1.1" />
diff --git a/src/AutoMapper.Collection.EntityFrameworkCore.Tests/EntityFrameworkCoreUsingMicrosoftDITests.cs b/src/AutoMapper.Collection.EntityFrameworkCore.Tests/EntityFrameworkCoreUsingMicrosoftDITests.cs
@@ -19,10 +19,11 @@ public EntityFrameworkCoreUsingMicrosoftDITests()
                 .AddEntityFrameworkInMemoryDatabase()
                 .AddDbContext<DB>(options => options.UseInMemoryDatabase("EfTestDatabase" + Guid.NewGuid()));
 
-            services.AddAutoMapper(automapper =>
+            services.AddAutoMapper(x =>
             {
-                automapper.AddCollectionMappers();
-                automapper.UseEntityFrameworkCoreModel<DB>(services);
+                x.AddCollectionMappers();
+                x.UseEntityFrameworkCoreModel<DB>(services);
+                x.CreateMap<ThingDto, Thing>().ReverseMap();
             }, new Assembly[0]);
 
             this._serviceProvider = services.BuildServiceProvider();
diff --git a/src/AutoMapper.Collection.EntityFrameworkCore.Tests/EntityFramworkCoreUsingCtorTests.cs b/src/AutoMapper.Collection.EntityFrameworkCore.Tests/EntityFramworkCoreUsingCtorTests.cs
@@ -6,15 +6,16 @@ namespace AutoMapper.Collection.EntityFrameworkCore.Tests
 {
     public class EntityFramworkCoreUsingCtorTests : EntityFramworkCoreTestsBase
     {
+        private readonly Mapper _mapper;
+
         public EntityFramworkCoreUsingCtorTests()
         {
-            Mapper.Reset();
-            Mapper.Initialize(x =>
+            _mapper = new Mapper(new MapperConfiguration(x =>
             {
                 x.AddCollectionMappers();
                 x.CreateMap<ThingDto, Thing>().ReverseMap();
                 x.UseEntityFrameworkCoreModel<DB>();
-            });
+            }));
         }
 
         protected override DBContextBase GetDbContext()
@@ -24,7 +25,7 @@ protected override DBContextBase GetDbContext()
 
         protected override IMapper GetMapper()
         {
-            return Mapper.Instance;
+            return _mapper;
         }
 
         public class DB : DBContextBase
diff --git a/src/AutoMapper.Collection.EntityFrameworkCore.Tests/EntityFramworkCoreUsingDITests.cs b/src/AutoMapper.Collection.EntityFrameworkCore.Tests/EntityFramworkCoreUsingDITests.cs
@@ -9,6 +9,7 @@ namespace AutoMapper.Collection.EntityFrameworkCore.Tests
     public class EntityFramworkCoreUsingDITests : EntityFramworkCoreTestsBase, IDisposable
     {
         private readonly ServiceProvider _serviceProvider;
+        private readonly Mapper _mapper;
         private readonly IServiceScope _serviceScope;
 
         public EntityFramworkCoreUsingDITests()
@@ -21,13 +22,13 @@ public EntityFramworkCoreUsingDITests()
 
             _serviceProvider = services.BuildServiceProvider();
 
-            Mapper.Reset();
-            Mapper.Initialize(x =>
+            _mapper = new Mapper(new MapperConfiguration(x =>
             {
                 x.ConstructServicesUsing(type => ActivatorUtilities.GetServiceOrCreateInstance(_serviceProvider, type));
                 x.AddCollectionMappers();
                 x.UseEntityFrameworkCoreModel<DB>(_serviceProvider);
-            });
+                x.CreateMap<ThingDto, Thing>().ReverseMap();
+            }));
 
             _serviceScope = _serviceProvider.GetRequiredService<IServiceScopeFactory>().CreateScope();
         }
@@ -45,7 +46,7 @@ protected override DBContextBase GetDbContext()
 
         protected override IMapper GetMapper()
         {
-            return Mapper.Instance;
+            return _mapper;
         }
 
         public class DB : DBContextBase
diff --git a/src/AutoMapper.Collection.EntityFrameworkCore/AutoMapper.Collection.EntityFrameworkCore.csproj b/src/AutoMapper.Collection.EntityFrameworkCore/AutoMapper.Collection.EntityFrameworkCore.csproj
@@ -15,7 +15,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="AutoMapper.Collection" Version="5.0.0" />
+    <PackageReference Include="AutoMapper.Collection" Version="6.0.0-ci-*" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/AutoMapper.Collection.EntityFrameworkCore/Extensions.cs b/src/AutoMapper.Collection.EntityFrameworkCore/Extensions.cs
@@ -9,16 +9,18 @@ namespace AutoMapper.EntityFrameworkCore
     public static class Extensions
     {
         /// <summary>
+        /// Obsolete: Use Persist(IMapper) instead.
         /// Create a Persistence object for the <see cref="T:System.Data.Entity.DbSet`1"/> to have data persisted or removed from
         /// Uses static API's Mapper for finding TypeMap between classes
         /// </summary>
         /// <typeparam name="TSource">Source table type to be updated</typeparam>
         /// <param name="source">DbSet to be updated</param>
         /// <returns>Persistence object to Update or Remove data</returns>
+        [Obsolete("Use Persist(IMapper) instead.", true)]
         public static IPersistence<TSource> Persist<TSource>(this DbSet<TSource> source)
             where TSource : class
         {
-            return new Persistence<TSource>(source, Mapper.Instance);
+            throw new NotSupportedException();
         }
 
         /// <summary>
diff --git a/src/AutoMapper.Collection.EntityFrameworkCore/GenerateEntityFrameworkCorePrimaryKeyPropertyMaps.cs b/src/AutoMapper.Collection.EntityFrameworkCore/GenerateEntityFrameworkCorePrimaryKeyPropertyMaps.cs
@@ -14,7 +14,7 @@ public class GenerateEntityFrameworkCorePrimaryKeyPropertyMaps<TDatabaseContext>
 
         public GenerateEntityFrameworkCorePrimaryKeyPropertyMaps()
         {
-            throw new InvalidOperationException("Use UseEntityFrameworkCoreModel instead of using SetGeneratePropertyMaps.");
+            throw new InvalidOperationException($"Use {nameof(MapperConfigurationExpressionExtensions.UseEntityFrameworkCoreModel)} instead of using SetGeneratePropertyMaps.");
         }
 
         public GenerateEntityFrameworkCorePrimaryKeyPropertyMaps(IModel model) => _model = model;
diff --git a/src/AutoMapper.Collection.EntityFrameworkCore/Persistence.cs b/src/AutoMapper.Collection.EntityFrameworkCore/Persistence.cs
@@ -16,7 +16,7 @@ public class Persistence<TTo> : IPersistence<TTo>
         public Persistence(DbSet<TTo> sourceSet, IMapper mapper)
         {
             _sourceSet = sourceSet;
-            _mapper = mapper;
+            _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
         }
 
         public TTo InsertOrUpdate<TFrom>(TFrom from)
@@ -85,15 +85,12 @@ private TTo MapObject(Type type, object from, TTo to)
         {
             if (to == null)
             {
-                to = (TTo)(_mapper?.Map(from, type, typeof(TTo)) ?? Mapper.Map(from, type, typeof(TTo)));
+                to = (TTo)_mapper.Map(from, type, typeof(TTo));
                 _sourceSet.Add(to);
             }
             else
             {
-                if (_mapper == null)
-                    Mapper.Map(from, to);
-                else
-                    _mapper.Map(from, to);
+                _mapper.Map(from, to);
             }
             return to;
         }
@@ -105,9 +102,7 @@ private Expression<Func<TTo, bool>> GetEquivalenceExpression<TFrom>(TFrom from)
 
         private Expression<Func<TTo, bool>> GetEquivalenceExpression(Type type, object from)
         {
-            return _mapper == null
-                ? Mapper.Map(from, type, typeof(Expression<Func<TTo, bool>>)) as Expression<Func<TTo, bool>>
-                : _mapper.Map(from, type, typeof(Expression<Func<TTo, bool>>)) as Expression<Func<TTo, bool>>;
+            return _mapper.Map(from, type, typeof(Expression<Func<TTo, bool>>)) as Expression<Func<TTo, bool>>;
         }
     }
 }
diff --git a/version.props b/version.props
@@ -1,5 +1,5 @@
 <Project>
   <PropertyGroup>
-    <VersionPrefix>0.3.0</VersionPrefix>
+    <VersionPrefix>1.0.0</VersionPrefix>
   </PropertyGroup>
 </Project>

Original file line number	Diff line number	Diff line change
`@@ -6,15 +6,16 @@ namespace AutoMapper.Collection.EntityFrameworkCore.Tests`
`6`	`6`	`{`
`7`	`7`	`public class EntityFramworkCoreUsingCtorTests : EntityFramworkCoreTestsBase`
`8`	`8`	`{`
	`9`	`+ private readonly Mapper _mapper;`
	`10`	`+`
`9`	`11`	`public EntityFramworkCoreUsingCtorTests()`
`10`	`12`	`{`
`11`		`- Mapper.Reset();`
`12`		`- Mapper.Initialize(x =>`
	`13`	`+ _mapper = new Mapper(new MapperConfiguration(x =>`
`13`	`14`	`{`
`14`	`15`	`x.AddCollectionMappers();`
`15`	`16`	`x.CreateMap<ThingDto, Thing>().ReverseMap();`
`16`	`17`	`x.UseEntityFrameworkCoreModel<DB>();`
`17`		`- });`
	`18`	`+ }));`
`18`	`19`	`}`
`19`	`20`
`20`	`21`	`protected override DBContextBase GetDbContext()`
`@@ -24,7 +25,7 @@ protected override DBContextBase GetDbContext()`
`24`	`25`
`25`	`26`	`protected override IMapper GetMapper()`
`26`	`27`	`{`
`27`		`- return Mapper.Instance;`
	`28`	`+ return _mapper;`
`28`	`29`	`}`
`29`	`30`
`30`	`31`	`public class DB : DBContextBase`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@ namespace AutoMapper.Collection.EntityFrameworkCore.Tests`
`9`	`9`	`public class EntityFramworkCoreUsingDITests : EntityFramworkCoreTestsBase, IDisposable`
`10`	`10`	`{`
`11`	`11`	`private readonly ServiceProvider _serviceProvider;`
	`12`	`+ private readonly Mapper _mapper;`
`12`	`13`	`private readonly IServiceScope _serviceScope;`
`13`	`14`
`14`	`15`	`public EntityFramworkCoreUsingDITests()`
`@@ -21,13 +22,13 @@ public EntityFramworkCoreUsingDITests()`
`21`	`22`
`22`	`23`	`_serviceProvider = services.BuildServiceProvider();`
`23`	`24`
`24`		`- Mapper.Reset();`
`25`		`- Mapper.Initialize(x =>`
	`25`	`+ _mapper = new Mapper(new MapperConfiguration(x =>`
`26`	`26`	`{`
`27`	`27`	`x.ConstructServicesUsing(type => ActivatorUtilities.GetServiceOrCreateInstance(_serviceProvider, type));`
`28`	`28`	`x.AddCollectionMappers();`
`29`	`29`	`x.UseEntityFrameworkCoreModel<DB>(_serviceProvider);`
`30`		`- });`
	`30`	`+ x.CreateMap<ThingDto, Thing>().ReverseMap();`
	`31`	`+ }));`
`31`	`32`
`32`	`33`	`_serviceScope = _serviceProvider.GetRequiredService<IServiceScopeFactory>().CreateScope();`
`33`	`34`	`}`
`@@ -45,7 +46,7 @@ protected override DBContextBase GetDbContext()`
`45`	`46`
`46`	`47`	`protected override IMapper GetMapper()`
`47`	`48`	`{`
`48`		`- return Mapper.Instance;`
	`49`	`+ return _mapper;`
`49`	`50`	`}`
`50`	`51`
`51`	`52`	`public class DB : DBContextBase`
Original file line number	Diff line number	Diff line change
`@@ -9,16 +9,18 @@ namespace AutoMapper.EntityFrameworkCore`
`9`	`9`	`public static class Extensions`
`10`	`10`	`{`
`11`	`11`	`/// <summary>`
	`12`	`+ /// Obsolete: Use Persist(IMapper) instead.`
`12`	`13`	/// Create a Persistence object for the <see cref="T:System.Data.Entity.DbSet`1"/> to have data persisted or removed from
`13`	`14`	`/// Uses static API's Mapper for finding TypeMap between classes`
`14`	`15`	`/// </summary>`
`15`	`16`	`/// <typeparam name="TSource">Source table type to be updated</typeparam>`
`16`	`17`	`/// <param name="source">DbSet to be updated</param>`
`17`	`18`	`/// <returns>Persistence object to Update or Remove data</returns>`
	`19`	`+ [Obsolete("Use Persist(IMapper) instead.", true)]`
`18`	`20`	`public static IPersistence<TSource> Persist<TSource>(this DbSet<TSource> source)`
`19`	`21`	`where TSource : class`
`20`	`22`	`{`
`21`		`- return new Persistence<TSource>(source, Mapper.Instance);`
	`23`	`+ throw new NotSupportedException();`
`22`	`24`	`}`
`23`	`25`
`24`	`26`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public class GenerateEntityFrameworkCorePrimaryKeyPropertyMaps<TDatabaseContext>`
`14`	`14`
`15`	`15`	`public GenerateEntityFrameworkCorePrimaryKeyPropertyMaps()`
`16`	`16`	`{`
`17`		`- throw new InvalidOperationException("Use UseEntityFrameworkCoreModel instead of using SetGeneratePropertyMaps.");`
	`17`	`+ throw new InvalidOperationException($"Use {nameof(MapperConfigurationExpressionExtensions.UseEntityFrameworkCoreModel)} instead of using SetGeneratePropertyMaps.");`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`public GenerateEntityFrameworkCorePrimaryKeyPropertyMaps(IModel model) => _model = model;`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public class Persistence<TTo> : IPersistence<TTo>`
`16`	`16`	`public Persistence(DbSet<TTo> sourceSet, IMapper mapper)`
`17`	`17`	`{`
`18`	`18`	`_sourceSet = sourceSet;`
`19`		`- _mapper = mapper;`
	`19`	`+ _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`public TTo InsertOrUpdate<TFrom>(TFrom from)`
`@@ -85,15 +85,12 @@ private TTo MapObject(Type type, object from, TTo to)`
`85`	`85`	`{`
`86`	`86`	`if (to == null)`
`87`	`87`	`{`
`88`		`- to = (TTo)(_mapper?.Map(from, type, typeof(TTo)) ?? Mapper.Map(from, type, typeof(TTo)));`
	`88`	`+ to = (TTo)_mapper.Map(from, type, typeof(TTo));`
`89`	`89`	`_sourceSet.Add(to);`
`90`	`90`	`}`
`91`	`91`	`else`
`92`	`92`	`{`
`93`		`- if (_mapper == null)`
`94`		`- Mapper.Map(from, to);`
`95`		`- else`
`96`		`- _mapper.Map(from, to);`
	`93`	`+ _mapper.Map(from, to);`
`97`	`94`	`}`
`98`	`95`	`return to;`
`99`	`96`	`}`
`@@ -105,9 +102,7 @@ private Expression<Func<TTo, bool>> GetEquivalenceExpression<TFrom>(TFrom from)`
`105`	`102`
`106`	`103`	`private Expression<Func<TTo, bool>> GetEquivalenceExpression(Type type, object from)`
`107`	`104`	`{`
`108`		`- return _mapper == null`
`109`		`- ? Mapper.Map(from, type, typeof(Expression<Func<TTo, bool>>)) as Expression<Func<TTo, bool>>`
`110`		`- : _mapper.Map(from, type, typeof(Expression<Func<TTo, bool>>)) as Expression<Func<TTo, bool>>;`
	`105`	`+ return _mapper.Map(from, type, typeof(Expression<Func<TTo, bool>>)) as Expression<Func<TTo, bool>>;`
`111`	`106`	`}`
`112`	`107`	`}`
`113`	`108`	`}`