Mapping Behavior

[JoshClose]

This discussion is to figure out how mapping should behave. Let's ignore how it currently behaves and talk about what is ideal.

Mapping scenarios.

1. class with default constructor.
2. class with no default constructor.
3. class with both default constructor and other constructors.
4. struct with default constructor.
5. struct with no default constructor.
6. struct with both default constructor and other constructors.
7. record
8. record struct
9. readonly record struct

Member mapping can be a property or field or both based on the CsvConfiguration.MemberTypes flag.

class with default constructor

Auto Map Rules:

class Foo
{
    [Name("id")]
    public int Id { get; set; }
    [Name("name")]
    public string Name { get; set; }
    [Ignore]
    public DateTimeOffset Date { get; set; }
    public decimal Amount { get; private set; }
}

1. No constructor mapping.
2. All members with public setters are mapped.
3. Attributes can be placed on members.
4. [Ignore] will stop from mapping.

Class Map Rules:

class Foo
{
    public int Id { get; set; }
    public string Name { get; set; }
    public DateTimeOffset Date { get; set; }
}

class FooMap : ClassMap<Foo>
{
    public FooMap()
    {
        Map(m => m.Id).Name("id");
        Map(m => m.Name).Name("name");
    }
}

1. Constructor mapping throws an exception because there is no constructor with parameters.
2. Only members that are in the map get mapped. No need to ignore.

class with no default constructor

Auto Map Rules:

class Foo
{
    public int Id { get; private set; }
    public string Name { get; private set; }
    public DateTimeOffset Date { get; set; }

    public Foo([Name("Id")]int id, [Name("Name")]string name)
    {
        Id = id;
        Name = name;
    }
}

1. All constructor parameters are mapped.
2. Attributes can be placed on parameters.
3. Members with public setters are mapped.
4. Attributes can be placed on members.
5. [Ignore] will stop from mapping.
6. If a parameter and member have the same name, case insensitive, the member will not be mapped unless the member has an attribute on it. The parameter has to be mapped because creating an instance requires it.

Class Map Rules:

class Foo
{
    public int Id { get; private set; }
    public string Name { get; private set; }
    public DateTimeOffset Date { get; set; }

    public Foo([Name("Id")]int id, [Name("Name")]string name)
    {
        Id = id;
        Name = name;
    }
}

class FooMap : ClassMap<Foo>
{
    public FooMap()
    {
        Parameter("id").Name("Id");
        Parameter("name").Name("Name");
        Map(m => m.Date);
    }
}

1. All parameters used must be mapped or an exception is thrown.
2. Members can be mapped.

class with both default constructor and other constructors

Auto Map Rules:

class Foo
{
    [Name("id")]
    public int Id { get; set; }
    [Name("name")]
    public string Name { get; set; }
    [Ignore]
    public DateTimeOffset Date { get; set; }
    public decimal Amount { get; private set; }

    public Foo() {}

    public Foo(int id, string name)
    {
        Id = id;
        Name = name;
    }
}

1. Constructor parameters aren't mapped.
2. All rules for class with default constructor apply.

Class Map Rules:

class Foo
{
    public int Id { get; private set; }
    public string Name { get; private set; }
    public DateTimeOffset Date { get; set; }

    public Foo() {}

    public Foo([Name("Id")]int id, [Name("Name")]string name)
    {
        Id = id;
        Name = name;
    }
}

class FooMap : ClassMap<Foo>
{
    public FooMap()
    {
        Parameter("id").Name("Id");
        Parameter("name").Name("Name");
        Map(m => m.Date);
    }
}

1. Constructor parameter maps are ignored because the default constructor is used.
2. All rules for class with default constructor apply.

struct with default constructor

Auto Map Rules:

struct Foo
{
    public int Id;
    public string Name;
}

1. Same rules as class with default constructor apply.

Class Map Rules:

1. Same rules as class with default constructor apply.

struct with no default constructor.

struct Foo
{
    public int Id;
    public string Name;

    public Foo(int id, string name)
    {
        Id = id;
        Name = name;
    }
}

Auto Map Rules:

1. Constructor mapping does not work with structs but structs have an implicit default constructor.
2. Same rules as struct with default constructor apply.

Class Map Rules:

1. Constructor mapping does not work with structs but structs have an implicit default constructor.
2. Same rules as struct with default constructor apply.

struct with both default constructor and other constructors.

Auto Map Rules:

1. Same rules as class with no default constructor apply.

Class Map Rules:

1. Same rules as class with no default constructor apply.

record

record Foo([Name("id")]int Id, [Name("name")]string Name);

// Same as

class Foo
{
    public int Id { get; set; }
    public string Name { get; set; }

    public Foo([Name("id")]int Id, [Name("name")]string Name)
    {
        this.Id = Id;
        this.Name = Name;
    }
}

// Or

record Foo([property: Name("id")]int Id, [property: Name("name")]string Name);

// Same as

class Foo
{
    [Name("id")]
    public int Id { get; set; }
    [Name("name")]
    public string Name { get; set; }

    public Foo(int Id, string Name)
    {
        this.Id = Id;
        this.Name = Name;
    }
}

Auto Map Rules:

1. Same rules as class with no default constructor apply.

Class Map Rules:

1. Same rules as class with no default constructor apply.

