fix MapsterMapper#227: EmptyCollectionIfNull, CreateNewIfNull Destina…

…tionTransform

src/Mapster.Tests/WhenPerformingDestinationTransforms.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Shouldly;
@@ -52,6 +53,34 @@ public void Adapter_Destination_Transform_Is_Applied_To_Class()
  destination.Name.ShouldBe("TestMethod");
  }
 
+ [TestMethod]
+ public void Adapter_Destination_Transform_Collection()
+ {
+ var config = new TypeAdapterConfig();
+ config.Default.AddDestinationTransform((IReadOnlyList<ChildDto> list) => list ?? new List<ChildDto>());
+
+ var source = new CollectionPoco();
+ var destination = source.Adapt<CollectionDto>(config);
+
+ destination.Children.ShouldNotBeNull();
+ }
+
+ [TestMethod]
+ public void Adapter_Destination_Transform_Collection_Generic()
+ {
+ var config = new TypeAdapterConfig();
+ config.Default.AddDestinationTransform(DestinationTransform.EmptyCollectionIfNull);
+
+ var source = new CollectionPoco();
+ var destination = source.Adapt<CollectionDto>(config);
+
+ destination.Children.Count.ShouldBe(0);
+ destination.Array.Length.ShouldBe(0);
+ destination.MultiDimentionalArray.Length.ShouldBe(0);
+ destination.ChildDict.Count.ShouldBe(0);
+ destination.Set.Count.ShouldBe(0);
+ }
+
  #region TestClasses
 
  public class SimplePoco
@@ -84,6 +113,10 @@ public class CollectionPoco
  public string Name { get; set; }
 
  public List<ChildPoco> Children { get; set; }
+ public int[] Array { get; set; }
+ public double[,] MultiDimentionalArray { get; set; }
+ public Dictionary<string, ChildPoco> ChildDict { get; set; }
+ public HashSet<string> Set { get; set; }
  }
 
  public class CollectionDto
@@ -92,6 +125,10 @@ public class CollectionDto
  public string Name { get; set; }
 
  public IReadOnlyList<ChildDto> Children { get; internal set; }
+ public int[] Array { get; set; }
+ public double[,] MultiDimentionalArray { get; set; }
+ public IReadOnlyDictionary<string, ChildDto> ChildDict { get; set; }
+ public HashSet<string> Set { get; set; }
  }
 
  #endregion

src/Mapster/Adapters/BaseAdapter.cs

@@ -409,11 +409,9 @@ internal Expression CreateAdaptExpression(Expression source, Type destinationTyp
  var exp = CreateAdaptExpressionCore(source, destinationType, arg, mapping, destination);
 
  //transform(adapt(source));
- if (arg.Settings.DestinationTransforms.Transforms.ContainsKey(exp.Type))
- {
- var transform = arg.Settings.DestinationTransforms.Transforms[exp.Type];
- exp = transform.Apply(arg.MapType, exp);
- }
+ var transform = arg.Settings.DestinationTransforms.FirstOrDefault(it => it.Condition(exp.Type));
+ if (transform != null)
+ exp = transform.TransformFunc(exp.Type).Apply(arg.MapType, exp);
  return exp.To(destinationType);
  }
  }

src/Mapster/Mapster.csproj

@@ -19,7 +19,7 @@
  <NetStandardImplicitPackageVersion Condition=" '$(TargetFramework)' == 'netstandard1.3' ">1.6.1</NetStandardImplicitPackageVersion>
  <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
  <RootNamespace>Mapster</RootNamespace>
- <Version>5.1.0</Version>
+ <Version>5.2.0</Version>
  <LangVersion>8.0</LangVersion>
  <Nullable>enable</Nullable>
  </PropertyGroup>

