Releases/1.5

AgileMapper.PerformanceTester.Net45/AgileMapper.PerformanceTester.Net45.csproj

@@ -37,8 +37,8 @@
     <Reference Include="AgileObjects.NetStandardPolyfills, Version=1.4.0.0, Culture=neutral, PublicKeyToken=06131ac1c008ad4e, processorArchitecture=MSIL">
       <HintPath>..\packages\AgileObjects.NetStandardPolyfills.1.4.0\lib\net40\AgileObjects.NetStandardPolyfills.dll</HintPath>
     </Reference>
-    <Reference Include="AgileObjects.ReadableExpressions, Version=2.1.1.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
-      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.1.1\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
+    <Reference Include="AgileObjects.ReadableExpressions, Version=2.3.2.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
+      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.3.2\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
     </Reference>
     <Reference Include="AutoMapper, Version=7.0.1.0, Culture=neutral, PublicKeyToken=be96cd2c38ef1005, processorArchitecture=MSIL">
       <HintPath>..\packages\AutoMapper.7.0.1\lib\net45\AutoMapper.dll</HintPath>

AgileMapper.PerformanceTester.Net45/packages.config

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="AgileObjects.NetStandardPolyfills" version="1.4.0" targetFramework="net452" />
-  <package id="AgileObjects.ReadableExpressions" version="2.1.1" targetFramework="net452" />
+  <package id="AgileObjects.ReadableExpressions" version="2.3.2" targetFramework="net452" />
   <package id="AutoMapper" version="7.0.1" targetFramework="net452" />
   <package id="Expressmapper" version="1.9.1" targetFramework="net452" />
   <package id="Mapster" version="3.3.1" targetFramework="net452" />

AgileMapper.UnitTests.Common/ShouldExtensions.cs

@@ -52,7 +52,9 @@ public static void ShouldBe<TActual, TExpected>(this TActual value, TExpected ex
         {
             if (!AreEqual(expectedValue, value))
             {
-                Asplode(expectedValue.ToString(), value?.ToString());
+                Asplode(
+                    expectedValue?.ToString() ?? (typeof(TExpected).CanBeNull() ? "null" : "default"),
+                    value?.ToString() ?? (typeof(TActual).CanBeNull() ? "null" : "default"));
             }
         }
 
@@ -405,14 +407,18 @@ public static IDictionary<TKey, TValue> ShouldContainKeyAndValue<TKey, TValue>(
             return dictionary;
         }
 
-        public static void ShouldBeOfType<TExpected>(this object actual)
+        public static TExpected ShouldBeOfType<TExpected>(this object actual)
         {
-            if (!(actual is TExpected))
+            if (actual is TExpected expected)
             {
-                Asplode(
-                    "An object of type " + typeof(TExpected).GetFriendlyName(),
-                    actual.GetType().GetFriendlyName());
+                return expected;
             }
+
+            Asplode(
+                "An object of type " + typeof(TExpected).GetFriendlyName(),
+                actual.GetType().GetFriendlyName());
+
+            return default(TExpected);
         }
 
         public static void ShouldContain<T>(this IList<T> actual, T expected)

AgileMapper.UnitTests.Net35/packages.config

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="AgileObjects.NetStandardPolyfills" version="1.4.0" targetFramework="net35" />
-  <package id="AgileObjects.ReadableExpressions" version="2.1.1" targetFramework="net35" />
+  <package id="AgileObjects.ReadableExpressions" version="2.3.2" targetFramework="net35" />
   <package id="DynamicLanguageRuntime" version="1.1.2" targetFramework="net35" />
   <package id="NUnit" version="3.6.1" targetFramework="net35" />
   <package id="NUnit3TestAdapter" version="3.10.0" targetFramework="net35" />

AgileMapper.UnitTests.NonParallel/AgileMapper.UnitTests.NonParallel.csproj

@@ -42,8 +42,8 @@
     <Reference Include="AgileObjects.NetStandardPolyfills, Version=1.4.0.0, Culture=neutral, PublicKeyToken=06131ac1c008ad4e, processorArchitecture=MSIL">
       <HintPath>..\packages\AgileObjects.NetStandardPolyfills.1.4.0\lib\net40\AgileObjects.NetStandardPolyfills.dll</HintPath>
     </Reference>
-    <Reference Include="AgileObjects.ReadableExpressions, Version=2.1.1.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
-      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.1.1\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
+    <Reference Include="AgileObjects.ReadableExpressions, Version=2.3.2.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
+      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.3.2\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />

AgileMapper.UnitTests.NonParallel/packages.config

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="AgileObjects.NetStandardPolyfills" version="1.4.0" targetFramework="net461" />
-  <package id="AgileObjects.ReadableExpressions" version="2.1.1" targetFramework="net461" />
+  <package id="AgileObjects.ReadableExpressions" version="2.3.2" targetFramework="net461" />
   <package id="xunit" version="2.4.1" targetFramework="net461" />
   <package id="xunit.abstractions" version="2.0.3" targetFramework="net461" />
   <package id="xunit.analyzers" version="0.10.0" targetFramework="net461" />

AgileMapper.UnitTests.Orms.EfCore2/WhenCreatingProjections.cs

@@ -1,5 +1,7 @@
 namespace AgileObjects.AgileMapper.UnitTests.Orms.EfCore2
 {
+    using System.Collections.Generic;
+    using System.Linq;
     using System.Threading.Tasks;
     using Common;
     using Infrastructure;
@@ -49,5 +51,22 @@ public Task ShouldReuseACachedProjectionMapper()
                 mapper.RootMapperCountShouldBeOne();
             });
         }