record struct

record struct Foo([Name("id")]int Id, [Name("name")]string Name);

// Same as

struct Foo
{
    public int Id { get; set; }
    public string Name { get; set; }

    public Foo([Name("id")]int Id, [Name("name")]string Name)
    {
        this.Id = Id;
        this.Name = Name;
    }
}

// Or

record struct Foo([property: Name("id")]int Id, [property: Name("name")]string Name);

// Same as

struct Foo
{
    [Name("id")]
    public int Id { get; set; }
    [Name("name")]
    public string Name { get; set; }

    public Foo(int Id, string Name)
    {
        this.Id = Id;
        this.Name = Name;
    }
}

Auto Map Rules:

1. Same rules as struct with no default constructor apply.

Class Map Rules:

1. Same rules as struct with no default constructor apply.

readonly record struct

readonly record struct Foo([Name("id")]int Id, [Name("name")]string Name);

// Same as

struct Foo
{
    public int Id { get; init; }
    public string Name { get; init; }

    public Foo([Name("id")]int Id, [Name("name")]string Name)
    {
        this.Id = Id;
        this.Name = Name;
    }
}

// Or

readonly record struct Foo([property: Name("id")]int Id, [property: Name("name")]string Name);

// Same as

struct Foo
{
    [Name("id")]
    public int Id { get; init; }
    [Name("name")]
    public string Name { get; init; }

    public Foo(int Id, string Name)
    {
        this.Id = Id;
        this.Name = Name;
    }
}

Auto Map Rules:

1. Same rules as struct with no default constructor apply.

Class Map Rules:

1. Same rules as struct with no default constructor apply.

[BenMakesGames]

I don't think I would expect a difference based on the object type (struct, class, record), or the presence/absence of constructors and/or accessor keywords. I'm used to serialization libraries (including EF) ignoring almost everything, and just going "right: I've read a value labeled Field1, and this class has a thing called Field1 (or identified as such via an attribute) - I'm gonna make this happen!!!"

Things which are impossible (or inordinately difficult) due to language design/limitations are understandable. As long as CsvHelper calls these out (example, without knowing if this is even true: "we don't support structs with constructors, because how they work makes it really hard until .NET 7/C# 11, and CsvHelpers wants to support older versions"), I'm sure the community will come to know these limitations, and repeat them on StackOverflow, Discord, etc.

[Rob-Hague]

I think:

• Properties, fields and constructor parameters should be treated as the same member if they have the same name, ignoring case (or PascalCase vs camelCase), and at most one of them has any attributes defined on it. The mapping data/options would apply to all the corresponding members.
  • This could make record (and upcoming primary constructor?) mapping straightforward from the user's perspective.
  • The reason only one of them can have attributes is to avoid breaking someone who defines different attributes on a parameter vs its corresponding member in order to achieve different behaviour in writing vs reading.
  • This could be opt-out by configuration, or configurable via an IEqualityComparer<MemberInfo>.
  • Practically this might mean MemberMap and ParameterMap would have (nullable) references to each other, and the MemberMap is only invoked in object creation if the ParameterMap isn't. Perhaps ParameterMap would derive from MemberMap.
• The constructor with the most parameters should be used. This is what happens now if there is no parameterless constructor, the difference being that this would happen even if there is a parameterless constructor, with the parameterless constructor being used as a last resort.
  • In combination with the first suggestion, this allows for the most "coverage" in mapping, i.e. the most members that can be assigned (more chance to map a { get; } property)
  • The rule is consistent across types (should not have to worry about class vs struct)
• Additionally, there could be a new attribute which can be applied to a single constructor, which would specify that this constructor should be used in object creation (similar to the configurable GetConstructor). Suggested name UseConstructorAttribute.

Suggested amendments (maybe incomplete):

class with no default constructor

- 6. If a parameter and member have the same name, case insensitive, the member will not be mapped unless the member has an attribute on it. The parameter has to be mapped because creating an instance requires it.
+ 6. If a parameter and member have the same name, case insensitive,
+ 6.1 If either has no attribute, they will be mapped as the same member taking the configuration of the attributed member.
+ 6.2 If both have an attribute, they will be mapped as different members.

class with both default constructor and other constructors

- 1. Constructor parameters aren't mapped.
+ 1. Constructor parameters are mapped (and are linked to the `Id` and `Name` properties).

struct with no default constructor.

I feel like I'm missing something here. Why can't we use the constructor?

- 1. Constructor mapping does not work with structs but structs have an implicit default constructor.
+ 1. Constructor parameters are mapped (and are linked to the `Id` and `Name` fields).

record

record Foo([Name("id")]int Id, [Name("name")]string Name);

// Same as

class Foo
{
    public int Id { get; set; }
    public string Name { get; set; }

    public Foo([Name("id")]int Id, [Name("name")]string Name)
    {
        this.Id = Id;
        this.Name = Name;
    }
}

- // Or
+ // Same as

record Foo([property: Name("id")]int Id, [property: Name("name")]string Name);

// Same as

class Foo
{
    [Name("id")]
    public int Id { get; set; }
    [Name("name")]
    public string Name { get; set; }

    public Foo(int Id, string Name)
    {
        this.Id = Id;
        this.Name = Name;
    }
}

Same for record struct and readonly record struct