src/Mapster/Settings/DestinationTransform.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Mapster
+{
+ public class DestinationTransform
+ {
+ public static readonly DestinationTransform EmptyCollectionIfNull = new DestinationTransform
+ {
+ Condition = type => type.IsArray
+ || type.IsListCompatible()
+ || type.GetDictionaryType() != null,
+ TransformFunc = type =>
+ {
+ Expression newExp;
+ if (type.IsArray)
+ {
+ var rank = type.GetArrayRank();
+ var elemType = type.GetElementType()!;
+ newExp = Expression.NewArrayBounds(elemType, Enumerable.Repeat(Expression.Constant(0), rank));
+ }
+ else if (type.GetTypeInfo().IsInterface)
+ {
+ if (type.GetDictionaryType() != null)
+ {
+ var dict = type.GetDictionaryType()!;
+ var dictArgs = dict.GetGenericArguments();
+ var dictType = typeof(Dictionary<,>).MakeGenericType(dictArgs);
+ newExp = Expression.New(dictType);
+ }
+ else
+ {
+ var elemType = type.ExtractCollectionType();
+ var listType = typeof(List<>).MakeGenericType(elemType);
+ newExp = Expression.New(listType);
+ }
+ }
+ else
+ newExp = Expression.New(type);
+
+ var p = Expression.Parameter(type);
+ return Expression.Lambda(Expression.Coalesce(p, newExp), p);
+ }
+ };
+
+ public static readonly DestinationTransform CreateNewIfNull = new DestinationTransform
+ {
+ Condition = type =>
+ {
+ if (!type.CanBeNull())
+ return false;
+ if (type.GetTypeInfo().IsInterface || type.GetTypeInfo().IsAbstract)
+ return false;
+ var ci = type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).SingleOrDefault(c => c.GetParameters().Length == 0);
+ return ci != null;
+ },
+ TransformFunc = type =>
+ {
+ var p = Expression.Parameter(type);
+ return Expression.Lambda(
+ Expression.Coalesce(p, Expression.New(type)));
+ }
+ };
+
+ public Func<Type, bool> Condition { get; set; }
+ public Func<Type, LambdaExpression> TransformFunc { get; set; }
+
+ public DestinationTransform WithCondition(Func<Type, bool> condition)
+ {
+ return new DestinationTransform
+ {
+ Condition = condition,
+ TransformFunc = this.TransformFunc
+ };
+ }
+ }
+}

src/Mapster/TypeAdapterSetter.cs

@@ -29,7 +29,19 @@ public static TSetter AddDestinationTransform<TSetter, TDestinationMember>(this
  {
  setter.CheckCompiled();
 
- setter.Settings.DestinationTransforms.Upsert(transform);
+ setter.Settings.DestinationTransforms.Add(new DestinationTransform
+ {
+ Condition = t => t == typeof(TDestinationMember),
+ TransformFunc = _ => transform,
+ });
+ return setter;
+ }
+
+ public static TSetter AddDestinationTransform<TSetter>(this TSetter setter, DestinationTransform transform) where TSetter : TypeAdapterSetter
+ {
+ setter.CheckCompiled();
+
+ setter.Settings.DestinationTransforms.Add(transform);
  return setter;
  }
 
@@ -646,6 +658,14 @@ public TwoWaysTypeAdapterSetter<TSource, TDestination> AddDestinationTransform<T
  return this;
  }
 
+ public TwoWaysTypeAdapterSetter<TSource, TDestination> AddDestinationTransform(DestinationTransform transform)
+ {
+ SourceToDestinationSetter.AddDestinationTransform(transform);
+ if (typeof(TSource) != typeof(TDestination))
+ DestinationToSourceSetter.AddDestinationTransform(transform);
+ return this;
+ }
+
  public TwoWaysTypeAdapterSetter<TSource, TDestination> Ignore(params string[] names)
  {
  SourceToDestinationSetter.Ignore(names);

src/Mapster/TypeAdapterSettings.cs

@@ -11,9 +11,9 @@ public IgnoreDictionary Ignore
  {
  get => Get("Ignore", () => new IgnoreDictionary());
  }
- public TransformsCollection DestinationTransforms
+ public List<DestinationTransform> DestinationTransforms
  {
- get => Get("DestinationTransforms", () => new TransformsCollection());
+ get => Get("DestinationTransforms", () => new List<DestinationTransform>());
  }
  public NameMatchingStrategy NameMatchingStrategy
  {