Shouldn't DeepCloning=false ignore Lists and collections?

[alex-jitbit]

The docs at https://mapperly.riok.app/docs/configuration/mapper explicitly say that if DeepCloning is disabled and source/dest property cannot be simply assigned one to another - it won't be cloned. However with the new collection support in 2.7 and later it copies items one by one.

P.S. Moreover, if a collection has some nested non-collection-related property - it is also copied. Like dest.SomeCollection.Something = source.SomeCollection.Something

I fell like this should either be ignored, of you should clarify the docs, precisely defining what "deep" means. ;) Thanks for a great project.

[TimothyMakkison]

The docs at https://mapperly.riok.app/docs/configuration/mapper explicitly say that if DeepCloning is disabled and source/dest property cannot be simply assigned one to another - it won't be cloned. However with the new collection support in 2.7 and later it copies items one by one.

By default Mapperly tries to avoid copying objects but when it has to (ie MyObject[] -> List<MyObject>) it will still do a shallow copy and won't deep clone the elements. Mapperly will try to convert similar collections but it won't deep clone elements unless UseDeepCloning is enabled. I don't think the new collection support violates this?

[Mapper]
public static partial class Mapper
{
    public static partial B Map(A src);

    //     target.Value = global::System.Linq.Enumerable.ToList(src.Value);
    //     return target;
}

// With deep cloning
[Mapper(UseDeepCloning = true)]
public static partial class DeepMapper
{
    public static partial B Map(A src);

    //     target.Value = global::System.Linq.Enumerable.ToList (global::System.Linq.Enumerable.Select(src.Value, x => MapToMyObject(x)));
    //     return target;
       
    // private static global::Riok.Mapperly.Sample.MyObject MapToMyObject (global::Riok.Mapperly.Sample.MyObject source)
    // {
    //     var target = new global::Riok.Mapperly.Sample.MyObject();
    //     target.Number = source.Number;
    //     target.Details = (int[])source.Details.Clone();
    //     return target;
    // }
}
public class A
{
    public MyObject[] Value { get; set; }
}

public class B
{
    public List<MyObject> Value { get; set; }
}

public class MyObject
{
    public int Number { get; set; }
    public int[] Details { get; set; }
}

P.S. Moreover, if a collection has some nested non-collection-related property - it is also copied. Like dest.SomeCollection.Something = source.SomeCollection.Something

Do you have an example for this? Does this apply to classes like: public class MyCollection : IEnumerable<Item>.

[alex-jitbit]

Your code example is irrelevant, If two object have get-only collection property, mapperly will iterate the collection:

foreach (var item2 in source.Collection)
{
    dest.Collection.Add(item2);
}

It will also do the same for nested collections too, resulting in a SH*TLOAD of code and there;'s no way to disable that,

To repro try to map HttpRequestMessage object like this

public static partial void CopyTo(HttpRequestMessage source, HttpRequestMessage dest);

It will generate screens of stuff like this:

foreach (var item in source.Headers.Accept)
{
	dest.Headers.Accept.Add(item);
}

foreach (var item1 in source.Headers.AcceptCharset)
{
	dest.Headers.AcceptCharset.Add(item1);
}

foreach (var item2 in source.Headers.AcceptEncoding)
{
	dest.Headers.AcceptEncoding.Add(item2);
}

foreach (var item3 in source.Headers.AcceptLanguage)
{
	dest.Headers.AcceptLanguage.Add(item3);
}

What is it if not deep cloning.

P.S. That's the reason my company froze the dependency at 2.6 and will never be upgrading, because there's no way to turn this off.

[CommonGuy]

DeepCloning=true guarantees that new instances of (nested) objects will be generated. However, the opposite isn't true. DeepCloning=false simply allows Mapperly to use shortcuts where applicable to improve performance.

In your example, Mapperly sees the HttpRequestMessage.Headers.Accept property, which is read only. Mapperly has to enumerate the source collection and map the items one by one, there is no other way in this case.

You can work around this behaviour by implementing the mapping of the HTTP headers yourself:

[Mapper]
public static partial class MyMapper
{
   public static void CopyTo(HttpRequestMessage source, HttpRequestMessage dest)
   {
       Map(source, dest);
   	
       foreach (var header in source.Headers)
       {
           dest.Headers.TryAddWithoutValidation(header.Key, header.Value);
       }
   }
   
   [MapperIgnoreTarget(nameof(HttpRequestMessage.Headers))]
   private static partial void Map(HttpRequestMessage source, HttpRequestMessage dest);
}

An enhancement is tracked in #439 to make this easier to configure.

[alex-jitbit]

It's not about custom mapping. It's about performance, I don't want this wall of generated code in my app.

[alex-jitbit]

Any updates? How can I disable collection mapping completely?

[latonz]

No updates. Yes you can disable specific conversions: See docs. You may want to disable the Enumerable conversion.