Merge pull request #105 from Tasteful/valuetype

Support for value types

Author: TylerCarlson1

src/AutoMapper.Collection.Tests/ValueTypeTests.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using AutoMapper.EquivalencyExpression;
+using Xunit;
+
+namespace AutoMapper.Collection
+{
+    public class ValueTypeTests
+    {
+        [Fact]
+        public void MapValueTypes()
+        {
+            Mapper.Reset();
+            Mapper.Initialize(c =>
+            {
+                c.AddCollectionMappers();
+
+                c.CreateMap<Country, CountryDto>()
+                    .ForMember(x => x.Nationalities, m => m.MapFrom(x => x.Persons))
+                    .ReverseMap();
+
+                c.CreateMap<int, PersonNationality>()
+                    .EqualityComparison((src, dest) => dest.NationalityCountryId == src);
+            });
+
+            var persons = new[]
+            {
+                new PersonNationality{PersonId = 1, NationalityCountryId = 101},
+                new PersonNationality{PersonId = 2, NationalityCountryId = 102},
+                new PersonNationality{PersonId = 3, NationalityCountryId = 103},
+                new PersonNationality{PersonId = 4, NationalityCountryId = 104},
+            };
+
+            var country = new Country { Persons = new List<PersonNationality>(persons) };
+            var countryDto = new CountryDto { Nationalities = new List<int> { 104, 103, 105 } };
+
+            Mapper.Map(countryDto, country);
+
+            Assert.NotStrictEqual(new[] { persons[3], persons[2], country.Persons.Last() }, country.Persons);
+            Assert.Equal(0, country.Persons.Last().PersonId);
+        }
+
+        public class PersonNationality
+        {
+            public int PersonId { get; set; }
+            public int NationalityCountryId { get; set; }
+        }
+
+        public class Country
+        {
+            public IList<PersonNationality> Persons { get; set; }
+        }
+
+        public class CountryDto
+        {
+            public IList<int> Nationalities { get; set; }
+        }
+    }
+}

src/AutoMapper.Collection/EquivalencyExpression/EquivalentExpression.cs

@@ -25,16 +25,14 @@ public bool IsEquivalent(object source, object destination)
         }
     }
 
-    internal class EquivalentExpression<TSource,TDestination> : IEquivalentComparer<TSource, TDestination>
-        where TSource : class 
-        where TDestination : class
+    internal class EquivalentExpression<TSource, TDestination> : IEquivalentComparer<TSource, TDestination>
     {
         private readonly Expression<Func<TSource, TDestination, bool>> _equivalentExpression;
         private readonly Func<TSource, TDestination, bool> _equivalentFunc;
         private readonly Func<TSource, int> _sourceHashCodeFunc;
         private readonly Func<TDestination, int> _destinationHashCodeFunc;
 
-        public EquivalentExpression(Expression<Func<TSource,TDestination,bool>> equivalentExpression)
+        public EquivalentExpression(Expression<Func<TSource, TDestination, bool>> equivalentExpression)
         {
             _equivalentExpression = equivalentExpression;
             _equivalentFunc = _equivalentExpression.Compile();
@@ -43,22 +41,25 @@ public EquivalentExpression(Expression<Func<TSource,TDestination,bool>> equivale
             var destinationParameter = equivalentExpression.Parameters[1];
 
             var members = HashableExpressionsVisitor.Expand(sourceParameter, destinationParameter, equivalentExpression);
-            
+
             _sourceHashCodeFunc = members.Item1.GetHashCodeExpression<TSource>(sourceParameter).Compile();
             _destinationHashCodeFunc = members.Item2.GetHashCodeExpression<TDestination>(destinationParameter).Compile();
         }
 
         public bool IsEquivalent(object source, object destination)
         {
-            var src = source as TSource;
-            var dest = destination as TDestination;
 
-            if (src == null && dest == null)
+            if (source == null && destination == null)
             {
                 return true;
             }
 
-            if (src == null || dest == null)
+            if (source == null || destination == null)
+            {
+                return false;
+            }
+
+            if (!(source is TSource src) || !(destination is TDestination dest))
             {
                 return false;
             }
@@ -77,10 +78,10 @@ public Expression<Func<TDestination, bool>> ToSingleSourceExpression(TSource sou
 
         public int GetHashCode(object obj)
         {
-            if (obj is TSource)
-                return _sourceHashCodeFunc(obj as TSource);
-            if (obj is TDestination)
-                return _destinationHashCodeFunc(obj as TDestination);
+            if (obj is TSource src)
+                return _sourceHashCodeFunc(src);
+            if (obj is TDestination dest)
+                return _destinationHashCodeFunc(dest);
             return default(int);
         }
     }

src/AutoMapper.Collection/EquivalencyExpression/EquivalentExpressions.cs

@@ -104,8 +104,6 @@ internal static IEquivalentComparer GetEquivalentExpression(IConfigurationProvid
         /// <param name="EquivalentExpression">Equivalent Expression between <typeparamref name="TSource"/> and <typeparamref name="TDestination"/></param>
         /// <returns></returns>
         public static IMappingExpression<TSource, TDestination> EqualityComparison<TSource, TDestination>(this IMappingExpression<TSource, TDestination> mappingExpression, Expression<Func<TSource, TDestination, bool>> EquivalentExpression)
-            where TSource : class
-            where TDestination : class
         {
             var typePair = new TypePair(typeof(TSource), typeof(TDestination));
 

src/AutoMapper.Collection/Mappers/EquivalentExpressionAddRemoveCollectionMapper.cs

@@ -16,7 +16,7 @@ public class EquivalentExpressionAddRemoveCollectionMapper : IConfigurationObjec
 
         public static TDestination Map<TSource, TSourceItem, TDestination, TDestinationItem>(TSource source, TDestination destination, ResolutionContext context, IEquivalentComparer equivalentComparer)
             where TSource : IEnumerable<TSourceItem>
-            where TDestination : class, ICollection<TDestinationItem>
+            where TDestination : ICollection<TDestinationItem>
         {
             if (source == null || destination == null)
             {