Data Filtering in .NET: Using View Models for Cleaner Data Handling

In .NET applications, data filtering is a crucial step to ensure that only relevant and necessary information is exposed / provide to the client. One common approach is using View Models to filter out sensitive or unnecessary data from the database models before sending it to the frontend.

Why Use Data Filtering?

When dealing with APIs or MVC applications, exposing the entire database model to the client can pose several risks, including:

• Security risks (Exposing sensitive data such as passwords and internal fields)

• Performance issues (Sending unnecessary data increases payload size)

• Better maintainability (View Models allow structuring the data specifically for UI needs)

Implementing Data Filtering with View Models

A practical way to filter data in .NET is by using View Models. Let's consider an example:

1. Defining the Model (Entity)

This represents the database structure:

public class User
{
    [Key]
    public int Id { get; set; }
    
    [Required]
    public string Name { get; set; }
    
    [Required]
    public string Email { get; set; }
    
    public string? Address { get; set; }
    
    [Required]
    public string Username { get; set; }
    
    [Required]
    public string Password { get; set; }
    
    public DateTime CreateDate { get; set; } = DateTime.Now;
}

This model contains sensitive data such as Username, Password, and CreateDate, which should not be exposed to the client.

2. Creating a View Model

To filter out unnecessary fields, we create a UserViewModel:

public class UserViewModel
{
    public string Name { get; set; }
    public string Email { get; set; }
    public string? Address { get; set; }
}

This ensures that only Name, Email, and Address are exposed to the client.

3. Mapping Model to View Model

Now, in the API or service layer, we can map the User entity to UserViewModel before returning the response:

public List<UserViewModel> GetUsers()
{
    var users = _context.Users.ToList();
    return users.Select(u => new UserViewModel
    {
        Name = u.Name,
        Email = u.Email,
        Address = u.Address
    }).ToList();
}

By doing this, we prevent exposing sensitive data such as Password and Username to the frontend.

4. Using AutoMapper for Efficient Mapping (Alternative mapping)

Instead of manually mapping, we can use AutoMapper to automate the conversion:

-- Create profile

 public class MapperProfile : Profile
 {
     public MapperProfile() { 
         CreateMap<User, UserViewModel>().ReverseMap();
     }
 }

-- Initialize AutoMapper service in constructor 

public class UserManagementService
{
   private readonly AppDbContext _context;
   private readonly IMapper _mapper;

   public UserManagementService(AppDbContext context, IMapper mapper)
   {
      _context = context;
      _mapper = mapper;
   }

   public List<UserViewModel> GetUsers()
   {
       var users = _context.Users.ToList();    
       var model = _mapper.Map<List<UserViewModel>>(users);    
       return model;
   }

}

This reduces code redundancy and makes mapping easier to maintain.

Benefits of Using View Models for Data Filtering

• Security: Prevents exposing sensitive fields

• Performance: Reduces payload size for API responses

• Flexibility: Allows customizing the data for different API consumers

• Maintainability: Decouples domain models from presentation models

Conclusion

Using View Models in .NET is an effective way to filter data and ensure that only necessary information is sent to the client. By implementing this technique, you can improve security, performance, and maintainability in your .NET applications.

Do you use View Models in your .NET projects? Let us know your thoughts in the comments! 🚀