We Keep Coding

AutoMapper ForMember method breaks the functionality of mapping

I want to use AutoMapper in my .Net 6 APIs to convert the entity model User to DTO model UserDTO.
The User model class is:
public class User : BaseEntity
{
public Guid Id { get; set; }
public string FirstName { get; set; } = null!;
public string LastName { get; set; } = null!;
public string Avatar { get; set; } = null!;
public string Email { get; set; } = null!;
public ICollection<Book>? FavoriteBooks { get; set; }
}
And the UserDTO is a record as follows:
public record UserDTO(Guid Id, string FullName, string Avatar, string Email);
I have added the required package AutoMapper.Extensions.Microsoft.DependencyInjection v.12.0.0,
and the configuration steps are given below:
1- Create MappingProfile that inherits from the Profile class
public class MappingProfiles : Profile
{
public MappingProfiles()
{
CreateMap<User, UserDTO>()
.ForMember(
dest => dest.FullName,
opt => opt.MapFrom(src => string.Join(" ", src.FirstName, src.LastName))
);
}
}
2- Register the service in Program.cs file:
builder.Services.AddAutoMapper(typeof(Program));
3- Use the mapper as an injected service inside Service project:
public IEnumerable<UserDTO> GetAllUsers(bool trackChanges)
{
var users = _repository.User.GetAllUsers(trackChanges);
return _mapper.Map<IEnumerable<UserDTO>>(users);
}
When I call the GetAllUsers method in postman, I get the following error:
Error mapping types.
Mapping types:
List -> IEnumerable
After a few days of struggling and searching, I realized that the .ForMember() method breaks the functionality of the profile class. In other words, if I change the UserDTO record:
public record UserDTO(Guid Id, string FirsName, string Avatar, string Email);
the FullName filed changed to FirstName to have compatibility with the User model. Also change the MappingProfile class:
public class MappingProfiles : Profile
{
public MappingProfiles()
{
CreateMap<User, UserDTO>();
}
}
the GetAllUsers method works as expected. So to conclude, if I add the .ForMember() method to the constructor of the MappingProfile class as in documentation, it breaks the functionality of the CreatMap method.
How should I use the .ForMember() method to map the User model to the corresponding DTO? Is this method obsolete? Is there any replacement for this method?