+
+        [Fact]
+        public Task ShouldMapAQueryableAsAnEnumerable()
+        {
+            return RunTest(async (context, mapper) =>
+            {
+                await context.BoolItems.AddRangeAsync(new PublicBool { Value = true }, new PublicBool { Value = false });
+                await context.SaveChangesAsync();
+
+                var result = mapper
+                    .Map(context.BoolItems.Where(bi => bi.Value))
+                    .ToANew<List<PublicBoolDto>>();
+
+                result.ShouldNotBeNull();
+                result.ShouldHaveSingleItem().Value.ShouldBeTrue();
+            });
+        }
     }
 }

AgileMapper.UnitTests/AgileMapper.UnitTests.csproj

@@ -44,8 +44,8 @@
     <Reference Include="AgileObjects.NetStandardPolyfills, Version=1.4.0.0, Culture=neutral, PublicKeyToken=06131ac1c008ad4e, processorArchitecture=MSIL">
       <HintPath>..\packages\AgileObjects.NetStandardPolyfills.1.4.0\lib\net40\AgileObjects.NetStandardPolyfills.dll</HintPath>
     </Reference>
-    <Reference Include="AgileObjects.ReadableExpressions, Version=2.1.1.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
-      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.1.1\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
+    <Reference Include="AgileObjects.ReadableExpressions, Version=2.3.2.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
+      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.3.2\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
     </Reference>
     <Reference Include="Microsoft.Extensions.Primitives, Version=2.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
       <HintPath>..\packages\Microsoft.Extensions.Primitives.2.0.0\lib\netstandard2.0\Microsoft.Extensions.Primitives.dll</HintPath>
@@ -103,6 +103,9 @@
     <Compile Include="Configuration\Inline\WhenConfiguringTypeIdentifiersInline.cs" />
     <Compile Include="Configuration\Inline\WhenIgnoringMembersInline.cs" />
     <Compile Include="Configuration\Inline\WhenIgnoringMembersInlineIncorrectly.cs" />
+    <Compile Include="Configuration\Inline\WhenIgnoringSourceMemberInlineIncorrectly.cs" />
+    <Compile Include="Configuration\Inline\WhenIgnoringSourceMembersByValueFilterInline.cs" />
+    <Compile Include="Configuration\Inline\WhenIgnoringSourceMembersInline.cs" />
     <Compile Include="Configuration\Inline\WhenMappingToNullInline.cs" />
     <Compile Include="Configuration\Inline\WhenValidatingMappingsInline.cs" />
     <Compile Include="Configuration\Inline\WhenViewingMappingPlans.cs" />
@@ -111,6 +114,12 @@
     <Compile Include="Configuration\WhenConfiguringEntityMapping.cs" />
     <Compile Include="Configuration\WhenConfiguringReverseDataSources.cs" />
     <Compile Include="Configuration\WhenConfiguringReverseDataSourcesIncorrectly.cs" />
+    <Compile Include="Configuration\WhenIgnoringSourceMembers.cs" />
+    <Compile Include="Configuration\WhenIgnoringSourceMembersByFilter.cs" />
+    <Compile Include="Configuration\WhenIgnoringSourceMembersByGlobalFilter.cs" />
+    <Compile Include="Configuration\WhenIgnoringSourceMembersByValueFilter.cs" />
+    <Compile Include="Configuration\WhenIgnoringSourceMembersByValueFilterIncorrectly.cs" />
+    <Compile Include="Configuration\WhenIgnoringSourceMembersIncorrectly.cs" />
     <Compile Include="Configuration\WhenResolvingServices.cs" />
     <Compile Include="Configuration\WhenViewingMappingPlans.cs" />
     <Compile Include="Dictionaries\WhenMappingFromDictionariesOnToComplexTypes.cs" />
@@ -144,6 +153,7 @@
     <Compile Include="Extensions\WhenUnflatteningFromQueryStringsViaExtensionMethods.cs" />
     <Compile Include="Extensions\WhenUnflatteningViaExtensionMethods.cs" />
     <Compile Include="MapperCloning\WhenCloningConstructorDataSources.cs" />
