Misleading exception message for ctor argument names

[Ekkeir]

There's an exception produced when mapping to a class with a ctor:

public class Destination
{
    public Destination(int number)
    {
        Id = number;
    }

    public int Id { get; }
}

public class Source
{
    public int Number { get; set; }
}

[Fact]
public void Should_Map()
{
    var config = new TypeAdapterConfig();

    config.ForType<Source, Destination>()
        .Map(dest => dest.Id, source => source.Number);

    config.Compile(); // throws an exception
}

The following exception is produced:

System.InvalidOperationException : No default constructor for type 'Destination', please use 'ConstructUsing' or 'MapWith'.

The exception message seems misleading as (I may have missed it in documentation) mapster seems to depend on argument names.
Renaming Destination ctor argument from number to id is enough for the test to succeed. That is, changing to the following:

public class Destination
{
    public Destination(int id)
    {
        Id = id;
    }

    public int Id { get; }
}

Suggestions:

• maybe this name-dependency could be reduced?
• it would be great if the exception message could mention that there's an option of renaming ctor arguments to match the properties

[stagep]

What should happen in this scenario if name-dependency was reduced?

public class Destination
{
    public Destination(int number1, int number2)
    {
        Id1 = number2;
        Id2 = number1;
    }
    public int Id1 { get; }
    public int Id2 { get; }
}

[DocSvartz]

@stagep What version of mapster are you using?

By default, mapping to class class must always have a constructor without parameters.

After renaming
Your everything started to work because after the change your class started to be mistakenly defined as a record type. (v 7.4.0)

Use this if you need to map to a class constructor

TypeAdapterConfig<Source, Destination>
    .ForType()
    .Map(dest => dest.Id, source => source.Number)
    .MapToConstructor(true)
    .Compile();

[DocSvartz]

@andrerav Possible regression in the development branch. I don't remember if it was like that initially or not))

Properties without a setter are not updated for classes.

[TestMethod]
public void ProblemClassCtorfromIssue719()
{
    TypeAdapterConfig<Source719, Destination719>
        .ForType()
        .Map(dest => dest.Id, source => source.Number)
        .MapToConstructor(true)
        .Compile();

    var sourse = new Source719() { Number = 123 };
    var destination = new Destination719(202);

    var result = sourse.Adapt<Destination719>();
    var d = sourse.Adapt(destination); // d.Number (destination.number) == 202, not update  from sourse

}



  class Destination719
  {
     
      public Destination719(int id)
      {
          Id = id;
      }

      public int Id { get;} // if replace  to private set   update  it will work
  }

  class Source719
  {
      public int Number { get; set; }
  }

[andrerav]

@DocSvartz Hm, that would be a read-only autoproperty. They can only be assigned in the constructor or as part of the declaration. So I think this is as expected.

Source: https://codeblog.jonskeet.uk/2014/12/08/c-6-in-action/

[DocSvartz]

@andrerav I also think that the behavior is consistent with the specification for this type of fields.

The behavior for class in 7.4 is similar. The field is not updated with the value from the Source

class Destination719
{

    public Destination719(int number)
    {
        Id = number;
    }
   
    public int Id { get; }
}

[DocSvartz]

@stagep @andrerav

It seems to me that there is a problem here, on the contrary, in that if Fields are mapped to the constructor, then they will be mapped again to the property:

1. Using ConstructUsing
2. Using Any matching conditions .IgnoreNullValues(true) IgnoreIF
3. If ctor param is not MemberExpression - other type Expression but mapping the constructor parameters were successful

[TestMethod]
public void Tst()
{
    TypeAdapterConfig<Source7191, Destination7191>.NewConfig()
     .MapToConstructor(true)
     .IgnoreNullValues(true) // double mapping
     //.ConstructUsing(x => new Destination7191(33, 44)) // double mapping when using property src
     .Map(dest => dest.Data3, src => src.Data1)
     .Map(dest => dest.Data4, src => src.Data2)
  //   .IgnoreIf((src, dest) => src.Data1 == 20, dest => dest.Data1) // double mapping
  //   .IgnoreIf((src, dest) => src.Data2 == 40, dest => dest.Data2) // double mapping
     //.Ignore(x=>x.Data2)
     /*.Ignore(x=>x.Data1)*/;

    var source = new Source7191(5, 6); 

    var s = source.BuildAdapter().CreateMapExpression<Destination7191>();

    var result = source.Adapt<Destination7191>();
}

 public class Source7191
 {
     public Source7191(int data1, int data2)
     {
         Data1 = data1;
         Data2 = data2;
     }

     public int Data1 { get; private set; }
     public int Data2 { get; private set; }

     
 }
 public class Destination7191
 {
     public Destination7191(int data1, int data2)
     {
         Data1 = data2;
         Data2 = data1;
     }

     public int Data1 { get; private set; }
     public int Data2 { get; private set; }

     public int Data3 { get; set; }
     public int Data4 { get; set; }
 }

map function

.Lambda #Lambda1<System.Func`2[Mapster.Tests.Source7191,Mapster.Tests.Destination7191]>(Mapster.Tests.Source7191 $var1) {
    .Block(Mapster.Tests.Destination7191 $result) {
        .If ($var1 == null) {
            .Return #Label1 { null }
        } .Else {
            .Default(System.Void)
        };
        $result = .New Mapster.Tests.Destination7191(
            $var1.Data1,
            $var1.Data2);
        .Block() {
            $result.Data1 = $var1.Data1; // this not if map without condition
            $result.Data2 = $var1.Data2; // this not if map without condition
            $result.Data3 = $var1.Data1;
            $result.Data4 = $var1.Data2
        };
        .Return #Label1 { $result };
        .Label
            null
        .LabelTarget #Label1:
    }
}

if not using condition you get this (comment .IgnoreNullValues in this sample):

.Lambda #Lambda1<System.Func`2[Mapster.Tests.Source7191,Mapster.Tests.Destination7191]>(Mapster.Tests.Source7191 $var1) {
    .If ($var1 == null) {
        null
    } .Else {
        .New Mapster.Tests.Destination7191(
            $var1.Data1,
            $var1.Data2){
            Data3 = $var1.Data1,
            Data4 = $var1.Data2
        }
    }
}