I found 2 solutions:
Solution 1:
I created a method to get the full name of the user. The method name should be prefixed with get:
The naming convention can cover simpler examples where the source object has a property, method, or method with a “Get” as a prefix with the same name as the property of a destination object.
so I have modified the User model class and added the following method:
public class User : BaseEntity
{
... // User model properties
public string GetFullName() => $"{this.FirstName} {this.LastName}";
}
and removed the .ForMemeber()` method from the profile class:
public MappingProfiles()
{
CreateMap<User, UserDTO>();
}
Solution 2:
It seems that .ForMember() is obsolete, I have found an alternative for that, .ForCtorParam():
public MappingProfiles()
{
CreateMap<User, UserDTO>()
.ForCtorParam(
"FullName",
opt => opt.MapFrom(src => string.Join(" ", src.FirstName, src.LastName))
);
}
In these ways, I have converted my User model class to UserDTO.

Is it possible in EF Core to make a one-way navigation property required?

I am working on a basic group chat system, for which I created these classes:
public class Role
{
public Guid Id { get; set; };
public string Username { get; set; }
}
public class Message
{
public Guid Id { get; set; };
public Role Author { get; set; }
public Conversation Conversation { get; set; }
public DateTime Date { get; set; }
public string Text { get; set; }
}
public class Conversation
{
public Guid Id { get; set; };
public IList<ConversationParticipant> ConversationParticipants { get; set; };
public IList<Message> Messages { get; set; };
}
public class ConversationParticipant
{
public Conversation Conversation { get; set; }
public Role Role { get; set; }
}
We are using EF Core 3.1 Code-First with migrations.
I am looking for a way to make Message.Author a required property, which should lead to a column in table Message that is created as AuthorId NOT NULL.
I tried:
public static void Map(this EntityTypeBuilder<Message> builder)
{
builder.HasOne(m => m.Author);
}
As this is applied using Add-Migration and Update-Database, the database column AuthorId is created, but with NULLs allowed.
There does not seem to be a method IsRequired() that I can add after HasOne().
I also tried:
public static void Map(this EntityTypeBuilder<Message> builder)
{
builder.Property(m => m.Author).IsRequired();
}
but that fails saying
The property 'Message.Author' is of type 'Role' which is not supported by current database provider. Either change the property CLR type or ignore the property using the '[NotMapped]' attribute or by using 'EntityTypeBuilder.Ignore' in 'OnModelCreating'.
Doing .HasOne(...) followed by .Property(...).IsRequired() also does not work:
'Author' cannot be used as a property on entity type 'Message' because it is configured as a navigation.
I managed to make Message.Conversation required through this:
public static void Map(this EntityTypeBuilder<Conversation> builder)
{
builder.HasMany(c => c.Messages) // A conversation can have many messages
.WithOne(e => e.Conversation) // Each message belongs to at most 1 conversation
.IsRequired(); // A message always has a conversation
}
However I'd rather not make Role aware of Messages, as I will never want to retrieve Messages directly from a Role (this will happen through Conversations and Participants).
My ultimate question is: Is there a way to make Message.Author required (NOT NULL), without linking Message and Role together in a full 1-to-many relationship with a Messages property in Role?

What about adding Role's foreign key to Message and then requiring that property to not be null? Something like:
// MessageConfiguration.cs
builder.Property(b => b.RoleId).IsRequired()

While the answer by #Ben Sampica was helpful and got me where I needed to be, the comments by #Ivan Stoev provided details and clarity that made me think that a more comprehensive answer would be useful.
There are multiple ways to make a foreign key column required (NOT NULL) in the generated table.
The simplest is to put [Required] on the navigation property:
public class Message
{
// ...
[Required] public Role Author { get; set; }
// ...
}
This will cause EF to create a shadow property AuthorId of type Guid because Message.Author is a Role and Role.Id is of type Guid. This leads to UNIQUEIDENTIFIER NOT NULL in case of SQL Server.
If you omit [Required] then EF will use Guid?, which leads to UNIQUEIDENTIFIER NULL, unless you apply one of the other options.
You can use an explicit Id property with a type that can't be null:
public class Message
{
// ...
public Guid AuthorId { get; set; }
public Role Author { get; set; }
// ...
}
Note (i) - This only works if you follow EF Core shadow property naming rules, which in this case means you must name the Id property nameof(Author) + nameof(Role.Id) == AuthorId.
Note (ii) - This will break if one day you decide to rename Author or Role.Id but forget to rename AuthorId accordingly.
If you can't or don't want to change the Model class, then you can tell EF Core that it needs to treat the shadow property as required:
builder.Property("AuthorId").IsRequired();
The same Notes apply as listed at 2, with the addition that you could now use nameof() to reduce the effort and the risks.
In the end I decided to use the [Required] approach, because
It is simple and descriptive,
No effort needed to think of which shadow property name to use,
No risk of breaking the shadow property name later on.
This may apply sometimes, not always:
Input forms may use the Model class attribute to check if a property is required. However it may be a better approach to build your forms around DTO classes, and then an attribute on an EF Model class may provide no worth for your forms.

Dapper Extension: class with composite fields, mapped to an individual table

I have the following classes:
public class Publication
{
public int Id { get; set; }
public string Title { get; set; }
public string Headline { get; set; }
public DateTime Published { get; set; }
public ProductContact Contact { get; set; }
}
public class ProductContact
{
public string FullName { get; set; }
public string JobTitle { get; set; }
public string Email { get; set; }
}
And the table associated with this structure, "Publications", has all these fields (included the properties of ProductContact).
If I try to insert a Publication row (with the ProductContact information included) the program throws an exception:
System.NotSupportedException: The member Contact of type ProductContact cannot be used as a parameter value
So, I added a mapper to map out the ProductContact properties to fields in the Properties table:
public PublicationMapper ()
{
TableName = "Publications";
Map(x => x.Contact.FullName).Column("ContactFullName");
Map(x => x.Contact.JobTitle).Column("ContactJobTitle");
Map(x => x.Contact.Email).Column("ContactEmail");
AutoMap();
}
With this mapper I get the same exception.
Then, I added the ignore statement for the Contact field, to tell Dapper to not include this element in the insert statement
Map(x => x.Contact).Ignore();
In this case, I get another exception:
System.Data.SqlClient.SqlException (0x80131904): Must declare the scalar variable "#FullName".
It indicates that Dapper is ignoring completely this property, and the mapping added in the previous step does not have effect.
Is there a way to map out the ProductContact properties to the table fields?
Thank you.

I don't think that this is possible with DapperExtensions.
In one of their issues, they say
Currently, we aren't planning to support nested objects. However, you
can create your own Mapper that will allow for skipping over the
nested object
I have tried a variety of approaches and different mapping classes and can't get anywhere - I don't think that they support any way to map nested property values and to ignore the property itself (which, if not done, will result in "cannot be used as a parameter value" error).
One approach would be to manually flatten your object into an anonymous class (as suggested by #juharr in a comment on your question), another approach would be to use something like AutoMapper to flatten your complex object into a flattened insert model.

Unable to determine the serialization information for i => i.Id using interfaces

First up, I know there is already questions out there with this error message, but I haven't found any that relate to the use of using interfaces with this type of query.
I'm currently trying to update a MongoDB entity using the C# Driver 2.0. However, I'm getting an error when it's trying to build the query (I'm assuming it's the Builders<T>.Filter.Eq(i => i.Id, entity.Id) bit of code) and I'm getting the following error:
Unable to determine the serialization information for i => i.Id.
I've got the following class that I'm trying to update
public interface IEntity {
string Id { get; set; }
}
public interface ITrack : IEntity {
string Name { get; set; }
}
public class TrackDTO : ITrack
{
[BsonId]
public string Id { get; set; }
public string Name { get; set; }
}
I'm then using the interface to save the object into the database using the following method in a generic DAO class to replace the entire document. Note, in the example below T is coded as ITrack (i.e. TrackDao = new Dao<ITrack>) but when the object is passed in at runtime it's a TrackDTO object (which is correct):
public async Task<T> Save(T entity)
{
// Save the entity to the collection.
ReplaceOneResult result = await _collection.ReplaceOneAsync(Builders<T>.Filter.Eq(i => i.Id, entity.Id), entity, new UpdateOptions() { IsUpsert = true });
// return the saved user object.
return entity;
}
I don't know if the Id property of my IEntity class also requires the [BsonId] attribute, but I'd like to avoid this if possible, as I want to keep my model layer (where IEntity resides) free of any database platform specific references.
I've also tried adding the following class map which has had no effect either:
BsonClassMap.RegisterClassMap<TrackDTO>(cm =>
{
cm.AutoMap();
cm.MapMember(c => c.Id).SetSerializer(new StringSerializer(BsonType.ObjectId));
cm.SetIdMember(cm.GetMemberMap(c => c.Id));
});
For the same reason as not having the [BsonId] attributes in the Model layer, I don't want to have the Model classes decorated with [BsonKnownTypes] that reference DTO objects, however I don't mind if this needs to occur as part of a class map.

For
"Unable to determine the serialization information for i => i.Id."
Try to use: nameof().
Builders<T>.Filter.Eq(nameof(IEntity.Id), entity.Id)
2.
...but I'd like to avoid this if possible, as I want to keep my model
layer (where IEntity resides) free of any database platform specific
references.
My solution for problem like your and similar problems:
public interface IEntity {
[BsonId]
string Id { get; set; }
string IdEntity { get; set; }
}
[BsonIgnoreExtraElements(Inherited = true)]
public abstract class BaseEntity : IEntity
{
[BsonRepresentation(BsonType.ObjectId)]
public virtual string Id { get; set; }
[BsonIgnoreIfNull]
public string IdEntity { get; set; }
}

AutoMapper Profiles: flattening a dto for mapping

I have a Main class that has a nested class. I have used this successfully to map using Mapper class
public class Main
{
public string Name { get; set; }
public List<QuantityLocation> NC { get; set; }
}
public class NestedClass
{
public decimal B { get; set; }
public string A { get; set; }
}
public class Flattened
{
public string Name { get; set; }
public string A { get; set; }
public decimal B { get; set; }
}
Mapping done using the Mapper class as below.
Mapper.CreateMap<NestedClass, Flattened>();
Mapper.CreateMap<Main, Flattened>();
Mapper.CreateMap<Main, List<Flattened>>()
.ConvertUsing(i =>
i.NC.Select(
flat =>
{
var flatList = Mapper.Map<Flattened>(i);
Mapper.Map(flat, flatList);
return flatList;
}).ToList());
Now when I moved this mapping to my Profile class, I had to change the lines above to this below:
CreateMap<NestedClass, Flattened>();
CreateMap<Main, Flattened>();
CreateMap<Main, List<Flattened>>()
.ConvertUsing(i =>
i.NC.Select(
flat =>
{
var flatList = Mapper.Map<Flattened>(i);
Mapper.Map(flat, flatList);
return flatList;
}).ToList());
The problem I am facing is how to convert these two lines below in the snippet above.
var flatList = Mapper.Map<Flattened>(i);
Mapper.Map(flat, flatList);
you see I am injecting the Mapper.Engine to the constructor of my controllers. Earlier I was just using the Static Mapper class which used to get called in my global.asax. Now I get an error like the one below.
Missing type map configuration or unsupported mapping.
Mapping types: Main -> List`1 MyProj.Main -> System.Collections.Generic.List`1[[MyProj.Flattened, MyProj, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]
Destination path: List`1
Source value: MyProj.Main

The proper way to do is to use a custom type converter, in which you inject the mapping engine itself. And use ConstructServicesUsing in your profile declaration.
Assuming you use some of IoC container, and you have registered in it the mapping engine, and the custom type converter, inside the converter you will use engine.Map instead the static Mapper.