+    <Compile Include="MapperCloning\WhenCloningDictionarySettings.cs" />
     <Compile Include="MapperCloning\WhenCloningMemberIgnores.cs" />
     <Compile Include="Configuration\WhenConfiguringObjectTracking.cs" />
     <Compile Include="Configuration\WhenConfiguringObjectTrackingIncorrectly.cs" />
@@ -219,7 +229,9 @@
     <Compile Include="TestClasses\PaymentTypeUk.cs" />
     <Compile Include="TestClasses\PaymentTypeUs.cs" />
     <Compile Include="TestClasses\PublicCtorStruct.cs" />
+    <Compile Include="TestClasses\PublicEnumerable.cs" />
     <Compile Include="TestClasses\PublicImplementation.cs" />
+    <Compile Include="TestClasses\PublicIndex.cs" />
     <Compile Include="TestClasses\PublicSealed.cs" />
     <Compile Include="TestClasses\PublicPropertyStruct.cs" />
     <Compile Include="TestClasses\PublicTwoFields.cs" />
@@ -301,6 +313,7 @@
     <Compile Include="WhenMappingToNewEnumerableMembers.cs" />
     <Compile Include="WhenMappingToNewEnumerables.cs" />
     <Compile Include="Members\WhenMatchingSourceToTargetMembers.cs" />
+    <Compile Include="WhenWorkingWithQueryStrings.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="app.config">

AgileMapper.UnitTests/Configuration/Inline/WhenConfiguringDataSourcesInline.cs

@@ -7,7 +7,9 @@
     using Common;
     using TestClasses;
 #if !NET35
+    using NetStandardPolyfills;
     using Xunit;
+    using static System.Linq.Expressions.Expression;
 #else
     using Fact = NUnit.Framework.TestAttribute;
 
@@ -317,6 +319,194 @@ public void ShouldApplyDifferingTargetTypeInlineDataSourceMemberConfig()
             }
         }
 
+        [Fact]
+        public void ShouldApplyAnInlineNullCheckedArrayIndexDataSource()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var source = new PublicProperty<PublicField<Address>[]>
+                {
+                    Value = new[]
+                    {
+                        new PublicField<Address> { Value = new Address { Line1 = "1.1" } },
+                        new PublicField<Address> { Value = new Address { Line1 = "1.2" } }
+                    }
+                };
+
+                var result = mapper.Map(source).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(s => s.Value[1].Value, t => t.Value));
+
+                result.Value.ShouldNotBeNull();
+                result.Value.Line1.ShouldBe("1.2");
+
+                var nullArraySource = new PublicProperty<PublicField<Address>[]> { Value = null };
+
+                var nullArrayResult = mapper.Map(nullArraySource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(s => s.Value[1].Value, t => t.Value));
+
+                nullArrayResult.Value.ShouldBeNull();
+
+                var tooSmallArraySource = new PublicProperty<PublicField<Address>[]>
+                {
+                    Value = new[]
+                    {
+                        new PublicField<Address> { Value = new Address { Line1 = "1.1" } }
+                    }
+                };
+
+                var tooSmallArrayResult = mapper.Map(tooSmallArraySource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(s => s.Value[1].Value, t => t.Value));
+
+                tooSmallArrayResult.Value.ShouldBeNull();
+
+                var nullArrayObjectSource = new PublicProperty<PublicField<Address>[]>
+                {
+                    Value = new[]
+                    {
+                        new PublicField<Address> { Value = new Address { Line1 = "1.1" } },
+                        new PublicField<Address> { Value = null }
+                    }
+                };
+
+                var nullArrayObjectResult = mapper.Map(nullArrayObjectSource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(s => s.Value[1].Value, t => t.Value));
+
+                nullArrayObjectResult.Value.ShouldBeNull();
+            }
+        }
+
+#if !NET35
+        // System.Linq.Expressions.Expression.MakeIndex() is missing in .NET 3.5, so not much danger of this configuration:
+        [Fact]
+        public void ShouldApplyAnInlineNullCheckedIntKeyedIndexDataSource()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var source = new PublicProperty<PublicIndex<int, PublicField<Address>>>
+                {
+                    Value = new PublicIndex<int, PublicField<Address>>
+                    {
+                        [0] = new PublicField<Address> { Value = new Address { Line1 = "1.1" } },
+                        [1] = new PublicField<Address> { Value = new Address { Line1 = "1.2" } }
+                    }
+                };
+
+                var sourceParameter = Parameter(source.GetType(), "s");
+                var sourceValueProperty = Property(sourceParameter, "Value");
+                var sourceValueIndexer = sourceValueProperty.Type.GetPublicInstanceProperty("Item");
+                var sourceValueIndex = MakeIndex(sourceValueProperty, sourceValueIndexer, new[] { Constant(1) });
+
+                var sourceLambda = Lambda<Func<PublicProperty<PublicIndex<int, PublicField<Address>>>, Address>>(
+                    Field(sourceValueIndex, "Value"),
+                    sourceParameter);
+
+                var result = mapper.Map(source).ToANew<PublicField<Address>>(cfg => cfg
+                    .Map(sourceLambda, t => t.Value));
+
+                result.Value.ShouldNotBeNull();
+                result.Value.Line1.ShouldBe("1.2");
+
+                var nullIndexerSource = new PublicProperty<PublicIndex<int, PublicField<Address>>> { Value = null };
+
+                var nullIndexerResult = mapper.Map(nullIndexerSource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(sourceLambda, t => t.Value));
+
+                nullIndexerResult.Value.ShouldBeNull();
+
+                var noEntrySource = new PublicProperty<PublicIndex<int, PublicField<Address>>>
+                {
+                    Value = new PublicIndex<int, PublicField<Address>>
+                    {
+                        [0] = new PublicField<Address> { Value = new Address { Line1 = "1.1" } }
+                    }
+                };
+
+                var noEntryResult = mapper.Map(noEntrySource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(sourceLambda, t => t.Value));
+
+                noEntryResult.Value.ShouldBeNull();
+
+                var nullIndexedObjectSource = new PublicProperty<PublicIndex<int, PublicField<Address>>>
+                {
+                    Value = new PublicIndex<int, PublicField<Address>>
+                    {
+                        [0] = new PublicField<Address> { Value = new Address { Line1 = "1.1" } },
+                        [1] = new PublicField<Address> { Value = null }
+                    }
+                };
+
+                var nullIndexedObjectResult = mapper.Map(nullIndexedObjectSource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(sourceLambda, t => t.Value));
+
+                nullIndexedObjectResult.Value.ShouldBeNull();
+            }
+        }
+
+        [Fact]
+        public void ShouldApplyAnInlineNullCheckedStringKeyedIndexDataSource()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var source = new PublicProperty<PublicIndex<string, PublicField<Address>>>
+                {
+                    Value = new PublicIndex<string, PublicField<Address>>
+                    {
+                        ["A"] = new PublicField<Address> { Value = new Address { Line1 = "1.1" } },
+                        ["B"] = new PublicField<Address> { Value = new Address { Line1 = "1.2" } }
+                    }
+                };
+
+                var sourceParameter = Parameter(source.GetType(), "s");
+                var sourceValueProperty = Property(sourceParameter, "Value");
+                var sourceValueIndexer = sourceValueProperty.Type.GetPublicInstanceProperty("Item");
+                var sourceValueIndex = MakeIndex(sourceValueProperty, sourceValueIndexer, new[] { Constant("B") });
+
+                var sourceLambda = Lambda<Func<PublicProperty<PublicIndex<string, PublicField<Address>>>, Address>>(
+                    Field(sourceValueIndex, "Value"),
+                    sourceParameter);
+
+                var result = mapper.Map(source).ToANew<PublicField<Address>>(cfg => cfg
+                    .Map(sourceLambda, t => t.Value));
+
+                result.Value.ShouldNotBeNull();
+                result.Value.Line1.ShouldBe("1.2");
+
+                var nullIndexerSource = new PublicProperty<PublicIndex<string, PublicField<Address>>> { Value = null };
+
+                var nullIndexerResult = mapper.Map(nullIndexerSource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(sourceLambda, t => t.Value));
+
+                nullIndexerResult.Value.ShouldBeNull();
+
+                var noEntrySource = new PublicProperty<PublicIndex<string, PublicField<Address>>>
+                {
+                    Value = new PublicIndex<string, PublicField<Address>>
+                    {
+                        ["A"] = new PublicField<Address> { Value = new Address { Line1 = "1.1" } }
+                    }
+                };
+
+                var noEntryResult = mapper.Map(noEntrySource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(sourceLambda, t => t.Value));
+
+                noEntryResult.Value.ShouldBeNull();
+
+                var nullIndexedObjectSource = new PublicProperty<PublicIndex<string, PublicField<Address>>>
+                {
+                    Value = new PublicIndex<string, PublicField<Address>>
+                    {
+                        ["A"] = new PublicField<Address> { Value = new Address { Line1 = "1.1" } },
+                        ["B"] = new PublicField<Address> { Value = null }
+                    }
+                };
+
+                var nullIndexedObjectResult = mapper.Map(nullIndexedObjectSource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(sourceLambda, t => t.Value));
+
+                nullIndexedObjectResult.Value.ShouldBeNull();
+            }
+        }
+#endif
         [Fact]
         public void ShouldHandleANullSourceMember()
         {